510ba85
@@ -5,9 +5,9 @@
Counter-Strike-shaped defusal shooter, five against five on one map — bomb
rounds, a buy menu and an economy, bots that walk to a site and shoot back —
and the leaderboard of the matches people played. The second, at `/range`, is
built only out of the engine the shooter was taken apart into: a shooting
**range** — pop-up targets from a seeded spawn, a shot traced through the
engine's boxes, a thirty second clock and a score, with the fixed step and the
controls under it — and it is **drawn by the engine's renderer**: its own room,
**range** — two drills of seeded targets, plates that pop up and plates that
slide across the lane, a shot traced through the engine's boxes, a thirty
second clock and a score, with the fixed step and the controls under it — and it is **drawn by the engine's renderer**: its own room,
its own plates and its own tracer, out of an atlas and two meshes it painted
and built itself. The third, at `/example`, is the **example**: the guide's own
game — one room seen from above, one plate, thirty seconds and a score, drawn
@@ -101,9 +101,16 @@
the rest.
At `/range` the same controls drive the second game, on its own bindings:
<kbd>WASD</kbd> move, <kbd>Space</kbd> jump, <kbd>Ctrl</kbd> crouch,
<kbd>Shift</kbd> walk, <kbd>F</kbd> or the mouse fires, <kbd>R</kbd> reload,
<kbd>Enter</kbd> starts a thirty second run. Plates pop up down the lane, each
worth 100 to 200 points by how far away it stood; the panel keeps the score, the
clock and the accuracy, and the best of the visit. The room, the plates and the
<kbd>Enter</kbd> starts a thirty second run and <kbd>T</kbd> chooses the drill
between runs. There are two. **Pop-up** is the one the range shipped with: three
plates at a time, standing still down the lane, each worth 100 to 200 points by
how far away it stood. **Tracking** is the second: two at a time, nearer and
longer-lived, each sliding across the lane at 90 to 260 units a second until its
lifetime or its lane runs out, worth 100 to 160 for the distance plus a third of
a point for every unit a second it is crossing at — so you lead it, and the fast
one pays most. Switching mid-run does nothing rather than corrupting the run, and
the panel keeps the score, the clock, the accuracy and a best *per drill*,
because a tracking score means nothing beside a pop-up one. The room, the plates and the
tracer are drawn by the engine's renderer and the range makes its own noise
through the engine's sound device — a dry crack, a tone for a hit, a knock as a
plate stands up, a tick for each of the last three seconds and one falling tone
@@ -304,8 +311,9 @@
renderer, no atlas, no mesh and no sound ship in that bundle, and
  and its own siblings, and nothing else. **It is a game with no renderer under
  it**: `binding.ts` is its own key table (50 Hz, its own actions — no buy,
  no scoreboard, no weapon slots) and the one function from held actions to an
  intent; `targets.ts` is the game itself — a seeded `rng` pops plates up as
  `Box`es down a lane, `step` runs their lifetimes and the run's clock, and
  intent; `targets.ts` is the game itself — a seeded `rng` stands plates up as
  `Box`es down a lane, `step` slides them by their own velocity and runs their
  lifetimes and the run's clock, retiring what has expired or left the lane, and
  `shoot` traces the engine's `rayBox` along the view and folds the hit, the
  score and the accuracy in, all plain data in and plain data out with no canvas
  anywhere near it; `readout.ts` draws a horizon, the plates on it as blips
@@ -370,10 +378,13 @@
renderer, no atlas, no mesh and no sound ship in that bundle, and
  canvases, draws its ticks, answers a key and — given WebGL2 — uploads its
  atlas and draws the room — so a bundling mistake fails
  `bun test` rather than the preview. The range's rules are pinned the way the
  shooter's round is: `pin.ts` plays one seeded thirty-second run through one
  fixed script of shots and hashes every tick, against the digest committed in
  `pin.test.ts` — so a renderer, an atlas or a movement tuning that changes the
  game says so, naming the second of the run where it changed. `src/pages/range.ts` is its page: its own title, prose and overlay
  shooter's round is: `pin.ts` plays one seeded thirty-second run per drill
  through one fixed script of shots each and hashes every tick, against the two
  digests committed in `pin.test.ts` — so a renderer, an atlas or a movement
  tuning that changes the game says so, naming the drill and the second of the
  run where it changed. A drill is data: one table in `targets.ts` holds the
  spawn rate, the lifetime, the speed range and the scoring of each, `createRun`
  takes which one, and a third drill is one more entry in it. `src/pages/range.ts` is its page: its own title, prose and overlay
  through the same shell, with no database, no endpoint and no cookie behind it.
- `src/example/` — the third game, at `/example`, and the wiring of one and
  nothing else: `main.ts` finds the canvas, hands the engine's controls the
@@ -87,6 +87,15 @@
export type Game = {
 * the app's bundle and in neither line of the range's. Measured 2026-09-18 after
 * #106: app 71,646 raw / 33,273 gzipped, range 27,268 raw / 11,674 gzipped.
 * Both fit, so neither ceiling moved.
 * #88 gave the range a second drill — plates that slide across the lane, chosen
 * before a run — and the range grew 1,545 raw / 572 gzipped bytes for it: a
 * velocity on every plate, a second entry in the drill table, the retirement of
 * a plate that has left the lane, and the drill's name and its per-drill best on
 * the panel. Measured 2026-09-20 after #88: range 28,813 raw / 12,246 gzipped,
 * which fits today's 29,400 / 12,700 with 587 raw and 454 gzipped bytes to
 * spare, so the ceiling did not move — but that is the thinnest headroom on this
 * page, and the next thing the range gains will want it raised. Neither other
 * bundle moved a byte: nothing outside `src/range/` changed.
 * #80 added a third entry, `example`, and its ceiling is the first number in
 * this file nobody had to argue about: the guide's game with a page around it
 * builds to 8,754 raw / 4,229 gzipped, so its ceiling is 9,700 / 4,700, today's
@@ -112,7 +121,7 @@
export const GAMES: readonly Game[] = [
    entry: "src/range/main.ts",
    ceiling: { raw: 29_400, gzip: 12_700 },
    blurb:
      "thirty seconds on the clock, pop-up plates down a lane, a shot traced in three dimensions and a score — every line of it out of the engine and none of it out of the shooter.",
      "thirty seconds on the clock and two drills down one lane — plates that pop up, and plates that slide across it — a shot traced in three dimensions and a score, every line of it out of the engine and none of it out of the shooter.",
  },
  {
    name: "example",
@@ -17,18 +17,22 @@
import { page, type PageOptions as ShellOptions, stage } from "./shell.ts";
export type PageOptions = Pick<ShellOptions, "env" | "pull" | "commit" | "script" | "ssh">;
const NOTE = `
      <h2>The range: thirty seconds on the clock</h2>
      <p>Capture the mouse, press <kbd>Enter</kbd>, and shoot the plates as they pop up: each one
        is a box in space, traced by the engine and drawn by it, and the panel keeps the score,
        the clock and your accuracy. You stand at the firing line and turn on the spot — there is
        no walking yet. On a browser with no WebGL2 the range falls back to the flat horizon it
        shipped with, plates as squares projected from the angle each subtends, and the same game
        plays on it.</p>
      <h2>The range: thirty seconds on the clock, two drills</h2>
      <p>Capture the mouse, press <kbd>Enter</kbd>, and shoot the plates: each one is a box in
        space, traced by the engine and drawn by it, and the panel keeps the score, the clock and
        your accuracy. There are two drills and <kbd>T</kbd> switches between them before a run —
        <strong>pop-up</strong>, where plates stand up down the lane and drop when their time is
        up, and <strong>tracking</strong>, where they stand up and slide across it at their own
        speed, worth more the faster they are going. You stand at the firing line and turn on the
        spot — there is no walking yet. On a browser with no WebGL2 the range falls back to the
        flat horizon it shipped with, plates as squares projected from the angle each subtends,
        and the same two drills play on it.</p>
      <div class="row"><button type="button" class="primary" id="look">Capture the mouse</button></div>
      <p class="hint"><kbd>WASD</kbd> move · <kbd>Space</kbd> jump · <kbd>Ctrl</kbd> crouch ·
        <kbd>Shift</kbd> walk · <kbd>F</kbd> or the mouse fires · <kbd>R</kbd> reload ·
        <kbd>Enter</kbd> start · <kbd>Esc</kbd> gives the mouse back. On a touch screen the left of
        the view is a stick, the right looks around, and the buttons do the rest.</p>
        <kbd>Enter</kbd> start · <kbd>T</kbd> the other drill · <kbd>Esc</kbd> gives the mouse
        back. On a touch screen the left of the view is a stick, the right looks around, and the
        buttons do the rest.</p>
      <p class="hint">It makes its own noise, through the engine's sound device and the range's own
        recipes: a short dry crack, a clean tone for a hit, a knock as a plate stands up — quieter
        the farther down the lane it is — a tick for each of the last three seconds and one falling
@@ -54,7 +58,7 @@
export function rangePage(options: PageOptions): string {
          { action: "walk", label: "walk" },
        ],
        [
          { action: "reload", label: "reload" },
          { action: "drill", label: "drill" },
          { action: "start", label: "start" },
          { action: "fire", label: "fire" },
        ],
@@ -72,12 +76,26 @@
export function rangePage(options: PageOptions): string {
      actions are held, what movement they and the thumb stick add up to, and where you are
      looking.</p>
    <p>There is a game on top of that, and the engine's renderer under it. Press <kbd>Enter</kbd> and
      thirty seconds start: plates pop up down the lane from a seeded spawn, each with its own
      lifetime and worth 100 to 200 points depending on how far away it stood, and a click traces
      a ray from your eye along your own view angles with the engine's own box trace — so a hit
      is a hit in three dimensions, not a hit on a picture. The clock ends the run, stops the
      trigger and reports the score, the hits, the shots and the accuracy; <kbd>Enter</kbd>
      starts the next one, and the best of this visit is kept on the page and nowhere else.</p>
      thirty seconds start: plates stand up down the lane from a seeded spawn, each with its own
      lifetime, and a click traces a ray from your eye along your own view angles with the
      engine's own box trace — so a hit is a hit in three dimensions, not a hit on a picture. The
      clock ends the run, stops the trigger and reports the score, the hits, the shots and the
      accuracy; <kbd>Enter</kbd> starts the next one, and the best of this visit is kept on the
      page and nowhere else.</p>
    <p>Two drills share that lane, and <kbd>T</kbd> chooses between them before a run — mid-run
      the key does nothing rather than splicing two games into one score. <strong>Pop-up</strong>
      is the drill this range shipped with, unchanged in every number: three plates at a time,
      standing still, worth 100 to 200 points by how far down the lane they stood.
      <strong>Tracking</strong> is the second: two at a time, nearer and longer-lived, each
      sliding across the lane at 90 to 260 units a second until its time or its lane runs out,
      and worth 100 to 160 for the distance plus a third of a point for every unit a second it is
      crossing at — so the fast one is the one to take first, and you have to lead it. The best
      score is kept per drill, because a tracking score means nothing beside a pop-up one. A
      drill is one entry in a table in <code>src/range/targets.ts</code> — spawn rate, lifetime,
      speed range, scoring — and nothing under this page branches on which one is being played: a
      third drill is one more row. Each has a digest of its own in
      <code>src/range/pin.test.ts</code>, a seeded run played through a fixed script and hashed
      tick by tick, so a tuning of one says which one it changed.</p>
    <p>You can see it now, and by the same renderer the shooter uses: the room is one mesh built
      from this game's own numbers, every plate is one instance of one cube sized to its own box,
      the shot leaves a tracer for eighty milliseconds, and the atlas they are painted from is
@@ -18,11 +18,13 @@
test("the range's bindings are its own, not the shooter's", () => {
  expect(RANGE_KEYS.ShiftLeft).toBe("walk");
  expect(RANGE_KEYS.KeyR).toBe("reload");
  expect(RANGE_KEYS.Enter).toBe("start");
  // One key for the one choice this game offers: which drill the next run is.
  expect(RANGE_KEYS.KeyT).toBe("drill");
  // A keyboard reaches the trigger too: pointer lock is not the only way in.
  expect(RANGE_KEYS.KeyF).toBe("fire");
  expect(RANGE_MOUSE[0]).toBe("fire");
  expect(RANGE_MOUSE[2]).toBeUndefined();
  expect([...RANGE_TAP]).toEqual(["jump", "reload", "start"]);
  expect([...RANGE_TAP]).toEqual(["jump", "reload", "start", "drill"]);
  // Nothing cs-shaped: no buy, no scoreboard, no weapon slots.
  for (const code of ["KeyB", "Tab", "Digit1", "Digit2", "Digit3"])
    expect(RANGE_KEYS[code]).toBeUndefined();
@@ -52,13 +54,14 @@
test("the stick adds to the keys and the sum clamps to ±1", () => {
});
test("every held action lands on its field", () => {
  const held = intent(["jump", "duck", "walk", "fire", "reload", "start"]);
  const held = intent(["jump", "duck", "walk", "fire", "reload", "start", "drill"]);
  expect(held.jump).toBe(true);
  expect(held.duck).toBe(true);
  expect(held.walk).toBe(true);
  expect(held.fire).toBe(true);
  expect(held.reload).toBe(true);
  expect(held.start).toBe(true);
  expect(held.drill).toBe(true);
});
test("an action the range does not know changes nothing", () => {
@@ -15,14 +15,14 @@
export const RANGE_KEYS: Record<string, string> = {
  KeyW: "forward", KeyS: "back", KeyA: "left", KeyD: "right",
  ArrowUp: "forward", ArrowDown: "back", ArrowLeft: "left", ArrowRight: "right",
  Space: "jump", ControlLeft: "duck", KeyC: "duck", ShiftLeft: "walk",
  KeyF: "fire", KeyR: "reload", Enter: "start",
  KeyF: "fire", KeyR: "reload", Enter: "start", KeyT: "drill",
};
/** One weapon, one button: the left one. There is nothing to scope here. */
export const RANGE_MOUSE: Record<number, string> = { 0: "fire" };
/** On-screen buttons that are a tap, not a hold. */
export const RANGE_TAP = ["jump", "reload", "start"] as const;
export const RANGE_TAP = ["jump", "reload", "start", "drill"] as const;
/**
 * Every action the range knows, in the order the readout prints them. An
@@ -30,7 +30,7 @@
export const RANGE_TAP = ["jump", "reload", "start"] as const;
 * `data-action` — is collected by the controls and ignored here.
 */
export const RANGE_ACTIONS = [
  "forward", "back", "left", "right", "jump", "duck", "walk", "fire", "reload", "start",
  "forward", "back", "left", "right", "jump", "duck", "walk", "fire", "reload", "start", "drill",
] as const;
export type RangeAction = (typeof RANGE_ACTIONS)[number];
@@ -51,11 +51,18 @@
export type Intent = {
  reload: boolean;
  /** Begin a run — the button and <kbd>Enter</kbd> both say it. */
  start: boolean;
  /**
   * Switch to the next drill — <kbd>T</kbd> and the button say it. What it
   * means is the game's: `targets.ts` refuses it mid-run, and this file only
   * reports that it was asked for.
   */
  drill: boolean;
};
/** Nothing held, nothing pushed. */
export const NO_INTENT: Intent = {
  forward: 0, side: 0, jump: false, duck: false, walk: false, fire: false, reload: false, start: false,
  forward: 0, side: 0, jump: false, duck: false, walk: false, fire: false, reload: false,
  start: false, drill: false,
};
export function readIntent(held: ReadonlySet<string>, stick: { x: number; y: number }): Intent {
@@ -69,6 +76,7 @@
export function readIntent(held: ReadonlySet<string>, stick: { x: number; y: num
    fire: down("fire"),
    reload: down("reload"),
    start: down("start"),
    drill: down("drill"),
  };
}
@@ -172,8 +172,8 @@
test("Enter starts a run, the clock runs and the plates pop up", () => {
  const { p, undo } = booted();
  try {
    p.step(20);
    expect(hudTexts(p)).toContain("press Enter for a 30 second run");
    expect(hudTexts(p)).toContain("score 0 · best 0 · 0/0 hits · 0%");
    expect(hudTexts(p)).toContain("press Enter for a 30 second run · T for tracking");
    expect(hudTexts(p)).toContain("pop-up · score 0 · best 0 · 0/0 hits · 0%");
    p.window.fire("keydown", { code: "Enter" });
    p.step(20); // one 50 Hz tick: 0.02 s off the clock, and the first plate up
@@ -218,19 +218,19 @@
test("a mouse plays it: turn onto a plate, click, and the score moves", () => {
    // first: the bullet goes where the crosshair ended up.
    p.window.fire("keydown", { code: "KeyF" });
    p.step(20);
    const score = latest(p, "score");
    expect(score).toMatch(/^score \d+ · best 0 · 1\/1 hits · 100%$/);
    expect(Number(/^score (\d+)/.exec(score)?.[1])).toBeGreaterThanOrEqual(100);
    const score = latest(p, "pop-up");
    expect(score).toMatch(/^pop-up · score \d+ · best 0 · 1\/1 hits · 100%$/);
    expect(Number(/score (\d+)/.exec(score)?.[1])).toBeGreaterThanOrEqual(100);
    // The trigger held down is one shot, not one a frame.
    p.step(20);
    expect(latest(p, "score")).toContain("1/1 hits");
    expect(latest(p, "pop-up")).toContain("1/1 hits");
    // Letting go and pulling again is a second shot, and the plate is gone.
    p.window.fire("keyup", { code: "KeyF" });
    p.step(20);
    p.window.fire("keydown", { code: "KeyF" });
    p.step(20);
    expect(latest(p, "score")).toContain("1/2 hits · 50%");
    expect(latest(p, "pop-up")).toContain("1/2 hits · 50%");
  } finally {
    undo();
  }
@@ -246,24 +246,24 @@
test("the clock ends the run, the entry stops shooting and the best score stays"
    p.window.fire("keydown", { code: "KeyF" });
    p.step(20);
    p.window.fire("keyup", { code: "KeyF" });
    expect(latest(p, "score")).toContain("/1 hits");
    expect(latest(p, "pop-up")).toContain("/1 hits");
    // Thirty seconds, eight 50 Hz ticks to a frame: 188 frames of 160 ms.
    for (let i = 0; i < 190; i++) p.step(160);
    expect(latest(p, "run over")).toMatch(/^run over · \d+ points · Enter for another$/);
    expect(latest(p, "run over")).toMatch(/^run over · \d+ points · Enter for another · T for tracking$/);
    // The clock at zero refuses the trigger: still the one shot.
    p.window.fire("keydown", { code: "KeyF" });
    p.step(20);
    expect(latest(p, "score")).toContain("/1 hits");
    expect(latest(p, "pop-up")).toContain("/1 hits");
    // And the run that just ended is the best so far, however it went.
    const score = /^score (\d+) · best (\d+)/.exec(latest(p, "score"));
    const score = /score (\d+) · best (\d+)/.exec(latest(p, "pop-up"));
    expect(score?.[2]).toBe(score?.[1] as string);
    // Enter gives a fresh thirty seconds, and the best survives it.
    p.window.fire("keydown", { code: "Enter" });
    p.step(20);
    expect(latest(p, "score")).toMatch(/^score 0 · best \d+ · 0\/0 hits · 0%$/);
    expect(latest(p, "pop-up")).toMatch(/^pop-up · score 0 · best \d+ · 0\/0 hits · 0%$/);
    expect(hudTexts(p)).toContain("30.0 s left · 1 up");
  } finally {
    undo();
@@ -422,7 +422,7 @@
test("a run makes its own noise: one device, a plate popping up, a crack and a h
    played = sounds(p).length;
    p.window.fire("keydown", { code: "KeyF" });
    p.step(20);
    expect(latest(p, "score")).toContain("1/1 hits");
    expect(latest(p, "pop-up")).toContain("1/1 hits");
    expect(sincePlayed(p, played).filter((sound) => sound !== "pop")).toEqual(["crack", "hit"]);
    // The trigger held down is one shot, so it is one crack and not one a frame.
@@ -456,7 +456,7 @@
test("a miss cracks and nothing more, and a trigger outside a run is silent", ()
    p.window.fire("keydown", { code: "KeyF" });
    p.step(20);
    p.window.fire("keyup", { code: "KeyF" });
    expect(latest(p, "score")).toContain("0/1 hits");
    expect(latest(p, "pop-up")).toContain("0/1 hits");
    expect(sincePlayed(p, played).filter((sound) => sound !== "pop")).toEqual(["crack"]);
    // Run the clock out, then pull the trigger: the run refuses the shot, so
@@ -528,3 +528,74 @@
test("a browser with no WebGL2 keeps the game on the 2D horizon, and says so", (
    undo();
  }
});
test("T chooses the drill between runs, and does nothing during one", () => {
  const { p, undo } = booted();
  try {
    p.step(20);
    expect(latest(p, "pop-up")).toContain("score 0");
    // One press is one switch, held down or not.
    p.window.fire("keydown", { code: "KeyT" });
    p.step(20);
    p.step(20);
    expect(latest(p, "tracking")).toContain("score 0 · best 0");
    expect(hudTexts(p)).toContain("press Enter for a 30 second run · T for pop-up");
    p.window.fire("keyup", { code: "KeyT" });
    // Mid-run it is refused: the drill, the clock and the plates carry on.
    p.window.fire("keydown", { code: "Enter" });
    p.step(20);
    p.window.fire("keyup", { code: "Enter" });
    p.step(200);
    const during = latest(p, "tracking");
    p.window.fire("keydown", { code: "KeyT" });
    p.step(20);
    expect(latest(p, "tracking")).toStartWith("tracking · ");
    expect(during).toStartWith("tracking · ");
    expect(hudTexts(p).some((line) => /^29\.\d s left · \d+ up$/.test(line))).toBe(true);
    p.window.fire("keyup", { code: "KeyT" });
    p.step(20);
    // And the plates of that drill move: the one standing is drawn in two
    // places two frames apart, which a pop-up plate never is.
    const where = (): number => {
      const before = p.scene.paint?.calls.length ?? 0;
      p.step(20);
      return (platesDrawn(p, before)[0] as [string, number, ...unknown[]])[1];
    };
    expect(where()).not.toBe(where());
  } finally {
    undo();
  }
});
test("a best score belongs to its drill and is never shown beside the other", () => {
  const { p, undo } = booted();
  try {
    // A pop-up run, played to the end: whatever it scored is the pop-up best.
    p.window.fire("keydown", { code: "Enter" });
    p.step(20);
    p.window.fire("keyup", { code: "Enter" });
    p.window.fire("keydown", { code: "KeyF" });
    p.step(20);
    p.window.fire("keyup", { code: "KeyF" });
    for (let i = 0; i < 190; i++) p.step(160);
    const popup = /score (\d+) · best (\d+)/.exec(latest(p, "pop-up")) as RegExpExecArray;
    expect(popup[2]).toBe(popup[1] as string);
    // Switching drills shows that drill's own best, which is nothing yet.
    p.window.fire("keydown", { code: "KeyT" });
    p.step(20);
    p.window.fire("keyup", { code: "KeyT" });
    expect(latest(p, "tracking")).toBe("tracking · score 0 · best 0 · 0/0 hits · 0%");
    // And switching back finds the pop-up best where it was left. The key has
    // to come up first: one press is one switch, and this is the second press.
    p.step(20);
    p.window.fire("keydown", { code: "KeyT" });
    p.step(20);
    p.window.fire("keyup", { code: "KeyT" });
    expect(latest(p, "pop-up")).toBe(`pop-up · score 0 · best ${popup[2]} · 0/0 hits · 0%`);
  } finally {
    undo();
  }
});
@@ -7,6 +7,13 @@
 * the readout's panel on the HUD canvas above it, and `audio.ts` is what the
 * same frame sounds like through the engine's sound device.
 *
 * There are two drills and the choice between them is one key: <kbd>T</kbd>, or
 * the button beside it, asks `targets.ts` for the next one in its table. The
 * game itself decides whether that is allowed — a live run refuses — and this
 * file only passes the press on and prints which drill is being played and what
 * the key would switch to. The best score is kept per drill, here and nowhere
 * else: nothing on this page is stored.
 *
 * Every sound is a crossing this file found in the game's own facts: a plate
 * with an id the last frame had not reached stood up, the shot `shoot` handed
 * back was taken and maybe hit, the clock passed one of the last three whole
@@ -27,7 +34,10 @@
import { createRangeAudio } from "./audio.ts";
import { RANGE_KEYS, RANGE_MOUSE, RANGE_TAP, heldActions, readIntent } from "./binding.ts";
import { drawHorizon, drawReadout, wrapDegrees, type Paint } from "./readout.ts";
import { buildRangeScene, createRangeScene, rangeAssets, type Trail } from "./scene.ts";
import { EYE, createRun, report, shoot, start, step, type Target } from "./targets.ts";
import {
  DRILLS, EYE, createRun, nextDrill, report, setDrill, shoot, start, step,
  type DrillName, type Target,
} from "./targets.ts";
import {
  angleVectors, attachButtons, clamp, createControls, createLoop, createRenderer,
} from "../engine/index.ts";
@@ -113,15 +123,22 @@
export function boot(): void {
  // two runs are two different thirty seconds, and a run is still reproducible
  // from the one number it was spawned with.
  const run = createRun(freshSeed());
  let best = 0;
  // Both of these are edges, not holds: a held trigger is one shot, and a held
  // Enter is one run. The mouse says "fire" for as long as the button is down.
  /**
   * The best of this visit, per drill: a tracking score next to a pop-up best
   * would be two games in one number. Nothing is stored anywhere — this page
   * keeps no cookie and writes no table — so both start at zero.
   */
  const bests: Record<DrillName, number> = { popup: 0, tracking: 0 };
  // All three of these are edges, not holds: a held trigger is one shot, a held
  // Enter is one run and a held T is one switch. The mouse says "fire" for as
  // long as the button is down.
  let firing = false;
  let starting = false;
  let switching = false;
  /** Remember the score of a run that is finishing, whatever finished it. */
  const keepBest = (): void => {
    best = Math.max(best, run.score);
    bests[run.drill.name] = Math.max(bests[run.drill.name], run.score);
  };
  // The mouse only turns the view under pointer lock; a finger on the stage
@@ -168,6 +185,13 @@
export function boot(): void {
    // the trigger and Enter half of it is the game.
    const intent = readIntent(controls.held, controls.stick);
    // The drill is chosen between runs: `setDrill` refuses a live one, so a T
    // pressed mid-run changes nothing at all rather than half a game.
    // A finished run has already had its score kept, and one that has not
    // started has none, so there is nothing to remember here.
    if (intent.drill && !switching) setDrill(run, DRILLS[nextDrill(run.drill.name)]);
    switching = intent.drill;
    if (intent.start && !starting) {
      keepBest();
      start(run, freshSeed());
@@ -233,7 +257,8 @@
export function boot(): void {
      hudCtx,
      {
        run: report(run),
        best,
        best: bests[run.drill.name],
        next: DRILLS[nextDrill(run.drill.name)].label,
        hz: Math.round(1 / TICK),
        ticks,
        frameMs,
@@ -1,13 +1,19 @@
/**
 * The range's golden digest: what this game does, pinned.
 * The range's golden digests: what each drill does, pinned.
 *
 * One run — thirty seconds at 50 Hz from seed 20260917, played through the
 * fixed script in `pin.ts` — hashed tick by tick. If it fails, read the
 * message: it names the first second of the run at which the play and the pin
 * part company and prints the constants to paste in. Paste them only when the
 * change to the game was deliberate, and say in the pull what moved and why.
 * A renderer, an atlas or a movement tuning that moves this digest has changed
 * the game and is not any of those three things.
 * Two runs — thirty seconds at 50 Hz from seed 20260917, one per drill, each
 * played through its script in `pin.ts` — hashed tick by tick. If one fails,
 * read the message: it names the drill, the first second of the run at which
 * the play and the pin part company, and prints the constants to paste in.
 * Paste them only when the change to the game was deliberate, and say in the
 * pull what moved and why. A renderer, an atlas or a movement tuning that moves
 * a digest has changed the game and is not any of those three things.
 *
 * Two digests because a drill is a different game: tuning the tracking drill
 * moves `TRACKING` and leaves `RANGE` where it is, so the pull that does it
 * says which game it changed. `RANGE` has not moved since it was first written
 * down, and that is this pull's own claim checked: a second drill that costs
 * the first one a byte is not a second drill, it is a retuning of the first.
 *
 * Measured: the pinned thirty seconds fold in 8 ms (14 ms cold), and the whole
 * file is 60 ms on its own, Bun's start and all — `bun test` is 4.2 s before
@@ -18,9 +24,9 @@
import { expect, test } from "bun:test";
import {
  CHECKPOINT_CHARS, compare, fold, play, PLATE_FIELDS, QUANTUM, RUN_FIELDS, SCRIPT, snapshot,
  TICK, TICKS_PER_SECOND, trigger, type Pin, type Pinned,
  TICK, TICKS_PER_SECOND, TRACKING_SCRIPT, trigger, type Pin, type Pinned,
} from "./pin.ts";
import { accuracy, createRun, EYE, shoot, start, step, type Run } from "./targets.ts";
import { accuracy, createRun, DRILLS, EYE, shoot, start, step, type Run } from "./targets.ts";
import { angleVectors } from "../engine/index.ts";
/** The run: a named seed, thirty seconds of it, at the range's own 50 Hz. */
@@ -46,7 +52,31 @@
const RANGE_SECONDS = [
];
const RANGE_PIN: Pin = {
  label: "thirty-second range run", constant: "RANGE", digest: RANGE, checkpoints: RANGE_SECONDS,
  label: "thirty-second pop-up run", constant: "RANGE", digest: RANGE, checkpoints: RANGE_SECONDS,
};
/**
 * Thirty seconds of the tracking drill on the same seed, played through
 * `TRACKING_SCRIPT`: seventeen trigger pulls on the same seventeen ticks as the
 * pop-up run's, aimed at this drill's own lane. Computed when #88 added the
 * drill, and moved by any change to how a plate slides, how fast it may go, how
 * long it lives or what its speed is worth.
 */
const TRACKING = "8462440f5c6fb9aa3ef1f345243351003b0042f17dbf9f1c42fdd7525173ff59";
const TRACKING_SECONDS = [
  "e5e0793137c0", "3e49fb9e82aa", "4396dfb53c12", "913963a811b6",
  "8fbce1a4635b", "c30f7e1d537f", "28ca6bc5d103", "190d91d28b22",
  "63c8d3c43631", "5d94ccd33204", "549a60fa98bd", "d9acc4c3879d",
  "197ad3519f9c", "5fe779484245", "5260c155c8e0", "dd67cade9b06",
  "ae28ec143c97", "f8e1607029fc", "5a01e5ec8ad8", "e0e3b6678692",
  "b52b87f23250", "dfdb918f998b", "8e4815615b48", "92ad91b2e9ac",
  "0125b182c493", "ccdba1fef546", "ffa32e68868b", "74ecc60ced90",
  "a490df99d433", "ded614fadd7b",
];
const TRACKING_PIN: Pin = {
  label: "thirty-second tracking run", constant: "TRACKING", digest: TRACKING,
  checkpoints: TRACKING_SECONDS,
};
/** A run that has not been played yet, seeded and live. */
@@ -56,6 +86,13 @@
function ready(seed: number = SEED): Run {
  return run;
}
/** The same, on the tracking drill. */
function tracking(seed: number = SEED): Run {
  const run = createRun(seed, DRILLS.tracking);
  start(run, seed);
  return run;
}
const must = (run: Pinned, pin: Pin): void => {
  const complaint = compare(run, pin);
  if (complaint !== null) throw new Error(complaint);
@@ -93,6 +130,46 @@
test("the pinned run is a real one: a score, fourteen hits and three misses", ()
  expect(SCRIPT.every((aim) => aim.tick >= 0 && aim.tick < TICKS)).toBe(true);
});
test("a seeded thirty-second tracking run plays exactly as it played", () => {
  const run = tracking();
  const pinned = play(run, TICKS, TRACKING_SCRIPT);
  must(pinned, TRACKING_PIN);
  expect(pinned.digest).toBe(TRACKING);
  expect(pinned.checkpoints).toEqual(TRACKING_SECONDS);
});
/**
 * The tracking run in numbers, beside the pop-up one: the same seventeen shots
 * land fourteen again, but on plates that were sliding — so the score is made
 * of depth and speed together, and the 2,534 points are 309 more than the same
 * count of hits paid on the standing drill.
 */
test("the pinned tracking run is a real one: moving plates, hit where they were", () => {
  const run = tracking();
  play(run, TICKS, TRACKING_SCRIPT);
  expect(run.phase).toBe("over");
  expect(run.shots).toBe(17);
  expect(run.hits).toBe(14);
  expect(run.score).toBe(2534);
  expect(run.spawned).toBe(33);
  expect(TRACKING_SCRIPT.map((aim) => aim.tick)).toEqual(SCRIPT.map((aim) => aim.tick));
});
/**
 * The two digests are two games. Same seed, same seventeen ticks, and not one
 * second of the thirty hashes the same — the drill's salt gives it its own lane
 * rather than the pop-up lane with speeds bolted on.
 */
test("the two drills never share a run: not a digest, not a second, not a plate", () => {
  expect(TRACKING).not.toBe(RANGE);
  for (let i = 0; i < SECONDS; i++) expect(TRACKING_SECONDS[i]).not.toBe(RANGE_SECONDS[i]);
  // Even unshot and unscripted, the lanes differ from the first plate on.
  const bare = (run: Run): Pinned => fold(run, 4 * TICKS_PER_SECOND, () => step(run, TICK));
  expect(bare(tracking()).digest).not.toBe(bare(ready()).digest);
  // And each is its own repeatable run: the same seed and drill, twice.
  expect(bare(tracking()).digest).toBe(bare(tracking()).digest);
});
test("the same seed is the same run, and another seed is another run", () => {
  const four = 4 * TICKS_PER_SECOND;
  const a = play(ready(), four);
@@ -1,5 +1,6 @@
/**
 * The range's pin: one seeded run, one fixed script of shots, one sha256.
 * The range's pin: one seeded run per drill, one fixed script of shots each,
 * one sha256 each.
 *
 * A renderer, an atlas and a movement tuning are all about to land under this
 * game, and every one of them will end with the claim "the range plays exactly
@@ -20,6 +21,15 @@
 * a sentence saying what behaviour changed and why. A digest updated without
 * that sentence is a pin that has stopped pinning anything.
 *
 * **One digest per drill.** A drill is a different game, so it gets a number of
 * its own: a tuning of the tracking drill moves the tracking digest and leaves
 * the pop-up one alone, and the failure says which. Neither field list below
 * changed when the second drill landed, which is how the first digest survived
 * it — a plate's velocity is not hashed because it does not need to be. A plate
 * that moves is at another place on the next tick, and the place is hashed on
 * every one of them: 1,500 positions pin a speed far more tightly than one
 * number would, and a plate that started sliding the wrong way shows on tick 1.
 *
 * What is hashed is the run's rules playing out — the phase, the clock, the
 * score, the hits, the shots and every standing plate's place, size, lifetime
 * and worth. Not a plate's id and not the order of the lane: those are how
@@ -146,6 +156,41 @@
export const SCRIPT: Aim[] = [
  { tick: 1420, yaw: 11.77, pitch: 0.84 }, // hit, 172
];
/**
 * The same seventeen trigger pulls, on the same seventeen ticks, aimed at the
 * tracking drill's lane: fourteen at the plate with the longest left to stand
 * on that tick, two six degrees wide of one, and the same sixty degrees of sky.
 * The drill's own salt makes it a different lane, so the angles are its own and
 * not the pop-up script's — this is the same script, re-aimed, not a second
 * kind of script.
 *
 * Every hit here is a hit on a plate that was *moving*, at the place the tick
 * had just put it: these angles were read off the run after its step and before
 * its trigger, which is the order `play` below fires in and the order `main.ts`
 * does. Aimed one tick behind, at 260 units a second and 5.2 units of travel a
 * tick, a plate 18 units from centre to edge is still hit — but the digest
 * moves, and that is the point of pinning it.
 */
export const TRACKING_SCRIPT: Aim[] = [
  { tick: 40, yaw: -18.89, pitch: -6.3 }, // hit, 139 points at 101 u/s
  { tick: 130, yaw: -0.41, pitch: 1.42 }, // hit, 205 at 155 u/s
  { tick: 220, yaw: -33.62, pitch: -1.38 }, // hit, 217 at 221 u/s
  { tick: 300, yaw: -9, pitch: -2.8 }, // 6° wide of the plate at tick 300: a miss
  { tick: 320, yaw: -12.44, pitch: -2.84 }, // hit, 197 at 106 u/s
  { tick: 430, yaw: 15.88, pitch: 1.07 }, // hit, 158 at 120 u/s
  { tick: 540, yaw: 40.03, pitch: -2.47 }, // hit, 188 at 243 u/s
  { tick: 650, yaw: 40.44, pitch: -3.25 }, // hit, 186 at 229 u/s
  { tick: 700, yaw: 0, pitch: -60 }, // sky: a miss with nothing anywhere near it
  { tick: 760, yaw: 5.55, pitch: -3.48 }, // hit, 164 at 152 u/s
  { tick: 870, yaw: -24.21, pitch: -3.75 }, // hit, 200 at 157 u/s
  { tick: 980, yaw: -34.84, pitch: -4.78 }, // hit, 163 at 176 u/s
  { tick: 1000, yaw: 9.41, pitch: 2.06 }, // 6° wide again: a miss
  { tick: 1090, yaw: -33.33, pitch: 0.04 }, // hit, 155 at 154 u/s
  { tick: 1200, yaw: -16, pitch: -1.22 }, // hit, 170 at 166 u/s
  { tick: 1310, yaw: -15.84, pitch: -4.74 }, // hit, 163 at 105 u/s
  { tick: 1420, yaw: 6.58, pitch: -1.23 }, // hit, 229 at 241 u/s
];
/**
 * A cursor over the script: hand it a tick and it fires whatever that tick
 * holds, in order. A tick with no aim on it is a tick with the trigger off,
@@ -35,17 +35,20 @@
function recorder(): Paint & { calls: Call[]; texts: string[]; lines: Call[] } {
  } as Paint & { calls: Call[]; texts: string[]; lines: Call[] };
}
const RUN = { phase: "live" as const, clock: 12.34, score: 700, hits: 4, shots: 6, accuracy: 4 / 6, up: 3 };
const RUN = {
  drill: "popup" as const, label: "pop-up", phase: "live" as const,
  clock: 12.34, score: 700, hits: 4, shots: 6, accuracy: 4 / 6, up: 3,
};
const READOUT: Readout = {
  run: RUN, best: 1200,
  run: RUN, best: 1200, next: "tracking",
  hz: 50, ticks: 1234, frameMs: 16.66, held: ["forward", "fire"],
  move: { forward: 1, side: -0.5 }, yaw: 45, pitch: -10, locked: true, drawn: true,
};
test("the panel leads with the score and the clock, then the loop and the controls", () => {
  const lines = readoutLines(READOUT);
  expect(lines[0]).toBe("score 700 · best 1200 · 4/6 hits · 67%");
  expect(lines[0]).toBe("pop-up · score 700 · best 1200 · 4/6 hits · 67%");
  expect(lines[1]).toBe("12.3 s left · 3 up");
  expect(lines[2]).toBe("tick 1234 · 50 Hz fixed step");
  expect(lines[3]).toBe("frame 16.7 ms · 60 fps");
@@ -60,12 +63,12 @@
test("the panel leads with the score and the clock, then the loop and the contro
test("the clock line says how to start a run, how long is left, and how it went", () => {
  const ready = readoutLines({ ...READOUT, run: { ...RUN, phase: "ready", clock: 30, up: 0 } });
  expect(ready[1]).toBe("press Enter for a 30 second run");
  expect(ready[1]).toBe("press Enter for a 30 second run · T for tracking");
  const over = readoutLines({ ...READOUT, run: { ...RUN, phase: "over", clock: 0, up: 0 } });
  expect(over[1]).toBe("run over · 700 points · Enter for another");
  expect(over[1]).toBe("run over · 700 points · Enter for another · T for tracking");
  // No shots taken is no accuracy, not a NaN on the page.
  const fresh = readoutLines({ ...READOUT, run: { ...RUN, score: 0, hits: 0, shots: 0, accuracy: 0 }, best: 0 });
  expect(fresh[0]).toBe("score 0 · best 0 · 0/0 hits · 0%");
  expect(fresh[0]).toBe("pop-up · score 0 · best 0 · 0/0 hits · 0%");
});
test("nothing held says so, and an unlocked pointer says how to lock it", () => {
@@ -186,3 +189,21 @@
test("a run's own targets are what the scene draws, and they go when the run doe
  expect(paint.calls.filter((c) => c[0] === "fillRect").length).toBe(2 + run.targets.length);
  expect(readoutLines({ ...READOUT, run: report(run) })[1]).toContain(`${run.targets.length} up`);
});
test("the panel names the drill, and the score beside it is that drill's own", () => {
  const popup = readoutLines(READOUT);
  expect(popup[0]).toStartWith("pop-up · ");
  // The same numbers on the other drill read as the other drill's: the label
  // and the best move together, because a best belongs to one of them.
  const tracked = readoutLines({
    ...READOUT,
    run: { ...RUN, drill: "tracking", label: "tracking" },
    best: 90,
    next: "pop-up",
  });
  expect(tracked[0]).toBe("tracking · score 700 · best 90 · 4/6 hits · 67%");
  // Mid-run the switch is not offered, because mid-run it does nothing.
  expect(tracked[1]).toBe("12.3 s left · 3 up");
  expect(readoutLines({ ...READOUT, run: { ...RUN, phase: "ready" }, next: "tracking" })[1])
    .toContain("T for tracking");
});
@@ -28,10 +28,16 @@
export type View = { yaw: number; pitch: number };
/** Everything the panel prints, gathered by `main.ts` once a frame. */
export type Readout = View & {
  /** The run: the score, the clock and what they are made of. */
  /** The run: which drill it is, the score, the clock and what they are made of. */
  run: Report;
  /** The best score of this visit. Nothing is stored, so it starts at zero. */
  /**
   * The best score of this visit *on this drill*. Nothing is stored, so it
   * starts at zero, and a tracking score is never shown beside a pop-up best:
   * they are different games and the number would mean nothing.
   */
  best: number;
  /** What the drill key would switch to next. Named, so the key is discoverable. */
  next: string;
  /** Seconds of simulation per tick, as the rate it is usually said at. */
  hz: number;
  /** Ticks the loop has run since the page booted. */
@@ -62,24 +68,32 @@
const perDegree = (height: number): number => height / 90;
/** Degrees into 0..360, so the compass reads like a compass. */
export const wrapDegrees = (angle: number): number => ((angle % 360) + 360) % 360;
/** What the score line says about the run, whichever part of one it is in. */
/**
 * What the score line says about the run, whichever part of one it is in. The
 * drill leads it: the score and the best under it are that drill's and no
 * other's, so the name has to be the first thing read.
 */
export function scoreLine(run: Report, best: number): string {
  const percent = (run.accuracy * 100).toFixed(0);
  return `score ${run.score} · best ${best} · ${run.hits}/${run.shots} hits · ${percent}%`;
  return `${run.label} · score ${run.score} · best ${best} · ${run.hits}/${run.shots} hits · ${percent}%`;
}
/** What the clock line says: how to start one, how long is left, or how it went. */
export function clockLine(run: Report): string {
  if (run.phase === "ready") return `press Enter for a ${run.clock.toFixed(0)} second run`;
/**
 * What the clock line says: how to start one, how long is left, or how it went
 * — and, whenever a run is not in progress, what the drill key would switch to.
 * Mid-run it says nothing about switching, because mid-run the key does nothing.
 */
export function clockLine(run: Report, next: string): string {
  if (run.phase === "ready") return `press Enter for a ${run.clock.toFixed(0)} second run · T for ${next}`;
  if (run.phase === "live") return `${run.clock.toFixed(1)} s left · ${run.up} up`;
  return `run over · ${run.score} points · Enter for another`;
  return `run over · ${run.score} points · Enter for another · T for ${next}`;
}
/** The panel's lines, in order. Separate from the drawing so a test can read them. */
export function readoutLines(r: Readout): string[] {
  return [
    scoreLine(r.run, r.best),
    clockLine(r.run),
    clockLine(r.run, r.next),
    `tick ${r.ticks} · ${r.hz} Hz fixed step`,
    `frame ${r.frameMs.toFixed(1)} ms · ${(1000 / Math.max(0.1, r.frameMs)).toFixed(0)} fps`,
    `held ${r.held.length === 0 ? "nothing" : r.held.join(" ")}`,
@@ -14,7 +14,9 @@
import {
  MESH, PLATE_HALF, RANGE_SKY, TRACER_LIFE, buildRangeScene, createRangeScene, rangeAssets,
  rangeMeshes, type Trail,
} from "./scene.ts";
import { EYE, PLATE_MAT, createRun, type Run, type Target } from "./targets.ts";
import {
  DRILLS, EYE, PLATE_MAT, createRun, start, step, type Run, type Target,
} from "./targets.ts";
/** A plate standing at `at`, with `half` its half-width and `left` of its life. */
function plate(id: number, at: [number, number, number], half = PLATE_HALF, left = 1): Target {
@@ -180,3 +182,52 @@
test("a frame allocates nothing: the pool and the buffer are the ones from befor
  expect([...scene.instances]).toEqual(objects);
  expect(scene.lines).toBe(lines);
});
/**
 * A moving plate is drawn where it is. The run is a real tracking one, stepped
 * a tick at a time, and every frame's instance is compared with the box the
 * trace would use on that same tick — so an instance built from last frame's
 * position, or a scene that cached a place, fails here.
 */
test("a sliding plate is drawn where the tick left it, not where it was", () => {
  const run = createRun(20260917, DRILLS.tracking);
  start(run, 20260917);
  const scene = createRangeScene();
  let moved = 0;
  let previous: number | null = null;
  for (let tick = 0; tick < 200; tick++) {
    step(run, 1 / 50);
    buildRangeScene(run, VIEW, null, tick / 50, scene);
    const drawn = live(scene).slice(1);
    expect(drawn.length).toBe(run.targets.length);
    run.targets.forEach((target, i) => {
      const box = target.box;
      expect(drawn[i]?.pos).toEqual([
        (box.min[0] + box.max[0]) / 2,
        (box.min[1] + box.max[1]) / 2,
        (box.min[2] + box.max[2]) / 2,
      ]);
    });
    const first = run.targets[0];
    if (first !== undefined && previous !== null && (drawn[0]?.pos[1] as number) !== previous) moved += 1;
    previous = first === undefined ? null : (drawn[0]?.pos[1] as number);
  }
  // It really was moving: a still lane would have drawn the same y all along.
  expect(moved).toBeGreaterThan(100);
});
test("a plate that slid out of the lane is not drawn any more", () => {
  const run = standing([plate(1, [500, 0, 64])]);
  // The tracking drill's lane, with nothing new allowed to stand up in it: what
  // is drawn at the end is whatever is left of the one plate that was there.
  run.drill = { ...DRILLS.tracking, atOnce: 0 };
  const plateOne = run.targets[0] as Target;
  plateOne.vel = [0, 400, 0];
  plateOne.life = 30;
  const scene = createRangeScene();
  expect(buildRangeScene(run, VIEW, null, 0, scene).instanceCount).toBe(2);
  // Four seconds at 400 units a second is well past the drill's own lane.
  for (let i = 0; i < 200; i++) step(run, 1 / 50);
  expect(run.targets).not.toContain(plateOne);
  expect(live(buildRangeScene(run, VIEW, null, 4, scene)).map((i) => i.mesh)).not.toContain(MESH.PLATE);
});
@@ -55,7 +55,7 @@
export const LINE_CAPACITY = 2;
/**
 * Instances one frame may place: the room, and one plate for every target
 * standing. `STANDARD.atOnce` is three, so a standard frame is four; the
 * headroom is for a `Rules` that stands more, and past it a plate is simply not
 * headroom is for a drill that stands more, and past it a plate is simply not
 * drawn — the engine's policy at a cap, which the tracer above has always had.
 */
export const INSTANCE_CAPACITY = 16;
@@ -63,7 +63,7 @@
export const INSTANCE_CAPACITY = 16;
/**
 * The half-width the plate mesh is built at. Every plate is drawn from that one
 * cube, sized by `Instance.size` to the half-width its box actually has — so a
 * `Rules` with bigger plates draws bigger plates without a second mesh.
 * drill with bigger plates draws bigger plates without a second mesh.
 */
export const PLATE_HALF = STANDARD.half;
@@ -7,7 +7,8 @@
import { expect, test } from "bun:test";
import { angleVectors, dist, type Vec3 } from "../engine/index.ts";
import {
  accuracy, createRun, EYE, report, shoot, start, step, STANDARD, type Rules, type Run,
  accuracy, createRun, DRILL_NAMES, DRILLS, EYE, nextDrill, report, setDrill, shoot, start, step,
  STANDARD, type Drill, type Run,
} from "./targets.ts";
/**
@@ -16,7 +17,7 @@
import {
 * Everything below that is not about the spawn uses this, so the geometry is a
 * sum rather than a seed.
 */
const FLAT: Rules = {
const FLAT: Drill = {
  ...STANDARD,
  runTime: 10,
  atOnce: 1,
@@ -36,8 +37,40 @@
function lane(): Run {
  return run;
}
/**
 * The same flat lane, with the plates sliding north at exactly 100 units a
 * second and 400 units of lane to do it in: a moving plate whose place after
 * any number of ticks is a multiplication, not a seed.
 */
const CROSS: Drill = {
  ...FLAT,
  name: "tracking",
  label: "tracking",
  life: { min: 10, max: 10 },
  speed: { min: 100, max: 100 },
  escape: 400,
  points: { near: 100, far: 100, perSpeed: 0.5 },
};
const down = (yaw: number, pitch: number): Vec3 => angleVectors(yaw, pitch).forward;
/** Where a plate's centre is across the lane, which is the only axis one moves on. */
const across = (run: Run, i = 0): number => {
  const box = (run.targets[i] as NonNullable<(typeof run.targets)[0]>).box;
  return (box.min[1] + box.max[1]) / 2;
};
/** The yaw that looks at a point `y` across the lane, 512 units down it. */
const yawTo = (y: number): number => (180 / Math.PI) * Math.atan2(y, 512);
/** A live run on `CROSS` with its first plate already sliding. */
function crossing(seed = 1): Run {
  const run = createRun(seed, CROSS);
  start(run);
  step(run, 0.02);
  return run;
}
test("a plate pops up down the lane, as a box arithmetic can place", () => {
  const run = lane();
  expect(run.targets.length).toBe(1);
@@ -179,7 +212,10 @@
test("accuracy is what a hand count says, and no shots is not a division", () =>
test("the clock runs the run: thirty seconds, then it is over and the lane is empty", () => {
  const run = createRun(3);
  expect(report(run)).toEqual({ phase: "ready", clock: 30, score: 0, hits: 0, shots: 0, accuracy: 0, up: 0 });
  expect(report(run)).toEqual({
    drill: "popup", label: "pop-up", phase: "ready", clock: 30,
    score: 0, hits: 0, shots: 0, accuracy: 0, up: 0,
  });
  start(run);
  for (let i = 0; i < 1499; i++) step(run, 0.02);
  expect(run.phase).toBe("live");
@@ -256,3 +292,161 @@
test("the plates stand in front of the shooter, inside the lane the rules give",
  }
  expect(run.spawned).toBeGreaterThan(20);
});
// --- the drills -----------------------------------------------------------
test("a moving plate is somewhere else after a tick, by its own speed", () => {
  const run = crossing();
  const plate = run.targets[0] as NonNullable<(typeof run.targets)[0]>;
  // 100 units a second, one way or the other: the drill's speed, exactly.
  expect(Math.abs(plate.vel[1])).toBe(100);
  expect(plate.vel[0]).toBe(0);
  expect(plate.vel[2]).toBe(0);
  expect(plate.rate).toBe(100);
  const before = across(run);
  step(run, 0.02);
  expect(across(run) - before).toBeCloseTo(plate.vel[1] * 0.02, 9);
  // A second of it is a hundred units, and only across the lane: the depth and
  // the height a plate stood up at are the depth and the height it keeps.
  for (let i = 0; i < 49; i++) step(run, 0.02);
  expect(across(run) - before).toBeCloseTo(plate.vel[1], 6);
  expect(plate.box.min[0]).toBe(496);
  expect(plate.box.min[2]).toBe(48);
  // And the distance it is at now, not the one it stood up at.
  expect(plate.distance).toBeCloseTo(Math.hypot(512, across(run)), 6);
});
test("a pop-up plate does not move: the drill that stands still stands still", () => {
  const run = lane();
  const plate = run.targets[0] as NonNullable<(typeof run.targets)[0]>;
  const min = [...plate.box.min];
  const max = [...plate.box.max];
  expect(plate.vel).toEqual([0, 0, 0]);
  expect(plate.rate).toBe(0);
  for (let i = 0; i < 40; i++) step(run, 0.02);
  expect(plate.box.min).toEqual(min as typeof plate.box.min);
  expect(plate.box.max).toEqual(max as typeof plate.box.max);
});
test("a shot meets a moving plate where the tick left it, not where it was", () => {
  const run = crossing();
  const plate = run.targets[0] as NonNullable<(typeof run.targets)[0]>;
  const was = across(run);
  // 200 ms of travel is 20 units, and the plate is 16 from its centre to its
  // edge: where it was is now outside it, and where it is is inside.
  for (let i = 0; i < 10; i++) step(run, 0.02);
  const is = across(run);
  expect(Math.abs(is - was)).toBeCloseTo(20, 6);
  expect(shoot(run, EYE, down(yawTo(was), 0))?.target).toBeNull();
  const hit = shoot(run, EYE, down(yawTo(is), 0));
  expect(hit?.target).toBe(plate);
  expect(run.hits).toBe(1);
  expect(run.shots).toBe(2);
});
test("a plate that slides out of the lane retires, with life still on it", () => {
  const run = crossing();
  const plate = run.targets[0] as NonNullable<(typeof run.targets)[0]>;
  // 400 units of lane at 100 a second: four seconds of sliding, and ten of life.
  for (let i = 0; i < 200; i++) step(run, 0.02);
  expect(run.targets).toContain(plate);
  step(run, 0.02);
  expect(run.targets).not.toContain(plate);
  expect(plate.life).toBeGreaterThan(5);
  expect(Math.abs((plate.box.min[1] + plate.box.max[1]) / 2)).toBeGreaterThan(CROSS.escape);
  // It is gone from the game, so it cannot be shot: the lane has moved on.
  expect(shoot(run, EYE, down(yawTo(across(run)), 0))?.target).not.toBe(plate);
});
test("a faster plate is worth more, by the drill's own rate", () => {
  const slow = createRun(1, { ...CROSS, speed: { min: 40, max: 40 } });
  start(slow);
  step(slow, 0.02);
  const fast = createRun(1, { ...CROSS, speed: { min: 240, max: 240 } });
  start(fast);
  step(fast, 0.02);
  // 100 for the depth, and half a point for every unit a second it crosses at.
  expect(slow.targets[0]?.points).toBe(120);
  expect(fast.targets[0]?.points).toBe(220);
  // A pop-up plate's speed pays nothing, because there is none of it.
  expect(lane().targets[0]?.points).toBe(100);
});
test("the same seed and drill play the same run twice, plates and speeds alike", () => {
  const play = (drill: typeof DRILLS.popup, seed: number): string => {
    const run = createRun(seed, drill);
    start(run);
    const seen: string[] = [];
    for (let i = 0; i < 300; i++) {
      step(run, 0.02);
      for (const t of run.targets) seen.push(`${t.id} ${t.box.min.join()} ${t.vel.join()} ${t.points}`);
    }
    return seen.join("\n");
  };
  expect(play(DRILLS.tracking, 2026)).toBe(play(DRILLS.tracking, 2026));
  expect(play(DRILLS.tracking, 2026)).not.toBe(play(DRILLS.tracking, 7));
  // Two drills on one seed are two lanes: not the same plates at other speeds.
  expect(play(DRILLS.tracking, 2026)).not.toBe(play(DRILLS.popup, 2026));
  const first = (drill: typeof DRILLS.popup): number[] => {
    const run = createRun(11, drill);
    start(run);
    step(run, 0.02);
    return [...(run.targets[0] as NonNullable<(typeof run.targets)[0]>).box.min];
  };
  expect(first(DRILLS.tracking)).not.toEqual(first(DRILLS.popup));
});
test("the drill is chosen between runs and never during one", () => {
  const run = createRun(5);
  expect(run.drill.name).toBe("popup");
  expect(setDrill(run, DRILLS.tracking)).toBe(true);
  expect(run.drill.name).toBe("tracking");
  expect(report(run).label).toBe("tracking");
  // Mid-run it does nothing at all: not the drill, not the lane, not the score.
  start(run);
  for (let i = 0; i < 100; i++) step(run, 0.02);
  shoot(run, EYE, down(0, 0));
  const before = { ...report(run), targets: run.targets.length, spawned: run.spawned };
  expect(setDrill(run, DRILLS.popup)).toBe(false);
  expect(run.drill.name).toBe("tracking");
  expect({ ...report(run), targets: run.targets.length, spawned: run.spawned }).toEqual(before);
  // Once the clock is out it takes, and the lane starts over on the new drill.
  for (let i = 0; i < 1500; i++) step(run, 0.02);
  expect(run.phase).toBe("over");
  expect(setDrill(run, DRILLS.popup)).toBe(true);
  expect(report(run)).toEqual({
    drill: "popup", label: "pop-up", phase: "ready", clock: 30,
    score: 0, hits: 0, shots: 0, accuracy: 0, up: 0,
  });
  start(run);
  step(run, 0.02);
  expect(run.targets[0]?.vel).toEqual([0, 0, 0]);
});
test("the drills are a table, and the one control walks round it", () => {
  expect(DRILL_NAMES).toEqual(["popup", "tracking"]);
  expect(nextDrill("popup")).toBe("tracking");
  // However many there are, the last one wraps back to the first.
  expect(nextDrill(DRILL_NAMES[DRILL_NAMES.length - 1] as "popup")).toBe(DRILL_NAMES[0] as "popup");
  for (const name of DRILL_NAMES) {
    const drill = DRILLS[name];
    expect(drill.name).toBe(name);
    expect(drill.label.length).toBeGreaterThan(0);
    expect(drill.about.length).toBeGreaterThan(0);
    // Every plate stands up inside the lane it may not leave, and a plate that
    // never moves can never reach the edge of one.
    expect(drill.escape).toBeGreaterThanOrEqual(drill.spread);
    expect(drill.speed.min).toBeLessThanOrEqual(drill.speed.max);
    expect(drill.runTime).toBeGreaterThan(0);
  }
  // The pop-up drill is the default and its salt is zero: the run that was
  // pinned is the run a caller who names no drill still gets.
  expect(STANDARD).toBe(DRILLS.popup);
  expect(DRILLS.popup.salt).toBe(0);
  expect(DRILLS.popup.speed).toEqual({ min: 0, max: 0 });
  expect(createRun(1).drill).toBe(DRILLS.popup);
});
@@ -1,10 +1,11 @@
/**
 * The range's game: pop-up targets, a traced shot, a clock and a score. Plain
 * data in, plain data out — no canvas, no document, no room, no physics. A
 * `Run` is a mutable record and the three verbs below move it: `start` begins
 * one, `step` advances the clock and the targets, `shoot` traces a bullet.
 * Nothing in here draws anything and nothing in here reads a clock of its own,
 * which is why the whole game plays through in a test in a millisecond.
 * The range's game: plates down a lane, a traced shot, a clock and a score.
 * Plain data in, plain data out — no canvas, no document, no room, no physics.
 * A `Run` is a mutable record and the verbs below move it: `start` begins one,
 * `step` advances the clock and the targets, `shoot` traces a bullet, and
 * `setDrill` swaps which drill the next run will be. Nothing in here draws
 * anything and nothing in here reads a clock of its own, which is why the whole
 * game plays through in a test in a millisecond.
 *
 * Units are the engine's: Source units, one unit about an inch, X east, Y north
 * and Z up. The shooter stands at the origin looking down +X (yaw 0) with an
@@ -14,6 +15,20 @@
 * Everything random comes from the engine's `rng`, drawn in one fixed order, so
 * a seed reproduces a run exactly: the same seed pops the same plates up at the
 * same moments with the same lifetimes.
 *
 * **A drill is data.** `DRILLS` below is the whole difference between one kind
 * of run and another — how often a plate stands up, how long it stands, how
 * fast it slides and what hitting it is worth — and `createRun(seed, drill)`
 * takes which one. There is no `if (tracking)` anywhere under this file: a
 * still plate is a moving plate whose speed is zero, and a third drill is one
 * more entry in that table.
 *
 * **The tick boundary.** A plate moves at the top of a tick and a bullet leaves
 * at the end of one: `main.ts` steps the run and then reads the trigger, and
 * `pin.ts` folds the digest in that same order. So a shot is traced against
 * where the plate *is* on the tick it was fired — never where it was on the one
 * before — and `scene.ts` draws the same box the trace used. Three places, one
 * answer, and `targets.test.ts` holds them to it.
 */
import {
@@ -31,8 +46,27 @@
export const EYE: Vec3 = [0, 0, 64];
 */
export const PLATE_MAT = 0;
/** The dial settings of one kind of run. Plain numbers, all of them tunable. */
export type Rules = {
/** What the drills are called. One name per entry in `DRILLS`, and no others. */
export type DrillName = "popup" | "tracking";
/**
 * One drill: the dial settings of one kind of run, and what to call it. Plain
 * numbers, all of them tunable, and the only thing that separates two kinds of
 * run at this range.
 */
export type Drill = {
  /** Which drill this is. The key it is filed under in `DRILLS`. */
  name: DrillName;
  /** What the panel and the page call it. Text, escaped where it is rendered. */
  label: string;
  /** The one sentence that says what this drill is for. */
  about: string;
  /**
   * Mixed into the seed, so two drills on one seed are two different lanes
   * rather than the same plates with different speeds. The pop-up drill's is
   * zero — that is what keeps its thirty seconds the thirty seconds they were.
   */
  salt: number;
  /** How long one run lasts, in seconds. */
  runTime: number;
  /** Most plates standing at once. */
@@ -43,50 +77,129 @@
export type Rules = {
  life: { min: number; max: number };
  /** How far down the lane a plate may stand, in units. */
  depth: { min: number; max: number };
  /** Half the width of the lane, in units: a plate stands within ±this of it. */
  /** Half the width a plate may *stand up* in, in units: ±this across the lane. */
  spread: number;
  /**
   * How far across the lane a plate may get before it retires, in units. A
   * plate that slides past ±this has left and is taken down, hit or not. It is
   * not `spread`, so a moving plate has room to travel past where any plate
   * stands up, and it is inside the room's own ±640 wall in `level.ts`, so what
   * retires has left the lane and not gone through the concrete. A still drill
   * stands up inside `spread` and never moves, so it never reaches this.
   */
  escape: number;
  /** The band a plate's centre stands in, in units above the floor. */
  height: { min: number; max: number };
  /**
   * How fast a plate slides across the lane, in units a second: the slowest and
   * the fastest. `{ min: 0, max: 0 }` is a drill whose plates stand still, and
   * that is the whole of what "pop-up" means here — no branch, one zero.
   */
  speed: { min: number; max: number };
  /** Half the side of a plate, in units: they are cubes, so this is all of it. */
  half: number;
  /** What a plate is worth at `depth.min`, and at `depth.max`. */
  points: { near: number; far: number };
  /**
   * What a plate is worth at `depth.min`, at `depth.max`, and per unit a second
   * of the speed it was sliding at. A still drill's `perSpeed` never multiplies
   * anything but zero.
   */
  points: { near: number; far: number; perSpeed: number };
  /** How far a bullet carries, in units. Hitscan: it arrives or it does not. */
  range: number;
};
/**
 * The run a person gets by pressing Enter. Thirty seconds, three plates up at
 * a time, each worth between 100 and 200 points depending on how far away it
 * stood — a 36-unit cube at 1,200 units is about 1.7° wide, which is a shot
 * worth taking with a mouse and not one worth taking by accident.
 * The drills, in the order the one control cycles them. Adding a third is an
 * entry here and a name in `DrillName` — nothing else in the range branches on
 * which drill is being played.
 *
 * **pop-up** is the run this range shipped with and every number in it is
 * untouched: thirty seconds, three plates up at a time, each worth between 100
 * and 200 points depending on how far away it stood — a 36-unit cube at 1,200
 * units is about 1.7° wide, which is a shot worth taking with a mouse and not
 * one worth taking by accident. Its speed is zero and its salt is zero, which
 * together are why `pin.test.ts`'s first digest has not moved.
 *
 * **tracking** is the second: fewer plates, standing up nearer and for longer,
 * each sliding across the lane at 90 to 260 units a second until it runs out of
 * life or runs out of lane. It is worth less for the distance and more for the
 * speed — a plate crossing at 260 is worth 91 points of its own on top of the
 * 100 to 160 its depth pays, so the fast one is the one to take first.
 */
export const STANDARD: Rules = {
  runTime: 30,
  atOnce: 3,
  gap: 0.6,
  life: { min: 1.1, max: 2.4 },
  depth: { min: 320, max: 1200 },
  spread: 420,
  height: { min: 28, max: 148 },
  half: 18,
  points: { near: 100, far: 200 },
  range: 4096,
export const DRILLS: Record<DrillName, Drill> = {
  popup: {
    name: "popup",
    label: "pop-up",
    about: "plates stand up down the lane and drop when their time is up: find them and hit them.",
    salt: 0,
    runTime: 30,
    atOnce: 3,
    gap: 0.6,
    life: { min: 1.1, max: 2.4 },
    depth: { min: 320, max: 1200 },
    spread: 420,
    escape: 560,
    height: { min: 28, max: 148 },
    speed: { min: 0, max: 0 },
    half: 18,
    points: { near: 100, far: 200, perSpeed: 0 },
    range: 4096,
  },
  tracking: {
    name: "tracking",
    label: "tracking",
    about: "plates stand up and slide across the lane: lead them, and the fast ones pay most.",
    // "trac", which is only a number nobody else uses.
    salt: 0x74_72_61_63,
    runTime: 30,
    atOnce: 2,
    gap: 0.9,
    life: { min: 2, max: 3.4 },
    depth: { min: 360, max: 900 },
    spread: 300,
    escape: 560,
    height: { min: 40, max: 120 },
    speed: { min: 90, max: 260 },
    half: 18,
    points: { near: 100, far: 160, perSpeed: 0.35 },
    range: 4096,
  },
};
/** The drills in the order the control cycles them: the table's own order. */
export const DRILL_NAMES = Object.keys(DRILLS) as DrillName[];
/** The next drill round the table, wrapping. One control, however many drills. */
export const nextDrill = (name: DrillName): DrillName =>
  DRILL_NAMES[(DRILL_NAMES.indexOf(name) + 1) % DRILL_NAMES.length] as DrillName;
/**
 * The drill a run gets when its caller named none: the pop-up one, under the
 * name the rest of the range has always called it by.
 */
export const STANDARD: Drill = DRILLS.popup;
/** One plate, standing. */
export type Target = {
  /** 1, 2, 3… in the order they popped up this run. */
  id: number;
  /** Where it is, as the engine traces it. */
  box: Box;
  /**
   * How fast it is sliding, in units a second on each axis. Every plate has
   * one; a pop-up plate's is three zeroes, and adding zero times a tick to its
   * box is how it stands still without anything asking whether it should.
   */
  vel: Vec3;
  /** How fast it is going, in units a second. What its speed was worth, once. */
  rate: number;
  /** Seconds left before it drops. */
  life: number;
  /** Seconds it was given, so a readout can show how much of that is left. */
  span: number;
  /** What hitting it is worth. Farther is worth more. */
  /** What hitting it is worth. Farther is worth more, and faster is worth more. */
  points: number;
  /** Units from `EYE` to its centre, kept because every reader wants it. */
  /** Units from `EYE` to its centre right now, kept because every reader wants it. */
  distance: number;
};
@@ -94,7 +207,8 @@
export type Target = {
export type Phase = "ready" | "live" | "over";
export type Run = {
  rules: Rules;
  /** Which drill is being played, whole. A run is never between two of them. */
  drill: Drill;
  phase: Phase;
  /** Seconds left in the run. `runTime` before it starts, zero once it is over. */
  clock: number;
@@ -111,12 +225,21 @@
export type Run = {
  random: () => number;
};
/**
 * The stream a run draws its plates from: the seed it was given, mixed with the
 * drill's own salt. Two drills on one seed are two different lanes, which is
 * what stops a person memorising one drill's spawns and playing the other by
 * heart — and the pop-up drill's salt is zero, so its stream is the stream it
 * always was.
 */
const stream = (seed: number, drill: Drill): (() => number) => rng(((seed >>> 0) ^ drill.salt) >>> 0);
/** A run that has not started: the clock is full and the lane is empty. */
export function createRun(seed: number, rules: Rules = STANDARD): Run {
export function createRun(seed: number, drill: Drill = STANDARD): Run {
  return {
    rules,
    drill,
    phase: "ready",
    clock: rules.runTime,
    clock: drill.runTime,
    nextIn: 0,
    targets: [],
    spawned: 0,
@@ -124,7 +247,7 @@
export function createRun(seed: number, rules: Rules = STANDARD): Run {
    hits: 0,
    score: 0,
    seed: seed >>> 0,
    random: rng(seed),
    random: stream(seed, drill),
  };
}
@@ -135,9 +258,9 @@
export function createRun(seed: number, rules: Rules = STANDARD): Run {
 */
export function start(run: Run, seed: number = run.seed): void {
  run.seed = seed >>> 0;
  run.random = rng(run.seed);
  run.random = stream(run.seed, run.drill);
  run.phase = "live";
  run.clock = run.rules.runTime;
  run.clock = run.drill.runTime;
  run.nextIn = 0;
  run.targets = [];
  run.spawned = 0;
@@ -146,17 +269,55 @@
export function start(run: Run, seed: number = run.seed): void {
  run.score = 0;
}
/** One plate, drawn from the run's rng in this order: depth, side, height, life. */
/**
 * Choose the drill the next run will be, and say whether it took. A live run is
 * left strictly alone — a drill swapped halfway through would be a score made
 * of two games — so this answers false and changes nothing until the clock has
 * run out. Choosing between runs clears the lane back to `ready`: a finished
 * run's score belongs to the drill it was played on and is not carried across.
 */
export function setDrill(run: Run, drill: Drill): boolean {
  if (run.phase === "live") return false;
  run.drill = drill;
  run.phase = "ready";
  run.clock = drill.runTime;
  run.nextIn = 0;
  run.targets = [];
  run.spawned = 0;
  run.shots = 0;
  run.hits = 0;
  run.score = 0;
  run.random = stream(run.seed, drill);
  return true;
}
/**
 * One plate, drawn from the run's rng in this order: depth, side, height, life
 * — and then, on a drill whose plates move, how fast and which way.
 *
 * Those last two are drawn only when `speed.max` is above zero, and that is the
 * one guard in this file that exists for the sake of a digest: a drill that
 * stands its plates still asks its stream for four numbers a plate, exactly as
 * this game always did, so the pop-up run is the run that was pinned. A drill
 * that moves asks for six.
 */
function pop(run: Run): Target {
  const r = run.rules;
  const r = run.drill;
  const depth = lerp(r.depth.min, r.depth.max, run.random());
  const side = lerp(-r.spread, r.spread, run.random());
  const centre = lerp(r.height.min, r.height.max, run.random());
  const span = lerp(r.life.min, r.life.max, run.random());
  const rate = r.speed.max > 0 ? lerp(r.speed.min, r.speed.max, run.random()) : 0;
  // Across the lane, one way or the other: the plate slides in ±Y and nothing
  // else, so a shot at it is a lead and not a guess about depth.
  const vel: Vec3 = [0, rate === 0 ? 0 : run.random() < 0.5 ? -rate : rate, 0];
  const at: Vec3 = [depth, side, centre];
  const reach = r.depth.max - r.depth.min;
  // Points are linear in how far down the lane it stood, rounded to a whole.
  const points = Math.round(lerp(r.points.near, r.points.far, reach > 0 ? (depth - r.depth.min) / reach : 0));
  // Points are linear in how far down the lane it stood and in how fast it is
  // crossing, rounded to a whole. A still plate adds nothing for its speed.
  const points = Math.round(
    lerp(r.points.near, r.points.far, reach > 0 ? (depth - r.depth.min) / reach : 0) + r.points.perSpeed * rate,
  );
  run.spawned += 1;
  return {
    id: run.spawned,
@@ -165,6 +326,8 @@
function pop(run: Run): Target {
      max: [at[0] + r.half, at[1] + r.half, at[2] + r.half],
      mat: PLATE_MAT,
    },
    vel,
    rate,
    life: span,
    span,
    points,
@@ -179,11 +342,19 @@
function pop(run: Run): Target {
 */
const SPENT = 1e-9;
/** The one vector a tick writes a plate's centre into: a step allocates nothing. */
const CENTRE: Vec3 = [0, 0, 0];
/**
 * Advance `dt` seconds: the clock runs down, standing plates lose that much of
 * their lifetime and the expired ones drop, and new ones pop up on the gap
 * until the lane is full. When the clock reaches zero the run is over and the
 * lane is cleared — a plate cannot be shot after time, because it is not there.
 * Advance `dt` seconds: the clock runs down, standing plates slide by their own
 * velocity and lose that much of their lifetime, the expired ones and the ones
 * that have left the lane drop, and new ones pop up on the gap until the lane
 * is full. When the clock reaches zero the run is over and the lane is cleared
 * — a plate cannot be shot after time, because it is not there.
 *
 * The plates move first and the shot is fired afterwards, by `main.ts` and by
 * `pin.ts` alike: a bullet leaves at the end of the tick it was pulled on, and
 * meets the plates where this step has just put them.
 *
 * Only a live run moves. A step outside one, or with a dt that is not a
 * positive number, does nothing at all.
@@ -191,13 +362,31 @@
const SPENT = 1e-9;
export function step(run: Run, dt: number): void {
  if (run.phase !== "live" || !Number.isFinite(dt) || dt <= 0) return;
  run.clock = Math.max(0, run.clock - dt);
  for (const target of run.targets) target.life -= dt;
  run.targets = run.targets.filter((target) => target.life > 0);
  for (const target of run.targets) {
    target.life -= dt;
    // Every plate is moved. A still one is moved by zero, which is the same
    // double it already held — no branch, and no drill named in this loop.
    const box = target.box;
    const vel = target.vel;
    box.min[0] += vel[0] * dt; box.max[0] += vel[0] * dt;
    box.min[1] += vel[1] * dt; box.max[1] += vel[1] * dt;
    box.min[2] += vel[2] * dt; box.max[2] += vel[2] * dt;
    // A plate that moved is a plate at another distance, and the readers of
    // that — the panel, the sound of a hit — want where it is now.
    CENTRE[0] = (box.min[0] + box.max[0]) / 2;
    CENTRE[1] = (box.min[1] + box.max[1]) / 2;
    CENTRE[2] = (box.min[2] + box.max[2]) / 2;
    target.distance = segmentLength(EYE, CENTRE);
  }
  const escape = run.drill.escape;
  run.targets = run.targets.filter(
    (target) => target.life > 0 && Math.abs((target.box.min[1] + target.box.max[1]) / 2) <= escape,
  );
  run.nextIn -= dt;
  while (run.clock > SPENT && run.nextIn <= 0 && run.targets.length < run.rules.atOnce) {
  while (run.clock > SPENT && run.nextIn <= 0 && run.targets.length < run.drill.atOnce) {
    run.targets.push(pop(run));
    run.nextIn += run.rules.gap;
    run.nextIn += run.drill.gap;
  }
  if (run.clock <= SPENT) {
    run.phase = "over";
@@ -234,7 +423,7 @@
export function shoot(run: Run, eye: Vec3, direction: Vec3): Shot | null {
  const aim = normalize(direction);
  if (length(aim) < 0.5) return null;
  const to = add(eye, scale(aim, run.rules.range));
  const to = add(eye, scale(aim, run.drill.range));
  run.shots += 1;
  const hit = traceWorld(eye, to, run.targets.map((target) => target.box));
  const target = hit === null ? null : run.targets.find((t) => t.box === hit.what) ?? null;
@@ -252,6 +441,10 @@
export const accuracy = (hits: number, shots: number): number => (shots > 0 ? hi
/** Everything a scoreboard or a readout needs, and nothing it would have to compute. */
export type Report = {
  /** Which drill this is a run of. A score means nothing without it. */
  drill: DrillName;
  /** That drill's name for a person, ready to print. */
  label: string;
  phase: Phase;
  /** Seconds left, never below zero. */
  clock: number;
@@ -264,6 +457,8 @@
export type Report = {
};
export const report = (run: Run): Report => ({
  drill: run.drill.name,
  label: run.drill.label,
  phase: run.phase,
  clock: Math.max(0, run.clock),
  score: run.score,
@@ -80,8 +80,12 @@
test("the range page carries every id and action its entry reaches for", async (
  // the engine's controls; nothing type-checks that, so the page is checked.
  const body = await (await fetch(base + "/range")).text();
  for (const id of ["scene", "hud", "fps", "touch", "note", "look"]) expect(body).toContain(`id="${id}"`);
  for (const action of ["duck", "jump", "walk", "reload", "start", "fire"])
  // Six buttons, and `drill` is one of them: a phone chooses the drill the way a
  // keyboard does with T. It took `reload`'s place, which this game has nothing
  // to do — there is no magazine at this range, and the key still says so.
  for (const action of ["duck", "jump", "walk", "drill", "start", "fire"])
    expect(body).toContain(`data-action="${action}"`);
  expect(body).not.toContain('data-action="reload"');
  // cs's ids are not on this page: a shared shell is not a shared game.
  for (const id of ["menu", "pause", "buy", "stats", "play"]) expect(body).not.toContain(`id="${id}"`);
});
		@@ -5,9 +5,9 @@ Counter-Strike-shaped defusal shooter, five against five on one map — bomb
5	5	rounds, a buy menu and an economy, bots that walk to a site and shoot back —
6	6	and the leaderboard of the matches people played. The second, at `/range`, is
7	7	built only out of the engine the shooter was taken apart into: a shooting
8		range — pop-up targets from a seeded spawn, a shot traced through the
9		engine's boxes, a thirty second clock and a score, with the fixed step and the
10		controls under it — and it is drawn by the engine's renderer: its own room,
	8	range — two drills of seeded targets, plates that pop up and plates that
	9	slide across the lane, a shot traced through the engine's boxes, a thirty
	10	second clock and a score, with the fixed step and the controls under it — and it is drawn by the engine's renderer: its own room,
11	11	its own plates and its own tracer, out of an atlas and two meshes it painted
12	12	and built itself. The third, at `/example`, is the example: the guide's own
13	13	game — one room seen from above, one plate, thirty seconds and a score, drawn
		@@ -101,9 +101,16 @@ the rest.
101	101	At `/range` the same controls drive the second game, on its own bindings:
102	102	<kbd>WASD</kbd> move, <kbd>Space</kbd> jump, <kbd>Ctrl</kbd> crouch,
103	103	<kbd>Shift</kbd> walk, <kbd>F</kbd> or the mouse fires, <kbd>R</kbd> reload,
104		<kbd>Enter</kbd> starts a thirty second run. Plates pop up down the lane, each
105		worth 100 to 200 points by how far away it stood; the panel keeps the score, the
106		clock and the accuracy, and the best of the visit. The room, the plates and the
	104	<kbd>Enter</kbd> starts a thirty second run and <kbd>T</kbd> chooses the drill
	105	between runs. There are two. Pop-up is the one the range shipped with: three
	106	plates at a time, standing still down the lane, each worth 100 to 200 points by
	107	how far away it stood. Tracking is the second: two at a time, nearer and
	108	longer-lived, each sliding across the lane at 90 to 260 units a second until its
	109	lifetime or its lane runs out, worth 100 to 160 for the distance plus a third of
	110	a point for every unit a second it is crossing at — so you lead it, and the fast
	111	one pays most. Switching mid-run does nothing rather than corrupting the run, and
	112	the panel keeps the score, the clock, the accuracy and a best per drill,
	113	because a tracking score means nothing beside a pop-up one. The room, the plates and the
107	114	tracer are drawn by the engine's renderer and the range makes its own noise
108	115	through the engine's sound device — a dry crack, a tone for a hit, a knock as a
109	116	plate stands up, a tick for each of the last three seconds and one falling tone
		@@ -304,8 +311,9 @@ renderer, no atlas, no mesh and no sound ship in that bundle, and
304	311	and its own siblings, and nothing else. **It is a game with no renderer under
305	312	it**: `binding.ts` is its own key table (50 Hz, its own actions — no buy,
306	313	no scoreboard, no weapon slots) and the one function from held actions to an
307		intent; `targets.ts` is the game itself — a seeded `rng` pops plates up as
308		`Box`es down a lane, `step` runs their lifetimes and the run's clock, and
	314	intent; `targets.ts` is the game itself — a seeded `rng` stands plates up as
	315	`Box`es down a lane, `step` slides them by their own velocity and runs their
	316	lifetimes and the run's clock, retiring what has expired or left the lane, and
309	317	`shoot` traces the engine's `rayBox` along the view and folds the hit, the
310	318	score and the accuracy in, all plain data in and plain data out with no canvas
311	319	anywhere near it; `readout.ts` draws a horizon, the plates on it as blips
		@@ -370,10 +378,13 @@ renderer, no atlas, no mesh and no sound ship in that bundle, and
370	378	canvases, draws its ticks, answers a key and — given WebGL2 — uploads its
371	379	atlas and draws the room — so a bundling mistake fails
372	380	`bun test` rather than the preview. The range's rules are pinned the way the
373		shooter's round is: `pin.ts` plays one seeded thirty-second run through one
374		fixed script of shots and hashes every tick, against the digest committed in
375		`pin.test.ts` — so a renderer, an atlas or a movement tuning that changes the
376		game says so, naming the second of the run where it changed. `src/pages/range.ts` is its page: its own title, prose and overlay
	381	shooter's round is: `pin.ts` plays one seeded thirty-second run per drill
	382	through one fixed script of shots each and hashes every tick, against the two
	383	digests committed in `pin.test.ts` — so a renderer, an atlas or a movement
	384	tuning that changes the game says so, naming the drill and the second of the
	385	run where it changed. A drill is data: one table in `targets.ts` holds the
	386	spawn rate, the lifetime, the speed range and the scoring of each, `createRun`
	387	takes which one, and a third drill is one more entry in it. `src/pages/range.ts` is its page: its own title, prose and overlay
377	388	through the same shell, with no database, no endpoint and no cookie behind it.
378	389	- `src/example/` — the third game, at `/example`, and the wiring of one and
379	390	nothing else: `main.ts` finds the canvas, hands the engine's controls the
		@@ -87,6 +87,15 @@ export type Game = {
87	87	* the app's bundle and in neither line of the range's. Measured 2026-09-18 after
88	88	* #106: app 71,646 raw / 33,273 gzipped, range 27,268 raw / 11,674 gzipped.
89	89	* Both fit, so neither ceiling moved.
	90	* #88 gave the range a second drill — plates that slide across the lane, chosen
	91	* before a run — and the range grew 1,545 raw / 572 gzipped bytes for it: a
	92	* velocity on every plate, a second entry in the drill table, the retirement of
	93	* a plate that has left the lane, and the drill's name and its per-drill best on
	94	* the panel. Measured 2026-09-20 after #88: range 28,813 raw / 12,246 gzipped,
	95	* which fits today's 29,400 / 12,700 with 587 raw and 454 gzipped bytes to
	96	* spare, so the ceiling did not move — but that is the thinnest headroom on this
	97	* page, and the next thing the range gains will want it raised. Neither other
	98	* bundle moved a byte: nothing outside `src/range/` changed.
90	99	* #80 added a third entry, `example`, and its ceiling is the first number in
91	100	* this file nobody had to argue about: the guide's game with a page around it
92	101	* builds to 8,754 raw / 4,229 gzipped, so its ceiling is 9,700 / 4,700, today's
		@@ -112,7 +121,7 @@ export const GAMES: readonly Game[] = [
112	121	entry: "src/range/main.ts",
113	122	ceiling: { raw: 29_400, gzip: 12_700 },
114	123	blurb:
115		"thirty seconds on the clock, pop-up plates down a lane, a shot traced in three dimensions and a score — every line of it out of the engine and none of it out of the shooter.",
	124	"thirty seconds on the clock and two drills down one lane — plates that pop up, and plates that slide across it — a shot traced in three dimensions and a score, every line of it out of the engine and none of it out of the shooter.",
116	125	},
117	126	{
118	127	name: "example",
		@@ -17,18 +17,22 @@ import { page, type PageOptions as ShellOptions, stage } from "./shell.ts";
17	17	export type PageOptions = Pick<ShellOptions, "env" \| "pull" \| "commit" \| "script" \| "ssh">;
18	18
19	19	const NOTE = `
20		<h2>The range: thirty seconds on the clock</h2>
21		<p>Capture the mouse, press <kbd>Enter</kbd>, and shoot the plates as they pop up: each one
22		is a box in space, traced by the engine and drawn by it, and the panel keeps the score,
23		the clock and your accuracy. You stand at the firing line and turn on the spot — there is
24		no walking yet. On a browser with no WebGL2 the range falls back to the flat horizon it
25		shipped with, plates as squares projected from the angle each subtends, and the same game
26		plays on it.</p>
	20	<h2>The range: thirty seconds on the clock, two drills</h2>
	21	<p>Capture the mouse, press <kbd>Enter</kbd>, and shoot the plates: each one is a box in
	22	space, traced by the engine and drawn by it, and the panel keeps the score, the clock and
	23	your accuracy. There are two drills and <kbd>T</kbd> switches between them before a run —
	24	<strong>pop-up</strong>, where plates stand up down the lane and drop when their time is
	25	up, and <strong>tracking</strong>, where they stand up and slide across it at their own
	26	speed, worth more the faster they are going. You stand at the firing line and turn on the
	27	spot — there is no walking yet. On a browser with no WebGL2 the range falls back to the
	28	flat horizon it shipped with, plates as squares projected from the angle each subtends,
	29	and the same two drills play on it.</p>
27	30	<div class="row"><button type="button" class="primary" id="look">Capture the mouse</button></div>
28	31	<p class="hint"><kbd>WASD</kbd> move · <kbd>Space</kbd> jump · <kbd>Ctrl</kbd> crouch ·
29	32	<kbd>Shift</kbd> walk · <kbd>F</kbd> or the mouse fires · <kbd>R</kbd> reload ·
30		<kbd>Enter</kbd> start · <kbd>Esc</kbd> gives the mouse back. On a touch screen the left of
31		the view is a stick, the right looks around, and the buttons do the rest.</p>
	33	<kbd>Enter</kbd> start · <kbd>T</kbd> the other drill · <kbd>Esc</kbd> gives the mouse
	34	back. On a touch screen the left of the view is a stick, the right looks around, and the
	35	buttons do the rest.</p>
32	36	<p class="hint">It makes its own noise, through the engine's sound device and the range's own
33	37	recipes: a short dry crack, a clean tone for a hit, a knock as a plate stands up — quieter
34	38	the farther down the lane it is — a tick for each of the last three seconds and one falling
		@@ -54,7 +58,7 @@ export function rangePage(options: PageOptions): string {
54	58	{ action: "walk", label: "walk" },
55	59	],
56	60	[
57		{ action: "reload", label: "reload" },
	61	{ action: "drill", label: "drill" },
58	62	{ action: "start", label: "start" },
59	63	{ action: "fire", label: "fire" },
60	64	],
		@@ -72,12 +76,26 @@ export function rangePage(options: PageOptions): string {
72	76	actions are held, what movement they and the thumb stick add up to, and where you are
73	77	looking.</p>
74	78	<p>There is a game on top of that, and the engine's renderer under it. Press <kbd>Enter</kbd> and
75		thirty seconds start: plates pop up down the lane from a seeded spawn, each with its own
76		lifetime and worth 100 to 200 points depending on how far away it stood, and a click traces
77		a ray from your eye along your own view angles with the engine's own box trace — so a hit
78		is a hit in three dimensions, not a hit on a picture. The clock ends the run, stops the
79		trigger and reports the score, the hits, the shots and the accuracy; <kbd>Enter</kbd>
80		starts the next one, and the best of this visit is kept on the page and nowhere else.</p>
	79	thirty seconds start: plates stand up down the lane from a seeded spawn, each with its own
	80	lifetime, and a click traces a ray from your eye along your own view angles with the
	81	engine's own box trace — so a hit is a hit in three dimensions, not a hit on a picture. The
	82	clock ends the run, stops the trigger and reports the score, the hits, the shots and the
	83	accuracy; <kbd>Enter</kbd> starts the next one, and the best of this visit is kept on the
	84	page and nowhere else.</p>
	85	<p>Two drills share that lane, and <kbd>T</kbd> chooses between them before a run — mid-run
	86	the key does nothing rather than splicing two games into one score. <strong>Pop-up</strong>
	87	is the drill this range shipped with, unchanged in every number: three plates at a time,
	88	standing still, worth 100 to 200 points by how far down the lane they stood.
	89	<strong>Tracking</strong> is the second: two at a time, nearer and longer-lived, each
	90	sliding across the lane at 90 to 260 units a second until its time or its lane runs out,
	91	and worth 100 to 160 for the distance plus a third of a point for every unit a second it is
	92	crossing at — so the fast one is the one to take first, and you have to lead it. The best
	93	score is kept per drill, because a tracking score means nothing beside a pop-up one. A
	94	drill is one entry in a table in <code>src/range/targets.ts</code> — spawn rate, lifetime,
	95	speed range, scoring — and nothing under this page branches on which one is being played: a
	96	third drill is one more row. Each has a digest of its own in
	97	<code>src/range/pin.test.ts</code>, a seeded run played through a fixed script and hashed
	98	tick by tick, so a tuning of one says which one it changed.</p>
81	99	<p>You can see it now, and by the same renderer the shooter uses: the room is one mesh built
82	100	from this game's own numbers, every plate is one instance of one cube sized to its own box,
83	101	the shot leaves a tracer for eighty milliseconds, and the atlas they are painted from is
		@@ -18,11 +18,13 @@ test("the range's bindings are its own, not the shooter's", () => {
18	18	expect(RANGE_KEYS.ShiftLeft).toBe("walk");
19	19	expect(RANGE_KEYS.KeyR).toBe("reload");
20	20	expect(RANGE_KEYS.Enter).toBe("start");
	21	// One key for the one choice this game offers: which drill the next run is.
	22	expect(RANGE_KEYS.KeyT).toBe("drill");
21	23	// A keyboard reaches the trigger too: pointer lock is not the only way in.
22	24	expect(RANGE_KEYS.KeyF).toBe("fire");
23	25	expect(RANGE_MOUSE[0]).toBe("fire");
24	26	expect(RANGE_MOUSE[2]).toBeUndefined();
25		expect([...RANGE_TAP]).toEqual(["jump", "reload", "start"]);
	27	expect([...RANGE_TAP]).toEqual(["jump", "reload", "start", "drill"]);
26	28	// Nothing cs-shaped: no buy, no scoreboard, no weapon slots.
27	29	for (const code of ["KeyB", "Tab", "Digit1", "Digit2", "Digit3"])
28	30	expect(RANGE_KEYS[code]).toBeUndefined();
		@@ -52,13 +54,14 @@ test("the stick adds to the keys and the sum clamps to ±1", () => {
52	54	});
53	55
54	56	test("every held action lands on its field", () => {
55		const held = intent(["jump", "duck", "walk", "fire", "reload", "start"]);
	57	const held = intent(["jump", "duck", "walk", "fire", "reload", "start", "drill"]);
56	58	expect(held.jump).toBe(true);
57	59	expect(held.duck).toBe(true);
58	60	expect(held.walk).toBe(true);
59	61	expect(held.fire).toBe(true);
60	62	expect(held.reload).toBe(true);
61	63	expect(held.start).toBe(true);
	64	expect(held.drill).toBe(true);
62	65	});
63	66
64	67	test("an action the range does not know changes nothing", () => {
		@@ -15,14 +15,14 @@ export const RANGE_KEYS: Record<string, string> = {
15	15	KeyW: "forward", KeyS: "back", KeyA: "left", KeyD: "right",
16	16	ArrowUp: "forward", ArrowDown: "back", ArrowLeft: "left", ArrowRight: "right",
17	17	Space: "jump", ControlLeft: "duck", KeyC: "duck", ShiftLeft: "walk",
18		KeyF: "fire", KeyR: "reload", Enter: "start",
	18	KeyF: "fire", KeyR: "reload", Enter: "start", KeyT: "drill",
19	19	};
20	20
21	21	/** One weapon, one button: the left one. There is nothing to scope here. */
22	22	export const RANGE_MOUSE: Record<number, string> = { 0: "fire" };
23	23
24	24	/** On-screen buttons that are a tap, not a hold. */
25		export const RANGE_TAP = ["jump", "reload", "start"] as const;
	25	export const RANGE_TAP = ["jump", "reload", "start", "drill"] as const;
26	26
27	27	/**
28	28	* Every action the range knows, in the order the readout prints them. An
		@@ -30,7 +30,7 @@ export const RANGE_TAP = ["jump", "reload", "start"] as const;
30	30	* `data-action` — is collected by the controls and ignored here.
31	31	*/
32	32	export const RANGE_ACTIONS = [
33		"forward", "back", "left", "right", "jump", "duck", "walk", "fire", "reload", "start",
	33	"forward", "back", "left", "right", "jump", "duck", "walk", "fire", "reload", "start", "drill",
34	34	] as const;
35	35
36	36	export type RangeAction = (typeof RANGE_ACTIONS)[number];
		@@ -51,11 +51,18 @@ export type Intent = {
51	51	reload: boolean;
52	52	/** Begin a run — the button and <kbd>Enter</kbd> both say it. */
53	53	start: boolean;
	54	/**
	55	* Switch to the next drill — <kbd>T</kbd> and the button say it. What it
	56	* means is the game's: `targets.ts` refuses it mid-run, and this file only
	57	* reports that it was asked for.
	58	*/
	59	drill: boolean;
54	60	};
55	61
56	62	/** Nothing held, nothing pushed. */
57	63	export const NO_INTENT: Intent = {
58		forward: 0, side: 0, jump: false, duck: false, walk: false, fire: false, reload: false, start: false,
	64	forward: 0, side: 0, jump: false, duck: false, walk: false, fire: false, reload: false,
	65	start: false, drill: false,
59	66	};
60	67
61	68	export function readIntent(held: ReadonlySet<string>, stick: { x: number; y: number }): Intent {
		@@ -69,6 +76,7 @@ export function readIntent(held: ReadonlySet<string>, stick: { x: number; y: num
69	76	fire: down("fire"),
70	77	reload: down("reload"),
71	78	start: down("start"),
	79	drill: down("drill"),
72	80	};
73	81	}
74	82
		@@ -172,8 +172,8 @@ test("Enter starts a run, the clock runs and the plates pop up", () => {
172	172	const { p, undo } = booted();
173	173	try {
174	174	p.step(20);
175		expect(hudTexts(p)).toContain("press Enter for a 30 second run");
176		expect(hudTexts(p)).toContain("score 0 · best 0 · 0/0 hits · 0%");
	175	expect(hudTexts(p)).toContain("press Enter for a 30 second run · T for tracking");
	176	expect(hudTexts(p)).toContain("pop-up · score 0 · best 0 · 0/0 hits · 0%");
177	177
178	178	p.window.fire("keydown", { code: "Enter" });
179	179	p.step(20); // one 50 Hz tick: 0.02 s off the clock, and the first plate up
		@@ -218,19 +218,19 @@ test("a mouse plays it: turn onto a plate, click, and the score moves", () => {
218	218	// first: the bullet goes where the crosshair ended up.
219	219	p.window.fire("keydown", { code: "KeyF" });
220	220	p.step(20);
221		const score = latest(p, "score");
222		expect(score).toMatch(/^score \d+ · best 0 · 1\/1 hits · 100%$/);
223		expect(Number(/^score (\d+)/.exec(score)?.[1])).toBeGreaterThanOrEqual(100);
	221	const score = latest(p, "pop-up");
	222	expect(score).toMatch(/^pop-up · score \d+ · best 0 · 1\/1 hits · 100%$/);
	223	expect(Number(/score (\d+)/.exec(score)?.[1])).toBeGreaterThanOrEqual(100);
224	224
225	225	// The trigger held down is one shot, not one a frame.
226	226	p.step(20);
227		expect(latest(p, "score")).toContain("1/1 hits");
	227	expect(latest(p, "pop-up")).toContain("1/1 hits");
228	228	// Letting go and pulling again is a second shot, and the plate is gone.
229	229	p.window.fire("keyup", { code: "KeyF" });
230	230	p.step(20);
231	231	p.window.fire("keydown", { code: "KeyF" });
232	232	p.step(20);
233		expect(latest(p, "score")).toContain("1/2 hits · 50%");
	233	expect(latest(p, "pop-up")).toContain("1/2 hits · 50%");
234	234	} finally {
235	235	undo();
236	236	}
		@@ -246,24 +246,24 @@ test("the clock ends the run, the entry stops shooting and the best score stays"
246	246	p.window.fire("keydown", { code: "KeyF" });
247	247	p.step(20);
248	248	p.window.fire("keyup", { code: "KeyF" });
249		expect(latest(p, "score")).toContain("/1 hits");
	249	expect(latest(p, "pop-up")).toContain("/1 hits");
250	250
251	251	// Thirty seconds, eight 50 Hz ticks to a frame: 188 frames of 160 ms.
252	252	for (let i = 0; i < 190; i++) p.step(160);
253		expect(latest(p, "run over")).toMatch(/^run over · \d+ points · Enter for another$/);
	253	expect(latest(p, "run over")).toMatch(/^run over · \d+ points · Enter for another · T for tracking$/);
254	254
255	255	// The clock at zero refuses the trigger: still the one shot.
256	256	p.window.fire("keydown", { code: "KeyF" });
257	257	p.step(20);
258		expect(latest(p, "score")).toContain("/1 hits");
	258	expect(latest(p, "pop-up")).toContain("/1 hits");
259	259	// And the run that just ended is the best so far, however it went.
260		const score = /^score (\d+) · best (\d+)/.exec(latest(p, "score"));
	260	const score = /score (\d+) · best (\d+)/.exec(latest(p, "pop-up"));
261	261	expect(score?.[2]).toBe(score?.[1] as string);
262	262
263	263	// Enter gives a fresh thirty seconds, and the best survives it.
264	264	p.window.fire("keydown", { code: "Enter" });
265	265	p.step(20);
266		expect(latest(p, "score")).toMatch(/^score 0 · best \d+ · 0\/0 hits · 0%$/);
	266	expect(latest(p, "pop-up")).toMatch(/^pop-up · score 0 · best \d+ · 0\/0 hits · 0%$/);
267	267	expect(hudTexts(p)).toContain("30.0 s left · 1 up");
268	268	} finally {
269	269	undo();
		@@ -422,7 +422,7 @@ test("a run makes its own noise: one device, a plate popping up, a crack and a h
422	422	played = sounds(p).length;
423	423	p.window.fire("keydown", { code: "KeyF" });
424	424	p.step(20);
425		expect(latest(p, "score")).toContain("1/1 hits");
	425	expect(latest(p, "pop-up")).toContain("1/1 hits");
426	426	expect(sincePlayed(p, played).filter((sound) => sound !== "pop")).toEqual(["crack", "hit"]);
427	427
428	428	// The trigger held down is one shot, so it is one crack and not one a frame.
		@@ -456,7 +456,7 @@ test("a miss cracks and nothing more, and a trigger outside a run is silent", ()
456	456	p.window.fire("keydown", { code: "KeyF" });
457	457	p.step(20);
458	458	p.window.fire("keyup", { code: "KeyF" });
459		expect(latest(p, "score")).toContain("0/1 hits");
	459	expect(latest(p, "pop-up")).toContain("0/1 hits");
460	460	expect(sincePlayed(p, played).filter((sound) => sound !== "pop")).toEqual(["crack"]);
461	461
462	462	// Run the clock out, then pull the trigger: the run refuses the shot, so
		@@ -528,3 +528,74 @@ test("a browser with no WebGL2 keeps the game on the 2D horizon, and says so", (
528	528	undo();
529	529	}
530	530	});
	531
	532	test("T chooses the drill between runs, and does nothing during one", () => {
	533	const { p, undo } = booted();
	534	try {
	535	p.step(20);
	536	expect(latest(p, "pop-up")).toContain("score 0");
	537	// One press is one switch, held down or not.
	538	p.window.fire("keydown", { code: "KeyT" });
	539	p.step(20);
	540	p.step(20);
	541	expect(latest(p, "tracking")).toContain("score 0 · best 0");
	542	expect(hudTexts(p)).toContain("press Enter for a 30 second run · T for pop-up");
	543	p.window.fire("keyup", { code: "KeyT" });
	544
	545	// Mid-run it is refused: the drill, the clock and the plates carry on.
	546	p.window.fire("keydown", { code: "Enter" });
	547	p.step(20);
	548	p.window.fire("keyup", { code: "Enter" });
	549	p.step(200);
	550	const during = latest(p, "tracking");
	551	p.window.fire("keydown", { code: "KeyT" });
	552	p.step(20);
	553	expect(latest(p, "tracking")).toStartWith("tracking · ");
	554	expect(during).toStartWith("tracking · ");
	555	expect(hudTexts(p).some((line) => /^29\.\d s left · \d+ up$/.test(line))).toBe(true);
	556	p.window.fire("keyup", { code: "KeyT" });
	557	p.step(20);
	558
	559	// And the plates of that drill move: the one standing is drawn in two
	560	// places two frames apart, which a pop-up plate never is.
	561	const where = (): number => {
	562	const before = p.scene.paint?.calls.length ?? 0;
	563	p.step(20);
	564	return (platesDrawn(p, before)[0] as [string, number, ...unknown[]])[1];
	565	};
	566	expect(where()).not.toBe(where());
	567	} finally {
	568	undo();
	569	}
	570	});
	571
	572	test("a best score belongs to its drill and is never shown beside the other", () => {
	573	const { p, undo } = booted();
	574	try {
	575	// A pop-up run, played to the end: whatever it scored is the pop-up best.
	576	p.window.fire("keydown", { code: "Enter" });
	577	p.step(20);
	578	p.window.fire("keyup", { code: "Enter" });
	579	p.window.fire("keydown", { code: "KeyF" });
	580	p.step(20);
	581	p.window.fire("keyup", { code: "KeyF" });
	582	for (let i = 0; i < 190; i++) p.step(160);
	583	const popup = /score (\d+) · best (\d+)/.exec(latest(p, "pop-up")) as RegExpExecArray;
	584	expect(popup[2]).toBe(popup[1] as string);
	585
	586	// Switching drills shows that drill's own best, which is nothing yet.
	587	p.window.fire("keydown", { code: "KeyT" });
	588	p.step(20);
	589	p.window.fire("keyup", { code: "KeyT" });
	590	expect(latest(p, "tracking")).toBe("tracking · score 0 · best 0 · 0/0 hits · 0%");
	591	// And switching back finds the pop-up best where it was left. The key has
	592	// to come up first: one press is one switch, and this is the second press.
	593	p.step(20);
	594	p.window.fire("keydown", { code: "KeyT" });
	595	p.step(20);
	596	p.window.fire("keyup", { code: "KeyT" });
	597	expect(latest(p, "pop-up")).toBe(`pop-up · score 0 · best ${popup[2]} · 0/0 hits · 0%`);
	598	} finally {
	599	undo();
	600	}
	601	});
		@@ -7,6 +7,13 @@
7	7	* the readout's panel on the HUD canvas above it, and `audio.ts` is what the
8	8	* same frame sounds like through the engine's sound device.
9	9	*
	10	* There are two drills and the choice between them is one key: <kbd>T</kbd>, or
	11	* the button beside it, asks `targets.ts` for the next one in its table. The
	12	* game itself decides whether that is allowed — a live run refuses — and this
	13	* file only passes the press on and prints which drill is being played and what
	14	* the key would switch to. The best score is kept per drill, here and nowhere
	15	* else: nothing on this page is stored.
	16	*
10	17	* Every sound is a crossing this file found in the game's own facts: a plate
11	18	* with an id the last frame had not reached stood up, the shot `shoot` handed
12	19	* back was taken and maybe hit, the clock passed one of the last three whole
		@@ -27,7 +34,10 @@ import { createRangeAudio } from "./audio.ts";
27	34	import { RANGE_KEYS, RANGE_MOUSE, RANGE_TAP, heldActions, readIntent } from "./binding.ts";
28	35	import { drawHorizon, drawReadout, wrapDegrees, type Paint } from "./readout.ts";
29	36	import { buildRangeScene, createRangeScene, rangeAssets, type Trail } from "./scene.ts";
30		import { EYE, createRun, report, shoot, start, step, type Target } from "./targets.ts";
	37	import {
	38	DRILLS, EYE, createRun, nextDrill, report, setDrill, shoot, start, step,
	39	type DrillName, type Target,
	40	} from "./targets.ts";
31	41	import {
32	42	angleVectors, attachButtons, clamp, createControls, createLoop, createRenderer,
33	43	} from "../engine/index.ts";
		@@ -113,15 +123,22 @@ export function boot(): void {
113	123	// two runs are two different thirty seconds, and a run is still reproducible
114	124	// from the one number it was spawned with.
115	125	const run = createRun(freshSeed());
116		let best = 0;
117		// Both of these are edges, not holds: a held trigger is one shot, and a held
118		// Enter is one run. The mouse says "fire" for as long as the button is down.
	126	/**
	127	* The best of this visit, per drill: a tracking score next to a pop-up best
	128	* would be two games in one number. Nothing is stored anywhere — this page
	129	* keeps no cookie and writes no table — so both start at zero.
	130	*/
	131	const bests: Record<DrillName, number> = { popup: 0, tracking: 0 };
	132	// All three of these are edges, not holds: a held trigger is one shot, a held
	133	// Enter is one run and a held T is one switch. The mouse says "fire" for as
	134	// long as the button is down.
119	135	let firing = false;
120	136	let starting = false;
	137	let switching = false;
121	138
122	139	/** Remember the score of a run that is finishing, whatever finished it. */
123	140	const keepBest = (): void => {
124		best = Math.max(best, run.score);
	141	bests[run.drill.name] = Math.max(bests[run.drill.name], run.score);
125	142	};
126	143
127	144	// The mouse only turns the view under pointer lock; a finger on the stage
		@@ -168,6 +185,13 @@ export function boot(): void {
168	185	// the trigger and Enter half of it is the game.
169	186	const intent = readIntent(controls.held, controls.stick);
170	187
	188	// The drill is chosen between runs: `setDrill` refuses a live one, so a T
	189	// pressed mid-run changes nothing at all rather than half a game.
	190	// A finished run has already had its score kept, and one that has not
	191	// started has none, so there is nothing to remember here.
	192	if (intent.drill && !switching) setDrill(run, DRILLS[nextDrill(run.drill.name)]);
	193	switching = intent.drill;
	194
171	195	if (intent.start && !starting) {
172	196	keepBest();
173	197	start(run, freshSeed());
		@@ -233,7 +257,8 @@ export function boot(): void {
233	257	hudCtx,
234	258	{
235	259	run: report(run),
236		best,
	260	best: bests[run.drill.name],
	261	next: DRILLS[nextDrill(run.drill.name)].label,
237	262	hz: Math.round(1 / TICK),
238	263	ticks,
239	264	frameMs,
		@@ -1,13 +1,19 @@
1	1	/**
2		* The range's golden digest: what this game does, pinned.
	2	* The range's golden digests: what each drill does, pinned.
3	3	*
4		* One run — thirty seconds at 50 Hz from seed 20260917, played through the
5		* fixed script in `pin.ts` — hashed tick by tick. If it fails, read the
6		* message: it names the first second of the run at which the play and the pin
7		* part company and prints the constants to paste in. Paste them only when the
8		* change to the game was deliberate, and say in the pull what moved and why.
9		* A renderer, an atlas or a movement tuning that moves this digest has changed
10		* the game and is not any of those three things.
	4	* Two runs — thirty seconds at 50 Hz from seed 20260917, one per drill, each
	5	* played through its script in `pin.ts` — hashed tick by tick. If one fails,
	6	* read the message: it names the drill, the first second of the run at which
	7	* the play and the pin part company, and prints the constants to paste in.
	8	* Paste them only when the change to the game was deliberate, and say in the
	9	* pull what moved and why. A renderer, an atlas or a movement tuning that moves
	10	* a digest has changed the game and is not any of those three things.
	11	*
	12	* Two digests because a drill is a different game: tuning the tracking drill
	13	* moves `TRACKING` and leaves `RANGE` where it is, so the pull that does it
	14	* says which game it changed. `RANGE` has not moved since it was first written
	15	* down, and that is this pull's own claim checked: a second drill that costs
	16	* the first one a byte is not a second drill, it is a retuning of the first.
11	17	*
12	18	* Measured: the pinned thirty seconds fold in 8 ms (14 ms cold), and the whole
13	19	* file is 60 ms on its own, Bun's start and all — `bun test` is 4.2 s before
		@@ -18,9 +24,9 @@
18	24	import { expect, test } from "bun:test";
19	25	import {
20	26	CHECKPOINT_CHARS, compare, fold, play, PLATE_FIELDS, QUANTUM, RUN_FIELDS, SCRIPT, snapshot,
21		TICK, TICKS_PER_SECOND, trigger, type Pin, type Pinned,
	27	TICK, TICKS_PER_SECOND, TRACKING_SCRIPT, trigger, type Pin, type Pinned,
22	28	} from "./pin.ts";
23		import { accuracy, createRun, EYE, shoot, start, step, type Run } from "./targets.ts";
	29	import { accuracy, createRun, DRILLS, EYE, shoot, start, step, type Run } from "./targets.ts";
24	30	import { angleVectors } from "../engine/index.ts";
25	31
26	32	/** The run: a named seed, thirty seconds of it, at the range's own 50 Hz. */
		@@ -46,7 +52,31 @@ const RANGE_SECONDS = [
46	52	];
47	53
48	54	const RANGE_PIN: Pin = {
49		label: "thirty-second range run", constant: "RANGE", digest: RANGE, checkpoints: RANGE_SECONDS,
	55	label: "thirty-second pop-up run", constant: "RANGE", digest: RANGE, checkpoints: RANGE_SECONDS,
	56	};
	57
	58	/**
	59	* Thirty seconds of the tracking drill on the same seed, played through
	60	* `TRACKING_SCRIPT`: seventeen trigger pulls on the same seventeen ticks as the
	61	* pop-up run's, aimed at this drill's own lane. Computed when #88 added the
	62	* drill, and moved by any change to how a plate slides, how fast it may go, how
	63	* long it lives or what its speed is worth.
	64	*/
	65	const TRACKING = "8462440f5c6fb9aa3ef1f345243351003b0042f17dbf9f1c42fdd7525173ff59";
	66	const TRACKING_SECONDS = [
	67	"e5e0793137c0", "3e49fb9e82aa", "4396dfb53c12", "913963a811b6",
	68	"8fbce1a4635b", "c30f7e1d537f", "28ca6bc5d103", "190d91d28b22",
	69	"63c8d3c43631", "5d94ccd33204", "549a60fa98bd", "d9acc4c3879d",
	70	"197ad3519f9c", "5fe779484245", "5260c155c8e0", "dd67cade9b06",
	71	"ae28ec143c97", "f8e1607029fc", "5a01e5ec8ad8", "e0e3b6678692",
	72	"b52b87f23250", "dfdb918f998b", "8e4815615b48", "92ad91b2e9ac",
	73	"0125b182c493", "ccdba1fef546", "ffa32e68868b", "74ecc60ced90",
	74	"a490df99d433", "ded614fadd7b",
	75	];
	76
	77	const TRACKING_PIN: Pin = {
	78	label: "thirty-second tracking run", constant: "TRACKING", digest: TRACKING,
	79	checkpoints: TRACKING_SECONDS,
50	80	};
51	81
52	82	/** A run that has not been played yet, seeded and live. */
		@@ -56,6 +86,13 @@ function ready(seed: number = SEED): Run {
56	86	return run;
57	87	}
58	88
	89	/** The same, on the tracking drill. */
	90	function tracking(seed: number = SEED): Run {
	91	const run = createRun(seed, DRILLS.tracking);
	92	start(run, seed);
	93	return run;
	94	}
	95
59	96	const must = (run: Pinned, pin: Pin): void => {
60	97	const complaint = compare(run, pin);
61	98	if (complaint !== null) throw new Error(complaint);
		@@ -93,6 +130,46 @@ test("the pinned run is a real one: a score, fourteen hits and three misses", ()
93	130	expect(SCRIPT.every((aim) => aim.tick >= 0 && aim.tick < TICKS)).toBe(true);
94	131	});
95	132
	133	test("a seeded thirty-second tracking run plays exactly as it played", () => {
	134	const run = tracking();
	135	const pinned = play(run, TICKS, TRACKING_SCRIPT);
	136	must(pinned, TRACKING_PIN);
	137	expect(pinned.digest).toBe(TRACKING);
	138	expect(pinned.checkpoints).toEqual(TRACKING_SECONDS);
	139	});
	140
	141	/**
	142	* The tracking run in numbers, beside the pop-up one: the same seventeen shots
	143	* land fourteen again, but on plates that were sliding — so the score is made
	144	* of depth and speed together, and the 2,534 points are 309 more than the same
	145	* count of hits paid on the standing drill.
	146	*/
	147	test("the pinned tracking run is a real one: moving plates, hit where they were", () => {
	148	const run = tracking();
	149	play(run, TICKS, TRACKING_SCRIPT);
	150	expect(run.phase).toBe("over");
	151	expect(run.shots).toBe(17);
	152	expect(run.hits).toBe(14);
	153	expect(run.score).toBe(2534);
	154	expect(run.spawned).toBe(33);
	155	expect(TRACKING_SCRIPT.map((aim) => aim.tick)).toEqual(SCRIPT.map((aim) => aim.tick));
	156	});
	157
	158	/**
	159	* The two digests are two games. Same seed, same seventeen ticks, and not one
	160	* second of the thirty hashes the same — the drill's salt gives it its own lane
	161	* rather than the pop-up lane with speeds bolted on.
	162	*/
	163	test("the two drills never share a run: not a digest, not a second, not a plate", () => {
	164	expect(TRACKING).not.toBe(RANGE);
	165	for (let i = 0; i < SECONDS; i++) expect(TRACKING_SECONDS[i]).not.toBe(RANGE_SECONDS[i]);
	166	// Even unshot and unscripted, the lanes differ from the first plate on.
	167	const bare = (run: Run): Pinned => fold(run, 4 * TICKS_PER_SECOND, () => step(run, TICK));
	168	expect(bare(tracking()).digest).not.toBe(bare(ready()).digest);
	169	// And each is its own repeatable run: the same seed and drill, twice.
	170	expect(bare(tracking()).digest).toBe(bare(tracking()).digest);
	171	});
	172
96	173	test("the same seed is the same run, and another seed is another run", () => {
97	174	const four = 4 * TICKS_PER_SECOND;
98	175	const a = play(ready(), four);
		@@ -1,5 +1,6 @@
1	1	/**
2		* The range's pin: one seeded run, one fixed script of shots, one sha256.
	2	* The range's pin: one seeded run per drill, one fixed script of shots each,
	3	* one sha256 each.
3	4	*
4	5	* A renderer, an atlas and a movement tuning are all about to land under this
5	6	* game, and every one of them will end with the claim "the range plays exactly
		@@ -20,6 +21,15 @@
20	21	* a sentence saying what behaviour changed and why. A digest updated without
21	22	* that sentence is a pin that has stopped pinning anything.
22	23	*
	24	* One digest per drill. A drill is a different game, so it gets a number of
	25	* its own: a tuning of the tracking drill moves the tracking digest and leaves
	26	* the pop-up one alone, and the failure says which. Neither field list below
	27	* changed when the second drill landed, which is how the first digest survived
	28	* it — a plate's velocity is not hashed because it does not need to be. A plate
	29	* that moves is at another place on the next tick, and the place is hashed on
	30	* every one of them: 1,500 positions pin a speed far more tightly than one
	31	* number would, and a plate that started sliding the wrong way shows on tick 1.
	32	*
23	33	* What is hashed is the run's rules playing out — the phase, the clock, the
24	34	* score, the hits, the shots and every standing plate's place, size, lifetime
25	35	* and worth. Not a plate's id and not the order of the lane: those are how
		@@ -146,6 +156,41 @@ export const SCRIPT: Aim[] = [
146	156	{ tick: 1420, yaw: 11.77, pitch: 0.84 }, // hit, 172
147	157	];
148	158
	159	/**
	160	* The same seventeen trigger pulls, on the same seventeen ticks, aimed at the
	161	* tracking drill's lane: fourteen at the plate with the longest left to stand
	162	* on that tick, two six degrees wide of one, and the same sixty degrees of sky.
	163	* The drill's own salt makes it a different lane, so the angles are its own and
	164	* not the pop-up script's — this is the same script, re-aimed, not a second
	165	* kind of script.
	166	*
	167	* Every hit here is a hit on a plate that was moving, at the place the tick
	168	* had just put it: these angles were read off the run after its step and before
	169	* its trigger, which is the order `play` below fires in and the order `main.ts`
	170	* does. Aimed one tick behind, at 260 units a second and 5.2 units of travel a
	171	* tick, a plate 18 units from centre to edge is still hit — but the digest
	172	* moves, and that is the point of pinning it.
	173	*/
	174	export const TRACKING_SCRIPT: Aim[] = [
	175	{ tick: 40, yaw: -18.89, pitch: -6.3 }, // hit, 139 points at 101 u/s
	176	{ tick: 130, yaw: -0.41, pitch: 1.42 }, // hit, 205 at 155 u/s
	177	{ tick: 220, yaw: -33.62, pitch: -1.38 }, // hit, 217 at 221 u/s
	178	{ tick: 300, yaw: -9, pitch: -2.8 }, // 6° wide of the plate at tick 300: a miss
	179	{ tick: 320, yaw: -12.44, pitch: -2.84 }, // hit, 197 at 106 u/s
	180	{ tick: 430, yaw: 15.88, pitch: 1.07 }, // hit, 158 at 120 u/s
	181	{ tick: 540, yaw: 40.03, pitch: -2.47 }, // hit, 188 at 243 u/s
	182	{ tick: 650, yaw: 40.44, pitch: -3.25 }, // hit, 186 at 229 u/s
	183	{ tick: 700, yaw: 0, pitch: -60 }, // sky: a miss with nothing anywhere near it
	184	{ tick: 760, yaw: 5.55, pitch: -3.48 }, // hit, 164 at 152 u/s
	185	{ tick: 870, yaw: -24.21, pitch: -3.75 }, // hit, 200 at 157 u/s
	186	{ tick: 980, yaw: -34.84, pitch: -4.78 }, // hit, 163 at 176 u/s
	187	{ tick: 1000, yaw: 9.41, pitch: 2.06 }, // 6° wide again: a miss
	188	{ tick: 1090, yaw: -33.33, pitch: 0.04 }, // hit, 155 at 154 u/s
	189	{ tick: 1200, yaw: -16, pitch: -1.22 }, // hit, 170 at 166 u/s
	190	{ tick: 1310, yaw: -15.84, pitch: -4.74 }, // hit, 163 at 105 u/s
	191	{ tick: 1420, yaw: 6.58, pitch: -1.23 }, // hit, 229 at 241 u/s
	192	];
	193
149	194	/**
150	195	* A cursor over the script: hand it a tick and it fires whatever that tick
151	196	* holds, in order. A tick with no aim on it is a tick with the trigger off,
		@@ -35,17 +35,20 @@ function recorder(): Paint & { calls: Call[]; texts: string[]; lines: Call[] } {
35	35	} as Paint & { calls: Call[]; texts: string[]; lines: Call[] };
36	36	}
37	37
38		const RUN = { phase: "live" as const, clock: 12.34, score: 700, hits: 4, shots: 6, accuracy: 4 / 6, up: 3 };
	38	const RUN = {
	39	drill: "popup" as const, label: "pop-up", phase: "live" as const,
	40	clock: 12.34, score: 700, hits: 4, shots: 6, accuracy: 4 / 6, up: 3,
	41	};
39	42
40	43	const READOUT: Readout = {
41		run: RUN, best: 1200,
	44	run: RUN, best: 1200, next: "tracking",
42	45	hz: 50, ticks: 1234, frameMs: 16.66, held: ["forward", "fire"],
43	46	move: { forward: 1, side: -0.5 }, yaw: 45, pitch: -10, locked: true, drawn: true,
44	47	};
45	48
46	49	test("the panel leads with the score and the clock, then the loop and the controls", () => {
47	50	const lines = readoutLines(READOUT);
48		expect(lines[0]).toBe("score 700 · best 1200 · 4/6 hits · 67%");
	51	expect(lines[0]).toBe("pop-up · score 700 · best 1200 · 4/6 hits · 67%");
49	52	expect(lines[1]).toBe("12.3 s left · 3 up");
50	53	expect(lines[2]).toBe("tick 1234 · 50 Hz fixed step");
51	54	expect(lines[3]).toBe("frame 16.7 ms · 60 fps");
		@@ -60,12 +63,12 @@ test("the panel leads with the score and the clock, then the loop and the contro
60	63
61	64	test("the clock line says how to start a run, how long is left, and how it went", () => {
62	65	const ready = readoutLines({ ...READOUT, run: { ...RUN, phase: "ready", clock: 30, up: 0 } });
63		expect(ready[1]).toBe("press Enter for a 30 second run");
	66	expect(ready[1]).toBe("press Enter for a 30 second run · T for tracking");
64	67	const over = readoutLines({ ...READOUT, run: { ...RUN, phase: "over", clock: 0, up: 0 } });
65		expect(over[1]).toBe("run over · 700 points · Enter for another");
	68	expect(over[1]).toBe("run over · 700 points · Enter for another · T for tracking");
66	69	// No shots taken is no accuracy, not a NaN on the page.
67	70	const fresh = readoutLines({ ...READOUT, run: { ...RUN, score: 0, hits: 0, shots: 0, accuracy: 0 }, best: 0 });
68		expect(fresh[0]).toBe("score 0 · best 0 · 0/0 hits · 0%");
	71	expect(fresh[0]).toBe("pop-up · score 0 · best 0 · 0/0 hits · 0%");
69	72	});
70	73
71	74	test("nothing held says so, and an unlocked pointer says how to lock it", () => {
		@@ -186,3 +189,21 @@ test("a run's own targets are what the scene draws, and they go when the run doe
186	189	expect(paint.calls.filter((c) => c[0] === "fillRect").length).toBe(2 + run.targets.length);
187	190	expect(readoutLines({ ...READOUT, run: report(run) })[1]).toContain(`${run.targets.length} up`);
188	191	});
	192
	193	test("the panel names the drill, and the score beside it is that drill's own", () => {
	194	const popup = readoutLines(READOUT);
	195	expect(popup[0]).toStartWith("pop-up · ");
	196	// The same numbers on the other drill read as the other drill's: the label
	197	// and the best move together, because a best belongs to one of them.
	198	const tracked = readoutLines({
	199	...READOUT,
	200	run: { ...RUN, drill: "tracking", label: "tracking" },
	201	best: 90,
	202	next: "pop-up",
	203	});
	204	expect(tracked[0]).toBe("tracking · score 700 · best 90 · 4/6 hits · 67%");
	205	// Mid-run the switch is not offered, because mid-run it does nothing.
	206	expect(tracked[1]).toBe("12.3 s left · 3 up");
	207	expect(readoutLines({ ...READOUT, run: { ...RUN, phase: "ready" }, next: "tracking" })[1])
	208	.toContain("T for tracking");
	209	});