@homie-rocks/studio 0.46.0 → 0.46.3

package/netplay/netplay.ts

@@ -529,6 +529,7 @@ export interface NetStats {
   offline: boolean;
   rtt: number | null;
   offset: number;
+  telemetrySource: 'server' | 'browser' | 'offline' | 'disconnected';
   snapHzIn: number;
   snapHzOut: number;
   inputHzIn: number;
@@ -550,6 +551,8 @@ export interface NetStats {
   stateKeys: number;
   peers: number;
   reconnects: number;
+  /** Most recent loss, retained after recovery so a brief reconnect is diagnosable. */
+  lastDisconnect?: { at: number; why: string; code: number | null; reason: string | null; silentMs: number };
   /** Revision 9: times a link that was up went down (a reconnect that worked on the first knock counts once). */
   drops?: number;
   /** Revision 9: where this browser stands with its room. */
@@ -1679,7 +1682,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     else if (m.t === 'state' && typeof m.k === 'string') applyState(m.k, m.d);
     else if (m.t === 'round') { const incoming = m.round as RoundInfo; roundInfo = m.retime && roundInfo?.n === incoming.n ? { ...roundInfo, ...incoming } : incoming; if (!m.retime) { emit('round', roundInfo); post?.({ what: 'round', round: roundInfo }); } }
     else if (m.t === 'roster' && (offline || !connected)) { slots = m.slots as Slot[]; emit('roster', slots); post?.({ what: 'roster', slots }); }
-    else if (m.t === 'ev' && (m.to === undefined || m.to === seat || m.to === id)) emit('event', { k: String(m.k), d: m.d, from: typeof m.from === 'number' ? m.from : null });
+    else if (m.t === 'ev' && (m.to === undefined || m.to === seat || m.to === id || (m.to === -1 && seat === null))) emit('event', { k: String(m.k), d: m.d, from: typeof m.from === 'number' ? m.from : null });
   }
   let role: Role = 'replica';
   let roleKnown = false;
@@ -1695,6 +1698,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   let ws: WebSocketLike | null = null;
   let attempt = 0;
   let reconnects = 0;
+  let lastDisconnect: NetStats['lastDisconnect'];
   let drops = 0;
   let heartbeats = 0;
   /** My welcome gave me back the seat my token named (the same player), and a newer build is live (section 23). */
@@ -1777,6 +1781,9 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   let playableSent = false;
   let autoArmed = false;
   let snapSeen = false;
+  /** The newest tick this socket has been sent (rules games): said on inputs and pings as `g`, so a Gate that
+   * finds this player far behind the room sends it fewer, fresher frames instead of every one late. */
+  let gotTick: number | null = null;
   let loadingAt = 0;
   const createdAt = (typeof performance !== 'undefined' ? performance.now() : Date.now());
   const arrived: ArrivalInfo = { mode: arrival, by: null, playableMs: null, explicitMs: null, lateMs: null };
@@ -2619,6 +2626,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     if (wasOffline && rulesGame) rulesNotice('Connection restored. Joining the online round.');
     offline = false;
     connected = true;
+    gotTick = null;
     downSince = 0;
     attempt = 0;
     if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
@@ -2764,6 +2772,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     if (Array.isArray(m['c'])) s.c = m['c'] as ControlWire[];
     if (m['hb'] === 1) s.hb = 1;
     if (typeof m['e'] === 'number') s.e = m['e'];
+    if (!local && rulesGame) gotTick = s.k;
     if (acceptSnap(s, bytes, true, local)) { emit('snapshot', s); if (!snapSeen) { snapSeen = true; autoPlayable(); } }
   }
 
@@ -2881,7 +2890,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     pingsOut.set(c, c);
     if (pingsOut.size > 16) { const first = pingsOut.keys().next().value; if (first !== undefined) pingsOut.delete(first); }
     // A hidden host's yield is behind its checkpoint in the sender: the relay hears of the hidden tab after both.
-    raw({ t: 'ping', c, hid: hidden() && !rulesSender?.handing, ...(rulesGame ? { readySpeed } : {}) });
+    raw({ t: 'ping', c, hid: hidden() && !rulesSender?.handing, ...(rulesGame ? { readySpeed } : {}), ...(gotTick !== null ? { g: gotTick } : {}) });
   }
 
   function sendCheckpoint(): void {
@@ -2939,12 +2948,13 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
   function statsNow(): NetStats {
     const t = wall();
     return {
+      telemetrySource: offline ? 'offline' : !connected ? 'disconnected' : opts.rulesHost?.mode === 'server' ? 'server' : 'browser',
       role, seat, host, connected, offline, rtt, offset: Math.round(offset),
       snapHzIn: snapIn.hz(t), snapHzOut: snapOut.hz(t), inputHzIn: inputIn.hz(t), inputHzOut: inputOut.hz(t), idleInputsSkipped: idleSkipped,
       lastSnapBytes, maxSnapBytes, bytesInPerS: perSecond(bytesIn), bytesOutPerS: perSecond(bytesOut),
       interpDelay: Math.round(interpDelay()), snapAgeP90: Math.round(ageP90), starvedPct: +starvedPct.toFixed(3), rejectedSnaps,
       owned: api.owned, pending: sentHist.length, stateKeys: stateMap.size,
-      peers: peers.size, reconnects, drops, link, heartbeats, promotions, round: roundInfo ? roundInfo.n : null,
+      peers: peers.size, reconnects, lastDisconnect, drops, link, heartbeats, promotions, round: roundInfo ? roundInfo.n : null,
       decides: { asked: decideStats.asked, ai: decideStats.ai, local: decideStats.local, floor: decideStats.floor, msP50: [...decideStats.ms].sort((x, y) => x - y)[Math.floor(decideStats.ms.length / 2)] ?? null },
     };
   }
@@ -2980,8 +2990,10 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
     else paintLink();
   }
 
-  function lost(sock: WebSocketLike, why: string): void {
+  function lost(sock: WebSocketLike, why: string, event?: unknown): void {
     if (ws !== sock) return;
+    const detail = event && typeof event === 'object' ? event as { code?: unknown; reason?: unknown } : null;
+    lastDisconnect = { at: Date.now(), why, code: typeof detail?.code === 'number' ? detail.code : null, reason: typeof detail?.reason === 'string' ? detail.reason.slice(0, 160) : null, silentMs: Math.max(0, wall() - lastMsgAt) };
     ws = null;
     sock.onclose = null; sock.onmessage = null; sock.onerror = null; sock.onopen = null;
     if (why !== 'closed') { try { sock.close(4000, why); } catch { /* gone */ } }
@@ -3011,13 +3023,14 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
       lastMsgAt = wall();
       raw({
         t: 'hello', rules: rulesGame, v: NETPLAY_VERSION, rev: NETPLAY_REVISION, token, name: name || undefined, device, want, canHost: asAgent && asAgent.hands === 'host' ? false : canHost, game: opts.game, max: opts.maxPlayers,
+        ...(rulesGame ? { coast: 1 } : {}),
         ...(watching ? { watch: true } : {}), ...(caps.size ? { caps: [...caps] } : {}), ...(asAgent ? { agent: asAgent } : {}),
         // Revision 9 (an older relay ignores both): the game's revision and what this build can do.
         ...(version ? { ver: version } : {}), ...(features.length ? { feat: features } : {}),
       });
     };
     sock.onmessage = (ev) => onMessage(ev.data);
-    sock.onclose = () => lost(sock, 'closed');
+    sock.onclose = (event) => lost(sock, 'closed', event);
     // Browsers follow an error with close; Node's WebSocket, on a refused connection, never does.
     sock.onerror = () => lost(sock, 'error');
   }
@@ -3415,7 +3428,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
       if (seat === null || !entries.length) return false;
       if (rulesHost && offline) { rulesHost.frame({ t: 'in', from: seat, e, k, s: entries, r }); return true; }
       if ((!rulesGame && role === 'host') || offline || !connected) return false;
-      if (!raw({ t: 'in', e, k, s: entries, r })) return false;
+      if (!raw({ t: 'in', e, k, s: entries, r, ...(gotTick !== null ? { g: gotTick } : {}) })) return false;
       inputOut.hit(wall());
       return true;
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.46.0",
+  "version": "0.46.3",
   "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",
@@ -95,6 +95,7 @@
     }
   },
   "files": [
+    "docs/",
     "bin/",
     "lib/",
     "netplay/",
@@ -158,10 +159,11 @@
     "three": "0.185.1",
     "typescript": "5.9.3",
     "viem": "2.57.4",
+    "ws": "8.22.0",
     "zod": "4.3.6"
   },
   "scripts": {
     "test": "node --test --test-concurrency=2 --test-timeout=1800000 test/*.test.mjs",
-    "prepack": "node ../../scripts/authoring-guides.mjs --check"
+    "prepack": "node lib/build-identity.mjs --check && node ../../scripts/authoring-guides.mjs --check"
   }
 }

package/rules/core.ts

@@ -69,6 +69,10 @@ export const SEND = 16;
 export const THROWN = 512;
 /** The most effects (`world.emit`) one tick takes. */
 export const FX_MAX = 256;
+/** The most entities one effect's audience names (`world.emit(effect, at, data, { to })`). */
+export const FX_TO_MAX = 32;
+/** Who may perceive an effect: within so many metres of where it happened (-1: no distance), the entities named, and where it happened. */
+export type FxAudience = [within: number, to: string[], from: [number, number, number] | null];
 /** The most area events (`world.sendArea`) one tick takes. */
 export const AREAS_MAX = 64;
 /** What the log names when a room ends because of what it holds, not because of a handler. */
@@ -85,7 +89,7 @@ export interface StepInput { values: Record<string, unknown>; claim?: { pos: Vec
 export interface ResultRow { seat: number; id: string; driver: Driver; score: number; place: number }
 export type CoreOut =
   | { t: 'round'; n: number; phase: 'live' | 'over'; endsAt: number; startedAt: number; results?: ResultRow[] }
-  | { t: 'fx'; tick: number; list: [number, unknown, unknown][] }
+  | { t: 'fx'; tick: number; list: [number, unknown, unknown, FxAudience?][] }
   | { t: 'ask'; n: string; state: unknown; questions: Record<string, unknown> }
   | { t: 'goalDone'; seat: number; ok: boolean }
   | { t: 'seats' }
@@ -162,6 +166,8 @@ export interface Core {
   /** The current round, for a host rebasing wall-clock deadlines after a pause or restore. */
   round(): Extract<CoreOut, { t: 'round' }>;
   bodies(): Body[];
+  /** Every person's body with where it stands: who an effect with an audience reaches (0.46.3). */
+  listeners(): { seat: number; id: string; pos: Vec3 }[];
   /** The body in a seat, as the host runtime needs it for the input protocol. */
   character(seat: number): import('./rules.ts').Character | null;
   bodyOf(seat: number): { id: string; kind: KindTable; r: number; away: boolean; driver: Driver } | null;
@@ -235,7 +241,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
   let sharedROVer = -1;
   const sharedChanged = (): void => { sharedDirty = true; sharedVer += 1; };
   let out: CoreOut[] = [];
-  let fx: [number, unknown, unknown][] = [];
+  let fx: [number, unknown, unknown, FxAudience?][] = [];
   /** What is left of the running tick's budget. A room's first `room.start` runs before any tick, with a whole one. */
   let left = c.settings.budget.tick;
   let trips = 0;
@@ -527,6 +533,8 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
   const world = brand({} as Record<string, unknown>);
   const getters: Record<string, () => unknown> = {
     tick: () => tick, dt: () => dt, round: () => roundApi, shared: sharedView, level: () => policy.level, levelMax: () => policy.levelMax, guideLevel: () => policy.guideLevel ?? policy.level, guideSeats: () => policy.guideSeats ?? EMPTY_GUIDE_SEATS, kids: () => Boolean(policy.kids), levelSet: () => Boolean(policy.levelSet),
+    // What the running handler may still spend (0.46.3): a handler that plans can stop short of its share instead of being stopped.
+    unitsLeft: () => Math.max(0, Math.min(2147483647, Math.floor(G.left))),
     stage: () => stage, tune: () => c.tune, math: () => math, map: () => mapApi,
   };
   for (const [name, get] of Object.entries(getters)) Object.defineProperty(world, name, { get, enumerable: true });
@@ -594,14 +602,30 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
       const wait = w >= 1 ? Math.min(w, 0x7fffffff) : 1;
       push({ due: tick + wait, to: cx.ent ? cx.ent.id : '', kind: cx.ent ? 'ev' : 'room', ev: ev as string, data: shapeData(c.events, ev, 'the event', data), at: tick });
     },
-    emit: (effect: unknown, at: unknown, data?: unknown): void => {
+    emit: (effect: unknown, at: unknown, data?: unknown, audience?: unknown): void => {
       charge(10);
       if (cx.scope !== 'ent' && cx.scope !== 'room') throw new Error('world.emit is for handlers');
       const i = typeof effect === 'string' ? c.effectNames.indexOf(effect) : -1;
       if (i < 0) throw new Error(`the effect "${said(effect)}" is not declared in shapes.effects`);
       if (fx.length >= FX_MAX) { G.note?.('effect', '', said(effect)); return; }
       const shape = c.effects[c.effectNames[i]];
-      fx.push([i, typeof at === 'string' ? at.slice(0, 24) : packVec(V(at), dims), packFields(shape, shapeData(c.effects, effect, 'the effect', data), dims)]);
+      const row: [number, unknown, unknown, FxAudience?] = [i, typeof at === 'string' ? at.slice(0, 24) : packVec(V(at), dims), packFields(shape, shapeData(c.effects, effect, 'the effect', data), dims)];
+      // An audience (0.46.3): who may perceive this effect. Without one it is public, as before.
+      if (audience !== undefined && audience !== null) {
+        charge(8);
+        const to = own(audience, 'to'), within = own(audience, 'within');
+        const ids: string[] = [];
+        if (typeof to === 'string') ids.push(to.slice(0, 24));
+        else if (Array.isArray(to)) { if (to.length > FX_TO_MAX) throw new Error(`an effect's audience names at most ${FX_TO_MAX} entities`); for (let n = 0; n < to.length; n++) { const id = to[n]; if (typeof id === 'string') ids.push(id.slice(0, 24)); } }
+        else if (to !== undefined) throw new Error('an effect\'s audience is { to: id | [ids], within: metres }');
+        if (within !== undefined && (typeof within !== 'number' || !Number.isFinite(within) || within < 0)) throw new Error('an effect\'s audience `within` is a distance in metres');
+        if (typeof to === 'undefined' && within === undefined) throw new Error('an effect\'s audience is { to: id | [ids], within: metres }');
+        // The place it is heard from: where it was emitted, or where the entity it names stands now.
+        const e = typeof at === 'string' ? ents.get(at.slice(0, 24)) : undefined;
+        const from = typeof at === 'string' ? (e && !e.dead ? e.pos : null) : V(at);
+        row.push([typeof within === 'number' ? within : -1, ids, from ? [from.x, from.y, from.z] : null]);
+      }
+      fx.push(row);
     },
     spawn: (kind: unknown, at: unknown, fields?: unknown): string => {
       charge(10);
@@ -1484,6 +1508,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
     shared: () => packFields(c.shared, shared, dims),
     character: (seat) => { const e = playerBodies().find(e => e.seat === seat); return e ? JSON.parse(JSON.stringify({ kind: e.kind.name, at: e.pos, heading: e.heading, fields: e.f, motion: e.m })) : null; },
     bodies: () => playerBodies().map((e) => ({ seat: e.seat, id: e.id, kind: e.kind.name, driver: e.driver, owner: e.owner, away: e.away, score: e.kind.score ? Number(e.f[e.kind.score]) || 0 : 0, r: e.r })),
+    listeners: () => playerBodies().filter((e) => e.driver === 'person').map((e) => ({ seat: e.seat, id: e.id, pos: e.pos })),
     bodyOf: (seat) => { const s = seats.get(seat); const e = s?.id ? ents.get(s.id) : null; return e ? { id: e.id, kind: e.kind, r: e.r, away: e.away, driver: e.driver } : null; },
     drain: () => { const o = out; out = []; return o; },
     save,

package/rules/host.ts

@@ -1,3 +1,4 @@
+import { stageTimings } from './timing.mjs';
 /*
  * host.ts — the host runtime: a rules module playing the host's part on the wire.
  * =============================================================================
@@ -112,6 +113,8 @@ export interface Host {
   readonly privateDelivery: boolean;
   projectSnapshot(snap: any, seat: number | null): any;
   readonly viewSettings: Compiled['settings']['view'];
+  /** The studio's own pace on player messages (`room.rates`), or null: Homie sets none. */
+  readonly rates: Record<string, number> | null;
   frame(m: Record<string, unknown>): void;
   /** Start the tick loop (the first person has joined). */
   start(): void;
@@ -129,9 +132,12 @@ export interface Host {
   readonly core: Core;
 }
 
-interface Entry { at: number; values: Record<string, unknown>; presses: (string | [string, number])[]; claim: StepInput['claim'] }
+interface Entry { at: number; values: Record<string, unknown>; presses: (string | [string, number])[]; claim: StepInput['claim']; /** How many ticks before its own tick it arrived (0.46.3): the time the input itself waited here. */ early?: number }
 interface SeatIn {
-  pulses?: [string,number][];
+  /** A valued pulse, and the tick its browser predicted it on (0: none given, act at once). */
+  pulses?: [string,number,number?,number?][];
+  /** The wait of the entry now held, in ticks (see Entry.early). */
+  early?: number;
   held: Record<string, unknown>; claim: StepInput['claim']; entries: Entry[];
   /** The newest stamp this seat has sent, the stamps not yet acknowledged, and the newest acknowledged. */
   newest: number; stamps: number[]; ack: number;
@@ -158,7 +164,7 @@ const SPEECH = /^(?:say|chat|emote)/i;
 /**
  * The overrun check's memory: the last few ticks that started in this isolate, whichever rooms' they were, each with
  * when it started. Time inside a Worker stands still while code runs, so a tick cannot time itself; but the start of
- * the next tick, in any room, shows how long it took. A tick that starts more than a period late blames the newest
+ * the next tick, in any room, gives a scheduling interval (including other work). A late callback suspects the newest
  * tick here that took more than a period: the one just before it, or, when that one was quick and was itself held up,
  * the one before that.
  */
@@ -251,7 +257,7 @@ export function createHost(o: HostOptions): Host {
       for (const [seat, q] of saved.inputs) {
         check(uint(seat) && seat < c.seats && q && valuesOk(seat, q.held) && claimOk(q.claim) && uint(q.newest) && uint(q.ack) && uint(q.lastFrameTick) && Number.isInteger(q.lead) && q.lead >= -127 && q.lead <= 127);
         check(Array.isArray(q.stamps) && q.stamps.length <= 256 && q.stamps.every(uint) && Array.isArray(q.entries) && q.entries.length <= c.settings.tickHz + 1);
-        if(q.pulses!==undefined)check(Array.isArray(q.pulses)&&q.pulses.length<=16&&q.pulses.every(p=>Array.isArray(p)&&p.length===2&&c.kinds.some(k=>k.input.some(([n,f])=>n===p[0]&&f.t==='pulse'))&&Number.isInteger(p[1])&&p[1]>0&&p[1]<=255));
+        if(q.pulses!==undefined)check(Array.isArray(q.pulses)&&q.pulses.length<=16&&q.pulses.every(p=>Array.isArray(p)&&(p.length===2||p.length>=3&&p.length<=4&&uint(p[2])&&(p[3]===undefined||uint(p[3])))&&c.kinds.some(k=>k.input.some(([n,f])=>n===p[0]&&f.t==='pulse'))&&Number.isInteger(p[1])&&p[1]>0&&p[1]<=255));
         for (const e of q.entries) check(uint(e.at) && valuesOk(seat, e.values) && claimOk(e.claim) && Array.isArray(e.presses) && e.presses.every((p) => c.kinds.some((k) => k.input.some(([name, fd]) => (typeof p === 'string' ? name === p && fd.t === 'press' : Array.isArray(p) && p.length === 2 && name === p[0] && fd.t === 'pulse' && Number.isInteger(p[1]) && p[1] > 0 && p[1] <= 255)))));
       }
     }
@@ -270,7 +276,26 @@ export function createHost(o: HostOptions): Host {
       }
     },
   } : {};
-  const core = createCore(c, { ...characterOptions, rewindTicks: seat => Math.ceil(((measuredRtt.get(seat) ?? 0) + 150 + period) / period), label: (seat,driver)=>nameOf(seat,driver), moved: o.moved, observe: o.observe, noted: o.noted, seed: Math.floor(random() * 4294967296) >>> 0, epoch: saved ? undefined : (Math.floor(random() * 4294967295) >>> 0) + 1, restore: saved?.core ?? null, restoreEpoch: o.restoreEpoch, stage: o.stage, decisions: !o.check });
+  /*
+   * How far back a person's ray may look (0.46.3). A shot is judged where the shooter saw the target, so the rewind is
+   * the age of that view when the input was RECEIVED, plus the time the input then waited for its tick:
+   *
+   *   the view's age   the relay's own measurement of this connection's round trip (a low percentile over a window of
+   *                    acknowledgements carried by the input frames themselves, worker/room.mjs), plus 150 ms of
+   *                    presentation delay. A client cannot bring the measurement under its real latency. It can
+   *                    pretend to be slower, by holding back what it sends, and then its input is late too.
+   *   the wait         whole ticks between an entry's arrival and the tick it was stamped for (at least one, at most a
+   *                    quarter of a second): tied to when the server received the input, not to what the client says.
+   *
+   * `room.rewindSeconds` is the game's hard cap on the sum. Without it the cap is `room.historySeconds`, as before.
+   */
+  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));
+    const need = Math.ceil(((measuredRtt.get(seat) ?? 0) + 150) / period) + waited;
+    return rewindCap === null ? need : Math.min(rewindCap, need);
+  };
+  const core = createCore(c, { ...characterOptions, rewindTicks, label: (seat,driver)=>nameOf(seat,driver), moved: o.moved, observe: o.observe, noted: o.noted, seed: Math.floor(random() * 4294967296) >>> 0, epoch: saved ? undefined : (Math.floor(random() * 4294967295) >>> 0) + 1, restore: saved?.core ?? null, restoreEpoch: o.restoreEpoch, stage: o.stage, decisions: !o.check });
   let epoch = core.epoch;
   if (saved && (o.startPaused ?? o.restoreEpoch !== undefined)) for (const body of core.bodies()) if (body.driver !== 'bot' && body.owner !== 'reserved') core.seatAway(body.seat, true);
   let lastSaveAt = o.clock.now();
@@ -395,6 +420,7 @@ export function createHost(o: HostOptions): Host {
   /** Where in a tick the runtime is, for the log line of a fault. */
   let phase = '';
   let faultLoggedAt = -Infinity;
+  const timing = stageTimings();
   const stats = { ticks: 0, late: 0, slips: 0, since: 0, ins: 0, dropped: 0, lateEntries: 0, loggedAt: 0, faults: 0, lastFault: '' };
   /** Something was thrown in the runtime itself: it is counted, and said in the log at most once a second. */
   function fault(where: string, error: unknown): void {
@@ -411,9 +437,21 @@ export function createHost(o: HostOptions): Host {
   for (const [seat, held, claim, newest, ack] of saved?.queues ?? []) queues.set(seat, { held, claim, entries: [], newest, stamps: [], ack, lead: 127, lastFrameTick: core.tick });
   for (const [seat, q] of saved?.inputs ?? []) queues.set(seat, q);
   const neutral = (kind: KindTable): Record<string, unknown> => { const v = initFields(kind.input, c.dims); for (const [name, fd] of kind.input) if (fd.t === 'press' || fd.t === 'pulse') v[name] = fd.t === 'press' ? false : 0; return v; };
+  /*
+   * `f.held()` inputs that arrive late (0.46.3). A held value is how much of ONE tick a control was down, so the sum over
+   * a tap's ticks is the tap. When an entry misses its tick, that tick has already run on the value before it (a
+   * release that arrives late ran one more whole tick of movement), and applying the entry a tick later as well would
+   * count the tap twice over. So the difference between what the missed ticks ran on and what they were meant to run
+   * on is owed, and paid on the next ticks, inside the range the control reads in. The body then ends where the
+   * browser predicted it, however the frames fell. Kept beside the queues and not saved: a restart forgets a debt.
+   */
+  const heldNames = new Map<KindTable, string[]>();
+  const heldOf = (kind: KindTable): string[] => { let names = heldNames.get(kind); if (!names) { names = kind.input.filter(([, fd]) => fd.t === 'held').map(([name]) => name); heldNames.set(kind, names); } return names; };
+  const pulsesTaken = new Map<number, number>();
+  const heldBook = new Map<number, { ran: [number, Record<string, number>][]; debt: Record<string, number>; until: number }>();
   function queueOf(seat: number, kind: KindTable): SeatIn {
     let q = queues.get(seat);
-    if (!q) { q = { held: neutral(kind), claim: null, entries: [], newest: 0, stamps: [], ack: 0, lead: 127, lastFrameTick: core.tick }; queues.set(seat, q); }
+    if (!q) { q = { held: neutral(kind), claim: null, entries: [], newest: 0, stamps: [], ack: 0, lead: 127, lastFrameTick: core.tick }; queues.set(seat, q); pulsesTaken.delete(seat); }
     return q;
   }
   const people = (): number => { let n = 0; for (const person of present.values()) if (person) n += 1; return n; };
@@ -457,9 +495,11 @@ export function createHost(o: HostOptions): Host {
       }
       const claim = kind.body?.owner && raw.length >= i + 9 ? { pos: unpackVec([raw[i], raw[i + 1], raw[i + 2]], c.dims), vel: unpackVec([raw[i + 3], raw[i + 4], raw[i + 5]], c.dims), heading: unpackVec([raw[i + 6], raw[i + 7], raw[i + 8]], c.dims), r } : null;
       q.stamps.push(j);
-      if (j > K) { q.entries.push({ at: j, values, presses, claim }); continue; }
+      if (j > K) { q.entries.push({ at: j, values, presses, claim, early: Math.min(lateTicks, j - K) }); continue; }
       // Late: its values hold from the next tick, and its presses fire there if that is within a quarter of a second of its stamp.
       stats.lateEntries += 1;
+      const book = heldBook.get(seat as number);
+      if (book) for (const row of book.ran) if (row[0] >= j) { for (const name of heldOf(kind)) { const meant = Number(values[name]) || 0; book.debt[name] = (book.debt[name] ?? 0) + meant - (row[1][name] ?? 0); row[1][name] = meant; } book.until = K + 1 + lateTicks; }
       const at = (K + 1) >>> 0;
       const keep = at - j <= lateTicks ? presses : [];
       const same = q.entries.find((x) => x.at === at);
@@ -550,9 +590,15 @@ export function createHost(o: HostOptions): Host {
         if (agents && (kind === 'agent:do' || /^ask:/.test(kind) || (SPEECH.test(kind) && present.get(m.from as number) === false))) { if (agentInbox.length < 128) agentInbox.push(m); return; }
         if(kind === 'pulse') {
           const data=m.d,body=core.bodyOf(m.from as number);
-          if(!body || !hasHands(m.from as number,body.driver) || !Array.isArray(data) || data.length!==3 || data[0]!==epoch || typeof data[1]!=='string' || !body.kind.input.some(([name,fd])=>name===data[1]&&fd.t==='pulse'))return;
+          if(!body || !hasHands(m.from as number,body.driver) || !Array.isArray(data) || data.length<3 || data.length>5 || data[0]!==epoch || typeof data[1]!=='string' || !body.kind.input.some(([name,fd])=>name===data[1]&&fd.t==='pulse'))return;
           const value=coerce({t:'pulse'},data[2],c.dims) as number,q=queueOf(m.from as number,body.kind);q.pulses??=[];
-          if(value && q.pulses.length<16)q.pulses.push([data[1],value]);return;
+          // The browser names the tick it predicted the pulse on (0.46.3): the server acts on it in that tick, as it does for a
+          // stamped input, so what was predicted is what the tick's snapshot holds. A tick already run, or none: at once.
+          const at=Number.isInteger(data[3])&&(data[3] as number)>0?Math.min(data[3] as number,0xffffffff):0;
+          // Its number in this browser's own count (0.46.3): the control row says the newest one acted on, so a browser knows
+          // whether a pulse it predicted has happened yet, however late its message was.
+          const n=Number.isInteger(data[4])&&(data[4] as number)>0?Math.min(data[4] as number,0xffffffff):0;
+          if(value && q.pulses.length<16)q.pulses.push(n?[data[1],value,at,n]:at?[data[1],value,at]:[data[1],value]);return;
         }
         if (kind === 'cmd') { const d = m.d as unknown[]; if (Array.isArray(d) && typeof d[0] === 'string') core.command(m.from as number, d[0], d[1]); return; }
         // Speech keeps its payload, except the identity fields only the host may attach.
@@ -612,10 +658,27 @@ export function createHost(o: HostOptions): Host {
         } });
       } else if (x.t === 'ask') o.send({ t: 'decide', n: x.n, state: x.state, questions: x.questions });
       else if (x.t === 'goalDone') agents?.done(x.seat, x.ok);
-      else if (x.t === 'fx') o.send({ t: 'ev', from: null, k: 'fx', d: [x.tick, x.list] });
+      else if (x.t === 'fx') {
+        // Effects with an audience (0.46.3) go to who may perceive them: one frame a person whose body is named or in
+        // range, with the tick's public effects in the order they were emitted. A watcher (no seat) and a seat with no
+        // body perceive the room: every effect with a range, never one addressed only `to` somebody.
+        // A tick with no audience at all is one frame for everybody, as before.
+        if (!x.list.some((row) => row[3])) o.send({ t: 'ev', from: null, k: 'fx', d: [x.tick, x.list] });
+        else {
+          const all = x.list.map((row) => [row[0], row[1], row[2]]);
+          const bodies = new Map(core.listeners().map((l) => [l.seat, l]));
+          const watching = all.filter((_, n) => { const a = x.list[n][3]; return !a || a[0] >= 0; });
+          for (const seat of present.keys()) {
+            const l = bodies.get(seat);
+            const mine = !l ? watching : all.filter((_, n) => { const a = x.list[n][3]; return !a || a[1].includes(l.id) || (a[0] >= 0 && a[2] !== null && Math.hypot(a[2][0] - l.pos.x, a[2][1] - l.pos.y, a[2][2] - l.pos.z) <= a[0]); });
+            if (mine.length) o.send({ t: 'ev', from: null, k: 'fx', d: [x.tick, mine], to: seat });
+          }
+          if (watching.length) o.send({ t: 'ev', from: null, k: 'fx', d: [x.tick, watching], to: -1 });
+        }
+      }
       else if (x.t === 'seats') roster = true;
       else if (x.t === 'shared') o.send({ t: 'state', k: 'shared', d: core.shared() });
-      else if (x.t === 'epoch') { forceSave = true; epoch = x.epoch; queues.clear(); roster = true; } else if (x.t === 'fail') end('budget', { kind: x.kind, handler: x.handler });
+      else if (x.t === 'epoch') { forceSave = true; epoch = x.epoch; queues.clear(); heldBook.clear(); pulsesTaken.clear(); roster = true; } else if (x.t === 'fail') end('budget', { kind: x.kind, handler: x.handler });
     }
     if (roster || !rosterText) sendRoster();
   }
@@ -635,49 +698,75 @@ export function createHost(o: HostOptions): Host {
       const presses: (string | [string, number])[] = [];
       while (q.entries.length && q.entries[0].at <= t) {
         const e = q.entries.shift() as Entry;
-        q.held = e.values; q.claim = e.claim;
+        q.held = e.values; q.claim = e.claim; q.early = e.early ?? 1;
         if (e.at === t) for (const p of e.presses) presses.push(p);
       }
       // Silence: no frame for a second. Its input is neutral until the next entry.
       if (t - q.lastFrameTick > tickHz && !q.entries.length) { q.held = neutral(body.kind); q.claim = null; }
       while (q.stamps.length && q.stamps[0] <= t) q.ack = q.stamps.shift() as number;
       const values = { ...q.held };
+      const heldFields = heldOf(body.kind);
+      if (heldFields.length) {
+        let book = heldBook.get(seat);
+        if (!book) { book = { ran: [], debt: {}, until: 0 }; heldBook.set(seat, book); }
+        const level: Record<string, number> = {};
+        for (const name of heldFields) level[name] = Number(values[name]) || 0;
+        book.ran.push([t, level]); if (book.ran.length > lateTicks + 1) book.ran.shift();
+        if (book.until >= t) for (const name of heldFields) { const owed = book.debt[name]; if (owed) { const range = Math.max(1, Math.abs(level[name])), want = level[name] + owed, paid = Math.max(-range, Math.min(range, want)); values[name] = paid; book.debt[name] = want - paid; } }
+        else book.debt = {};
+      }
       for (const p of presses) { if (typeof p === 'string') values[p] = true; else values[p[0]] = p[1]; }
-      const pulse=q.pulses?.shift();if(pulse)values[pulse[0]]=pulse[1];
+      // One pulse a tick, in order: the head waits for its own tick when that is no more than a quarter of a second ahead.
+      const head=q.pulses?.[0];if(head&&!((head[2]??0)>t&&(head[2] as number)-t<=Math.ceil(tickHz/4))){q.pulses!.shift();values[head[0]]=head[1];if(head[3])pulsesTaken.set(seat,head[3]);}
       inputs.set(seat, { values, claim: q.claim });
     }
     if (roundRebasePending) publishRebase(now);
     phase = 'step';
+    const rulesAt = timing.now();
     core.step(inputs, guideBeat);
+    timing.record('rules', rulesAt);
     phase = 'frames';
+    const framesAt = timing.now();
     const out = core.drain();
     handle(out, now);
+    timing.record('frames', framesAt);
     if (ended) return;
     phase = 'snapshot';
+    const snapshotAt = timing.now();
     const data = core.snapshot();
+    timing.record('snapshot', snapshotAt);
     const nextPhase = (data[0] as number[])[1];
     if (roundPhase === 1 && nextPhase === 0) forceSave = true;
     roundPhase = nextPhase;
+    const checkpointAt = timing.now();
     checkpoint(forceSave);
+    timing.record('checkpoint', checkpointAt);
+    const encodeAt = timing.now();
     // The control table: one row a seat, [seat, r, ack, lead].
     const rows: number[][] = [];
     for (const b of core.bodies()) {
       if (!hasHands(b.seat, b.driver)) continue;
       const q = queues.get(b.seat);
-      rows.push([b.seat, b.r, q ? q.ack : 0, q && q.lead !== 127 ? q.lead : -128]);
+      // 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]);
       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 };
-    o.send(snap, JSON.stringify(snap));
+    const encoded = JSON.stringify(snap);
+    timing.record('encode', encodeAt);
+    const sendAt = timing.now();
+    o.send(snap, encoded);
+    timing.record('send', sendAt);
     stats.ticks += 1;
     stats.since += 1;
     if (now - stats.loggedAt >= 10_000) {
       // Tick figures, one line every ten seconds, never a line a tick.
       const s = core.stats;
-      log({ ev: 'ticks', game: o.game, ...(o.build ? { build: o.build } : {}), tick: core.tick, ticks: stats.since, late: stats.late, slips: stats.slips, ins: stats.ins, lateEntries: stats.lateEntries, dropped: stats.dropped, errors: s.errors, budgetStops: s.budgetStops, cut: s.ticksCut, maxUnits: s.maxUnits, worst: s.worst, maxTickUnits: s.maxTickUnits, ...(s.lost ? { lost: s.lost } : {}), ...(stats.faults ? { faults: stats.faults, lastFault: stats.lastFault } : {}), ...(s.lastError ? { lastError: s.lastError } : {}) });
+      log({ ev: 'ticks', timing: timing.facts(), game: o.game, ...(o.build ? { build: o.build } : {}), tick: core.tick, ticks: stats.since, late: stats.late, slips: stats.slips, ins: stats.ins, lateEntries: stats.lateEntries, dropped: stats.dropped, errors: s.errors, budgetStops: s.budgetStops, cut: s.ticksCut, maxUnits: s.maxUnits, worst: s.worst, maxTickUnits: s.maxTickUnits, ...(s.lost ? { lost: s.lost } : {}), ...(stats.faults ? { faults: stats.faults, lastFault: stats.lastFault } : {}), ...(s.lastError ? { lastError: s.lastError } : {}) });
       stats.loggedAt = now; stats.since = 0; stats.late = 0; stats.ins = 0; stats.lateEntries = 0;
     }
   }
@@ -687,6 +776,7 @@ export function createHost(o: HostOptions): Host {
    * of the clock the room ends, and the log names the handler (or the fault).
    */
   function tick(now: number): void {
+    const tickAt = timing.now();
     const cut = core.stats.ticksCut;
     let faulted = false;
     if (persistent) pendingOutput = [];
@@ -698,8 +788,9 @@ export function createHost(o: HostOptions): Host {
       pendingOutput = null;
       faulted = true; fault(`tick ${core.tick} (${phase})`, error);
       // Never continue from uncommitted memory or retire the last good save.
-      if (persistent) { stop(); o.onEnd?.('storage-or-tick-failed', { tick: core.tick }); return; }
+      if (persistent) { timing.record('tick', tickAt); stop(); o.onEnd?.('storage-or-tick-failed', { tick: core.tick }); return; }
     }
+    timing.record('tick', tickAt);
     if (ended) return;
     if (!faulted && core.stats.ticksCut === cut) { failingSince = null; return; }
     if (failingSince === null) failingSince = now;
@@ -753,8 +844,13 @@ export function createHost(o: HostOptions): Host {
         if (overSince !== null) {
           overTicks += 1;
           if (2 * overBlamed < overTicks) overSince = null;
-          // A room whose ticks have run slow for five seconds of the clock ends, and the log names the handler that used the most units.
-          else if (now - overSince >= OVERRUN_MS) { end('overrun', { worst: core.stats.worst, maxUnits: core.stats.maxUnits, seconds: Math.round((now - overSince) / 100) / 10 }); return; }
+          // Late callbacks can catch up at the requested rate. End only a
+          // blamed room that also loses sustained throughput, not a healthy
+          // 20 Hz room whose callbacks arrive in pairs during admission/I/O.
+          else if (now - overSince >= OVERRUN_MS) {
+            if (overTicks * period < (now - overSince) * 0.9) { end('overrun', { worst: core.stats.worst, maxUnits: core.stats.maxUnits, seconds: Math.round((now - overSince) / 100) / 10 }); return; }
+            overSince = null;
+          }
         }
         if (o.enforceOverrun) recent.push({ who: self, at: now });
         if (recent.length > 8) recent.shift();
@@ -837,7 +933,8 @@ export function createHost(o: HostOptions): Host {
   }
 
   function save(): Uint8Array {
-    return toBytes({ v: 1, ...(characters.size ? { characters: [...characters.values()] } : {}), core: core.save(), guideViews: [...guideViews], ...(agents ? { agents: agents.save() } : savedAgents ? { agents: savedAgents } : {}), names: [...names].filter(([seat]) => !core.bodies().some(b => b.seat === seat && b.owner === 'reserved')), queues: [...queues].map(([seat, q]) => [seat, q.held, q.claim, q.newest, q.ack]), inputs: [...queues] });
+    const reserved = new Set(core.bodies().filter(b => b.owner === 'reserved').map(b => b.seat));
+    return toBytes({ v: 1, ...(characters.size ? { characters: [...characters.values()] } : {}), core: core.save(), guideViews: [...guideViews], ...(agents ? { agents: agents.save() } : savedAgents ? { agents: savedAgents } : {}), names: [...names].filter(([seat]) => !reserved.has(seat)), queues: [...queues].map(([seat, q]) => [seat, q.held, q.claim, q.newest, q.ack]), inputs: [...queues] });
   }
   function checkpoint(force = false): void {
     if (persistent) {
@@ -888,6 +985,7 @@ export function createHost(o: HostOptions): Host {
     },
     characterReturned(account, lease) { if (characters.get(account)?.returning && characters.get(account)?.lease === lease) characters.delete(account); },
     get viewSettings() { return c.settings.view; },
+    get rates() { return c.settings.rates ?? null; },
     get viewRadiusM() { return c.settings.view?.radiusM ?? null; },
     get tick() { return core.tick; },
     get epoch() { return epoch; },
@@ -903,7 +1001,7 @@ export function createHost(o: HostOptions): Host {
       try { now = o.clock.now(); tick(now); } catch (error) { fault('tickNow', error); } finally { keepTime(); }
     },
     save,
-    facts: () => ({ tick: core.tick, epoch, running, paused, ended, armed, people: people(), tickHz, ...stats, core: { ...core.stats } }),
+    facts: () => ({ timing: timing.facts(), tick: core.tick, epoch, running, paused, ended, armed, people: people(), tickHz, ...stats, core: { ...core.stats } }),
     core,
   };
 }