@homie-rocks/studio 0.46.3 → 0.46.6

package/lib/template-history.json

@@ -2817,6 +2817,90 @@
      }
     }
    }
+  },
+  "0.46.5": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "394cbbe934e80722",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "5222e08ca55e326e",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "27881d11d3ff3803",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "611b437f5b3303f0"
+      }
+     }
+    }
+   }
+  },
+  "0.46.6": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "394cbbe934e80722",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "5222e08ca55e326e",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "27881d11d3ff3803",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "611b437f5b3303f0"
+      }
+     }
+    }
+   }
   }
  }
 }

package/netplay/NETPLAY.md

@@ -1699,6 +1699,18 @@ reads the other's snapshot with the wrong code.
 - **An old tab that knocks at the live build's room is refused**: `error stale` (final; the helper
   shows "This game was updated. Tap to reload." and the play page reloads the frame, at most twice
   a minute).
+- **A page older than the game it would host is brought up to date too (0.46.5).** The frame alone
+  is reloaded only while the play page around it is still the page the Worker would write now. The
+  page says what it was made for (`sh` on the frame's address: the toolkit's version and the parts
+  of the manifest a page is built around, `shellKey` in worker/pages.mjs; not the game's code or
+  words). When that differs, the Worker answers the frame with a stand-in that says so, and the
+  page does **one full reload**, to the same room (it is in the address) and the same seat (its
+  token is in the tab). A page from before this handshake has only one way to load a whole new
+  page, the one for leaving a finished room; it is used only when the game cannot work inside the
+  old page at all: the game keeps results for a player (`room.records`) and the old page holds no
+  player ticket. Such a player lands in a fresh page and a room the lobby gives them. A result
+  that still has no player to be written for is never dropped in silence: the log says
+  `record-unsaved`, and the player's screen says the round was not saved and to reload.
 - **A tab of the live build that knocks at a room still on the old build waits**: `error
   room-stale` (not final). The room's players are told to reload; when the last of them has left,
   the next knock is let in, and the room **starts fresh**: its checkpoint, snapshot, round, roster

package/netplay/netplay.ts

@@ -2547,6 +2547,8 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
         // An AI alone in a room (nobody seated): it knocks again only after a while (section 17).
         if (code === 'agents-alone') aloneUntil = wall() + AGENTS_ALONE_WAIT_MS;
         if (code === 'host-fault') { rulesNotice(String(m.message)); return; }
+        // A result the server could not keep for this player (0.46.5): said on their screen, not dropped in silence.
+        if (code === 'unsaved') { rulesNotice(String(m.message)); return; }
         if (code === 'vote') { warnOnce('vote', m['message']); return; }
         if (code === 'rate' || code === 'state-full') { warnOnce(`${code}:${String(m['of'] ?? '')}`, m['message']); return; }
         // The room still runs another build of the game (section 23): not final. Its players were told to reload; this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.46.3",
+  "version": "0.46.6",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/rules/host.ts

@@ -80,6 +80,8 @@ export interface HostOptions {
   clock: HostClock;
   /** Synchronous save: the caller's storage output gate holds this tick's outgoing frames until confirmed. */
   store?: { save(bytes: Uint8Array, commitment?: { force: boolean; seconds: number; tickHz: number; fields: { kinds: number[][]; shared: number[] } }): void };
+  /** Whether a snapshot is also handed over as text (the default). A room that sends the whole world to nobody answers false. */
+  snapshotText?: () => boolean;
   /** Table recovery reserves this epoch in storage before starting this host. Ordinary deterministic restores omit it. */
   restoreEpoch?: number;
   startDelayMs?: number;
@@ -289,6 +291,7 @@ export function createHost(o: HostOptions): Host {
    *
    * `room.rewindSeconds` is the game's hard cap on the sum. Without it the cap is `room.historySeconds`, as before.
    */
+  const historyTicks = Math.ceil((c.historySeconds ?? 0) * tickHz);
   const rewindCap = c.rewindSeconds !== undefined ? Math.ceil(c.rewindSeconds * tickHz) : null;
   const rewindTicks = (seat: number): number => {
     const waited = Math.max(1, Math.min(lateTicks, queues.get(seat)?.early ?? 1));
@@ -628,7 +631,9 @@ export function createHost(o: HostOptions): Host {
   /* ---------------------------------------------------------------- frames out */
 
   const hasHands = (seat: number, driver: Driver): boolean => driver === 'person' || (driver === 'ai' && [...peers.values()].some((p) => p.seat === seat && p.agent?.hands === 'self'));
-  const nameOf = (seat: number, driver: Driver): string => (driver === 'bot' || (driver === 'ai' && (core.bodies().find((b) => b.seat === seat)?.owner === 'reserved' || !names.has(seat))) ? BOT_NAMES[seat % BOT_NAMES.length] : names.get(seat) || `Player ${seat + 1}`);
+  // The game's own names for its bots (room.bots.names, 0.46.5), else the toolkit's.
+  const botNames = c.botNames?.length ? c.botNames : BOT_NAMES;
+  const nameOf = (seat: number, driver: Driver): string => (driver === 'bot' || (driver === 'ai' && (core.bodies().find((b) => b.seat === seat)?.owner === 'reserved' || !names.has(seat))) ? botNames[seat % botNames.length] : names.get(seat) || `Player ${seat + 1}`);
   function sendRoster(): void {
     const guides = new Map(agentSlots().map((s) => [s.slot, s.agent]));
     const slots = core.bodies().sort((a, b) => a.seat - b.seat).map((b) => ({ slot: b.seat, seat: b.driver === 'bot' ? null : b.seat, name: nameOf(b.seat, b.driver), bot: b.driver === 'bot', ...(guides.has(b.seat) ? { agent: guides.get(b.seat) } : {}) }));
@@ -749,14 +754,20 @@ export function createHost(o: HostOptions): Host {
       const q = queues.get(b.seat);
       // A fifth number only for a seat that has sent a numbered pulse: the newest one acted on.
       const taken = pulsesTaken.get(b.seat);
-      rows.push(taken === undefined ? [b.seat, b.r, q ? q.ack : 0, q && q.lead !== 127 ? q.lead : -128] : [b.seat, b.r, q ? q.ack : 0, q && q.lead !== 127 ? q.lead : -128, taken]);
+      const row = [b.seat, b.r, q ? q.ack : 0, q && q.lead !== 127 ? q.lead : -128];
+      // A sixth number only in a game that rewinds (room.historySeconds, 0.46.5): how many ticks back this seat's own
+      // ray may look right now, so its browser can predict against the pose the server will judge, not a guess at it.
+      if (historyTicks) row.push(taken ?? 0, Math.min(historyTicks, rewindTicks(b.seat)));
+      else if (taken !== undefined) row.push(taken);
+      rows.push(row);
       if (q) q.lead = 127;
     }
     // A snapshot is stamped with the moment its tick was due, so ticks run in a burst to catch up are still a tick
     // apart to whoever interpolates between them. The stamp always rises: a replica drops one that does not.
     lastSt = Math.max(lastSt + 1, Math.round(Math.min(now, dueOf(core.tick))));
     const snap = { t: 'snap', from: null, e: epoch, k: core.tick, st: lastSt, d: data, c: rows };
-    const encoded = JSON.stringify(snap);
+    // The whole world as text, for whoever is sent it whole. A room that sends it to nobody says so and is spared it.
+    const encoded = o.snapshotText?.() === false ? undefined : JSON.stringify(snap);
     timing.record('encode', encodeAt);
     const sendAt = timing.now();
     o.send(snap, encoded);

package/rules/rules.ts

@@ -167,7 +167,8 @@ export interface RulesDef {
   shared?: Fields;
   room?: {
     rounds?: { seconds: number; breakSeconds: number };
-    bots?: { keep: number };
+    /** `names` (0.46.5): what the game's bots are called, by seat; the toolkit's own list without it. */
+    bots?: { keep: number; names?: readonly string[] };
     records?: RoundRecords;
     historySeconds?: number;
   /** The furthest a person's ray may be rewound, in seconds (0.46.3): a hard cap under `historySeconds`, whatever their connection measures. */
@@ -396,6 +397,7 @@ export interface Compiled {
   rewindSeconds?: number;
   rounds: { seconds: number; breakSeconds: number } | null;
   bots: number;
+  botNames?: readonly string[];
   start: RoomHandler | null;
   join: NonNullable<RulesDef['room']>['join'] | null;
   roomOn: Record<string, RoomHandler>;
@@ -636,6 +638,8 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
   }
   const keep = room.bots === undefined ? 0 : typeof room.bots?.keep === 'number' ? Math.floor(room.bots.keep) : NaN;
   if (!(keep >= 0 && keep <= SEATS_MAX)) throw new Error(`room.bots is { keep: n }, 0 to ${SEATS_MAX}`);
+  const botNames = (room.bots as { names?: unknown } | undefined)?.names;
+  if (botNames !== undefined && !(Array.isArray(botNames) && botNames.length >= 1 && botNames.length <= 64 && botNames.every((n) => typeof n === 'string' && n.trim().length >= 1 && n.length <= 24 && !/[\u0000-\u001f\u007f\u200b-\u200f\u202a-\u202e\u2066-\u2069]/.test(n)))) throw new Error('room.bots.names is a list of 1 to 64 names, each 1 to 24 characters on one line');
   if (room.start !== undefined && typeof room.start !== 'function') throw new Error('room.start is a function');
   if (room.join !== undefined && typeof room.join !== 'function') throw new Error('room.join is a function');
   const players = kinds.filter((k) => k.player);
@@ -661,7 +665,7 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
   Object.freeze(navigation);
   return {
     navigation, contract: RULES_CONTRACT, save: SAVE_REVISION, dims, kinds, kindOf, events, commands, effects, effectNames: Object.keys(effects),
-    shared: fieldList(d.shared, 'shared'), view, ...(room.records?{records:room.records}:{}), ...(room.historySeconds ? {historySeconds:room.historySeconds}:{}), ...(room.rewindSeconds !== undefined ? {rewindSeconds:room.rewindSeconds}:{}), rounds, bots: Math.min(keep, seats), start: room.start ?? null, join: room.join ?? null, roomOn, asks,
+    shared: fieldList(d.shared, 'shared'), view, ...(room.records?{records:room.records}:{}), ...(room.historySeconds ? {historySeconds:room.historySeconds}:{}), ...(room.rewindSeconds !== undefined ? {rewindSeconds:room.rewindSeconds}:{}), rounds, ...(botNames ? { botNames: Object.freeze([...(botNames as string[])]) } : {}), bots: Math.min(keep, seats), start: room.start ?? null, join: room.join ?? null, roomOn, asks,
     tune, publicTune, map, settings, seats,
   };
 }
@@ -674,6 +678,8 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
  */
 export interface Schema {
   records?: true;
+  /** A game that rewinds (0.46.5): its window and its cap, for a browser predicting its own shots. */
+  rewind?: { historySeconds: number; capSeconds?: number };
   contract: 2;
   dims: 2 | 3;
   seats: number;
@@ -698,7 +704,7 @@ function publicField(field: Field, hidden=false): Field {
 }
 export function schemaOf(c: Compiled): Schema {
   return {
-    contract: RULES_CONTRACT, dims: c.dims, seats: c.seats, ...(c.records?{records:true as const}:{}),
+    contract: RULES_CONTRACT, dims: c.dims, seats: c.seats, ...(c.records?{records:true as const}:{}), ...(c.historySeconds ? { rewind: { historySeconds: c.historySeconds, ...(c.rewindSeconds !== undefined ? { capSeconds: c.rewindSeconds } : {}) } } : {}),
     kinds: c.kinds.map((k) => ({ ...(k.query?{query:k.query}:{}), ...(k.collider?{collider:k.collider}:{}), ...(k.body?.terrain ? {terrain:k.body.terrain} : {}), name: k.name, player: Boolean(k.player), ...(k.player?.control ? {control:k.player.control}:{}), owner: Boolean(k.body?.owner), radius: k.body?.radius ?? 0, ...(c.dims === 3 && k.body ? { shape: k.body.shape, height: k.body.height || 2 * k.body.radius } : {}), maxSpeed: k.body?.maxSpeed ?? 0, score: k.score, fields: k.fields.map(([name,field])=>[name,publicField(field)]), motion: k.motion, input: k.input })),
     effects: c.effects, effectNames: c.effectNames, commands: c.commands, shared: c.shared, rounds: c.rounds, settings: c.settings,
   };

package/rules/view.ts

@@ -47,8 +47,8 @@ import { createNetplay } from '../netplay/netplay.ts';
 import type { Netplay, NetplayOptions, RulesHostFactory, RoundInfo, Snapshot, StepEntry } from '../netplay/netplay.ts';
 import { lab } from '../lab/lab.ts';
 import { exposePort, type PortProbeOptions } from '../port/probe.ts';
-import { BudgetError } from './guard.ts';
-import { moveContext } from './math.ts';
+import { BudgetError, brand } from './guard.ts';
+import { math, moveContext } from './math.ts';
 import { coerce, coerceFields, dir, initFields, stepMove, thawFields, unpackEntity, unpackFields, unpackVec, vec3 } from './pack.ts';
 import type { Unpacked } from './pack.ts';
 import { compileMap } from './rules.ts';
@@ -113,6 +113,15 @@ export interface OpenRoomOptions {
 /** What a predictor (`openRoom({ predict })`) is handed beside the body and the tick's input. */
 export interface PredictContext extends RayQueries {
   readonly tick: number; readonly dt: number;
+  /** The same deterministic `math` a `move` is handed (0.46.5): a helper shared with the rules can be called with `ctx`. */
+  readonly math: typeof math;
+  /**
+   * The tick the server will judge this player's ray against when the browser says it aimed at `aimTick` (0.46.5):
+   * `aimTick`, held to how far back this seat may look right now (the server says so in every snapshot) and to this
+   * tick. Pass it to `ctx.ray(..., { atTick })`: the other bodies are then posed as the server will pose them, from
+   * the snapshots this browser holds (between two of them, or carried on from the newest along its velocity).
+   */
+  judgedTick(aimTick: number): number;
   /** The tick the other bodies are drawn at: what the player is looking at. */
   readonly viewTick: number;
   /** This run draws ahead of the tick; the tick's own run follows. What it shows is shown once. */
@@ -128,6 +137,8 @@ export interface PredictContext extends RayQueries {
 export type Predictor = (me: any, input: any, ctx: PredictContext) => void;
 export interface Room<R = unknown> extends RayQueries {
   readonly viewTick: number;
+  /** Where a body was at a tick, from the snapshots this browser holds (0.46.5); `known: false` past the newest one. */
+  poseAt(id: string, tick: number): { pos: Vec3; vel: Vec3; known: boolean } | null;
   readonly status: RoomStatus;
   readonly seat: number | null;
   readonly me: Entity | null;
@@ -184,6 +195,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
 
   let status: RoomStatus = 'connecting';
   let latest: Frame | null = null;
+  /** The snapshots this browser holds, oldest first: two seconds of them (see poseAt). */
+  const held2: Frame[] = [];
   let epoch = 0;
   let round: RoomRound | null = null;
   let results: RoundInfo['results'] | undefined;
@@ -380,11 +393,14 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // run has asked for: never by the order of everything asked, which changes when another action joins the tick.
     const asked = new Map<string, number>();
     const once = (what: string): boolean => { if (!live) return false; let set = shown.get(t); if (!set) { set = new Set(); shown.set(t, set); } const n = asked.get(what) ?? 0; asked.set(what, n + 1); const key = what + '#' + n; if (set.has(key)) return false; set.add(key); return true; };
-    const ctx: PredictContext = {
-      tick: t, dt: 1 / tickHz, preview,
+    // Branded as a world is (0.46.5): a guarded helper of the rules may call its queries, so the server's own aiming
+    // code can be run on it instead of being restated in the view.
+    const ctx: PredictContext = brand({
+      tick: t, dt: 1 / tickHz, preview, math,
+      judgedTick: (aimTick) => Math.max(t - rewindAllowance(), Math.min(t, Number(aimTick) || 0)),
       get viewTick() { return viewTickNow(); },
       ray: (from, direction, max, options) => viewRay(from, direction, max, options)[0],
-      rays: (options) => raySnapshot(map, viewTargets(), dims, options, id),
+      rays: (options) => raySnapshot(map, viewTargets(atTickOf(options)), dims, options, id),
       rayAll: (from, direction, max, options) => viewRay(from, direction, max, options, true),
       ghost(kindOfGhost, at, data = {}, options = {}) {
         const k = kindOf.get(kindOfGhost);
@@ -406,7 +422,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         if (waiting) waiting.confirms = true; else provisional.push({ name, tick: t, payload, match: options.match });
         emit(name, Object.freeze({ ...payload, predicted: true }));
       },
-    };
+    });
     const me = Object.assign(fields, { id, kind: kindName }) as Record<string, unknown>;
     for (const [key, value] of Object.entries({ pos: body.pos, vel: body.vel, heading: body.heading, grounded: body.grounded, motion: body.motion })) Object.defineProperty(me, key, { value, enumerable: false, configurable: true, writable: true });
     try { fn(me, input, ctx); } catch (err) { console.warn('[room] predict', err); }
@@ -551,6 +567,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     const before = latest;
     if (before && before.e === f.e && f.k <= before.k) return;
     latest = f;
+    if (before && before.e !== f.e) held2.length = 0;
+    held2.push(f); if (held2.length > 2 * tickHz) held2.shift();
     if (!before || before.e !== f.e) collisionHistory = [];
     const collision = f.collision;
     if (collision) {
@@ -785,11 +803,19 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       // and stops dead at a release, with nothing to blend away afterwards.
       for (const [name, fd] of kind.input) now[name] = (fd.t === 'press' || fd.t === 'pulse') ? (pressed.get(name) ?? (fd.t === 'press' ? false : 0)) : fd.t === 'held' ? coerce(fd, heldMean(name, fd.init, Math.min(clock(), edgeOf(stepped + 1)), false), dims) : coerce(fd, sample[name] ?? fd.init, dims);
       const next = runMove(kind.name, { pos: mine.pos, vel: mine.vel, heading: mine.heading, grounded: mine.grounded, motion: motionOf(mine.kind, mine.motion) }, Object.freeze(now), stepped + 1);
-      pos = vec3({ x: lerp(mine.pos.x, next.pos.x, a), y: lerp(mine.pos.y, next.pos.y, a), z: lerp(mine.pos.z, next.pos.z, a) }, dims);
+      // A landing does not take the whole tick (0.46.5): the body met the ground part way through it. How far through is
+      // read from the fall it would have made at the speed it entered the tick with; it is drawn down to the ground by
+      // then and standing from then, not sinking until the tick's end.
+      let av = a, landed = false;
+      if (dims === 3 && !mine.grounded && next.grounded && mine.vel.z < 0) {
+        const free = -mine.vel.z / tickHz, contact = free > 1e-6 ? Math.max(0.05, Math.min(1, (mine.pos.z - next.pos.z) / free)) : 1;
+        av = Math.min(1, a / contact); landed = a >= contact;
+      }
+      pos = vec3({ x: lerp(mine.pos.x, next.pos.x, a), y: lerp(mine.pos.y, next.pos.y, a), z: lerp(mine.pos.z, next.pos.z, av) }, dims);
       heading = blendHeading(mine.heading, next.heading, a, dims);
       velocity = vec3({ x: lerp(mine.vel.x, next.vel.x, a), y: lerp(mine.vel.y, next.vel.y, a), z: lerp(mine.vel.z, next.vel.z, a) }, dims);
       // A takeoff is airborne as soon as it rises; a landing waits for its contact.
-      grounded = mine.grounded && (a === 0 || next.grounded);
+      grounded = landed || mine.grounded && (a === 0 || next.grounded);
       preview = next;
       if (predictors[kind.name]) {
         // The own actions between ticks: the predictor on a copy of the fields, for the tick about to be stepped.
@@ -912,16 +938,43 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   if (typeof document !== 'undefined') document.addEventListener('visibilitychange', onShow);
 
   function viewTickNow(): number { const s=net.sample();const a=s?frameOf(s.a):latest,b=s?frameOf(s.b):latest;return a&&b?a.k+(b.k-a.k)*(s?.alpha??0):latest?.k??0; }
-  const viewTargets = () => {
+  /*
+   * WHERE A BODY WAS, OR WILL BE JUDGED TO BE (0.46.5). The server judges a rewound ray against poses it kept by
+   * tick. A browser holds the snapshots it has received: a pose at a tick between two of them is the point between;
+   * past the newest it is that snapshot's pose carried on along its velocity (`known: false`: a guess); before the
+   * oldest it is the oldest. A placement between the two is not glided across.
+   */
+  function poseAt(id: string, at: number): { pos: Vec3; vel: Vec3; known: boolean } | null {
+    let before: Frame | null = null, after: Frame | null = null;
+    for (const f of held2) { if (!f.ents.has(id)) continue; if (f.k <= at) before = f; if (f.k >= at && !after) after = f; }
+    const a = before?.ents.get(id), b = after?.ents.get(id);
+    if (a && b) { if (before === after || a.r !== b.r) return { pos: b.pos, vel: b.vel, known: true }; const m = (at - before!.k) / (after!.k - before!.k); return { pos: vec3({ x: lerp(a.pos.x, b.pos.x, m), y: lerp(a.pos.y, b.pos.y, m), z: lerp(a.pos.z, b.pos.z, m) }, dims), vel: b.vel, known: true }; }
+    if (a) { const s = Math.min(tickHz, at - before!.k) / tickHz; return { pos: vec3({ x: a.pos.x + a.vel.x * s, y: a.pos.y + a.vel.y * s, z: a.pos.z + a.vel.z * s }, dims), vel: a.vel, known: false }; }
+    return b ? { pos: b.pos, vel: b.vel, known: false } : null;
+  }
+  const atTickOf = (options: unknown): number | undefined => { const v = options !== null && typeof options === 'object' ? (options as { atTick?: unknown }).atTick : undefined; return typeof v === 'number' && Number.isFinite(v) ? v : undefined; };
+  /** How many ticks back this seat's ray may look: the server's own figure from the newest snapshot, else the rule it follows with this browser's round trip. */
+  function rewindAllowance(): number {
+    const seat = net.seat, row = seat === null ? undefined : latest?.rows.find((x) => x[0] === seat);
+    const history = Math.ceil((schema.rewind?.historySeconds ?? 0) * tickHz);
+    if (typeof row?.[5] === 'number') return row[5];
+    const cap = schema.rewind?.capSeconds !== undefined ? Math.ceil(schema.rewind.capSeconds * tickHz) : history;
+    return Math.min(history, cap, Math.ceil((authorityRtt() + 150) / period) + 1);
+  }
+  const viewTargets = (atTick?: number) => {
     pump();
     const targets: QueryTarget[] = collisionTargets(collisionMap(map, collisionHistory.at(-1)?.[2] ?? []));
     for(const k of schema.kinds) {
       if(k.collider || !k.radius)continue;
-      each(k.name,e=>targets.push({id:e.id,kind:k.name,query:k.query,fields:e as Record<string,unknown>,geometry:false,solid:solidAt(e.pos,{shape:k.shape??'circle',radius:k.radius,height:k.height??0}),at:e.pos}));
+      each(k.name,e=>{
+        // At a tick: where the server will have the body, with the fields as they are now (the server filters on current fields too).
+        const at = atTick !== undefined && e.id !== mine?.id && !e.provisional ? poseAt(e.id, atTick)?.pos ?? e.pos : e.pos;
+        targets.push({id:e.id,kind:k.name,query:k.query,fields:e as Record<string,unknown>,geometry:false,solid:solidAt(at,{shape:k.shape??'circle',radius:k.radius,height:k.height??0}),at});
+      });
     }
     return targets;
   };
-  const viewRay = (from: unknown, direction: unknown, max: number, options?: RayOptions, all=false) => rayQuery(map,viewTargets(),dims,from,direction,max,options,mine?.id,all);
+  const viewRay = (from: unknown, direction: unknown, max: number, options?: RayOptions, all=false) => rayQuery(map,viewTargets(atTickOf(options)),dims,from,direction,max,options,mine?.id,all);
   return {
     get viewTick() { return solo ? solo.viewTick : viewTickNow(); },
     get status() { return solo ? 'offline' : status; },
@@ -929,7 +982,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     get me() { pump(); return meNow(); },
     each, get,
     ray: (from,direction,max,options) => solo ? solo.ray(from,direction,max,options) : viewRay(from,direction,max,options)[0],
-    rays: options => solo ? solo.rays(options) : raySnapshot(map,viewTargets(),dims,options,mine?.id),
+    rays: options => solo ? solo.rays(options) : raySnapshot(map,viewTargets(atTickOf(options)),dims,options,mine?.id),
+    poseAt: (id, tick) => solo ? solo.poseAt(id, tick) : poseAt(id, tick),
     rayAll: (from,direction,max,options) => solo ? solo.rayAll(from,direction,max,options) : viewRay(from,direction,max,options,true),
     on(name, fn) { let set = listeners.get(name); if (!set) { set = new Set(); listeners.set(name, set); } set.add(fn); forwardSolo(name); return () => { set?.delete(fn); }; },
     get shared() { if (solo) return solo.shared; return Object.freeze(unpackFields(schema.shared, net.stateOf('shared'), dims)); },

package/worker/build-id.mjs

@@ -1,2 +1,2 @@
 // Generated by lib/build-identity.mjs; identifies the bundled runtime sources.
-export const STUDIO_BUILD = Object.freeze({"version":"0.46.3","sha256":"b36c0a219e734a32d419796f59d6965723849e1f462c75211468524c7b165266"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.46.6","sha256":"efd3ddbf72033f5d24b8107a41db2bc1a518f1d3f92963f5afd77c5c0e2f5059"});

package/worker/gate.mjs

@@ -36,9 +36,11 @@ function parseFrame(event) {
  * as full as it can serve, and a room opens only the Gates its players fill.
  * A studio chooses its room's size and nothing else. */
 export const GATE_PLAYERS = 50;
-export function roomLayout(seats) {
+/** `per`: players a Gate, for a trial that is finding the right number (`HOMIE_GATE_PLAYERS` on the Worker). A studio never sets it. */
+export const gatePlayers = (env) => { const n = Number(env?.HOMIE_GATE_PLAYERS); return Number.isInteger(n) && n >= 4 && n <= 200 ? n : GATE_PLAYERS; };
+export function roomLayout(seats, per = GATE_PLAYERS) {
   // A room of up to 64 is its Table alone, as it has been since 0.45.0.
-  const gates = seats <= 64 ? 1 : Math.ceil(seats / GATE_PLAYERS);
+  const gates = seats <= 64 ? 1 : Math.ceil(seats / per);
   return { gates, concentrators: 0 };
 }
 /** The Gate a key lands on when the room cannot be asked: spread evenly, as 0.45.0 did. */
@@ -52,17 +54,17 @@ function hashedGate(key, gates) {
  * Gate, not twenty with two or three players each, every one of them costing the room a channel. `held` is each
  * Gate's players now and `promised` those sent to it who have not arrived yet.
  */
-export function nextGate(gates, held, promised = new Map()) {
+export function nextGate(gates, held, promised = new Map(), per = GATE_PLAYERS) {
   let least = 0, fewest = Infinity;
   for (let i = 0; i < gates; i++) {
     const n = (held.get(i) ?? 0) + (promised.get(i) ?? 0);
-    if (n < GATE_PLAYERS) return i;
+    if (n < per) return i;
     if (n < fewest) { fewest = n; least = i; }
   }
   return least;
 }
 export function gateFor(env, game, room, seats, key) {
-  const layout = roomLayout(seats);
+  const layout = roomLayout(seats, gatePlayers(env));
   // One logical Gate is embedded in the Table for a small room. Same relay,
   // admission and delivery protocol; no extra Durable Object or seat clamp.
   const table = () => env.TABLE.get(env.TABLE.idFromName(`${game}/${room}`));
@@ -211,7 +213,9 @@ export function multiplexSession(socket, connect, { onMetrics = () => {}, delay
   const scheduleAdmission = () => {
     if (!closed && admissions.length && attaching < 8 && out.buffered() < 512 * 1024 && admissionTimer === null) admissionTimer = setTimeout(pump, 1);
   };
-  const transportFacts = () => ({ ...out.facts(), admissions: admissions.length, attaching });
+  // What this Gate has sent the room: frames, the rows in them (a row is a player's message, mostly) and their size.
+  const heard = { frames: 0, rows: 0, bytes: 0 };
+  const transportFacts = () => ({ ...out.facts(), in: { ...heard }, admissions: admissions.length, attaching });
   const shutdown = () => {
     if (closed) return;
     closed = true; out.close();
@@ -226,6 +230,7 @@ export function multiplexSession(socket, connect, { onMetrics = () => {}, delay
       if (closed) return;
       const rows = parseFrame(event);
       if (!Array.isArray(rows)) throw new Error('invalid multiplex batch');
+      heard.frames += 1; heard.rows += rows.length; heard.bytes += event.data.length;
       for (const [op, id, value, ip, agent] of expandBatch(rows)) {
         if (op === 'metrics') { onMetrics(id, value); continue; }
         if (op === 'open') {
@@ -291,26 +296,38 @@ export function acceptMultiplex(request, connect, options) {
  * A socket to a slow player has no back-pressure a Worker can read, so a Gate
  * that writes every tick to a link that carries fewer leaves that player
  * seconds behind for good: every frame arrives, each one later than the last.
- * A client names the newest tick it holds (`g`, on its inputs and pings). While
- * that trails the room by more than a second the Gate halves this player's
- * rate, down to one a second; when it is back within half a second the rate
- * doubles again. Each frame is a delta from the last one SENT, so a skipped
- * tick costs nothing later, and the player's own body is in every frame.
- * A client that names nothing is sent every tick, as before.
+ * A client names the newest tick it holds (`g`, on its inputs and pings).
+ *
+ * Being behind is not the reason to send less: a connection that stalls for a
+ * second and then delivers what it held catches up by itself, and sending it
+ * less only makes it worse (0.46.2 paced all 600 players of a healthy room
+ * when their one home link hiccuped). The reason is being behind and NOT
+ * catching up: more than a second behind on two reports half a second apart,
+ * the second not a quarter of a second nearer than the first. Then this
+ * player's rate halves, down to one a second, and halves again while that
+ * stays so. Within half a second of the room, the rate doubles back, a step a
+ * second. Each frame is a delta
+ * from the last one SENT, so a skipped tick costs nothing later, and the
+ * player's own body is in every frame. A client that names nothing is sent
+ * every tick, as before.
  */
 export function deliveryPace(hz = 20) {
-  let interval = 1, sent = -Infinity, got = null, changedAt = -Infinity, lag = null;
+  let interval = 1, sent = -Infinity, changedAt = -Infinity, lag = null, behind = null;
   const most = Math.max(1, Math.round(hz));
   return {
     /** The client holds tick `tick`; the room is at `world`. `now` in ms. */
     report(tick, world, now) {
       if (!Number.isFinite(tick) || !Number.isFinite(world)) return;
       // A new room epoch restarts its ticks: a tick from the old one says nothing.
-      got = tick > world ? null : tick;
-      lag = got === null ? null : world - got;
-      if (lag === null) return;
-      if (lag > hz && now - changedAt >= 500 && interval < most) { interval = Math.min(most, interval * 2); changedAt = now; }
-      else if (lag <= hz / 2 && now - changedAt >= 1000 && interval > 1) { interval = Math.max(1, interval / 2); changedAt = now; }
+      lag = tick > world ? null : world - tick;
+      if (lag === null) { behind = null; return; }
+      if (lag <= hz / 2) { behind = null; if (interval > 1 && now - changedAt >= 1000) { interval = Math.max(1, interval / 2); changedAt = now; } return; }
+      if (lag <= hz) { behind = null; return; }
+      if (behind === null) { behind = { lag, at: now }; return; }
+      if (now - behind.at < 500) return;
+      // Catching up means a quarter of a second nearer in half a second; anything less is a link that cannot keep this rate.
+      if (lag > behind.lag - hz / 4 && now - changedAt >= 500 && interval < most) { interval = Math.min(most, interval * 2); changedAt = now; }
+      behind = { lag, at: now };
     },
     due(tick) { return tick < sent || tick - sent >= interval; },
     sent(tick) { sent = tick; },
@@ -324,8 +341,19 @@ const COASTS = /^\{"t":"hello".{0,2000}?"coast":1[,}]/;
 const percentile = (sorted, p) => sorted.length ? sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))] : null;
 
 export class Gate {
-  constructor(ctx, env) { this.ctx = ctx; this.env = env; this.clients = new Map(); this.admissions = new Map(); this.sequence = 0; this.link = null; this.opening = null; this.timing = stageTimings(); this.metricsAt = 0; this.window = this.freshWindow(); this.worldTick = null; }
-  freshWindow() { return { worlds: 0, frames: 0, bytes: 0, skipped: 0, inputs: 0, worldAge: [], tickFrom: null, tickFromAt: 0, tickAt: 0, gapMax: 0 }; }
+  constructor(ctx, env) { this.ctx = ctx; this.env = env; this.clients = new Map(); this.admissions = new Map(); this.sequence = 0; this.link = null; this.opening = null; this.timing = stageTimings(); this.metricsAt = 0; this.window = this.freshWindow(); this.worldTick = null; this.behind = new Set(); this.idle = null; }
+  freshWindow() { return { worlds: 0, frames: 0, bytes: 0, skipped: 0, inputs: 0, worldAge: [], tickFrom: null, tickFromAt: 0, tickAt: 0, gapMax: 0, gaps: [0, 0, 0], late: 0, busy: 0 }; }
+  /** This Gate's own lateness: a timer every 20 ms, and how long past it each one came. A Gate that is out of time is late to its own timer. */
+  watchLoop() {
+    if (this.loopTimer) return;
+    let due = Date.now() + 20;
+    this.loopTimer = setInterval(() => {
+      const now = Date.now(), late = Math.max(0, now - due); due = now + 20;
+      this.window.late = Math.max(this.window.late, late); if (late > 20) this.window.busy += 1;
+      if (!this.link || !this.clients.size) { clearInterval(this.loopTimer); this.loopTimer = null; }
+    }, 20);
+    this.loopTimer?.unref?.();
+  }
   /** `[sent, received, answered]`: this Gate's clock when its frame left, the room's when it read it and when it answered. */
   roomClock([sent, received, answered]) {
     const now = Date.now(), offset = ((received - sent) + (answered - now)) / 2, delay = (now - sent) - (answered - received);
@@ -380,6 +408,13 @@ export class Gate {
         } catch (error) { lost({ error, reason: 'invalid room frame' }); try { socket.close(1011, 'room link failed'); } catch {} }
       });
       socket.addEventListener('close', lost); socket.addEventListener('error', lost);
+      // A Gate nobody is on gives its channel back after ten seconds: an open channel keeps the room and this Gate in
+      // memory (and billed) with nothing to carry. The next player to arrive opens another, as the first did.
+      this.rest = () => {
+        if (this.link !== link || this.clients.size) return;
+        this.link = null; this.worlds = null; link.close();
+        try { socket.close(1000, 'no players'); } catch { /* gone */ }
+      };
       this.link = link; return link;
     })();
     try { return await this.opening; } finally { this.opening = null; }
@@ -388,7 +423,7 @@ export class Gate {
   deliver(snap, settings, hz, drop) {
     const w = this.window, now = Date.now(); w.worlds++;
     if (w.tickFrom === null) { w.tickFrom = this.worldTick ?? snap.k; w.tickFromAt = this.worldAt ?? now; }
-    if (this.worldAt) w.gapMax = Math.max(w.gapMax, now - this.worldAt);
+    if (this.worldAt) { const gap = now - this.worldAt; w.gapMax = Math.max(w.gapMax, gap); if (gap > 75) w.gaps[0] += 1; if (gap > 150) w.gaps[1] += 1; if (gap > 300) w.gaps[2] += 1; }
     this.worldTick = snap.k; this.worldAt = now; w.tickAt = now;
     // By this Gate's clock, corrected for what the room's clock is measured to differ by.
     if (Number.isFinite(snap.st)) w.worldAge.push(Math.max(0, now - snap.st + (this.clock?.offsetMs ?? 0)));
@@ -431,7 +466,7 @@ export class Gate {
   async connect(request, server) {
     const link = await this.upstream(new URL(request.url));
     const id = String(++this.sequence);
-    this.clients.set(id, server);
+    this.clients.set(id, server); clearTimeout(this.idle); this.idle = null; this.watchLoop();
     let opened = false;
     const deadline = setTimeout(() => {
       this.admissions.delete(id);
@@ -458,12 +493,18 @@ export class Gate {
       }
       const now = Date.now();
       const said = REPORTED_TICK.exec(event.data);
-      if (said && server.pace && this.worldTick !== null) server.pace.report(Number(said[1]), this.worldTick, now);
+      if (said && server.pace && this.worldTick !== null) {
+        server.pace.report(Number(said[1]), this.worldTick, now);
+        // Counted, never acted on: players more than a second behind at this moment. Many at once on one Gate is a
+        // connection they share or something upstream of them all; each is still paced by their own reports alone
+        // (a full shared link is cured by sending each of them less, and nothing else cures it).
+        if ((server.pace.facts().lag ?? 0) > 20) this.behind.add(id); else this.behind.delete(id);
+      }
       this.window.inputs++;
       // Only the public Gate stamps ingress; a player cannot supply it inside their JSON.
       link.send(['data', id, event.data, Number.isFinite(event.receivedAt) ? event.receivedAt : now]);
     });
-    const left = () => { clearTimeout(deadline); this.admissions.delete(id); if (this.clients.delete(id) && opened) link.send(['close', id]); };
+    const left = () => { this.behind.delete(id); clearTimeout(deadline); this.admissions.delete(id); if (this.clients.delete(id) && opened) link.send(['close', id]); if (!this.clients.size && !this.idle) { this.idle = setTimeout(() => { this.idle = null; this.rest?.(); }, 10_000); this.idle?.unref?.(); } };
     server.addEventListener('close', left); server.addEventListener('error', left);
   }
   /** What this Gate did in the last second, for whoever is measuring the room. */
@@ -480,15 +521,21 @@ export class Gate {
       bytesPerSecond: Math.round(w.bytes / seconds), inputsPerSecond: Math.round(w.inputs / seconds), skipped: w.skipped,
       // Room stamp to this Gate writing it to players, ms (both are Cloudflare's clock at the start of an event).
       worldAgeMs: { p50: percentile(ages, 0.5), p95: percentile(ages, 0.95), max: ages.at(-1) ?? null },
+      // Of this second's worlds: how many were over 100, 200 and 400 ms old when this Gate wrote them, and how many came
+      // more than 75, 150 and 300 ms after the one before (a world is due every 50).
+      worldsOld: { n: ages.length, over100: ages.filter(a => a > 100).length, over200: ages.filter(a => a > 200).length, over400: ages.filter(a => a > 400).length },
+      worldGaps: { over75: w.gaps[0], over150: w.gaps[1], over300: w.gaps[2] },
       // How far behind the room players say they are, in ticks, and how many are being sent fewer frames for it.
       clientLagTicks: { reporting: lags.length, p50: percentile(lags, 0.5), p95: percentile(lags, 0.95), max: lags.at(-1) ?? null },
-      paced: paces.filter(p => p.interval > 1).length,
+      paced: paces.filter(p => p.interval > 1).length, behind: this.behind.size,
       coasting: subscribed.filter(c => c.coasts).length,
       // Ticks the room's worlds advanced a second, by THIS Gate's clock: the room's own clock cannot see itself run late.
       roomTickHz: w.tickFrom !== null && w.tickAt > w.tickFromAt ? Math.round((this.worldTick - w.tickFrom) / (w.tickAt - w.tickFromAt) * 100000) / 100 : null,
       worldGapMs: w.gapMax,
       // The room's clock less this Gate's, and the channel's delay, from stamps exchanged on the channel (as NTP does).
       roomClock: this.clock ?? null,
+      // The worst this Gate's own 20 ms timer came late in the second, and how many of the fifty came over 20 ms late.
+      loopLateMs: w.late, loopLateTimers: w.busy,
     };
   }
   publishMetrics(url, link) {