The lab

Godot’s tooling reports success in three ways that aren’t. Its type-check exits 0 even when it finds errors. A script it is told to run exits 0 when that script fails to parse. And a runtime error inside a test unwinds that one test function while the suite carries on and prints PASS. The last one surfaced the expensive way: a refactor renamed two methods, and the word-ladder suite skipped six assertions and still reported green.

So I designed a gate with three conditions. The type-check must pass before any suite runs. Each suite must print its own closing verdict line, because a crash halfway through also exits 0, with a plausible transcript. And no SCRIPT ERROR may appear anywhere in the output.

Before the runner trusts those gates, it tests them. A suite that doesn’t exist must come back red. The verdict check must reject a transcript with no verdict line, and the error check must recognise a real runtime-error line while letting a clean transcript that ends in PASS through. The 3D prototype and the platformer further down this page use the same runner.

A puzzle with two answers, or none, is a defect the player finds before you do. So the suite tests the shipped content, not only the code that plays it:

• Every alphametic (SEND + MORE = MONEY) is solved from scratch and must have exactly one answer. That answer is checked against the arithmetic, not against the solver that found it, and no answer is stored anywhere.
• The word ladder stores no solution at all. A breadth-first solver over the word list decides how many rungs a ladder has, any equally short route the player finds is accepted, and the solver is checked against route lengths from a separate implementation.
• Every word-search grid must contain each word exactly once, counting accidental spellings by the random filler, and every generated grid is checked before it can be played.
• Every Cryptogories theme must score as solvable rather than guessable, and every visual theme must pass a contrast gate.

Each gate carries a control case it must reject. The alphametic gate’s is TWO + TWO = FOUR, a real sum with more than one answer.

Then come the things measurement can’t see. A screenshot tool renders every page on a phone in portrait, three of them with the phone on its side, and one page across fourteen themes. Its first runs found layout defects that had passed every measurement (the 0.6.1 changelog lists four), among them a digit keypad of eleven keys laid out as a row of ten and a row of one.

CartoFancy checks the next new FreeCell deal in the background, and throws it away only if a full search proves it unwinnable. During play, a second background search runs after every move. When it proves that no line can win from the current position, the game says so and asks whether to play on. That is only honest if the solver’s “exhausted” really means lost, and never that one of its shortcuts pruned the win away.

The shortcuts are real. The search is best-first and capped by a node budget. It considers only canonical moves, and it folds boards that differ only in which free cell or column holds what, so each is searched once. It is also deterministic, with no clock and no randomness, so any time limit has to be expressed as a node budget.

So I made its verdict answer to a search with no shortcuts at all. On 240 small random boards, with and without moving cards back off the foundations, every verdict must match a plain exhaustive search, and every winning line must replay to a win. The test also fails unless both wins and losses actually occur in the sample. Hints, the lost-position check and the next-deal check each run the solver in a Web Worker of its own, so a long search never blocks a move.

The card engine is worth having because of one split: rules that know nothing about drawing, and a renderer that knows no rules. That split breaks the first time a rules file reaches for the DOM or a clock, so I made it a test rather than a convention.

The architecture suite reads every source file through the TypeScript scanner. Comments are skipped, and unicode escapes are resolved so a banned name can’t be respelled. It enforces import rules for each layer and bans the DOM, timers, clocks, Intl and Math.random from pure files. It keeps PixiJS inside the impure render files, allows colour literals in no pure file except the one colour registry, and compiles every pure file under a configuration with no DOM types. Every rule has a planted violation it must reject.

Beside it, a fuzz suite plays 100 seeded games of up to 300 random legal moves through the real session, with every state deep-frozen, so an in-place mutation throws instead of quietly corrupting the undo history. It then undoes each game to the exact deal and redoes it to the exact end.

Two review passes over the code turned up defects: nineteen in the headless core, then fourteen in the first version, by the commits’ own counts. Every fix landed with a regression test, and in the first pass each test was shown to fail against the unfixed code.

The lines aren’t drawn by hand. An edge extractor reads each mesh’s triangles and keeps only the creases, where two faces meet at more than a set angle, plus any open borders. It matches vertices by position rather than by index, because Godot’s primitive meshes duplicate a vertex wherever the normal changes, which would make every crease look like a border. Each object’s fill is one shader with two states, a translucent ghost and an opaque lit surface, so materializing is a tween on a single number rather than a material swap.

The extractor’s own tests pin that geometry. Walking, climbing, the grapple, slow-time focus and materializing are tested headlessly too, through the same fail-closed runner as Pocket Puzzles.

A body is data: a head and torso with sizes and shapes, arms and legs with lengths and widths, colours, and a few extras such as a hood, a scarf or a cape. The rig turns any body into every pose a platformer needs (idle, walk, run, skid, jump, fall, land and crouch), so a new body gets all eight animations at once. Feet are planted: each ground pose sets the hip so the lowest foot touches the floor, which is what makes a walk bounce and a crouch sink without a number for either. Because a pose is just numbers, a test can walk every body through every state without a renderer.

The character was chosen on a workshop bench, not in an image editor. The bench lines up the candidate bodies, animated by the game’s own rig on the game’s own ground and sky, pages through them, and isolates any one, enlarged, beneath a row of all its states. Its tests check that every candidate poses in every state with finite numbers, that each has its own name, and that the bench shows what it claims to.