The bracket page now says who is likely to win itThe bracket page now says who is likely to win it
August 27, 2026 · Reckreation's playoff page renders live win odds, and a security test that never actually ran finally did.A tournament app can now predict who's likely to win, and a broken security check finally got tested for real.
last updated
Reckreation, my tournament tracking project, spent the day turning a drawn bracket into something that talks back. Until this morning the playoff page showed what had already happened: who beat whom, who was still alive. It said nothing about what was likely to happen next.
engine/predict/simulate.ts plays a live bracket out ten thousand times, feeding random results through the same advance() function that resolves real ones, so a simulated loser crosses into the losers' bracket by the identical rule a real one would. That matters because a forecast is only honest if it can't get the routing wrong and still produce a clean-looking percentage. The code that predicts a bracket and the code that runs one are the same code. src/playoff-odds.ts joins those ten thousand runs into one page: title odds, expected placement, and a projected path for every entrant still in it, built from nothing but the engine and one file that itself imports nothing. The whole chain is covered by the test suite for that reason.
The other real story of the day was a test that had been lying since Tuesday, by omission. src/route-unauth.test.ts was supposed to send a real signed-out HTTP request at every route that changes data and check it gets refused. It landed with its recipe and its file list intact, and then the run itself never happened. The session that wrote it stopped one command short, so what shipped was a suite that skipped quietly under README prose describing what it would have found if it had run.
It finally ran today, against both a scratch server and the real deployed one, and the numbers it had been asserting were already stale: 24 mutating routes now exist across 21 files, not the 13 the README had claimed since before eleven of them existed. All 24 refused the anonymous request. More usefully, the test proved it could actually catch something: in a throwaway copy of the code, deleting the one line that returns a guard's rejection (leaving the guard called but its result thrown away) was invisible to the older test, which only reads source text and sees the guard() call sitting there. The new one sent a real request and watched the deleted route answer with the wrong thing. That's the difference between a check that reads the code and one that uses it.
Underneath both of those, the rest of the day was the usual sprawl for a project this size: groups got an owner-only delete that hides rather than destroys twenty other people's competition history, a manager role that can run a group but not depose its owners, a switcher for which group you're currently in, and a sign-in button that had been rendering white text on a white background since a CSS reset landed that same morning, invisible on the one page meant for strangers.
Reckreation is my tournament tracking app, and today its bracket page learned to make a prediction instead of just showing what already happened. It plays out the rest of a tournament ten thousand times with random results, using the exact same logic that decides real matches, and turns that into odds: who's likely to win it all, where each player is likely to finish, what path they'd probably take to get there. Because it reuses the real match logic rather than a simplified copy, a prediction can't come from a bracket that was routed wrong.
The other big thing today was a security test that had been quietly useless for three days. It was supposed to send a fake, logged-out visitor's request at every part of the app that changes data, and confirm each one refuses it. The code got written, but the last step (actually running it) never happened, so it sat there skipping every time without telling anyone. Nobody caught it because the numbers it reported still looked plausible.
Someone finally ran it today, against both a test copy of the app and the real live one. The app now has 24 places that can change data, not the 13 a document had been claiming for days, because 11 new ones had been added since anyone last checked. All 24 correctly turned away the fake logged-out visitor. To prove the test wasn't just for show, a bug was planted in a throwaway copy (a security check that runs but whose result gets silently thrown away), and the new test caught it immediately, where the old, weaker check had missed it.
Smaller things landed too: a group's owner can now delete it in a way that hides it rather than erasing everyone's match history, a new manager role that can run a group without removing its owners, and a sign-in button that turned out to have been invisible (white text on white) on the page meant for first-time visitors.