A missed load-time ceiling now explains itself instead of costing a worktreeA missed speed check now explains itself instead of costing a do-over

October 10, 2026 · Dice-lock's perf gate now prints what the laptop was doing when a timing check missed, instead of making a session prove it twice.Dice-lock's automatic speed check now tells you what the computer was doing when it failed, instead of making someone prove it wasn't their fault.
last updated

Dice-lock's perf tests gate two kinds of things on every build: how many bytes a page ships, and how long it takes to paint. JIO-1799 was filed on the belief that a wedged background process, fseventsd, pinned at 175 to 196 percent of a core for days and immune to anything short of a reboot, had pushed both of the project's load-time ceilings out of reach on any tree at all. If that were true, every session hitting the gate would be fighting the laptop, not its own change, and would need to know that before touching perf-budgets.json.

It was not true. Five runs of a tree that is byte-for-byte identical to main on everything a browser downloads came back at 548, 627, 556, 1186 and 428 ms against the homepage's 550 ms ceiling, and at between 7704 and 8960 ms against /play's 8000 ms ceiling on the matched pair of metrics. The fifth run cleared all twelve load ceilings in the suite with fseventsd still running at 183 percent of a core and the ten-core load average at 3.58. The daemon was not what those gates were failing on. One measurement taken against a hand-written number, with no second run to check it, was.

So a timing miss now carries the evidence a session used to have to go and get itself. When a millisecond figure breaks its ceiling, the probe prints the load average the run started under, the core count, and whichever process was busiest at that moment, and tells you to re-run before trusting the result. That line is what used to cost a second worktree and a control run: proving a red gate wasn't your branch. Byte counts are left out of this, deliberately: edgeBytes and requests come back to the same number every time a given tree is measured, so a miss there is the tree's fault and doesn't need a second opinion.

Two smaller things came out of the same investigation. /play's own edgeBytes ceiling had gone stale: three unrelated tickets, JIO-1797, JIO-1798 and JIO-1804, had landed 480 insertions across the project's web code since the ceiling was last pinned, without anyone re-pinning it, so an untouched main was failing its own byte budget by 1,856 bytes before any of this started. It's now pinned at the 1,321,802 bytes the current tree actually ships.

And a test asserting /play's largest-painted element had quietly rotted. It checked for the specific HTML id h1#d-title-title, left over from a sheet title that no longer exists; what actually paints largest now is a plain DICE/LOCK wordmark with no id at all, so the assertion was failing on an untouched main the moment any checkout ran the probe, caught nowhere else, because a checkout with no measurement on record skips the check entirely. It now asserts an h1, not a specific id, which is the part of the original claim that still matters: the page's title is what the browser paints first, so the load-complete moment and the first-interactive moment are one event, 28 ms apart rather than the fiction of a since-renamed element.

Dice-lock's automatic checks test two things every time the code changes: how much data a page sends, and how long it takes to show up on screen. One of those checks had started failing, and the ticket filed about it, JIO-1799, blamed a stuck background program on the laptop that had been hogging nearly two full processor cores for days, assuming that alone made the speed checks impossible to pass on any version of the code.

That turned out to be wrong. Running the exact same, unchanged code five times in a row gave five different timing results, some passing the limit and some missing it by a lot, even though nothing about the code had changed between runs. On the fifth run, every single speed check passed, with that same stuck background program still running at nearly two full cores. So the background program was never the real cause. A timing measurement taken once, with no second check, is simply noisy: it depends on whatever else the computer happens to be doing at that exact second.

So now, whenever a timing check fails, the tool automatically prints out what the computer was doing at that moment: how busy its processors were overall, and which single program was using the most processor time right then. It tells whoever is looking at the result to run the check again before believing it failed for a real reason. That's the exact information a person used to have to go dig up by hand, setting up a second, separate copy of the project just to prove the failure wasn't their own fault. The data-size checks don't get this treatment, because how much data a page sends doesn't wobble between runs the way timing does; if that number changes, it changed because the code changed.

Two smaller problems turned up along the way. First, the limit for how much data one page is allowed to send had gone out of date: three unrelated pieces of work had quietly added about 480 lines of code to the project since that limit was last checked, pushing the page just over its own budget by less than two kilobytes. The limit has now been updated to match what the page actually sends today.

Second, a test was checking for one specific, named piece of text on the page as proof that the right thing was loading first. That named piece of text didn't exist on the page anymore; the thing that actually loads and shows first now is the site's plain word-mark logo, which never had that specific label. So the test had been failing for an unrelated, harmless reason since whenever that label was removed. It now checks for the right kind of thing in general, rather than one exact, outdated label.