For an online leaderboard, two browsers have to agree on the same bounce down to the last decimal

The ask was an online Top 10 "like Gravira's": the browser records the inputs of a run, and a server plays those same inputs back through the real rules and keeps its own score — never trusting the number the browser reports. Gravira's version of this works because its simulation is built from integer-only arithmetic from the start. NiceBounce wasn't, and porting the idea meant finding every place that would break it first.

Two function calls the spec doesn't pin down

The simulation called a trigonometric function twice — for moving platforms and for wind gusts — and a third function once, for the coin magnet's pull. JavaScript's specification explicitly allows different engines to round those slightly differently from each other. That's invisible in a single browser playing its own game. It's exactly the problem for a replay: the same inputs, fed through the same rules on a different engine — a Node server instead of the browser that recorded them — could round one of those calls one bit differently, and a perfectly honest run could end up computing a different final position, and eventually a different score, from the one the player actually got.

What had to become exact

• The two rounding-sensitive calls were replaced with hand-written versions built only from addition, subtraction, multiplication, division and rounding down — operations every engine is required to agree on exactly — accurate to within one part in a billion of the originals.
• The playing field stopped depending on the window. A ranked run plays on one fixed size, scaled to fit and centred, so the shape of someone's browser window can never change what the generator produces.
• A ranked run locks to the base character with no upgrades and no revive, so loadout differences can't be a second source of disagreement.

With all three true, the server can take a recording of a run's inputs, play it back through the same code, and expect to land on the same score the player saw — not an approximation of it. Three short autopilot games are now frozen as a regression check: if a future change to the rules, the generator or the physics ever moves their numbers, that's the signal to bump the version everything is tagged with, not to ship quietly.

Said plainly: this doesn't catch a program playing well in real time, at normal speed — nothing on a player's own machine can tell that from a person. What it does guarantee is narrower: a counted score is never anything other than what this game's own rules produce from the inputs actually recorded, on whichever honest engine replays them. Safari and Firefox agreeing with the server is true by how the arithmetic was built, not yet proven by a test run on either — that's still open. The first two real runs, posted from the owner's own browser against the real server, did verify and post correctly.