quill/val Public Public: anyone can read this; nobody can change it.

/**

 * The client, played.

 *

 * The bundle the browser is served is loaded here against a stub document

 * and a canvas that only writes down what it was told to draw, and pointed

 * at the running server over a real socket. It is not a browser, but it is

 * the whole path a person takes: connect, take a snapshot, paint the HUD,

 * draw a frame, press a key, send an input back.

 */

import { expect, test } from "bun:test";

import { mkdtempSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

process.env.FORGE_APP_DATA ??= mkdtempSync(join(tmpdir(), "app-"));

process.env.PORT ??= "0";

const { server } = await import("./server.ts");

const base = `http://${server.hostname}:${server.port}`;

// ------------------------------------------------------------ the stub DOM

const drawn: string[] = [];

/**

 * Every canvas the client asked the document for. The widest is its offscreen

 * world buffer, whose width is however many columns the frame budget settled

 * on; the other is the minimap's tile layer. Keeping them is what lets a test

 * bound the frame's cost as a fraction of the columns actually used, instead

 * of against a number somebody picked once.

 */

const canvases: Record<string, unknown>[] = [];

const worldColumns = (): number => Math.max(0, ...canvases.map((c) => Number(c.width) || 0));

// Where the canvas was moved to: on the top-down view your own body is an

// arrow drawn about the origin, so the last translate of a frame is where

// this client thinks you are.

const moves: { x: number; y: number }[] = [];

const listeners = new Map<string, ((event: unknown) => void)[]>();

const frames: ((now: number) => void)[] = [];

const noop = () => {};

const context = () =>

  new Proxy(

    {

      measureText: (text: string) => ({ width: text.length * 6 }),

      createLinearGradient: () => ({ addColorStop: noop }),

    } as Record<string, unknown>,

    {

      get(target, prop: string) {

        if (prop in target) return target[prop];

        if (prop === "fillStyle" || prop === "strokeStyle" || prop === "font" || prop === "textAlign") return "";

        if (prop === "globalAlpha" || prop === "lineWidth") return 1;

        return (...args: unknown[]) => {

          if (prop === "translate") moves.push({ x: Number(args[0]), y: Number(args[1]) });

          return drawn.push(`${prop}(${args.length})`);

        };

      },

      set: () => true,

    },

  );

function element(id: string, attrs: Record<string, string> = {}) {

  const node: Record<string, unknown> = {

    id,

    dataset: { ...attrs },

    style: {},

    textContent: "",

    title: "",

    disabled: false,

    type: "",

    children: [] as unknown[],

    classList: {

      on: new Set<string>(),

      add(name: string) {

        (this.on as Set<string>).add(name);

      },

      remove(name: string) {

        (this.on as Set<string>).delete(name);

      },

      toggle(name: string, force?: boolean) {

        const on = force ?? !(this.on as Set<string>).has(name);

        if (on) (this.on as Set<string>).add(name);

        else (this.on as Set<string>).delete(name);

        return on;

      },

      contains(name: string) {

        return (this.on as Set<string>).has(name);

      },

    },

    events: new Map<string, ((event: unknown) => void)[]>(),

    addEventListener(kind: string, fn: (event: unknown) => void) {

      const map = node.events as Map<string, ((event: unknown) => void)[]>;

      map.set(kind, [...(map.get(kind) ?? []), fn]);

    },

    append(...kids: unknown[]) {

      (node.children as unknown[]).push(...kids);

    },

    replaceChildren(...kids: unknown[]) {

      node.children = kids;

    },

    getBoundingClientRect: () => ({ left: 0, top: 0, width: 900, height: 570 }),

    getContext: () => context(),

    requestPointerLock: noop,

    setPointerCapture: noop,

    width: 900,

    height: 570,

  };

  return node;

}

const click = (node: Record<string, unknown>) => {

  for (const fn of (node.events as Map<string, ((e: unknown) => void)[]>).get("click") ?? []) fn({});

};

const press = (code: string, key = "") => {

  for (const fn of listeners.get("keydown") ?? []) fn({ code, key, target: {}, preventDefault: noop });

};

const release = (code: string) => {

  for (const fn of listeners.get("keyup") ?? []) fn({ code });

};

const nodes = new Map<string, Record<string, unknown>>();

for (const id of [

  "view", "conn", "clock", "phase", "hp", "gun", "creds", "ultmeter", "kit", "buy", "buytoggle",

  "viewtoggle", "helptoggle", "helpclose", "help", "prompt", "flash", "dead", "aimhint", "stage",

  "log", "atkboard", "defboard", "helpagents", "roster", "feed", "perf",

])

  nodes.set(id, element(id));

const GUNS = ["classic", "ghost", "sheriff", "spectre", "phantom", "vandal", "operator"];

const buys = [

  ...GUNS.map((gun, i) => element(`g${i}`, { buy: gun, cost: gun === "vandal" ? "2900" : "0" })),

  element("b2", { buy: "c", cost: "0" }),

  element("b3", { buy: "q", cost: "0" }),

];

const agentButtons = [element("a1", { agent: "veil" })];

const scoreRed = element("red");

const scoreBlue = element("blue");

Object.assign(globalThis, {

  document: {

    getElementById: (id: string) => nodes.get(id) ?? null,

    querySelector: (sel: string) => (sel.includes("red") ? scoreRed : scoreBlue),

    querySelectorAll: (sel: string) => (sel.includes("data-buy") ? buys : agentButtons),

    createElement: (tag: string) => {

      const node = element(tag);

      if (tag === "canvas") canvases.push(node);

      return node;

    },

    addEventListener: noop,

    pointerLockElement: null,

    exitPointerLock: noop,

  },

  HTMLInputElement: class {},

  matchMedia: () => ({ matches: false }),

  devicePixelRatio: 1,

  localStorage: {

    store: new Map<string, string>(),

    getItem(key: string) {

      return this.store.get(key) ?? null;

    },

    setItem(key: string, value: string) {

      this.store.set(key, value);

    },

  },

  requestAnimationFrame: (fn: (now: number) => void) => frames.push(fn),

  addEventListener: (kind: string, fn: (event: unknown) => void) => {

    listeners.set(kind, [...(listeners.get(kind) ?? []), fn]);

  },

  location: new URL(base),

});

// Relative fetches, the way a page makes them.

const realFetch = globalThis.fetch;

globalThis.fetch = ((input: string, init?: RequestInit) =>

  realFetch(typeof input === "string" && input.startsWith("/") ? base + input : input, init)) as typeof fetch;

// A real browser attaches the session cookie to the websocket handshake on

// its own; this stub is not a browser, so it carries the cookie the page's

// own fetch was handed, the way one actually would.

let sessionCookie = "";

let openedSocket: WebSocket | null = null;

const RealWebSocket = globalThis.WebSocket;

globalThis.WebSocket = function (url: string) {

  openedSocket = new RealWebSocket(url, { headers: { cookie: sessionCookie } } as unknown as string[]);

  return openedSocket;

} as unknown as typeof WebSocket;

const runFrame = (at = performance.now()) => {

  const pending = frames.splice(0, frames.length);

  for (const fn of pending) fn(at);

};

const until = async (what: () => boolean, ms = 4000) => {

  const stop = Date.now() + ms;

  while (Date.now() < stop) {

    runFrame();

    if (what()) return true;

    await Bun.sleep(20);

  }

  return false;

};

// ------------------------------------------------------------------ the run

test("the bundled client connects, paints the HUD and draws a frame", async () => {

  // Every test in this run reaches the server from the one loopback address,

  // and a playing seat is rationed per address on purpose. A socket another

  // file closed a moment ago may not have given its seat back yet, and this

  // client would then be handed a spectator view and wait four seconds for a

  // health readout that never comes — the coin-flip failure the suite had.

  // Start from a clean slate, the way the server's own seat tests do.

  const { releaseAddress } = await import("./arena.ts");

  for (const address of ["127.0.0.1", "::1", "::ffff:127.0.0.1"]) releaseAddress(address);

  const first = await fetch(base + "/");

  sessionCookie = (first.headers.get("set-cookie") ?? "").split(";")[0] ?? "";

  const page = await first.text();

  const src = /src="(\/static\/val\.[0-9a-f]+\.js)"/.exec(page)![1]!;

  const script = await (await fetch(base + src)).text();

  const path = join(process.env.FORGE_APP_DATA!, "client.mjs");

  await Bun.write(path, script);

  await import(path);

  expect(await until(() => nodes.get("conn")!.textContent === "live")).toBe(true);

  // The one socket this module opens is already under way; put the global

  // back so another test file's raw `new WebSocket(...)` is not silently

  // handed a cookie this test happened to pick up.

  globalThis.WebSocket = RealWebSocket;

  expect(await until(() => String(nodes.get("hp")!.textContent).includes("hp"))).toBe(true);

  // The HUD says what the match says.

  expect(String(nodes.get("phase")!.textContent)).toContain("round");

  expect(String(nodes.get("creds")!.textContent)).toContain("cr");

  // The kit is four buttons, each named after the ability it casts.

  expect((nodes.get("kit")!.children as unknown[]).length).toBe(4);

  // One prompt, in words, about the round that is running.

  expect(String(nodes.get("prompt")!.textContent).length).toBeGreaterThan(8);

  // And the buy panel prices itself off the agent's real kit.

  expect(String(buys.find((b) => (b.dataset as { buy: string }).buy === "c")!.title)).toContain("charge");

  // The gun you hold is the one gun button marked as yours.

  const held = (await import("./arena.ts")).match().players.find((p) => !p.bot)!;

  const ownedGuns = buys.filter(

    (b) => GUNS.includes((b.dataset as { buy: string }).buy) && (b.classList as { contains: (n: string) => boolean }).contains("owned"),

  );

  expect(ownedGuns.map((b) => (b.dataset as { buy: string }).buy)).toEqual([held.weapon]);

  // The team is on screen whether anybody is in sight or not: five slots.

  const slots = nodes.get("roster")!.children as { className: string }[];

  expect(slots.length).toBe(5);

  expect(slots.filter((slot) => slot.className.includes("mine")).length).toBe(1);

  // Run the match on a few seconds: bots trade, and the feed fills with

  // names — and with nothing that says where anybody is.

  const arena = await import("./arena.ts");

  for (let i = 0; i < 40 && (nodes.get("feed")!.children as unknown[]).length === 0; i++) {

    arena.advance(5);

    await Bun.sleep(5);

  }

  const feedRows = nodes.get("feed")!.children as { children: { textContent: string }[] }[];

  expect(feedRows.length).toBeGreaterThan(0);

  // killer ▸ victim, and the gun or the ability it was: four spans, no numbers.

  const row = feedRows[0]!.children.map((span) => span.textContent).join("");

  expect(row).toContain(" ▸ ");

  expect(row).not.toMatch(/\d/);

  // A frame of the first-person view draws the world into its own buffer and

  // blits it, with the minimap's tiles blitted too. It is a picture, but it is

  // NOT one fill a screen column, nor one a map tile: the map has 570 tiles and

  // the buffer up to 960 columns, and the frame used to pay for both. The

  // minimap's tiles are the blit; the walls are a run a fill.

  //

  // That sentence is the whole assertion, and it is now written as one. It

  // used to demand more than 40 fills and fewer than 900, which failed about

  // one full-suite run in twenty-five: the loop above advances the SHARED

  // match until somebody dies — five to two hundred seconds of play — so the

  // view being counted was wherever that left the seat. Alone it draws 154 to

  // 236 fills; the run that failed drew 31, and a preview drew 525. Every one

  // of those is a correct frame of a different view. A bound on the count of

  // an unfixed view can only ever be luck.

  //

  // So the bounds are the two things true of EVERY view: it drew something,

  // and it cost fewer fills than the frame had columns. The column count is

  // read off the client's own offscreen buffer rather than hardcoded, because

  // the frame budget moves the world between 960 and 448 columns and a

  // constant cannot tell "a run a wall" at one rung from "a fill a column" at

  // another.

  const tally = () => ({

    fills: drawn.filter((op) => op.startsWith("fillRect")).length,

    blits: drawn.filter((op) => op.startsWith("drawImage")).length,

  });

  runFrame(); // whatever was cached at this size is cached before we count

  drawn.length = 0;

  runFrame();

  const fp = tally();

  drawn.length = 0;

  runFrame();

  const again = tally();

  expect(fp.blits).toBeGreaterThanOrEqual(2); // the world, and the map's tiles

  expect(fp.fills).toBeGreaterThan(0); // it drew a world, not an empty buffer

  expect(fp.fills).toBeLessThan(worldColumns()); // run-batched, not per column

  // The same state drawn twice costs the same. A frame whose cost wanders

  // while nothing moves is a renderer bug, and it is the shape of thing the

  // old bound was mistaking for flakiness.

  expect(again.fills).toBe(fp.fills);

  // Tab swaps that frame for the whole map. Its tiles are drawn once into a

  // canvas of their own and blitted from then on: the first such frame pays

  // for all 570 of them, and no frame after it pays for any.

  for (const fn of listeners.get("keydown") ?? []) fn({ code: "Tab", key: "", target: {}, preventDefault: noop });

  drawn.length = 0;

  runFrame();

  const built = tally();

  drawn.length = 0;

  runFrame();

  const top = tally();

  expect(built.fills).toBeGreaterThan(400);

  expect(top.blits).toBe(1);

  expect(top.fills).toBeLessThan(100);

  for (const fn of listeners.get("keyup") ?? []) fn({ code: "Tab" });

  drawn.length = 0;

  runFrame();

  expect(tally().blits).toBeGreaterThanOrEqual(2);

  // Holding W reaches the server as a direction, and it is the way we face.

  const seat = (await import("./arena.ts")).match().players.find((p) => !p.bot)!;

  press("KeyW");

  await Bun.sleep(160);

  expect(Math.hypot(seat.input.mx, seat.input.my)).toBeGreaterThan(0.9);

  expect(Math.atan2(seat.input.my, seat.input.mx)).toBeCloseTo(seat.input.angle, 4);

  // V falls back to the top-down view, and it draws too.

  press("KeyV");

  drawn.length = 0;

  runFrame();

  expect(drawn.some((op) => op.startsWith("fillRect"))).toBe(true);

  expect(nodes.get("stage")!.dataset).toMatchObject({ mode: "top" });

  press("KeyV");

  expect(nodes.get("stage")!.dataset).toMatchObject({ mode: "fp" });

  // Where you are looking is this browser's between snapshots. Turning with

  // the arrow key, the angle the server is told only ever climbs: the client

  // used to take `snap.me.angle` back on every snapshot, so the view was

  // dragged to a stale angle thirty times a second and what it sent stepped

  // backwards in between.

  const shortWay = (from: number, to: number) => ((to - from + Math.PI * 3) % (Math.PI * 2)) - Math.PI;

  press("ArrowRight");

  const angles: number[] = [];

  for (let i = 0; i < 60; i++) {

    runFrame(performance.now());

    await Bun.sleep(10);

    angles.push(seat.input.angle);

  }

  release("ArrowRight");

  const steps = angles.slice(1).map((angle, i) => shortWay(angles[i]!, angle));

  expect(Math.min(...steps)).toBeGreaterThan(-1e-9);

  expect(steps.reduce((sum, step) => sum + step, 0)).toBeGreaterThan(0.2);

  // H toggles the card either way, and the button closes it for good.

  const help = nodes.get("help")!.style as Record<string, string>;

  const before = help.display;

  press("KeyH");

  expect(help.display).not.toBe(before);

  if (help.display !== "grid") press("KeyH");

  expect(help.display).toBe("grid");

  click(nodes.get("helpclose")!);

  expect((nodes.get("help")!.style as Record<string, string>).display).toBe("none");

  expect((globalThis as unknown as { localStorage: Storage }).localStorage.getItem("val.help.seen")).toBe("1");

  // B works the buy panel either way — it opens itself in the buy phase.

  const panel = nodes.get("buy")!.classList as { contains: (n: string) => boolean };

  const wasOpen = panel.contains("on");

  press("KeyB");

  expect(panel.contains("on")).toBe(!wasOpen);

  // And the socket really took a seat in the running match.

  expect(seat.bot).toBe(false);

  // Your own body is drawn from a guess about your own movement, not from

  // the last thing the server said. With the arena stopped — no snapshot can

  // arrive at all — the drawn body still carries the keys you are holding

  // forward, as far as the cap and no further, and stops there.

  press("KeyV"); // the top-down view, where your own body is an arrow

  // The measurement needs a live round and a seat that can walk. The arena

  // has been run through whole rounds above with this seat standing still,

  // so by now it may be dead, mid-plant, slowed, or stood inside a barrier a

  // bot put up — and a guess about a body that cannot move is rightly nothing.

  // Put it on its feet, clear what abilities left, and let a snapshot carry

  // that to the client before the clock is stopped; try again if a round

  // ends or a bot lands a kill in that moment.

  for (let tries = 0; tries < 10; tries++) {

    for (let i = 0; i < 60 && arena.match().phase !== "live"; i++) arena.advance(1);

    Object.assign(seat, { alive: true, hp: 100, planting: 0, defusing: 0, haste: 0, slow: 0 });

    arena.match().zones.length = 0;

    arena.advance(1 / 30);

    await Bun.sleep(80);

    runFrame();

    arena.stopArena();

    if (arena.match().phase === "live" && seat.alive && arena.match().zones.length === 0) break;

    arena.startArena();

  }

  expect(arena.match().phase).toBe("live");

  expect(seat.alive).toBe(true);

  // Walk whichever way is open from where the server last put us.

  for (const code of ["KeyW", "KeyA", "KeyS", "KeyD"]) release(code);

  const { blockedCircle } = await import("./map.ts");

  const clear = ([

    ["KeyW", 0, -1],

    ["KeyS", 0, 1],

    ["KeyA", -1, 0],

    ["KeyD", 1, 0],

  ] as const).find(([, dx, dy]) =>

    [20, 40, 60, 80].every((step) => !blockedCircle(seat.x + dx * step, seat.y + dy * step, 16)),

  )!;

  expect(clear).toBeDefined();

  press(clear[0]);

  const arrow = () => moves[moves.length - 1]!;

  const startedAt = { x: seat.x, y: seat.y };

  const scale = 900 / (30 * 80); // canvas pixels to a world unit

  const t0 = performance.now();

  for (let i = 1; i <= 10; i++) {

    moves.length = 0;

    runFrame(t0 + i * 40);

  }

  const drawnAt = arrow();

  // The drawn body is ahead of the server's last word by the input held

  // since it was sent — a quarter of a second of running at most, and then

  // it waits, because past that a guess would be a claim. Smoothing toward

  // a snapshot that cannot arrive would have gone nowhere at all.

  const lead = (drawnAt.x / scale - seat.x) * clear[1] + (drawnAt.y / scale - seat.y) * clear[2];

  const sideways = (drawnAt.x / scale - seat.x) * clear[2] - (drawnAt.y / scale - seat.y) * clear[1];

  expect(lead).toBeGreaterThan(30);

  // A quarter second of THIS seat's movement, not of a walking one: haste

  // multiplies the speed by 1.35, and a seat that happened to be hasted led

  // by 84 where a bound written around the base 250 expected 72. The cap is

  // in time (predict.js LEAD_MAX), so the bound has to be read off the same

  // speed table the client used, or it measures the match's mood instead of

  // the rule.

  // The lead is the cap plus the slack the guess is allowed over the answer

  // (predict.js LEAD_SLACK: the lag your own keys take to reach the server).

  const { moveSpeed } = await import("./engine/glide.ts");

  const { LEAD_MAX, LEAD_SLACK } = await import("../static/engine/predict.js");

  expect(lead).toBeLessThan((LEAD_MAX + LEAD_SLACK) * moveSpeed(seat) + 10);

  expect(Math.abs(sideways)).toBeLessThan(6);

  // Nothing on the server moved: this is a drawing, and the match is still

  // the only thing that says where anybody is.

  expect(seat.x).toBe(startedAt.x);

  expect(seat.y).toBe(startedAt.y);

  arena.startArena();

  // Back to the first-person view for the last of it, and a frame of it to

  // measure: the one before is the one that rebuilds anything cached.

  press("KeyV");

  runFrame();

  drawn.length = 0;

  runFrame();

  const onePixel = tally().fills;

  expect(onePixel).toBeGreaterThan(40);

  // The frame is not the screen's pixel count. On a retina display the same

  // window is twice the canvas, and the world is still drawn at a capped

  // internal width and blitted up: the work does not double with the device

  // pixel ratio, which is what made this choppy on a retina Mac.

  (globalThis as { devicePixelRatio: number }).devicePixelRatio = 2;

  for (const fn of listeners.get("resize") ?? []) fn({});

  expect(nodes.get("view")!.width).toBe(1800);

  runFrame(); // the first frame at a new size redraws the minimap's tiles

  drawn.length = 0;

  runFrame();

  expect(drawn.some((op) => op.startsWith("drawImage"))).toBe(true);

  expect(drawn.filter((op) => op.startsWith("fillRect")).length).toBeLessThan(onePixel * 1.3);

  (globalThis as { devicePixelRatio: number }).devicePixelRatio = 1;

  for (const fn of listeners.get("resize") ?? []) fn({});

  // ` prints the numbers, so "it feels choppy" and "it delivers 30Hz" can be

  // told apart: the frame rate, the mean frame, the snapshot rate, the

  // interpolation delay, and the width the world is really drawn at.

  const perf = nodes.get("perf")!;

  expect((perf.style as Record<string, string>).display).not.toBe("block");

  press("Backquote");

  expect((perf.style as Record<string, string>).display).toBe("block");

  const readout = String(perf.textContent);

  expect(readout).toContain("fps");

  expect(readout).toContain("ms/frame");

  expect(readout).toContain("Hz in");

  expect(readout).toContain("ms behind");

  expect(readout).toContain("900×570"); // the internal size, of a 900×570 canvas

  // And the count of corrections taken outright, per minute: a stutter is a

  // jump, and this is how many there have been.

  expect(readout).toMatch(/\d+ jumps \([\d.]+\/min\)/);

  press("Backquote");

  expect((perf.style as Record<string, string>).display).toBe("none");

  // This test's loopback address is shared with every other test in the

  // run; close the socket so the address is free for the next real

  // connection rather than left holding a seat for the rest of the suite.

  openedSocket?.close();

  await Bun.sleep(50);

}, 15000);

test("a snapshot with no seat in it draws the watching view instead of throwing", async () => {

  // The shape no other test covers: score, round, clock and feed, and no `me`

  // and no players at all. The client used to reach straight into `snap.me`

  // on the way in, so a second tab's first frame threw and the page stopped

  // drawing. This is the server's own spectator snapshot, handed to the

  // bundled client the way the socket hands it over.

  const { spectatorSnapshot } = await import("./arena.ts");

  const deliver = (why: "address" | "cookie") =>

    openedSocket!.onmessage!({ data: spectatorSnapshot(why) } as MessageEvent);

  drawn.length = 0;

  deliver("address");

  runFrame();

  // It says what the match is doing, and why this connection is watching.

  expect(String(nodes.get("phase")!.textContent)).toContain("round");

  expect(String(nodes.get("hp")!.textContent)).toBe("watching");

  expect(String(nodes.get("prompt")!.textContent)).toContain("address");

  // Nothing on screen that would need a position to fill in.

  expect((nodes.get("kit")!.children as unknown[]).length).toBe(0);

  expect((nodes.get("roster")!.children as unknown[]).length).toBe(0);

  expect((nodes.get("atkboard")!.children as unknown[]).length).toBe(0);

  // And the canvas is words on a panel, not a map: one rectangle, no tiles.

  expect(drawn.filter((op) => op.startsWith("fillRect")).length).toBe(1);

  expect(drawn.filter((op) => op.startsWith("fillText")).length).toBeGreaterThan(3);

  // The other reason reads differently, and the frame after it still draws.

  deliver("cookie");

  runFrame();

  expect(String(nodes.get("prompt")!.textContent)).toContain("cookie");

});

test("your own camera is never drawn as a stranger arriving", async () => {

  // At spawn the buy phase turns prediction off, and the frame used to fall

  // through to the treatments meant for other people: drawn in the past, and

  // slid in from where it was last seen. On a respawn that slides the CAMERA

  // across the room — the shake somebody reported the first time they played

  // a round from the start.

  const { spectatorSnapshot } = await import("./arena.ts");

  expect(typeof spectatorSnapshot).toBe("function");

  const bundle = await Bun.file(new URL("../static/val.js", import.meta.url)).text();

  // The rule is small enough to state: own id short-circuits before both.

  const look = bundle.slice(bundle.indexOf("const look = (p) =>"));

  const body = look.slice(0, look.indexOf("};") + 2);

  const ownReturn = body.indexOf("if (p.id === snap.me.id) return p;");

  const slideCall = body.indexOf("slide(presence");

  expect(ownReturn).toBeGreaterThan(-1);

  expect(slideCall).toBeGreaterThan(ownReturn);

});

test("the buy phase is predicted, and its pen is the server's own rule", async () => {

  const bundle = await Bun.file(new URL("../static/val.js", import.meta.url)).text();

  // Prediction is no longer switched off for the whole buy phase: it is on

  // whenever the browser knows the pen, which it learns from the map it is

  // already given. Drawing your own body straight from a 30Hz snapshot while

  // rendering at 60 is a stutter, and that is what the phase used to do.

  expect(bundle).toContain('snap.phase !== "buy" || pens !== null');

  // And the pen is the server's number, not a guess: 120 from a spawn tile.

  expect(bundle).toContain("best > 120");

  // A refused step holds where it was rather than snapping to the server:

  // the pen is handed to the one step function as the place it is refused.

  expect(bundle).toContain("stepLocal(local, snap.me, held, speed");

  expect(bundle).toContain("world, refused)");

  expect(bundle).toContain("outsidePen(x, y) || insideBarrier(x, y)");

});

test("the drawn body runs at the speed the server sent, and never at one it works out", async () => {

  // Two snapshots a client that re-derived the rule would read backwards: one

  // that says stopped with every visible reason to be running, and one that

  // says running with a visible reason to be stopped. The drawing follows the

  // number both times, which is the whole of what it knows about movement.

  const arena = await import("./arena.ts");

  const { blockedCircle } = await import("./map.ts");

  arena.stopArena();

  const body = arena.match().players[0]!;

  const base = JSON.parse(arena.snapshot(body.id));

  // Somewhere with a hundred units of room in one direction to walk into.

  const clear = (

    [

      ["KeyW", 0, -1],

      ["KeyS", 0, 1],

      ["KeyA", -1, 0],

      ["KeyD", 1, 0],

    ] as const

  ).find(([, dx, dy]) => [25, 50, 75, 100].every((step) => !blockedCircle(body.x + dx * step, body.y + dy * step, 16)))!;

  expect(clear).toBeDefined();

  // The top-down view, where your own body is the last thing translated to.

  if ((nodes.get("stage")!.dataset as Record<string, string>).mode !== "top") press("KeyV");

  expect((nodes.get("stage")!.dataset as Record<string, string>).mode).toBe("top");

  for (const code of ["KeyW", "KeyA", "KeyS", "KeyD"]) release(code);

  press(clear[0]);

  const mine = (base.players as Record<string, unknown>[]).find((p) => p.id === base.me.id) ?? {

    id: base.me.id,

    name: body.name,

    agent: base.me.agent,

    angle: 0,

    hp: 100,

    armour: 0,

    mate: true,

    spike: false,

    blind: false,

    revealed: false,

  };

  const scale = 900 / (30 * 80); // canvas pixels to a world unit, as above

  const deliver = (me: Record<string, unknown>) => {

    const snap = {

      ...base,

      phase: "live",

      zones: [],

      // Your own body is on the map as one of the bodies you can see, and it

      // is the one the arrow is drawn for.

      players: [{ ...mine, alive: true, x: body.x, y: body.y }],

      shots: [],

      me: { ...base.me, alive: true, x: body.x, y: body.y, planting: 0, ...me },

    };

    openedSocket!.onmessage!({ data: JSON.stringify(snap) } as MessageEvent);

  };

  /** How far past the server's own word the body is drawn, after ten frames. */

  const leadOf = (me: Record<string, unknown>) => {

    deliver(me);

    const t0 = performance.now();

    runFrame(t0); // the first frame after a jump takes the server's word

    for (let i = 1; i <= 10; i++) {

      moves.length = 0;

      runFrame(t0 + i * 40);

    }

    const at = moves[moves.length - 1]!;

    return (at.x / scale - body.x) * clear[1] + (at.y / scale - body.y) * clear[2];

  };

  // Stopped, with nothing in the snapshot to say why: no planting, no

  // slow, a live round, a light weapon. A client working it out for itself

  // would run this body the whole quarter second.

  expect(leadOf({ speed: 0 })).toBeLessThan(1);

  // And moving, mid-plant — a reason the old client read as stopped. The

  // number is what counts, so the body walks.

  const walking = leadOf({ speed: 250, planting: 1 });

  expect(walking).toBeGreaterThan(30);

  // And the number is the whole of it: half the speed, half the lead. The

  // cap on a guess is a length of time (predict.js LEAD_MAX), so how far

  // ahead the drawing may be is the server's speed and nothing else.

  const half = leadOf({ speed: 125 });

  expect(half / walking).toBeGreaterThan(0.45);

  expect(half / walking).toBeLessThan(0.55);

  release(clear[0]);

  openedSocket?.close();

});