@homie-rocks/studio 0.39.0 → 0.40.0

package/starters/hero-rush-3d/src/{main.ts → view.ts}

@@ -1,69 +1,4 @@
-/*
- * HERO RUSH 3D — Gem Rush's arena with ANIMATED HEROES: knights, barbarians, mages and rogues run for the coins, JUMP,
- * and SWING to knock each other's run loose; skeletons fill the empty seats. The start for a 3D game with characters.
- *
- * THE RULES are Gem Rush's (the netplay v1 reference game): move, collect coins, score; 60 s rounds that cycle forever;
- * the round starts the moment the first browser arrives, with two bots, and every human who arrives takes a bot's body.
- * One browser hosts (pickups, scoring, bots, the clock) and broadcasts snapshots; everyone else moves their own hero
- * locally and draws the rest from interpolated snapshots; a promoted host continues the same round. Two verbs on top:
- *   JUMP   (Space, or the Jump button): a hero in the air is out of a swing's reach. Its height rides in the avatar and
- *          the snapshot, so every screen draws the jump, and the host decides what a swing hits by it.
- *   SWING  (F, a click, or the Swing button): every screen plays the swing at once; the host lands it T.windupMs later
- *          (the anticipation), knocking every body in front of the swinger and within reach that is on the ground.
- * The hot zone (keyed state) scores double; a watcher follows any player (`net.viewSeat`, `net.spotlight`); the swing
- * and the jump are tuned in the Game Lab (tunables.json, lab.json). The world is in metres, a 26 x 16 m clearing, x
- * across and y deep (y is three.js's z).
- *
- * THE BOTS never swamp a new player. They play at the room's skill dial (NETPLAY.md section 17; they jump a swing they
- * see coming), with two things on top (THE BOTS, below, says exactly how):
- *   - In somebody's first round in the room, when nobody set the dial (no vote, no owner), they play a level easier.
- *   - A RUBBER BAND: a bot ahead of the best person in the room by more than its dial allows eases off (it walks,
- *     reacts later, swings less) and comes to race near the people, so a rival is on their screen; otherwise it plays
- *     at its dial. The lead it may hold grows with the dial; at Maxed there is no rubber band (a party that voted
- *     Maxed asked for it).
- * Scores stay honest: nobody's score is ever changed, no coin is given, taken or faked; the bots just play softer.
- * And a bot is always labelled a bot (an AI agent "· AI") wherever its name or score shows, the phone's board too.
- *
- * THE ARRIVAL: the play page shows the game's arrival card (its title, art and a progress line this game feeds with
- * `net.loading`) until the game says `net.playable()`: the round's state is in and your own hero is drawn in its real
- * model (THE ARRIVAL, by the HUD). So the round opens on your hero, with no title card over it. On a phone held
- * upright the camera follows low and close (30 degrees, about 5.5 m across: the camera's comment says why), so every
- * hero reads as a character, a mage too, and your name chip says which you are ("You · Mage").
- *
- * THE CHARACTERS are KayKit's CC0 adventurers and skeletons from the Homie starter library, made phone-sized by `game new`
- * (lib/characters.mjs): each one skinned mesh, one draw call, its joints named by the skeleton standard, and every clip
- * in one shared clip library per skeleton (public/anims/<skeleton>.glb). They move through @homie-rocks/studio/animate:
- * idle, walk and run blended by ground speed, the swing on the upper body while running, an additive flinch and a
- * hit-stop when hit, jump, fall and land with squash and stretch, a lean into turns, a cheer for the round's winner.
- * Every number of that is a Game Lab tunable (the "Motion" group of tunables.json).
- *
- * THE LOOK comes from files beside game.json:
- *   style.json      the palette, fonts, light and camera (the art direction's tokens: `homie-studio style` writes it);
- *                   everything the code draws takes its colours from it
- *   public/models/  the heroes, the skeletons, the coin, the chest, trees, rocks and barrels: KayKit's CC0 packs from the
- *                   Homie starter library (one family, so they fit), fetched by `game new` (the repository keeps no model
- *                   files). assets/manifest.json names each library item and its SHA-256; assets/RIGHTS.md and
- *                   credits.json say what its licence allows.
- *   public/anims/   the clip libraries, baked by `game new` from the characters' own CC0 clips.
- * Every model loads through @homie-rocks/studio/assets (createModels: each file is checked before three.js reads a
- * byte). A model that is refused or not there is drawn as a stand-in in the same colours: a round never waits on, or
- * breaks for, a model.
- *
- * HEADINGS, AND THERE ARE TWO: a body's facing (`fa`, drawn as `yaw`) is `Math.atan2(dx, dy)` in the game's own x and y, so yaw 0 faces +y
- * (three.js's +z, the way the models are built) and it goes straight into `rotation.y`. That is also the yaw
- * `@homie-rocks/camera` means (0 faces +Z, positive turns toward +X, radians), so a follow or chase camera from that
- * package takes a body's facing as it stands. The knock and aim angles (`ang`, `base`) are the OTHER kind,
- * `Math.atan2(dy, dx)`: 0 faces +x. Never hand one of those to a camera or to `rotation.y` without converting it:
- * `headingFrom({ zero: '+x', toward: '+z' })` from `@homie-rocks/camera/heading.js` is the adapter.
- *
- * PHONE BUDGETS: under 100 draw calls and 150k triangles a frame (the `drawCalls` and `triangles` probes read
- * renderer.info), the pixel ratio at most 1.5 on a phone and 2 on a computer, and no shadow map on a phone: a soft
- * disc under each body, coin, tree and rock (a computer draws the sun's real shadows). Repeated things are one
- * InstancedMesh per model; far heroes pose less often (animate's crowd()).
- *
- * The HUD (clock, scores, names, results, "Reconnecting…", the controls hint and the touch buttons) is a 2D canvas over
- * the world, in style.json's fonts and colours.
- */
+/** Hero Rush 3D: server rules, predicted jumps, and the original meadow and heroes. */
 import {
   AmbientLight, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CircleGeometry, Color, ConeGeometry, CylinderGeometry,
   DodecahedronGeometry, IcosahedronGeometry,
@@ -77,17 +12,20 @@ import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js
 import { createModels, instancedCopies, placeCopy, repaint, stylize, type Copies } from '@homie-rocks/studio/assets';
 // Characters that move well: clips from the skeleton's clip library, blended, layered and tuned (Game Lab tunables).
 import { crowd, loadCharacter, type Character } from '@homie-rocks/studio/animate';
-import { createNetplay, guardGestures, Roster, q, lerp, capMove, skillPreset, PALETTE, AI_MARK, type Peer, type RoleChange, type RoundInfo, type RoundResult, type Skill, type Slot, type Snapshot } from '@homie-rocks/studio/netplay';
+import { guardGestures, PALETTE, AI_MARK, type RoundInfo, type Slot } from '@homie-rocks/studio/netplay';
 // The port toolkit: its probe (what `homie-studio port check` and `perf` read, and sandbox + audio shims), and name
 // labels that never pile up (port/view.ts).
 import { createBubbles, createLabels, exposePort, paintBubbles, type BubbleIn, type BubbleOut, type LabelIn, type LabelOut } from '@homie-rocks/studio/port';
 // The Game Lab: tunables, phases, tracks and overlays (no-ops outside the lab).
 import { lab } from '@homie-rocks/studio/lab';
-import tuning from '../tunables.json';
+import { openRoom, type Entity } from '@homie-rocks/studio/rules/view';
+import type rules from './rules';
+const room = openRoom<typeof rules>({ net: { game: 'hero-rush-3d', arrival: 'game' } });
+const net = room.net;
+guardGestures({ touch: 'canvas' });
 import styleFile from '../style.json';
 import gameFile from '../game.json';
 
-/* ------------------------------------------------------------------ rules */
 const W = 26;
 const H = 16;
 const R_AV = 0.44;
@@ -101,39 +39,16 @@ const OBSTACLES: readonly { x: number; y: number; r: number; kind: 'camp' | 'bus
   { x: 4.6, y: 3.8, r: 0.75, kind: 'bush' }, { x: 21.4, y: 4.6, r: 0.55, kind: 'rock' }, { x: 6.0, y: 12.6, r: 0.5, kind: 'rock' },
   { x: 20.2, y: 12.2, r: 0.75, kind: 'bush' }, { x: 9.6, y: 13.4, r: 0.45, kind: 'stone' }, { x: 23.6, y: 2.0, r: 0.5, kind: 'tree' },
 ];
-/** A position kept in the clearing and out of its features (pushed to their edge, so a body slides round them). */
-function bound(x: number, y: number): { x: number; y: number } {
-  x = Math.max(R_AV, Math.min(W - R_AV, x)); y = Math.max(R_AV, Math.min(H - R_AV, y));
-  for (const o of OBSTACLES) {
-    const dx = x - o.x; const dy = y - o.y; const d = Math.hypot(dx, dy); const min = o.r + R_AV;
-    if (d >= min) continue;
-    if (d > 1e-6) { x = o.x + (dx / d) * min; y = o.y + (dy / d) * min; } else x = o.x + min;
-  }
-  return { x, y };
-}
 const R_GEM = 0.3;
 const SPEED = 6.2;
-const BOT_SPEED = 4.2; // a player runs 6.2: a person who chases the coins out-runs a Fair bot
-/** A hero this high or higher is in the air: a swing passes under it. */
-const CLEAR_M = 0.3;
+const BOT_SPEED = 5;
 const ROUND_MS = 60_000;
 const BREAK_MS = 7_000;
 const GEM_COUNT = 14;
 const MIN_SLOTS = 3; // 1 human + 2 bots from the first frame
 const MAX_SLOTS = 8;
-/** The swing's, the jump's and the motion's numbers (tunables.json): the file's values, or the Game Lab's sliders. */
-const T = lab.tunables(tuning);
-/** The jump as a curve of time: up at the speed that reaches T.jumpHeight in T.jumpRise seconds, down T.fallFaster harder. */
-const jumpGravity = (): number => (2 * T.jumpHeight) / Math.max(0.05, T.jumpRise) ** 2;
-const jumpSpeed = (): number => jumpGravity() * Math.max(0.05, T.jumpRise);
-/** One jump step for anything with a height (h, metres up) and a vertical speed (vh): the same rule on every screen. */
-function fall(o: { h: number; vh: number }, dt: number): boolean {
-  if (o.h <= 0 && o.vh <= 0) { o.h = 0; o.vh = 0; return false; }
-  const g = jumpGravity() * (o.vh < 0 ? T.fallFaster : 1);
-  o.vh -= g * dt; o.h += o.vh * dt;
-  if (o.h <= 0) { o.h = 0; o.vh = 0; return true; } // landed this step
-  return false;
-}
+/** The knock's numbers (tunables.json): the file's values, or the Game Lab's sliders while it plays a take. */
+const T = room.tune as Record<string, number>;
 const ZONE_MS = 12_000;
 /** The contract's 12 colours (PALETTE, NETPLAY.md section 3): a person wears their seat's, so the watch page's strip matches. */
 const colourOf = (slot: number, seat: number | null): string => PALETTE[(seat ?? slot) % PALETTE.length] as string;
@@ -142,306 +57,49 @@ const botName = (slot: number): string => BOT_NAMES[slot % BOT_NAMES.length] as
 /** An AI's name already ends in " · AI" (the relay sees to it); a plain bot says bot. */
 const label = (name: string, bot: boolean): string => (name.endsWith(AI_MARK) ? name : bot ? `${name} · bot` : name);
 
-/* ------------------------------------------------------------ wire shapes */
-/** Snapshot: compact arrays, quantized to the centimetre. (Reset epochs ride in the helper's `c` table.) */
-type P = [slot: number, seat: number, x: number, y: number, score: number, vx: number, vy: number, h: number];
-type G = [id: number, x: number, y: number];
-interface Snap { r: [n: number, phase: number, startedAt: number, endsAt: number]; p: P[]; g: G[] }
-/**
- * Replica input: the avatar (owner movement) AND the stick intent (host movement), so either mode reads the same
- * frame. The helper stamps the reset epoch the replica has adopted.
- */
-type Avatar = [x: number, y: number, vx: number, vy: number, mx: number, my: number, h: number];
-/** A body's bump, while it lasts: its direction (kvx, kvy), where its slide starts (kx, ky) and when (kat, after the hit-stop). */
-interface Knock { kvx: number; kvy: number; kx: number; ky: number; kat: number; knockUntil: number }
-/** A body: where it is, its height off the ground (h) and vertical speed (vh), and which way it faces (fa, radians). */
-interface Body extends Knock { slot: number; seat: number | null; name: string; bot: boolean; x: number; y: number; vx: number; vy: number; h: number; vh: number; fa: number; score: number; tx: number; ty: number }
-interface Gem { id: number; x: number; y: number }
-/** Slow state, on the keyed state channel (net.state('zone', ...)), not in the 20 Hz snapshot. */
-interface Zone { n: number; x: number; y: number; r: number; until: number }
-/** `firstRound`: each person's first whole round here (seat, round), so a promoted host eases the same round. */
-interface Ckpt { round: RoundInfo; bodies: Body[]; gems: Gem[]; roster: Slot[]; tick: number; gemSeq: number; occ?: [number, number][]; firstRound?: [number, number][] }
-
-/* --------------------------------------------------------------- the net */
-/**
- * `?movement=host` plays host movement: the host moves every body from the seats' stick intents (its rules own
- * movement), and each replica PREDICTS its own body by replaying its unacknowledged intents on the host's position.
- * Default `owner`: each browser moves its own body and the host bounds it.
- */
-const MOVEMENT: 'owner' | 'host' = (() => { try { return new URLSearchParams(location.search).get('movement') === 'host' ? 'host' : 'owner'; } catch { return 'owner'; } })();
-// caps: its bots read the dial ('skill'), and its Roster takes an AI's slot for it ('agents': the join passes p.agent).
-// arrival 'game': the play page's arrival card stays until this game says it is playable (THE ARRIVAL, by the HUD).
-const net = createNetplay<Snap, Avatar, Ckpt>({ game: 'hero-rush-3d', maxPlayers: MAX_SLOTS, movement: MOVEMENT, snapshotHz: 20, inputHz: 20, checkpointMs: 1000, caps: ['skill', 'agents'], arrival: 'game', checkpoint: () => checkpoint() });
-// A touch game guards its own page (NETPLAY.md section 24): a long press on the canvas never selects text or raises
-// the copy/paste callout on a phone, and a touch on it never pans or zooms the page.
-guardGestures({ touch: 'canvas' });
-/** The Roster keeps the server's AI seats (revision 6): the policy is read whenever it fills. */
-const policy = () => net.policy;
-
-/* ------------------------------------------------------------ host state */
-let roster = new Roster({ min: MIN_SLOTS, max: MAX_SLOTS, botName, policy });
-let bodies = new Map<number, Body>();
-let gems: Gem[] = [];
-let gemSeq = 0;
-let round: RoundInfo | null = null;
-let zone: Zone | null = null;
-let tick = 0;
-let hosting = false;
-let cheatResets = 0;
-let controlResets = 0;
-let predictionError = 0;
-/** Gems each slot picked up this round (a gem, whatever it scored): the dial's numbers (`pickups` probe). */
-let pickups = new Map<number, number>();
-
-/* ------------------------------------------------ this browser's avatar */
-const me = { x: W / 2, y: H / 2, vx: 0, vy: 0, h: 0, vh: 0, kvx: 0, kvy: 0, kx: 0, ky: 0, kat: 0, knockUntil: 0, has: false };
-/** Offline (no shell) plays as a local seat 0, with keys or touch. */
-const mySeat = (): number | null => (net.offline ? 0 : net.seat);
-/** Whose view to draw: my own seat, or for a watcher the player it follows (null: the whole arena). */
-const viewSeat = (): number | null => (net.offline ? 0 : net.viewSeat);
-
-/* ------------------------------------------------------- replica view */
+const jumpSpeed = (): number => 2 * T.jumpHeight / T.jumpRise;
+const mySeat = (): number | null => room.seat;
+const viewSeat = (): number | null => net.viewSeat;
+const me = { x: 13, y: 8, h: 0, vh: 0, has: false };
+const poses = new Map<number, Entity>();
 const drawn = new Map<number, { x: number; y: number; h: number; seat: number; score: number; slot: number }>();
 const waves: { x: number; y: number; at: number; colour: string; knock?: boolean; fa?: number; slot?: number }[] = [];
-let wavesSeen = 0;
-let knocksSeen = 0;
-let jumpsSeen = 0;
-let dodgesSeen = 0;
-let firstStateAt = 0;
-let firstSnapAt = 0;
-let frames = 0;
-
-const rnd = (a: number, b: number): number => a + Math.random() * (b - a);
-const spawnPoint = (i: number): { x: number; y: number } => {
-  const a = (i / MAX_SLOTS) * Math.PI * 2;
-  return { x: W / 2 + Math.cos(a) * 6.6, y: H / 2 + Math.sin(a) * 5 };
-};
-const newGem = (): Gem => {
-  let x = rnd(1.2, W - 1.2); let y = rnd(1.2, H - 1.2);
-  for (let i = 0; i < 12 && OBSTACLES.some((o) => Math.hypot(o.x - x, o.y - y) < o.r + 0.7); i += 1) { x = rnd(1.2, W - 1.2); y = rnd(1.2, H - 1.2); }
-  return { id: ++gemSeq, x, y };
-};
-
-function bodyFor(slot: Slot): Body {
-  const sp = spawnPoint(slot.slot);
-  return { slot: slot.slot, seat: slot.seat, name: slot.name, bot: slot.bot, x: sp.x, y: sp.y, vx: 0, vy: 0, h: 0, vh: 0, fa: 0, score: 0, tx: sp.x, ty: sp.y, kvx: 0, kvy: 0, kx: sp.x, ky: sp.y, kat: 0, knockUntil: 0 };
-}
-
-function syncBodiesFromRoster(): void {
-  const seen = new Set<number>();
-  for (const s of roster.slots) {
-    seen.add(s.slot);
-    const b = bodies.get(s.slot);
-    if (!b) { bodies.set(s.slot, bodyFor(s)); continue; }
-    b.seat = s.seat; b.name = s.name; b.bot = s.bot;
-  }
-  for (const k of [...bodies.keys()]) if (!seen.has(k)) bodies.delete(k);
-}
-
-function publishRoster(): void { net.roster(roster.toJSON()); }
-
-/** The host moved body `b` itself: tell its owner (a replica adopts it; the host's own body is `me`). */
-function hostMoved(b: Body): void {
-  if (b.bot || b.seat === null) return;
-  if (b.seat === mySeat()) { me.x = b.x; me.y = b.y; me.vx = 0; me.vy = 0; me.h = 0; me.vh = 0; me.has = true; return; }
-  net.reset(b.seat);
-}
-
-function newZone(n: number): Zone {
-  return { n, x: rnd(4.4, W - 4.4), y: rnd(4, H - 4), r: 3, until: net.now() + ZONE_MS };
-}
-function setZone(z: Zone): void { zone = z; net.state('zone', z); }
-
-/** A round starts with every hero on its spawn ring facing the camera (fa 0): a line-up the hero intro opens on. */
-function startRound(n: number, rollover = false): void {
-  const now = net.now();
-  roster.trim();
-  // The next round of a running room: the trim is what makes room (the seats a server no longer keeps for AI go
-  // here), so whoever was seated with no body is given one now, before the bodies are placed.
-  if (rollover && !net.offline) seatWaiting();
-  syncBodiesFromRoster();
-  let i = 0;
-  for (const b of [...bodies.values()].sort((a, c) => a.slot - c.slot)) {
-    const sp = spawnPoint(i++);
-    b.x = sp.x; b.y = sp.y; b.vx = 0; b.vy = 0; b.h = 0; b.vh = 0; b.fa = 0; b.score = 0; b.tx = sp.x; b.ty = sp.y; b.kvx = 0; b.kvy = 0; b.knockUntil = 0;
-    hostMoved(b);
-  }
-  gems = Array.from({ length: GEM_COUNT }, newGem);
-  pickups = new Map();
-  sight.clear();
-  swings.length = 0;
-  round = { n, phase: 'live', startedAt: now, endsAt: now + ROUND_MS };
-  if (lab.stage === 'dummy' || lab.stage === 'jump') stageDummy();
-  setZone(newZone((zone?.n ?? 0) + 1));
-  net.round(round);
-  publishRoster();
-  net.snapshot(buildSnap(), tick, true);
-}
-
-function endRound(): void {
-  if (!round) return;
-  const now = net.now();
-  const ranked = [...bodies.values()].sort((a, b) => b.score - a.score || Number(a.bot) - Number(b.bot) || a.slot - b.slot);
-  const agentSlot = (slot: number): boolean => Boolean(roster.slots.find((x) => x.slot === slot)?.agent);
-  const results: RoundResult[] = ranked.map((b, i) => ({ slot: b.slot, seat: b.seat, name: b.name, score: b.score, bot: b.bot, place: i + 1, ...(agentSlot(b.slot) ? { agent: true as const } : {}) }));
-  round = { n: round.n, phase: 'over', startedAt: now, endsAt: now + BREAK_MS, results };
-  net.round(round);
-}
-
-/* ---------------------------------------------------- becoming the host */
-function becomeHost(e: RoleChange<Snap, Ckpt>): void {
-  hosting = true;
-  if (e.promoted) restore(e);
-  else {
-    roster = new Roster({ min: MIN_SLOTS, max: MAX_SLOTS, botName, policy });
-    bodies = new Map();
-    const seat = mySeat();
-    if (seat !== null) roster.claim(seat, net.offline ? 'You' : net.name);
-    syncBodiesFromRoster();
-    firstRound = new Map();
-    startRound((e.round?.n ?? 0) + 1);
-    welcome(seat);
-  }
-  // Whoever is connected now is who plays: seats that left during the gap become bots.
-  const peers = net.offline ? [{ seat: 0, name: 'You' }] : [...net.peers.values()].filter((p) => p.seat !== null).map((p) => ({ seat: p.seat, name: p.name, agent: p.agent ?? null, occ: p.occ ?? null }));
-  // `occ` (NETPLAY.md section 25): which stay in its seat each peer's is, so a seat number that changed hands while
-  // nobody was hosting is claimed afresh instead of inheriting the last player's body in silence.
-  const { claimed } = roster.reconcile(peers);
-  syncBodiesFromRoster();
-  for (const s of claimed) welcome(s.seat);
-  for (const s of claimed) { const b = bodies.get(s.slot); if (b && b.seat !== mySeat()) hostMoved(b); }
-  // My own body is wherever my local avatar is: it was client-owned a moment ago and still is.
-  const mine = mySeat() !== null ? [...bodies.values()].find((b) => b.seat === mySeat()) : undefined;
-  if (mine && me.has) { mine.x = me.x; mine.y = me.y; }
-  else if (mine) { me.x = mine.x; me.y = mine.y; me.has = true; }
-  // The hot zone is keyed state: the relay handed it over with the role.
-  zone = net.stateOf<Zone>('zone') ?? zone;
-  if (!zone && round) setZone(newZone(1));
-  publishRoster();
-}
-
-function restore(e: RoleChange<Snap, Ckpt>): void {
-  const ck = e.ckpt?.d ?? null;
-  if (ck) {
-    roster = Roster.from(ck.roster, { min: MIN_SLOTS, max: MAX_SLOTS, botName, policy }, ck.occ ?? null);
-    bodies = new Map(ck.bodies.map((b) => [b.slot, { ...b }]));
-    gems = ck.gems.map((g) => ({ ...g }));
-    gemSeq = ck.gemSeq;
-    round = ck.round;
-    tick = ck.tick;
-    firstRound = new Map(Array.isArray(ck.firstRound) ? ck.firstRound : []);
-  } else {
-    roster = Roster.from(e.roster ?? [], { min: MIN_SLOTS, max: MAX_SLOTS, botName, policy });
-    bodies = new Map();
-    syncBodiesFromRoster();
-  }
-  // The snapshot is newer than the checkpoint (20 Hz vs 1 Hz): positions, scores and gems from it.
-  const s = e.snap;
-  if (s && (!e.ckpt || s.st >= e.ckpt.st)) {
-    for (const [slot, seat, x, y, score, , , h] of s.d.p) {
-      let b = bodies.get(slot);
-      if (!b) {
-        const rs0 = roster.slots.find((r) => r.slot === slot) ?? { slot, seat: seat >= 0 ? seat : null, name: seat >= 0 ? `Player ${seat + 1}` : botName(slot), bot: seat < 0 };
-        b = bodyFor(rs0);
-        bodies.set(slot, b);
-      }
-      b.x = x; b.y = y; b.h = Number(h) || 0; b.score = score; b.tx = x; b.ty = y;
-    }
-    gems = s.d.g.map(([id, x, y]) => ({ id, x, y }));
-    gemSeq = Math.max(gemSeq, ...gems.map((g) => g.id));
-    const [n, ph, startedAt, endsAt] = s.d.r;
-    round = { n, phase: ph ? 'over' : 'live', startedAt, endsAt, ...(round?.n === n && round.results ? { results: round.results } : {}) };
-    tick = Math.max(tick, s.k);
+let wavesSeen = 0, knocksSeen = 0, frames = 0, jumpsSeen = 0, dodgesSeen = 0;
+let firstStateAt = 0, firstSnapAt = 0;
+let gems: { x: number; y: number; id: number }[] = [];
+let round: RoundInfo | null = null;
+let zone: { x: number; y: number; r: number } | null = null;
+const slotOf = (e: Entity): number => e.kind === 'runner' ? e.seat ?? 0 : 0;
+function updateView(): void {
+  const v = moveVector(); room.input({ ax: Math.round(v.x * 127), ay: Math.round(v.y * 127) });
+  const own = room.me; me.has = Boolean(own);
+  if (own) { me.x = own.pos.x; me.y = own.pos.y; me.h = own.pos.z; me.vh = own.vel.z; }
+  drawn.clear(); poses.clear(); room.each('runner', e => poses.set(slotOf(e), e));
+  room.each('runner', e => drawn.set(slotOf(e), { slot: slotOf(e), seat: e.driver === 'bot' ? -1 : e.seat ?? -1, x: e.pos.x, y: e.pos.y, h: e.pos.z, score: Number(e.score) }));
+  gems = []; room.each('gem', e => gems.push({ id: Number(e.serial), x: e.pos.x, y: e.pos.y }));
+  const z = room.shared.zone as { x: number; y: number } | undefined;
+  zone = z ? { x: z.x, y: z.y, r: 3 } : null;
+  if (own && !firstSnapAt) firstSnapAt = performance.now();
+  if (z && !firstStateAt) firstStateAt = performance.now();
+  const r = room.round;
+  round = r ? { ...r, startedAt: 0, endsAt: net.now() + r.secondsLeft * 1000 } : null;
+}
+function effect(name: 'swing' | 'knock', e: { id?: string; at?: { x: number; y: number } | null; dir?: { x: number; y: number }; by?: string }): void {
+  const body = e.id ? room.get(e.id) : null;
+  if (!body || body.kind !== 'runner' || !e.at) return;
+  const slot = slotOf(body), at = { x: body.pos.x, y: body.pos.y }, now = performance.now();
+  waves.push({ ...at, at: now, colour: name === 'knock' ? '#ffffff' : colourOf(slot, body.seat ?? null), knock: name === 'knock', slot, fa: e.dir ? Math.atan2(e.dir.x, e.dir.y) : 0 });
+  if (name === 'swing') { net.spotlight(body.driver === 'person' ? body.seat ?? null : null); wavesSeen++; swung(slot); }
+  else if (e.dir) {
+    const by = e.by ? room.get(e.by) : null;
+    knocksSeen++; bumped({ slot, dx: e.dir.x, dy: e.dir.y, by: by?.kind === 'runner' ? by.seat : undefined }, at);
+    if (lab.on) Object.assign(subject, { slot, at: net.now(), x0: at.x, y0: at.y, px: at.x, py: at.y, has: true });
   }
-  // A round message the relay kept is at least as authoritative as the checkpoint's copy.
-  if (e.round && (!round || e.round.n > round.n || (e.round.n === round.n && e.round.phase === 'over' && round.phase === 'live'))) round = e.round;
-  // Anyone already playing whose first round the checkpoint does not say is no newcomer: the dial stays exact for them.
-  for (const r of roster.slots) if (!r.bot && r.seat !== null && !firstRound.has(r.seat)) firstRound.set(r.seat, 0);
-  if (!round) { startRound(1); return; }
-  net.round(round);
-}
-
-function checkpoint(): Ckpt {
-  return {
-    round: round ?? { n: 0, phase: 'live', startedAt: 0, endsAt: 0 },
-    bodies: [...bodies.values()].map((b) => ({ ...b })),
-    gems: gems.map((g) => ({ ...g })),
-    roster: roster.toJSON(),
-    // Whose stay each body is, beside the roster: how the next host tells a player who came back from a new one.
-    occ: roster.occupants(),
-    tick,
-    gemSeq,
-    firstRound: [...firstRound],
-  };
 }
-
-net.on('role', (e) => {
-  if (e.role === 'host') becomeHost(e);
-  else { hosting = false; }
-});
-/** Host: a body for somebody the relay seated. False when every body is somebody's (they wait: see seatWaiting). */
-function giveBody(p: Peer): boolean {
-  if (p.seat === null) return false;
-  // An AI takes a seat kept for AI, a person never does (revision 6: the Roster needs p.agent for that).
-  const c = roster.claim(p.seat, p.name, p.agent ? { role: p.agent.role, hands: p.agent.hands } : null, p.occ ?? null);
-  if (!c) return false;
-  welcome(p.seat);
-  syncBodiesFromRoster();
-  const b = bodies.get(c.slot.slot);
-  // The arriving human takes over the bot's body where it stands, score and all (reset = "adopt this position").
-  if (b) { b.vx = 0; b.vy = 0; b.kvx = 0; b.kvy = 0; b.knockUntil = 0; hostMoved(b); }
-  return true;
-}
-/**
- * SEAT WHOEVER IS WAITING (NETPLAY.md section 28). The relay seats a person; this host gives them a body. A claim that
- * found every body taken (a server's AI seats were still kept, say) used to be tried once: that player watched for the
- * rest of the visit, online, with nothing said. It is tried again whenever a body frees up and at every round start.
- */
-function seatWaiting(): boolean {
-  let any = false;
-  for (const p of net.peers.values()) if (p.seat !== null && !roster.bySeat(p.seat) && giveBody(p)) any = true;
-  return any;
-}
-net.on('join', (p) => {
-  if (!hosting || !giveBody(p)) return;
-  publishRoster();
-  net.snapshot(buildSnap(), tick, true);
-});
-net.on('leave', (p) => {
-  if (!hosting || p.seat === null) return;
-  roster.release(p.seat); // their body stays, driven by a bot
-  firstRound.delete(p.seat); // whoever sits in this seat next is new here
-  syncBodiesFromRoster();
-  // A body just went to a bot: somebody seated with none takes it now.
-  const seated = seatWaiting();
-  publishRoster();
-  if (seated) net.snapshot(buildSnap(), tick, true);
-});
-// The server's policy changed: its AI seats come (or go between rounds) at once.
-net.on('policy', () => { if (!hosting) return; roster.fill(); syncBodiesFromRoster(); publishRoster(); });
-net.on('event', (e) => {
-  if (e.k === 'swing') addWave(e.d as { slot: number; fa?: number });
-  if (e.k === 'knock') addWave(e.d as { slot: number }, true);
-  if (e.k === 'jump') {
-    const slot = Number((e.d as { slot?: number })?.slot);
-    // A player's jump comes to the host from its own screen (its height is its own): the host passes it on to everyone,
-    // only for that player's own body.
-    if (hosting && e.from !== null) { const b = bodies.get(slot); if (!b || b.bot || b.seat !== e.from) return; net.send('jump', { slot }); }
-    jumped(slot);
-  }
-  if (e.k === 'dodge') dodged((e.d as { slot: number }).slot);
-});
-net.on('round', (r) => { round = hosting ? round : r; });
-net.on('state', (e) => { if (e.k === 'zone' && !hosting) zone = (e.d as Zone | null) ?? null; if (!firstStateAt) firstStateAt = performance.now(); });
-net.on('snapshot', () => { if (!firstSnapAt) firstSnapAt = performance.now(); });
-/** My body's control changed: on a reset, stand where the host put me (a new round, a takeover, a knockback's end). */
-net.on('control', (e) => {
-  if (!e.reset) return;
-  controlResets += 1;
-  const p = (e.snap as Snapshot<Snap>).d.p.find((x) => x[1] === net.seat);
-  if (p) { me.x = p[2]; me.y = p[3]; me.vx = 0; me.vy = 0; me.h = Number(p[7]) || 0; me.vh = 0; me.has = true; }
-});
-
+room.on('swing', e => effect('swing', e));
+room.on('knock', e => effect('knock', e));
+room.on('jump', e => { const b = e.id ? room.get(e.id) : null; if (b) jumped(slotOf(b)); });
+room.on('dodge', e => { const b = e.id ? room.get(e.id) : null; if (b) dodged(slotOf(b)); });
 /* ----------------------------------------------------------------- input */
 // The camera looks across the meadow from its near edge, square to it: screen right is +x and screen down is +y, so
 // keys and the stick move a body exactly as in Gem Rush. Space jumps; F (or J, Enter, a click) swings. On a phone the
@@ -491,483 +149,13 @@ function moveVector(): { x: number; y: number } {
     if (len > 6) { const m = Math.min(1, len / 56); x += (dx / len) * m; y += (dy / len) * m; }
   }
   const len = Math.hypot(x, y);
-  return len > 1 ? { x: x / len, y: y / len } : { x, y };
-}
-
-/** My jump: my body's height is mine (it rides in my avatar), so it starts here at once; every screen is told. */
-function jump(): void {
-  const seat = mySeat();
-  if (seat === null || !me.has || me.h > 0 || me.knockUntil > net.now()) return;
-  me.vh = jumpSpeed(); me.h = 1e-3;
-  const mine = hosting ? [...bodies.values()].find((x) => x.seat === seat) : [...drawn.values()].find((x) => x.seat === seat);
-  if (mine) { jumped(mine.slot); net.send('jump', { slot: mine.slot }); }
-  if (!hosting && MOVEMENT === 'host') net.press('jump');
-}
-
-/** My swing: the host lands it; every screen sees it start at once. */
-function swing(): void {
-  const seat = mySeat();
-  if (seat === null) return;
-  if (hosting) {
-    const b = [...bodies.values()].find((x) => x.seat === seat);
-    if (b) startSwing(b);
-  } else net.press('swing');
-}
-/**
- * Host: a swing starts. Every screen plays it now (the swing event); it LANDS T.windupMs later (the anticipation the
- * Game Lab tunes): every other body within T.knockRange, in front of the swinger (within T.swingArc degrees of where it
- * faces) and on the ground then, is knocked back. A body in the air is missed: it dodged.
- */
-const swings: { slot: number; at: number }[] = [];
-const swingReady = new Map<number, number>();
-function startSwing(from: Body): void {
-  const now = net.now();
-  if ((swingReady.get(from.slot) ?? 0) > now || from.knockUntil > now) return;
-  swingReady.set(from.slot, now + T.windupMs + T.swingRestMs);
-  const d = { slot: from.slot, fa: q(from.fa, 2) };
-  addWave(d); net.send('swing', d);
-  swings.push({ slot: from.slot, at: now + T.windupMs });
-  botsSee(from);
-}
-function landSwings(): void {
-  const now = net.now();
-  for (let i = swings.length - 1; i >= 0; i -= 1) {
-    const s = swings[i] as (typeof swings)[number];
-    if (now < s.at) continue;
-    swings.splice(i, 1);
-    const from = bodies.get(s.slot);
-    if (!from || from.knockUntil > now) continue;
-    const half = (T.swingArc * Math.PI) / 360;
-    for (const b of bodies.values()) {
-      if (b === from) continue;
-      const dx = b.x - from.x; const dy = b.y - from.y; const d = Math.hypot(dx, dy);
-      if (d > T.knockRange) continue;
-      let off = Math.atan2(dx, dy) - from.fa; off = Math.atan2(Math.sin(off), Math.cos(off));
-      if (d > R_AV * 1.5 && Math.abs(off) > half) continue;
-      const h = !b.bot && b.seat !== null && b.seat === mySeat() ? me.h : b.h;
-      if (h >= CLEAR_M) { dodged(b.slot); net.send('dodge', { slot: b.slot }); continue; }
-      knock(b, from.x, from.y, from.slot);
-    }
-  }
-}
-/**
- * Host: knock a body back. The hit LANDS first: for T.hitStopMs the body holds where it was hit (it flashes, flinches
- * and shakes on every screen), then it SLIDES T.knockDistance along the hit, fast at first and easing into the stop
- * (T.knockEase), so it arrives at rest, the same distance at any frame rate, and its owner steers again with no pop.
- * A replica's body is TAKEN for the whole bump (its owner's avatar frames are ignored; the host drives it; the owner
- * draws its body from snapshots), then the helper GIVES it back with a reset, so the owner stands where it ended.
- */
-function knock(b: Body, fx: number, fy: number, by: number): void {
-  let dx = b.x - fx; let dy = b.y - fy;
-  const len = Math.hypot(dx, dy);
-  if (len < 0.02) { const a = Math.random() * Math.PI * 2; dx = Math.cos(a); dy = Math.sin(a); } else { dx /= len; dy /= len; }
-  const at = net.now() + T.hitStopMs;
-  const o: Knock & { x: number; y: number } = !b.bot && b.seat !== null && b.seat === mySeat() ? me : b;
-  o.kvx = dx; o.kvy = dy; o.kx = o.x; o.ky = o.y; o.kat = at; o.knockUntil = at + T.knockMs;
-  if (o === b && !b.bot && b.seat !== null) net.take(b.seat, T.hitStopMs + T.knockMs);
-  labKnock(b);
-  const d = { slot: b.slot, dx: q(dx, 2), dy: q(dy, 2), by };
-  addWave(d, true); net.send('knock', d);
-}
-
-/** Where a bumped body is now: held through the hit-stop, then eased out along the hit. Sets its velocity too. */
-function slide(o: Knock & { x: number; y: number; vx: number; vy: number }, now: number, dt: number): void {
-  const u = Number.isFinite(o.kat) ? Math.max(0, Math.min(1, (now - o.kat) / Math.max(1, T.knockMs))) : 1;
-  const e = 1 - (1 - u) ** Math.max(1, T.knockEase);
-  const { x, y } = bound(o.kx + o.kvx * T.knockDistance * e, o.ky + o.kvy * T.knockDistance * e);
-  if (u >= 1) { o.vx = 0; o.vy = 0; } else if (dt > 0) { o.vx = (x - o.x) / dt; o.vy = (y - o.y) / dt; }
-  o.x = x; o.y = y;
-}
-/** The frame a bump is over: the body lands exactly where its slide ends, at rest (at 12 fps the last step is long). */
-function landed(o: Knock & { x: number; y: number; vx: number; vy: number }): void {
-  if (!o.kat) return;
-  slide(o, o.kat + T.knockMs, 0);
-  o.kat = 0;
-}
-function addWave(d: { slot: number; dx?: number; dy?: number; by?: number; fa?: number }, isKnock = false): void {
-  const pos = hosting ? bodies.get(d.slot) : [...drawn.values()].find((x) => x.slot === d.slot);
-  // The action, for a watcher on Auto: whoever swung (a person, never a bot).
-  const waver = pos && 'bot' in pos ? (pos.bot ? null : pos.seat) : pos && pos.seat >= 0 ? pos.seat : null;
-  if (!isKnock) net.spotlight(waver);
-  const mineSlot = hosting ? [...bodies.values()].find((x) => x.seat !== null && x.seat === mySeat())?.slot : [...drawn.values()].find((x) => x.seat === net.seat)?.slot;
-  const at = mineSlot === d.slot && me.has ? me : pos;
-  if (!at) return;
-  waves.push({ x: at.x, y: at.y, at: performance.now(), colour: isKnock ? '#ffffff' : PALETTE[d.slot % PALETTE.length] as string, knock: isKnock, fa: d.fa, slot: d.slot });
-  if (isKnock) knocksSeen += 1; else wavesSeen += 1;
-  if (isKnock) bumped(d, at); else swung(d.slot);
+  if (len > 1) { x /= len; y /= len; }
+  const c = Math.cos(view3.yaw), s = Math.sin(view3.yaw);
+  return { x: x * c + y * s, y: -x * s + y * c };
 }
 
-/* ---------------------------------------------------------------- simulate */
-/** The one movement rule, shared by the owner, the host (host movement) and a replica's prediction. */
-function integrate(o: { x: number; y: number; vx: number; vy: number }, mx: number, my: number, dt: number): void {
-  mx = Number(mx) || 0; my = Number(my) || 0;
-  const len = Math.hypot(mx, my);
-  if (len > 1) { mx /= len; my /= len; } // an intent is at most full stick: no speed hack through intents
-  const k = Math.min(1, dt * 14);
-  o.vx += (mx * SPEED - o.vx) * k;
-  o.vy += (my * SPEED - o.vy) * k;
-  const p = bound(o.x + o.vx * dt, o.y + o.vy * dt);
-  o.x = p.x; o.y = p.y;
-}
-
-function stepMe(dt: number): void {
-  const seat = mySeat();
-  if (seat === null) { me.has = false; return; }
-  // Host-driven (host movement, or knocked back on a replica): stepReplica predicts me instead.
-  if (!net.owned) { fall(me, dt); return; }
-  fall(me, dt);
-  if (me.knockUntil > net.now()) { slide(me, net.now(), dt); return; }
-  landed(me);
-  const v = moveVector();
-  integrate(me, v.x, v.y, dt);
-}
-/** Which way a body faces: where it goes, once it moves (a knocked body keeps its facing: it flies backwards). */
-function faceOf(o: { vx: number; vy: number; fa: number; knockUntil: number }, now: number): void {
-  if (o.knockUntil > now) return;
-  if (Math.hypot(o.vx, o.vy) > 0.6) o.fa = Math.atan2(o.vx, o.vy);
-}
-
-/**
- * Replica, host-driven body. My stick moves me locally every frame (instant response), with the same rule the host
- * runs. When a new snapshot lands: start from where the host has me, replay every intent it had not acknowledged,
- * and pull toward that by 30% (or jump, if it is far). The host stays the truth; I never wait for it.
- */
-let predictedK = -1;
-function predictMe(dt: number): void {
-  const v = moveVector();
-  integrate(me, v.x, v.y, dt);
-  const snap = net.latest();
-  if (!snap || snap.k === predictedK) return;
-  predictedK = snap.k;
-  const p = snap.d.p.find((x) => x[1] === net.seat);
-  if (!p) return;
-  const pred = { x: p[2], y: p[3], vx: p[5] ?? 0, vy: p[6] ?? 0 };
-  for (const f of net.pending()) {
-    let left = Math.min(0.25, f.dt / 1000);
-    while (left > 0) { const h = Math.min(left, 1 / 60); integrate(pred, f.a[4], f.a[5], h); left -= h; }
-  }
-  const err = Math.hypot(pred.x - me.x, pred.y - me.y);
-  predictionError = err;
-  if (!me.has || err > 3) { me.x = pred.x; me.y = pred.y; me.vx = pred.vx; me.vy = pred.vy; }
-  else { me.x += (pred.x - me.x) * 0.3; me.y += (pred.y - me.y) * 0.3; }
-  me.has = true;
-}
-
-function stepKnocked(b: Body, dt: number): void { slide(b, net.now(), dt); }
-
-/**
- * THE BOTS, AT THE ROOM'S DIAL (NETPLAY.md section 17), AND NEVER RUNNING AWAY WITH A NEW PLAYER'S ROUND.
- *
- * The dial: a bot re-reads the world only every `reactionMs` (what it last noticed is where it heads, and a miss costs
- * it that long again), aims up to 4 m off at aimNoise 1, leaves the hot zone to the people at positioning 0 and fights
- * for it at 1, and swings at a rival in reach about `aggression x 0.8` times a second. Rookie is beatable by anyone,
- * Maxed by few.
- *
- * On top of the dial, in plain words:
- *   A PLAYER'S FIRST ROUND. While somebody plays their first round in this room and nobody has set the dial (no vote,
- *     no owner: `net.policy.by` is absent), every bot plays one level easier for that round (Fair plays as Steady). A
- *     dial somebody set is always kept exactly.
- *   THE RUBBER BAND. Each bot compares its score with the best person's in the room (people only: never a bot, never
- *     an AI). Up to LEAD[level] points ahead of them it plays at its dial (2 at Fair, 5 at Strong; a Rookie eases off
- *     even a point behind them). Further ahead it eases off, the more the further (LEAD_BAND points more and it is all
- *     the way soft): it slows to a walk, notices things later, swings less, and races for the coins near the nearest
- *     person rather than the far ones. All the way soft it goes for no coin at all: it keeps near that person, a step
- *     up their screen, where a rival is seen (jogging after them when they run off), and goes round the coins on its
- *     way. The lead allowed grows with the dial; Maxed has no rubber band (a party that voted Maxed asked for the real
- *     thing). Within its lead, a bot always plays at its dial.
- *   HONEST. No score is ever changed: no coin is given, taken or faked, and a soft bot still picks up any coin it is
- *     knocked or walks onto, like anyone. Bots only play softer. Every bot is labelled where its name or score shows
- *     ("· bot"; an AI agent's name ends in "· AI"), on the phone's compact board too.
- */
-const sight = new Map<number, { at: number; tx: number; ty: number; arrived?: boolean; near?: number }>();
-/**
- * The lead (points over the best person) a bot may hold before it eases off, by level: Rookie (it eases off a point
- * BEHIND them: beatable by anyone), Steady, Fair, Strong, Maxed (no rubber band at all).
- */
-const LEAD = [-1, 1, 2, 5, Infinity] as const;
-/** Points past that lead over which a bot goes from its dial to all the way soft. */
-const LEAD_BAND = 2;
-/**
- * Each seated person and the first round they play whole in this room (the round they sat down in, or the next when
- * less than half of it was left). While one of them is in it, nobody set the dial and the bots play a level easier.
- * Kept in the checkpoint, so a promoted host goes on easing the same round.
- */
-let firstRound = new Map<number, number>();
-/** How each bot plays now (its level this round, and how soft the rubber band has it): the `pickups` probe. */
-const botPlay = new Map<number, { level: number; soft: number }>();
-
-/** A person sat down: their first whole round here is this one, or the next if less than half of this one is left. */
-function welcome(seat: number | null): void {
-  if (seat === null || firstRound.has(seat)) return;
-  const live = round?.phase === 'live';
-  firstRound.set(seat, !round ? 1 : live && round.endsAt - net.now() > ROUND_MS / 2 ? round.n : round.n + 1);
-}
-/** The people in the room: seated, not a bot, not an AI (an agent that plays its own seat is labelled · AI). */
-function people(): Body[] {
-  return [...bodies.values()].filter((b) => !b.bot && b.seat !== null && !b.name.endsWith(AI_MARK) && !roster.slots.find((x) => x.slot === b.slot)?.agent);
-}
-/** Somebody is playing their first round in this room now. */
-function newcomerRound(folk: Body[]): boolean {
-  return Boolean(round) && folk.some((b) => (firstRound.get(b.seat as number) ?? 0) >= (round as RoundInfo).n);
-}
-/** The dial a bot plays at this round: the room's, or a level easier in a newcomer's first round when nobody set it. */
-function dialOf(slot: number, easy: boolean): Skill {
-  const s: Skill = net.skillOf(slot); // Fair when nobody set a dial
-  return easy && !net.policy.by && s.level > 1 ? skillPreset(s.level - 1, net.policy.kids) : s;
-}
-/** The rubber band: 0 plays at the dial, 1 all the way soft, from how far this bot leads the best person. */
-function softness(b: Body, s: Skill, best: number | null): number {
-  const allowed = LEAD[Math.max(1, Math.min(5, s.level)) - 1] as number;
-  if (best === null || !Number.isFinite(allowed)) return 0;
-  return Math.max(0, Math.min(1, (b.score - best - allowed) / LEAD_BAND));
-}
-/** The nearest of `list` to `b`, or null. */
-function nearestOf(list: Body[], b: Body): Body | null {
-  let best: Body | null = null; let bd = Infinity;
-  for (const o of list) { const d = Math.hypot(o.x - b.x, o.y - b.y); if (d < bd) { bd = d; best = o; } }
-  return best;
-}
-/**
- * All the way soft: a spot near person `p`, 2.2 to 3 m off (just past a swing's reach) and a step up their screen
- * (where even a phone held upright shows a rival), turned a little each time it looks, so it keeps round them like a
- * rival waiting for a chance. It leaves the coins to them: of a few such spots, the first it can walk to without
- * running over a coin.
- */
-function beside(b: Body, p: Body): { x: number; y: number } {
-  const clear = R_AV + R_GEM + 0.15;
-  let spot = { x: b.x, y: b.y };
-  for (let i = 0; i < 6; i += 1) {
-    let a = Math.atan2(Math.min(b.y - p.y, -0.6), b.x - p.x) + (Math.random() - 0.5) * (1.2 + i * 0.5);
-    a = Math.max(-Math.PI + 0.7, Math.min(-0.7, a));
-    const r = 2.2 + Math.random() * 0.8;
-    spot = bound(p.x + Math.cos(a) * r, p.y + Math.sin(a) * r);
-    const dx = spot.x - b.x; const dy = spot.y - b.y; const len2 = dx * dx + dy * dy || 1;
-    // The nearest point of the walk to each coin: none closer than a pickup.
-    if (!gems.some((g) => { const u = Math.max(0, Math.min(1, ((g.x - b.x) * dx + (g.y - b.y) * dy) / len2)); return Math.hypot(b.x + dx * u - g.x, b.y + dy * u - g.y) < clear; })) break;
-  }
-  return spot;
-}
-
-function stepBots(dt: number): void {
-  const taken = new Set<number>();
-  const now = net.now();
-  const folk = people();
-  const best = folk.length ? Math.max(...folk.map((p) => p.score)) : null;
-  const easy = newcomerRound(folk);
-  for (const b of bodies.values()) {
-    if (!b.bot) continue;
-    fall(b, dt);
-    const leap = dodgeAt.get(b.slot);
-    if (leap !== undefined && now >= leap) { dodgeAt.delete(b.slot); if (b.h <= 0 && b.knockUntil <= now) { b.vh = jumpSpeed(); b.h = 1e-3; jumped(b.slot); net.send('jump', { slot: b.slot }); } }
-    if (b.knockUntil > now) { stepKnocked(b, dt); continue; }
-    landed(b);
-    if (lab.stage === 'dummy' || lab.stage === 'jump') { standStill(b, dt); continue; }
-    const s = dialOf(b.slot, easy);
-    const soft = softness(b, s, best); // THE RUBBER BAND
-    botPlay.set(b.slot, { level: s.level, soft });
-    let eye = sight.get(b.slot);
-    // REACTION TIME: later when soft (it notices coins late); all the way soft it only keeps up with its person.
-    if (!eye || now - eye.at >= s.reactionMs * (soft >= 1 ? 1 : 1 + 2.5 * soft)) {
-      const near = soft > 0 ? nearestOf(folk, b) : null;
-      let g: Gem | null = null;
-      let tx = b.tx; let ty = b.ty;
-      if (near && soft >= 1) { const at = beside(b, near); tx = at.x; ty = at.y; } // all the way soft: no coin, near them
-      else {
-        g = pickGem(b, taken, s, near, soft); // POSITIONING (soft: the coins near the nearest person)
-        const miss = 4 * s.aimNoise; // AIM NOISE: up to 4 m off at 1
-        if (g) { tx = g.x + (Math.random() - 0.5) * miss; ty = g.y + (Math.random() - 0.5) * miss; }
-      }
-      eye = { at: now, tx, ty, ...(near && soft >= 1 ? { near: near.slot } : {}) };
-      sight.set(b.slot, eye);
-      if (g) taken.add(g.id);
-    }
-    b.tx = eye.tx; b.ty = eye.ty;
-    const rival = nearestBody(b, T.knockRange * 0.9); // AGGRESSION: swings at a rival in reach, turning to it (less when soft)
-    if (rival && round?.phase === 'live' && Math.random() < s.aggression * (1 - 0.75 * soft) * 0.8 * dt) { b.fa = Math.atan2(rival.x - b.x, rival.y - b.y); startSwing(b); }
-    const dx = b.tx - b.x; const dy = b.ty - b.y; const dist = Math.hypot(dx, dy);
-    const len = dist || 1;
-    // Arrived where it aimed: it stands there, and notices what it missed only a reaction later.
-    if (dist < 0.12 && !eye.arrived) { eye.arrived = true; eye.at = now; }
-    // Soft: down to a walk; all the way soft it jogs back to its person when they have run off (a rival in view).
-    const kept = eye.near !== undefined ? bodies.get(eye.near) : undefined;
-    const far = kept ? Math.hypot(kept.x - b.x, kept.y - b.y) > 3.5 : false;
-    const speed = dist < 0.12 ? 0 : BOT_SPEED * (far ? 1 : 1 - 0.5 * soft);
-    const k = Math.min(1, dt * 5);
-    b.vx += ((dx / len) * speed - b.vx) * k;
-    b.vy += ((dy / len) * speed - b.vy) * k;
-    // All the way soft it steps round a coin in its way (turning a little, or a lot, or it waits): it leaves them to
-    // the people. It still takes one it is knocked onto, or one that lands under it: the rules' pickups are anyone's.
-    if (kept) sidestep(b, dt);
-    const p = bound(b.x + b.vx * dt, b.y + b.vy * dt);
-    b.x = p.x; b.y = p.y;
-    faceOf(b, now);
-  }
-}
-/** A soft bot's step that would touch a coin turns aside (60, then 120 degrees, either way), or it stands this frame. */
-function sidestep(b: Body, dt: number): void {
-  const reach = R_AV + R_GEM + 0.06;
-  const look = Math.max(0.25, Math.hypot(b.vx, b.vy) * dt * 4); // a few frames ahead
-  const touches = (vx: number, vy: number): boolean => {
-    const sp = Math.hypot(vx, vy) || 1; const x = b.x + (vx / sp) * look; const y = b.y + (vy / sp) * look;
-    return gems.some((g) => Math.hypot(g.x - x, g.y - y) < reach && Math.hypot(g.x - x, g.y - y) < Math.hypot(g.x - b.x, g.y - b.y));
-  };
-  if (Math.hypot(b.vx, b.vy) < 0.05 || !touches(b.vx, b.vy)) return;
-  for (const a of [1.05, -1.05, 2.1, -2.1]) {
-    const c = Math.cos(a); const sn = Math.sin(a);
-    const vx = b.vx * c - b.vy * sn; const vy = b.vx * sn + b.vy * c;
-    if (!touches(vx, vy)) { b.vx = vx; b.vy = vy; return; }
-  }
-  b.vx = 0; b.vy = 0;
-}
-/**
- * A bot sees a swing start near it: it may JUMP it, after its reaction time (half of it: a swing is loud), the more
- * likely the better its aim at the dial (a Rookie is caught, a Maxed bot hops most of them; a soft one less often).
- */
-const dodgeAt = new Map<number, number>();
-function botsSee(from: Body): void {
-  const easy = newcomerRound(people());
-  for (const b of bodies.values()) {
-    if (!b.bot || b === from || lab.stage === 'dummy' || lab.stage === 'jump') continue;
-    if (Math.hypot(b.x - from.x, b.y - from.y) > T.knockRange + 0.6) continue;
-    const s = dialOf(b.slot, easy);
-    const soft = botPlay.get(b.slot)?.soft ?? 0;
-    if (Math.random() < (0.15 + 0.6 * (1 - s.aimNoise)) * (1 - 0.5 * soft)) dodgeAt.set(b.slot, net.now() + Math.max(40, s.reactionMs * 0.5 - 60));
-  }
-}
-
-/**
- * Positioning: 0 leaves the hot zone to the people, 1 fights for it. A soft bot (`pull` 0 to 1) weighs how far each
- * coin is from the person `near` it too, so it races for theirs, where they can see it and beat it to them.
- */
-function pickGem(b: Body, taken: Set<number>, s: Skill, near: Body | null = null, pull = 0): Gem | null {
-  let best: Gem | null = null; let bd = Infinity;
-  for (const g of gems) {
-    if (taken.has(g.id)) continue;
-    const hot = zone !== null && Math.hypot(g.x - zone.x, g.y - zone.y) < zone.r;
-    const d = Math.hypot(g.x - b.x, g.y - b.y) * (hot ? 1.5 - s.positioning : 1) + (near ? 2 * pull * Math.hypot(g.x - near.x, g.y - near.y) : 0);
-    if (d < bd) { bd = d; best = g; }
-  }
-  return best;
-}
-
-/** The nearest other body within `range` (a bot's rival), or null. */
-function nearestBody(b: Body, range: number): Body | null {
-  let best: Body | null = null; let bd = range;
-  for (const o of bodies.values()) {
-    if (o === b) continue;
-    const d = Math.hypot(o.x - b.x, o.y - b.y);
-    if (d < bd) { bd = d; best = o; }
-  }
-  return best;
-}
-
-function stepHost(dt: number): void {
-  tick += 1;
-  const seat = mySeat();
-  const now0 = net.now();
-  for (const b of bodies.values()) {
-    if (b.bot) continue;
-    if (b.seat === seat) {
-      me.has = true;
-      b.x = me.x; b.y = me.y; b.vx = me.vx; b.vy = me.vy; b.h = me.h; b.vh = me.vh;
-      faceOf(b, now0);
-      continue;
-    }
-    if (b.seat === null) continue;
-    const ctl = net.control(b.seat);
-    if (ctl.taken || b.knockUntil > now0) { stepKnocked(b, dt); fall(b, dt); if (net.takePresses(b.seat)['swing']) startSwing(b); continue; } // the host drives the knockback
-    if (MOVEMENT === 'host') {
-      // Host movement: the seat sends intents; the rules move the body (and jump it).
-      const f = net.inputOf(b.seat);
-      integrate(b, f ? Number(f.a?.[4]) : 0, f ? Number(f.a?.[5]) : 0, dt);
-      const pr = net.takePresses(b.seat);
-      if (pr['jump'] && b.h <= 0) { b.vh = jumpSpeed(); b.h = 1e-3; }
-      fall(b, dt);
-      faceOf(b, now0);
-      if (pr['swing']) startSwing(b);
-      continue;
-    }
-    const a = net.avatar(b.seat); // null while taken, or until the owner has adopted the last reset
-    if (a && Array.isArray(a)) {
-      // Client-owned movement, bounded: to the arena, and to 1.3x top speed per frame. A legitimate avatar catches
-      // up within a frame; a teleport crawls, and a claim more than half a second of running away is reset.
-      const claim = bound(Number(a[0]) || 0, Number(a[1]) || 0);
-      const m = capMove(b, claim, SPEED * 1.3 * dt + 0.12);
-      if (m.over > SPEED * 0.5) { net.reset(b.seat); cheatResets += 1; }
-      else { b.x = m.x; b.y = m.y; b.vx = Number(a[2]) || 0; b.vy = Number(a[3]) || 0; }
-      // Its height is the owner's too, bounded by how high a jump goes.
-      b.h = Math.max(0, Math.min(T.jumpHeight * 1.15 + 0.05, Number(a[6]) || 0));
-      faceOf(b, now0);
-    }
-    if (net.takePresses(b.seat)['swing']) startSwing(b);
-  }
-  stepBots(dt);
-  landSwings();
-  const now = net.now();
-  if (round && round.phase === 'live') {
-    if (!zone || now >= zone.until) setZone(newZone((zone?.n ?? 0) + 1));
-    for (const b of bodies.values()) {
-      for (let i = 0; i < gems.length; i += 1) {
-        const g = gems[i] as Gem;
-        if (Math.hypot(g.x - b.x, g.y - b.y) < R_AV + R_GEM) {
-          b.score += zone && Math.hypot(g.x - zone.x, g.y - zone.y) < zone.r ? 2 : 1;
-          pickups.set(b.slot, (pickups.get(b.slot) ?? 0) + 1);
-          gems[i] = newGem();
-        }
-      }
-    }
-    if (now >= round.endsAt) endRound();
-  } else if (round && round.phase === 'over' && now >= round.endsAt) startRound(round.n + 1, true);
-  if (net.snapshotDue()) net.snapshot(buildSnap(), tick);
-}
-
-function buildSnap(): Snap {
-  const r = round ?? { n: 0, phase: 'live', startedAt: 0, endsAt: 0 };
-  return {
-    r: [r.n, r.phase === 'over' ? 1 : 0, r.startedAt, r.endsAt],
-    p: [...bodies.values()].map((b) => [b.slot, b.seat ?? -1, q(b.x, 2), q(b.y, 2), b.score, q(b.vx, 1), q(b.vy, 1), q(b.h, 2)] as P),
-    g: gems.map((g) => [g.id, q(g.x, 2), q(g.y, 2)] as G),
-  };
-}
-
-function stepReplica(dt: number): void {
-  const seat = net.seat;
-  if (seat !== null) {
-    // Host-driven (host movement, or taken for a knockback): predict from the host's position and my intents.
-    if (!net.owned) predictMe(dt);
-    // Only once I have a body (the first control event adopts it): before that my position is nobody's.
-    if (me.has) {
-      const v = moveVector();
-      // Stick direction as held "buttons": a new direction is a press edge, so it is sent within 16 ms.
-      const held = [v.x > 0.2 ? 'R' : v.x < -0.2 ? 'L' : '', v.y > 0.2 ? 'D' : v.y < -0.2 ? 'U' : ''].filter(Boolean);
-      net.input([q(me.x, 2), q(me.y, 2), q(me.vx, 1), q(me.vy, 1), q(v.x, 2), q(v.y, 2), q(me.h, 2)], held);
-    }
-  }
-  const smp = net.sample();
-  drawn.clear();
-  if (!smp) return;
-  const bySlot = new Map<number, P>(smp.a.d.p.map((p) => [p[0], p]));
-  for (const pb of smp.b.d.p) {
-    const pa = bySlot.get(pb[0]) ?? pb;
-    drawn.set(pb[0], { slot: pb[0], seat: pb[1], x: lerp(pa[2], pb[2], smp.alpha), y: lerp(pa[3], pb[3], smp.alpha), h: Math.max(0, lerp(Number(pa[7]) || 0, Number(pb[7]) || 0, smp.alpha)), score: pb[4] });
-  }
-  const [n, ph, startedAt, endsAt] = smp.b.d.r;
-  if (!round || round.n !== n || (round.phase === 'over') !== (ph === 1)) {
-    const kept = net.roundInfo && net.roundInfo.n === n ? net.roundInfo : null;
-    round = kept ?? { n, phase: ph ? 'over' : 'live', startedAt, endsAt };
-  }
-}
-
-/* -------------------------------------------------------------- how a swing, a hit and a jump look */
-/*
- * Every screen draws a swing from the swing event (the host's own, or the one it sends): the hero plays its attack (on
- * the upper body when it runs) and a slash arcs in front of it. A bump comes from the knock event: the hit lands (the
- * hero flashes white, flinches and holds through the hit-stop, shaking), flies (stretched along the hit, less as it
- * slows), stops (squashed, then a wobble that dies away: overlap), throws sparks, and kicks the camera of whoever was
- * in it. A jump plays from the jump event and the height in the snapshot; a dodge (a swing passing under a jumper)
- * pops a word. Sparks and the camera's kick roll lab.random(): their own dice, so the world's (Math.random) stay the
- * same as a build without them, which the Game Lab needs to compare two.
- */
+function jump(): void { const v = moveVector(); room.input({ ax: Math.round(v.x * 127), ay: Math.round(v.y * 127), jump: true }); }
+function swing(): void { const v = moveVector(); room.input({ ax: Math.round(v.x * 127), ay: Math.round(v.y * 127), swing: true }); }
 const bumps = new Map<number, { at: number; dx: number; dy: number }>();
 const pushes = new Map<number, number>();
 const sparks: { x: number; y: number; h: number; vx: number; vy: number; vh: number; at: number; life: number; gold?: boolean }[] = [];
@@ -984,7 +172,7 @@ function bumped(d: { slot: number; dx?: number; dy?: number; by?: number }, at:
   }
   if (sparks.length > 160) sparks.splice(0, sparks.length - 160);
   // The camera kicks for whoever was in it: the body bumped, or the one who waved.
-  const mine = hosting ? [...bodies.values()].find((x) => x.seat !== null && x.seat === mySeat())?.slot : [...drawn.values()].find((x) => x.seat === net.seat)?.slot;
+  const mine = [...drawn.values()].find((x) => x.seat === net.seat)?.slot;
   if (mine !== undefined && (d.slot === mine || d.by === mine)) kickAt = now;
   const hero = heroes.get(d.slot)?.char;
   if (hero) hero.hit(dx, dy, 1);
@@ -996,10 +184,9 @@ function swung(slot: number): void {
   h.char.act(h.char.has(HERO_ACTION[h.kind] ?? 'attack') ? (HERO_ACTION[h.kind] ?? 'attack') : 'attack', { from: T.swingSkip });
   labSwing(slot);
 }
-/** A jump started (its own owner jumped it; bots by the host). */
+/** Count authoritative jumps; the clip starts with the drawn takeoff, including prediction. */
 function jumped(slot: number): void {
   jumpsSeen += 1;
-  heroes.get(slot)?.char?.jump();
 }
 /** A swing passed under a jumper: a word pops over it. */
 const pops: { slot: number; at: number; text: string }[] = [];
@@ -1040,51 +227,11 @@ function bodyFx(slot: number, t: number): { ox: number; oy: number; sx: number;
   return out;
 }
 
-/* -------------------------------------------------------------- the Game Lab */
-/*
- * What the lab shows (lab.json's takes):
- *   "swing"  stage dummy: you swing at the dummy beside you. WINDUP (from the press to the moment it lands: the
- *            anticipation), then the dummy's HIT-STOP, LAUNCH, SLIDE and SETTLE. Tracks its speed and distance.
- *   "jump"   stage jump: you jump in an empty space. TAKE-OFF, RISE, HANG (near the top), FALL, LAND. Tracks the height
- *            and the body's stretch (the animator's squash and stretch).
- * The onion skin and the spacing arc (dots far apart: fast; close together: slow) are drawn as lines on the meadow.
- * Only in the lab: outside it, labKnock, labSwing and labReport never run.
- */
 type Pose = { x: number; y: number; sx?: number; sy?: number; a?: number };
-/**
- * The take's stage "dummy" (lab.stage, only ever set by the lab): you stand left of the middle, facing a bot a short
- * step to your right, and every bot stands still unless it is bumped, like a training dummy. Stage "jump": you stand in
- * the middle with nobody near.
- */
-function stageDummy(): void {
-  const seat = mySeat();
-  const list = [...bodies.values()].sort((a, c) => a.slot - c.slot);
-  const mine = list.find((b) => !b.bot && b.seat === seat);
-  const bots = list.filter((b) => b.bot);
-  const jumpStage = lab.stage === 'jump';
-  if (mine) { mine.x = W / 2 - (jumpStage ? 0 : 3.2); mine.y = H / 2; mine.fa = Math.PI / 2; hostMoved(mine); }
-  bots.forEach((b, i) => { b.x = i === 0 && !jumpStage ? W / 2 - 3.2 + 1.5 : W - 3.6; b.y = i === 0 && !jumpStage ? H / 2 : 3 + i * 5; b.tx = b.x; b.ty = b.y; b.fa = -Math.PI / 2; });
-}
-/** A dummy at rest: it eases to a stop wherever the last bump left it. */
-function standStill(b: Body, dt: number): void {
-  const k = Math.min(1, dt * 5);
-  b.vx -= b.vx * k; b.vy -= b.vy * k;
-  const p = bound(b.x + b.vx * dt, b.y + b.vy * dt); b.x = p.x; b.y = p.y;
-}
 const subject = { slot: -1, at: 0, x0: 0, y0: 0, px: 0, py: 0, has: false };
 const swinger = { slot: -1, at: 0 };
-function labKnock(b: Body): void {
-  if (!lab.on) return;
-  subject.slot = b.slot; subject.at = net.now(); subject.x0 = b.x; subject.y0 = b.y; subject.px = b.x; subject.py = b.y; subject.has = true;
-}
 function labSwing(slot: number): void { if (lab.on) { swinger.slot = slot; swinger.at = net.now(); } }
-/** Where the subject is now (the host's own body is `me`), or null. */
-function subjectAt(): Pose | null {
-  if (!subject.has) return null;
-  const b = bodies.get(subject.slot);
-  if (!b) return null;
-  return !b.bot && b.seat !== null && b.seat === mySeat() ? me : b;
-}
+function subjectAt(): Pose | null { return subject.has ? drawn.get(subject.slot) ?? null : null; }
 let apex = 0;
 function labReport(dt: number): void {
   if (dt <= 0) return;
@@ -1092,7 +239,7 @@ function labReport(dt: number): void {
     const hero = [...heroes.values()].find((x) => x.mine)?.char ?? null;
     lab.track('height', me.h, 'm');
     lab.track('stretch', hero ? (hero.root.children[0]?.scale.y ?? 1) * 100 - 100 : 0, '%');
-    if (me.h <= 0) { lab.phase(hero?.state === 'LAND' ? 'LAND' : null, 'Squash on touch-down, then back to the run'); apex = 0; }
+    if (room.me?.grounded) { lab.phase(hero?.state === 'LAND' ? 'LAND' : null, 'Squash on touch-down, then back to the run'); apex = 0; }
     else if (me.vh > jumpSpeed() * 0.55) lab.phase('TAKE-OFF', 'Leaves fast and stretched');
     else if (me.vh > jumpSpeed() * 0.15) lab.phase('RISE', 'Slows as it climbs');
     else if (me.vh > -jumpSpeed() * 0.25) { lab.phase('HANG', 'A moment at the top to read it'); apex = Math.max(apex, me.h); }
@@ -1808,7 +955,7 @@ interface Hero {
   slot: number; kind: string; mine: boolean;
   root: Group; tilt: Group; squash: Group; untilt: Group;
   char: Character | null; stand: Mesh | null; mats: MeshStandardMaterial[];
-  px: number; py: number; ph: number; speed: number; seen: number; yaw: number; held: string | null;
+  px: number; py: number; ph: number; grounded: boolean; speed: number; seen: number; yaw: number; held: string | null;
 }
 const heroes = new Map<number, Hero>();
 function heroFor(slot: number, kind: string, colour: string): Hero {
@@ -1818,7 +965,7 @@ function heroFor(slot: number, kind: string, colour: string): Hero {
     const root = new Group(); const tilt = new Group(); const squash = new Group(); const untilt = new Group();
     root.add(tilt); tilt.add(squash); squash.add(untilt);
     scene.add(root);
-    h = { slot, kind, mine: false, root, tilt, squash, untilt, char: null, stand: null, mats: [], px: NaN, py: NaN, ph: 0, speed: 0, seen: 0, yaw: 0, held: null };
+    h = { slot, kind, mine: false, root, tilt, squash, untilt, char: null, stand: null, mats: [], px: NaN, py: NaN, ph: 0, grounded: true, speed: 0, seen: 0, yaw: 0, held: null };
     heroes.set(slot, h);
   }
   h.kind = kind;
@@ -1871,7 +1018,8 @@ function poseHero(h: Hero, at: { x: number; y: number; h: number }, t: number, d
   const vh = dt > 0 ? (at.h - h.ph) / dt : 0;
   h.px = at.x; h.py = at.y; h.ph = at.h;
   // It faces where it goes, but not while flying from a bump (it is knocked backwards, not turned round).
-  if (sp > 0.6 && !bumps.has(h.slot) && Number.isFinite(step)) h.yaw = Math.atan2(dx, dy);
+  const pose = poses.get(h.slot);
+  if (pose) h.yaw = Math.atan2(pose.heading.x, pose.heading.y);
   h.tilt.rotation.y = -fx.ang; h.untilt.rotation.y = fx.ang;
   h.squash.scale.set(fx.sx, fx.up, fx.sy);
   for (const m of h.mats) if (m.emissive) m.emissive.setScalar(fx.flash * 0.9);
@@ -1879,7 +1027,9 @@ function poseHero(h: Hero, at: { x: number; y: number; h: number }, t: number, d
   if (!c) { if (h.stand) h.stand.rotation.y = h.yaw; return; }
   c.face(h.yaw, dt);
   c.move(bumps.has(h.slot) ? 0 : h.speed);
-  c.air(at.h <= 0.001, vh);
+  const grounded = pose?.grounded ?? at.h <= 0.002, vertical = pose?.vel.z ?? vh;
+  if (h.grounded && !grounded && vertical > 0) c.jump();
+  c.air(grounded, vertical); h.grounded = grounded;
   // The round's end: its winner cheers (held until the next round), everyone else stands.
   const want = over && place === 1 ? 'win' : null;
   if (want !== h.held) { if (want) c.hold(want); else if (h.held) c.hold(''); h.held = want; }
@@ -2072,7 +1222,6 @@ let lastDraw = 0;
 /** Where a seat's body is drawn now (host: the real body; replica: interpolated), or null. */
 function seatPos(seat: number): { x: number; y: number } | null {
   if (seat === mySeat() && me.has && !net.watching) return me;
-  if (hosting) { const b = [...bodies.values()].find((x) => !x.bot && x.seat === seat); return b ? { x: b.x, y: b.y } : null; }
   const d = [...drawn.values()].find((x) => x.seat === seat);
   return d ? { x: d.x, y: d.y } : null;
 }
@@ -2143,7 +1292,7 @@ function draw(t: number, dt: number): void {
   }
 
   // gems: spinning, bobbing, glowing; a taken one bursts into gold where it was
-  const gemList: { x: number; y: number; id: number }[] = hosting ? gems : (net.latest()?.d.g ?? []).map(([id, x, y]) => ({ id, x, y }));
+  const gemList: { x: number; y: number; id: number }[] = gems;
   const rn = round?.n ?? -1;
   const seenNow = new Set<number>();
   let nb = 0;
@@ -2182,8 +1331,7 @@ function draw(t: number, dt: number): void {
       const mat = m.material as MeshBasicMaterial; mat.color.set(w.colour); mat.opacity = 1 - age;
     } else {
       const m = slashMesh(ns2++);
-      const pos = hosting ? bodies.get(w.slot ?? -1) : null;
-      const fa = w.fa ?? pos?.fa ?? 0;
+      const fa = w.fa ?? 0;
       const r = 0.55 + Math.min(1, age * 2.2) * (T.knockRange - 0.55);
       m.visible = true; m.position.set(wx, 0.55, wz); m.rotation.set(0, fa, 0); m.scale.set(r, 1, r);
       const mat = m.material as MeshBasicMaterial; mat.color.set(w.colour); mat.opacity = 0.85 * (1 - age) ** 1.5;
@@ -2193,16 +1341,11 @@ function draw(t: number, dt: number): void {
   for (let i = ns2; i < slashPool.length; i += 1) (slashPool[i] as Mesh).visible = false;
 
   // the heroes
-  const names = new Map<number, Slot>((net.slots ?? roster.slots).map((s) => [s.slot, s]));
+  const names = new Map<number, Slot>((net.slots ?? []).map((s) => [s.slot, s]));
   // `mine`: the body whose view this is: my own, or the player a watcher follows (named, never "You").
   const list: { slot: number; seat: number | null; x: number; y: number; h: number; bot: boolean; name: string; mine: boolean }[] = [];
   const isView = (seat: number | null, bot: boolean): boolean => !bot && seat !== null && seat === view;
-  if (hosting) {
-    for (const b of bodies.values()) {
-      const own = !b.bot && b.seat !== null && b.seat === mySeat() && me.has;
-      list.push({ slot: b.slot, seat: b.seat, x: own ? me.x : b.x, y: own ? me.y : b.y, h: own ? me.h : b.h, bot: b.bot, name: b.name, mine: isView(b.seat, b.bot) });
-    }
-  } else {
+  {
     for (const d of drawn.values()) {
       const own = !net.watching && d.seat >= 0 && d.seat === net.seat;
       const s = names.get(d.slot);
@@ -2405,7 +1548,7 @@ function arrival(t: number): void {
   const view = [...heroes.values()].find((h) => h.mine) ?? null;
   if (!modelAt && view?.char && !net.watching) { modelAt = t; try { performance.mark('hero:model'); } catch { /* old browser */ } }
   if (playableAt) return;
-  const stateIn = Boolean(round) && (hosting || drawn.size > 0);
+  const stateIn = Boolean(round) && (drawn.size > 0);
   const dressed = view ? Boolean(view.char) : heroes.size > 0 && [...heroes.values()].every((h) => h.char);
   if (!stateIn || (!dressed && performance.now() - BOOT_AT < 5000)) return;
   playableAt = t;
@@ -2433,8 +1576,7 @@ function hud(cw: number, ch: number, phone: boolean, list: { slot: number; seat:
   // scores: the play page's room button (and a server's pill beside it) sit at the top right (game.json screen.share's
   // default): the scores start under that band, so the buttons never cover a score.
   const scores = new Map<number, number>();
-  if (hosting) for (const b of bodies.values()) scores.set(b.slot, b.score);
-  else for (const d of drawn.values()) scores.set(d.slot, d.score);
+  for (const d of drawn.values()) scores.set(d.slot, d.score);
   // A phone's board is compact (the top three, a short name and a small "bot" or "AI" tag after it; a bot's dot is
   // hollow), so a game's own HUD at the top left (a basket, a timer) has room beside it. Every bot and AI says so.
   const rows = [...list].sort((a, b) => (scores.get(b.slot) ?? 0) - (scores.get(a.slot) ?? 0)).slice(0, phone ? 3 : 6);
@@ -2534,11 +1676,9 @@ function hud(cw: number, ch: number, phone: boolean, list: { slot: number; seat:
 let lastT = -1;
 function frame(t: number): void {
   const dt = lab.time.dt(t, 0.05);
-  // The look's own clock (the heroes' clips): real seconds, at most a tenth, whatever the rules' step.
+  // The look's own clock (the animals' clips): real seconds, at most a tenth, whatever the rules' step.
   const ddt = lastT < 0 ? 0 : Math.min(0.1, Math.max(0, (t - lastT) / 1000)); lastT = t;
-  stepMe(dt);
-  if (hosting) stepHost(dt);
-  else stepReplica(dt);
+  updateView();
   if (lab.on) labReport(dt);
   draw(t, lab.on ? dt : ddt);
   frames += 1;
@@ -2548,37 +1688,18 @@ function frame(t: number): void {
 net.expose({
   // Room chat's bubbles on this screen now: whose, what, and where (an end-to-end test reads them).
   bubbles: () => shownBubbles.map((b) => ({ seat: b.key, text: b.lines.join(' '), alpha: b.alpha, left: Math.round(b.left), top: Math.round(b.top), right: Math.round(b.right), bottom: Math.round(b.bottom) })),
-  self: () => (me.has ? { x: me.x, y: me.y } : null),
+  self: () => (me.has ? { x: me.x, y: me.y, z: me.h } : null),
   peer: (seat: number) => {
-    if (hosting) { const b = [...bodies.values()].find((x) => x.seat === seat); return b ? { x: b.x, y: b.y } : null; }
     const d = [...drawn.values()].find((x) => x.seat === seat);
-    return d ? { x: d.x, y: d.y } : null;
+    return d ? { x: d.x, y: d.y, z: d.h } : null;
   },
   frames: () => frames,
-  scores: () => (hosting ? [...bodies.values()].map((b) => ({ slot: b.slot, seat: b.seat, bot: b.bot, score: b.score })) : [...drawn.values()].map((d) => ({ slot: d.slot, seat: d.seat >= 0 ? d.seat : null, bot: d.seat < 0, score: d.score }))),
-  /**
-   * Host: gems each slot picked up this round, the round's age, and how each bot plays: the room's dial (`dial`), the
-   * level it plays at this round (`level`: a level easier in a newcomer's first round) and the rubber band (`soft`, 0
-   * at its dial to 1 all the way soft). `newcomer`: somebody is in their first round here.
-   */
-  pickups: () => (hosting ? {
-    round: round ? { n: round.n, phase: round.phase, ageMs: net.now() - round.startedAt } : null,
-    newcomer: newcomerRound(people()),
-    slots: [...bodies.values()].map((b) => ({ slot: b.slot, bot: b.bot, gems: pickups.get(b.slot) ?? 0, dial: b.bot ? net.skillOf(b.slot).level : null, level: b.bot ? (botPlay.get(b.slot)?.level ?? net.skillOf(b.slot).level) : null, soft: b.bot ? +(botPlay.get(b.slot)?.soft ?? 0).toFixed(2) : null })),
-  } : null),
-  /** Where the coins are now (rules metres): what a harness's coin-chasing player steers by. */
-  gems: () => (hosting ? gems.map((g) => ({ id: g.id, x: g.x, y: g.y })) : (net.latest()?.d.g ?? []).map(([id, x, y]) => ({ id, x, y }))),
-  /** Host: when each bot last looked (its reaction clock). */
-  sight: () => (hosting ? [...sight.entries()].map(([slot, e]) => ({ slot, at: e.at })) : null),
+  scores: () => [...drawn.values()].map(d => ({ slot: d.slot, seat: d.seat >= 0 ? d.seat : null, bot: d.seat < 0, score: d.score })),
+  pickups: () => { const slots: unknown[] = []; room.each('runner', e => slots.push({ slot: e.seat, bot: e.driver === 'bot', gems: e.pickups })); return { round, slots }; },
   waves: () => wavesSeen,
-  swings: () => wavesSeen,
   knocks: () => knocksSeen,
   zone: () => zone,
-  owned: () => net.owned,
-  cheatResets: () => cheatResets,
-  movement: () => MOVEMENT,
-  controlResets: () => controlResets,
-  predictionError: () => predictionError,
+  movement: () => 'server',
   /** Where the camera looks (rules metres), how far away it is, its turn, and whose view it is. */
   camera: () => ({ x: view3.x, y: view3.y, dist: view3.dist, yaw: view3.yaw, view: viewSeat() }),
   /** The names as drawn (boxes, never the text): the e2e probe counts overlaps and checks your own. */
@@ -2589,39 +1710,25 @@ net.expose({
   drawCalls: () => renderer.info.render.calls,
   triangles: () => renderer.info.render.triangles,
   /** The models: how many loaded, their triangles, texture memory and bytes, and any refused (with why). */
-  models: () => ({ ...models.stats(), standIns: [...standIns], heroes: [...heroes.values()].map((h) => ({ slot: h.slot, hero: h.kind, standIn: !h.char })) }),
-  /** What every hero is doing now (IDLE, WALK, RUN, JUMP, FALL, LAND, ATTACK, CAST, HIT, HOLD), its clips and its pose rate. */
+  models: () => ({ ...models.stats(), standIns: [...standIns], heroes: [...heroes.values()].map(h => ({ slot: h.slot, state: h.char?.state })) }),
+
   heroes: () => [...heroes.values()].map((h) => ({ slot: h.slot, hero: h.kind, state: h.char?.state ?? 'LOADING', verbs: h.char?.verbs ?? [], lod: h.char?.lod ?? null, family: h.char?.family ?? null })),
   jumps: () => jumpsSeen,
   dodges: () => dodgesSeen,
   /** Harness hooks for this screen's own player: jump, swing. */
-  debugJump: () => { jump(); return me.h > 0; },
+  debugJump: () => { const accepted = Boolean(room.me?.grounded); jump(); return accepted; },
   debugSwing: () => { swing(); return true; },
-  /** Harness hook (host only): knock the body of `seat` back, toward the middle of the arena. */
-  debugKnock: (seat: number) => {
-    if (!hosting) return false;
-    const b = [...bodies.values()].find((x) => x.seat === seat);
-    if (!b) return false;
-    knock(b, b.x < W / 2 ? b.x - 0.05 : b.x + 0.05, b.y, -1); // push toward the middle, away from the nearer wall (bumped by nobody)
-    return true;
-  },
+
 });
 
 exposePort(net, {
   view: 'top',
   self: () => (me.has && mySeat() !== null ? { x: me.x, y: me.y } : null),
   size: R_AV,
-  score: () => { const seat = mySeat(); const b = hosting ? [...bodies.values()].find((x) => x.seat === seat) : [...drawn.values()].find((x) => x.seat === seat); return b ? b.score : null; },
+  score: () => { const seat = mySeat(); const b = [...drawn.values()].find((x) => x.seat === seat); return b ? b.score : null; },
   // The renderer's own counters, by the names `homie-studio perf` and the playtest read on the port probe (measured
   // scene cost while playing; port/probe.ts PortExtra). Nobody dies in this game, so there is no `alive` to say.
   extra: { drawCalls: () => renderer.info.render.calls, triangles: () => renderer.info.render.triangles },
 });
 
-void net.ready.then(() => {
-  const seat = mySeat();
-  if (seat !== null && hosting) {
-    const b = [...bodies.values()].find((x) => x.seat === seat);
-    if (b) { me.x = b.x; me.y = b.y; me.has = true; }
-  }
-});
 requestAnimationFrame(frame);