@homie-rocks/studio 0.45.3 → 0.46.2

package/worker/room-store.mjs

@@ -1,28 +1,77 @@
+import { normalizeWorld, denormalizeWorld, durableWorld, ownDurable, checkpointWorld, changes, applyChanges } from './world-journal.mjs';
 /**
- * A whole server-hosted room in SQLite. A small room updates one row; a large one uses pieces in the same synchronous
- * transaction. No index besides the integer primary key: the default is one row written per second, not two.
+ * Match rooms keep their whole save and its cadence. A lasting world (`persistent`) writes what the game declared
+ * durable the moment it changes, as one small journal transaction, and folds the rest of the room into a chunked
+ * checkpoint on an interval and on the way down. Restore is the last checkpoint and then the journal after it.
+ *
+ * The journal is a ring. Row 0 holds the floor: the last sequence number the checkpoint already contains, written in
+ * the checkpoint's own transaction. A record's row id is its sequence less the floor, so the records after a
+ * checkpoint overwrite the ones before it and a checkpoint never pays a row for each record it folds. A read takes
+ * only the rows above the floor, in order, and refuses a gap.
+ *
+ * Only integer primary keys: no secondary-index write amplification.
  * The boot row outlives a save being replayed, so two restores of that save can never reuse an epoch.
  */
-export function roomStore(storage) {
+export function roomStore(storage, { persistent = false } = {}) {
   const sql = storage.sql;
   sql.exec('CREATE TABLE IF NOT EXISTS save (id INTEGER PRIMARY KEY, data BLOB NOT NULL)');
   sql.exec('CREATE TABLE IF NOT EXISTS boots (id INTEGER PRIMARY KEY, data TEXT NOT NULL)');
+  let journalReady = false;
+  /** Opened once: a store that writes before it reads still continues the sequence on disk, so its checkpoint retires what is there. */
+  function journal() {
+    if (journalReady) return;
+    sql.exec('CREATE TABLE IF NOT EXISTS world_journal (id INTEGER PRIMARY KEY, seq INTEGER NOT NULL, data BLOB NOT NULL)');
+    floor = sql.exec('SELECT seq FROM world_journal WHERE id = 0').toArray()[0]?.seq ?? 0;
+    sequence = Math.max(floor, sql.exec('SELECT MAX(seq) AS seq FROM world_journal WHERE id > 0').toArray()[0]?.seq ?? 0);
+    journalReady = true;
+  }
+  // `base` is the world as last read or checkpointed, kept whole until a commit says which fields are durable;
+  // `durable` is the projection of the last world a commit saw, and is what the next one is compared with.
+  let sequence = 0, floor = 0, base = null, durable = null, checkpoint = null, checkpointAt = 0, checkpointTick = 0, committedInputs = null;
+  let lasting = persistent;
+  if (persistent) { const old = JSON.parse(sql.exec('SELECT data FROM boots WHERE id = 1').toArray()[0]?.data ?? 'null'); if (!old?.persistent) sql.exec('INSERT INTO boots(id,data) VALUES (1,?) ON CONFLICT(id) DO UPDATE SET data=excluded.data', JSON.stringify({ epoch: 0, count: 0, ...old, persistent: true })); }
   const encoder = new TextEncoder();
   const decoder = new TextDecoder('utf-8', { fatal: true });
   const pieceBytes = 1_000_000;
+  const inputState = v => ({inputs:v.host?.inputs ?? [],queues:v.host?.queues ?? []});
+  /** What is on disk now equals `value`: the next commit is compared with it. */
+  function settle(value) {
+    base = normalizeWorld(structuredClone(value)); durable = null;
+    checkpoint = JSON.stringify(checkpointWorld(base)); checkpointAt = value.at ?? 0; checkpointTick = base.host?.core?.tick ?? 0; committedInputs = inputState(base);
+  }
   return {
     read() {
-      if (this.boots()?.retired === true) return null;
+      const boot = this.boots();
+      if (boot?.retired === true) return null;
+      const maxBytes = boot?.persistent ? Infinity : 16_000_000;
       const total = sql.exec('SELECT SUM(length(data)) AS bytes FROM save').toArray()[0]?.bytes ?? 0;
-      if (total > 16_000_000) throw new Error('save exceeds 16 MB');
+      if (total > maxBytes) throw new Error('save exceeds 16 MB');
       const rows = sql.exec('SELECT id, data FROM save ORDER BY id').toArray();
       if (!rows.length) return null;
-      if (rows.some((r, i) => r.id !== i) || rows.reduce((n, r) => n + r.data.byteLength, 0) > 16_000_000) throw new Error('save pieces missing or save exceeds 16 MB');
+      if (rows.some((r, i) => r.id !== i) || rows.reduce((n, r) => n + r.data.byteLength, 0) > maxBytes) throw new Error('save pieces missing or save exceeds 16 MB');
       const pieces = rows.map((r) => new Uint8Array(r.data));
       const bytes = new Uint8Array(pieces.reduce((n, p) => n + p.length, 0));
       let at = 0;
       for (const p of pieces) { bytes.set(p, at); at += p.length; }
-      const value = JSON.parse(decoder.decode(bytes));
+      let value = JSON.parse(decoder.decode(bytes));
+      if (lasting) journal();
+      sequence = floor;
+      const journals = lasting ? sql.exec('SELECT id, seq, data FROM world_journal WHERE id > 0 AND seq > ? ORDER BY seq', floor).toArray() : [];
+      if (journals.length) {
+        let normalized = normalizeWorld(value);
+        let pending = '';
+        const stream = new TextDecoder('utf-8', {fatal:true});
+        for (const row of journals) {
+          if (row.seq !== sequence + 1 || row.id !== row.seq - floor) throw new Error('World journal has a gap');
+          pending += stream.decode(new Uint8Array(row.data), {stream:true}); sequence = row.seq;
+          let end;
+          while ((end = pending.indexOf('\n')) >= 0) { normalized = applyChanges(normalized, JSON.parse(pending.slice(0,end))); pending = pending.slice(end+1); }
+        }
+        pending += stream.decode();
+        if (pending) throw new Error('Incomplete world journal transaction');
+        value = denormalizeWorld(normalized);
+      }
+      if (lasting) settle(value);
       if (typeof value.host === 'string') {
         const hostText = value.host;
         value.host = JSON.parse(hostText);
@@ -30,19 +79,72 @@ export function roomStore(storage) {
       }
       return value;
     },
+    /**
+     * A lasting world's tick. Nothing durable changed and no checkpoint is due: no write. Something durable changed:
+     * one journal transaction holding just that. The interval has passed (or `force`) and the room differs from its
+     * checkpoint: the checkpoint, which takes the journal with it.
+     */
+    commit(value, { force = false, seconds = 30, tickHz = 20, fields }) {
+      journal();
+      if (!base) { this.write(value); return; }
+      const next = normalizeWorld(value);
+      durable ??= ownDurable(base, fields);
+      const moved = changes(durable, durableWorld(next, fields));
+      // The comparison is over sparse field maps. What is written is the full validated representation at each
+      // path, so a new entity is recorded with its initial pose.
+      const patches = moved.map((patch) => {
+        if (patch.length === 1) return patch;
+        let full = next;
+        for (const key of patch[0]) full = full[key];
+        return [patch[0], full];
+      });
+      if (force || value.at - checkpointAt >= seconds * 1000 || next.host.core.tick - checkpointTick >= seconds * tickHz) {
+        if (patches.length || JSON.stringify(checkpointWorld(next)) !== checkpoint) { this.write(value); return; }
+        // Still the checkpoint's own room: it is asked again an interval from now, not on every tick until then.
+        checkpointAt = value.at; checkpointTick = next.host.core.tick;
+      }
+      if (patches.length) {
+        // Input acknowledgements and pending pulses share the value transaction.
+        // A restart must not consume a checkpoint's already-spent pulse again.
+        const inputs = inputState(next);
+        changes(committedInputs, inputs, ['host'], patches);
+        // Advance logical time and RNG with a commitment, never once per tick.
+        for (const key of ['tick','rng','nextId','seq']) patches.push([['host','core',key],next.host.core[key]]);
+        patches.push([['at'],next.at]);
+        // One transaction may span several bounded rows. A read folds the whole
+        // transaction; no prefix can become visible across a crash.
+        const bytes = encoder.encode(JSON.stringify(patches) + '\n');
+        let last = sequence;
+        storage.transactionSync(() => {
+          for (let at = 0; at < bytes.length; at += pieceBytes) {
+            last += 1;
+            sql.exec('INSERT INTO world_journal (id, seq, data) VALUES (?, ?, ?) ON CONFLICT(id) DO UPDATE SET seq = excluded.seq, data = excluded.data', last - floor, last, bytes.slice(at,at+pieceBytes));
+          }
+        });
+        sequence = last;
+        committedInputs = structuredClone(inputs);
+      }
+      // Brought up to this tick by what changed in it (each value copied), never by copying the room.
+      durable = applyChanges(durable, moved);
+    },
     write(value) {
+      if (lasting) journal();
       const bytes = encoder.encode(JSON.stringify(value));
-      if (bytes.length > 16_000_000) throw new Error('save exceeds 16 MB');
+      if (bytes.length > 16_000_000 && !lasting) throw new Error('save exceeds 16 MB');
       storage.transactionSync(() => {
         let id = 0;
         for (let at = 0; at < bytes.length; at += pieceBytes) sql.exec('INSERT INTO save (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data', id++, bytes.slice(at, at + pieceBytes));
         sql.exec('DELETE FROM save WHERE id >= ?', id);
+        // The checkpoint holds every record so far: raising the floor retires them without touching their rows.
+        if (lasting && sequence !== floor) sql.exec("INSERT INTO world_journal (id, seq, data) VALUES (0, ?, x'') ON CONFLICT(id) DO UPDATE SET seq = excluded.seq", sequence);
       });
+      floor = sequence;
+      if (lasting) settle(value);
     },
-    boots() { return JSON.parse(sql.exec('SELECT data FROM boots WHERE id = 1').toArray()[0]?.data ?? 'null'); },
-    boot(value) { sql.exec('INSERT INTO boots (id, data) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data', JSON.stringify(value)); },
+    boots() { const value = JSON.parse(sql.exec('SELECT data FROM boots WHERE id = 1').toArray()[0]?.data ?? 'null'); lasting ||= value?.persistent === true; return value; },
+    boot(value) { sql.exec('INSERT INTO boots (id, data) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data', JSON.stringify({ ...value, ...(lasting ? { persistent: true } : {}) })); },
     retire() { this.boot({ retired: true }); },
-    clear() { storage.transactionSync(() => { sql.exec('DELETE FROM save'); sql.exec('DELETE FROM boots'); }); },
+    clear() { if (lasting) journal(); storage.transactionSync(() => { sql.exec('DELETE FROM save'); sql.exec('DELETE FROM boots'); if (lasting) sql.exec('DELETE FROM world_journal'); }); journalReady = false; base = null; durable = null; checkpoint = null; committedInputs = null; sequence = 0; floor = 0; },
   };
 }
 

package/worker/room.mjs

@@ -1,3 +1,4 @@
+import { STUDIO_BUILD } from './build-id.mjs';
 import { interestSnapshot, snapshotEncoder, scheduledView } from '../rules/interest.mjs';
 /*
  * room.mjs — the netplay v1 relay semantics, with no transport in it.
@@ -260,8 +261,9 @@ export class NetRoom {
   constructor({
     code, rules = false, tickHz = 20, maxPlayers = 8, maxScreens = 16, perIp = 12, stallMs = 1500, silentMs = 2500, idleMs = 10_000,
     holdMs = 60_000, forgetMs = 60_000, persistMs = 30_000, store = null, now = Date.now, log = () => {},
-    agentsAloneMs = AGENTS_ALONE_MS, voteMs = VOTE.ms, voteCooldownMs = VOTE.cooldownMs, autoVoteMs = VOTE.autoMs,
+    rates = null, agentsAloneMs = AGENTS_ALONE_MS, voteMs = VOTE.ms, voteCooldownMs = VOTE.cooldownMs, autoVoteMs = VOTE.autoMs,
   }) {
+    this.rates = rates;
     this.agentsAloneMs = agentsAloneMs;
     this.voteMs = voteMs;
     this.voteCooldownMs = voteCooldownMs;
@@ -386,6 +388,7 @@ export class NetRoom {
   /** The host runtime of a server-hosted room (`{ frame(m), facts() }`), or null. Seats already here are said as joins. */
   setServerHost(h) {
     this.server = h;
+    if (h?.rates) this.rates = h.rates;
     this.hostFailed = null;
     this.hostId = null;
     this.preferHost = null;
@@ -474,12 +477,24 @@ export class NetRoom {
     const out = text ?? JSON.stringify({ t: 'snap', from: c ? c.seat : null, ...snap, ...(m.hb === 1 ? { hb: 1 } : {}) });
     if (m.hb === 1) this.stats.heartbeats = (this.stats.heartbeats ?? 0) + 1;
     this.lastSnapText = out;
+    // A server-hosted room behind Gates hands each Gate ONE world a tick; the Gate selects, encodes and paces
+    // every player it holds (worker/gate.mjs). This object's tick does no per-player selection or serialisation:
+    // a player costs it one comparison here. A game with fields only their owner may see is the exception: the
+    // room alone knows who may see what, so it keeps each player's view to itself and the Gates only carry it.
+    const shared = !c && this.server && !this.server.privateDelivery;
+    const groups = shared ? new Set() : null;
     for (const o of this.others(c)) {
       if (this.lite(o)) continue; // an agent with no game client draws nothing
+      if (shared && o.conn.snapshotGroup) {
+        if (o.conn.snapshotSeat !== o.seat) { o.conn.snapshotSeat = o.seat; o.conn.subscribe(o.seat); }
+        groups.add(o.conn.snapshotGroup);
+        continue;
+      }
       // A congested socket skips a snapshot rather than queueing a stale one.
       if (o.conn.buffered && o.conn.buffered() > 256 * 1024) { this.stats.drops += 1; continue; }
       this.sendText(o.conn, this.hasViewSchedule() ? JSON.stringify({ t: 'snap', from: null, ...this.playerSnapshot(o, snap) }) : out);
     }
+    if (groups) for (const group of groups) group.snapshot(snap, this.server.viewSettings ?? {}, this.tickHz);
   }
 
   hasViewSchedule() {
@@ -490,6 +505,12 @@ export class NetRoom {
   /** The same per-player delivery role will run in Gates. Keyframes belong to sockets, not saved seats. */
   playerSnapshot(client, snap, welcome = false) {
     if (!snap || !this.hasViewSchedule()) return snap;
+    // Relayed clients get a complete welcome, then Gates own their delivery
+    // baselines. Retaining a welcome-only encoder here pins a second set of
+    // per-player rows for the lifetime of every seat, without ever using it.
+    if (welcome && client.conn.snapshotGroup && !this.server.privateDelivery) {
+      return scheduledView(this.server.viewSettings ?? { radiusM: this.server.viewRadiusM }, this.tickHz)(snap, client.seat);
+    }
     client.viewSchedule ??= scheduledView(this.server.viewSettings ?? { radiusM: this.server.viewRadiusM }, this.tickHz);
     let selected = client.viewSchedule(snap, client.seat);
     if(this.server?.projectSnapshot) selected=this.server.projectSnapshot(selected,client.seat);
@@ -601,7 +622,7 @@ export class NetRoom {
     this.clients.set(c.id, c);
     return {
       id: c.id,
-      onMessage: (text) => this.guard(c, 'message', () => this.onMessage(c, text), text),
+      onMessage: (text, receivedAt) => this.guard(c, 'message', () => this.onMessage(c, text, receivedAt), text),
       /** `via`: how the transport learned it (`close`, or `error`: the socket failed, which is how a lost network arrives). */
       onClose: (via = 'close') => this.guard(c, 'close', () => this.onClose(c, 'closed', via)),
     };
@@ -664,7 +685,9 @@ export class NetRoom {
   sendText(conn, text) {
     try { conn.send(text); this.stats.bytesOut += this.rules ? byteLength(text) : text.length; } catch { /* closing */ }
   }
-  send(c, msg) { this.sendText(c.conn, JSON.stringify(msg)); }
+  send(c, msg) {
+    this.sendText(c.conn, JSON.stringify(msg));
+  }
   error(c, code, message, extra = {}) { this.send(c, { t: 'error', code, message, ...extra }); }
   live() { return [...this.clients.values()].filter((c) => c.helloed); }
   others(c) { return this.live().filter((o) => o !== c); }
@@ -754,7 +777,7 @@ export class NetRoom {
     return true;
   }
 
-  allow(c, t, bytes, view = false) {
+  allow(c, t, bytes, view = false, receivedAt, kind = null) {
     // A spectator screen has little to say: its events are capped at 512 B (16 screens x 2/s x 512 B at most reach the host).
     const cap = t === 'ev' && c.seat === null && (view || c.id !== this.hostId) ? 512 : capOf(t, this.seatCap);
     const rulesOutput = !view && this.rules && c.rules && c.id === this.hostId;
@@ -765,10 +788,14 @@ export class NetRoom {
       if (rulesOutput) this.stopBrowserRules(c, 'size', `This game's rules exceeded the browser room size cap: ${detail}. Join again for a fresh room.`);
       return false;
     }
-    const now = this.now();
+    // Trusted Gate ingress time measures the sender, not a delayed batch's
+    // arrival at the Table. Direct sockets keep the Table clock. Monotonicity
+    // prevents a relay clock adjustment from resetting an existing rate window.
+    const now = Number.isFinite(receivedAt) ? (c.ingressRateAt = Math.max(c.ingressRateAt ?? receivedAt, receivedAt)) : this.now();
     if (rulesOutput) {
       c.rulesBuckets ??= new Map();
-      const rate = rulesRates(this.tickHz, this.seatCap)[t];
+      const rate = this.rates?.[t] ?? rulesRates(this.tickHz, this.seatCap)[t];
+      if (!(Number.isFinite(rate) && rate > 0)) return true;
       if (!takeRulesToken(c.rulesBuckets, t, rate, now)) return true;
       this.stats.drops += 1;
       if (t === 'snap') return false;
@@ -779,7 +806,16 @@ export class NetRoom {
       else { this.hostId = c.id; this.stopBrowserRules(c, 'rate', 'No player can host this room after its host failed. Join again for a fresh room.'); }
       return false;
     }
-    const limit = t === 'ev' ? EV_RATES[view ? (c.seat === null ? 'screen' : 'replica') : this.roleOf(c)] : (RATES[t] ?? RATES.other);
+    // Homie paces nothing a player sends a game whose rules run on the server: the rules hold every input to
+    // its declared type and their own budget, and a batch a slow network delivered late is not a flood (0.45.3
+    // dropped honest input at 60 a second in a room of 1,000). A studio that wants a pace names one
+    // (`room.rates` in game.json, messages a second per player; 0 lifts one). What players say to each other
+    // (speech, chat, reactions) keeps its pace, and so does every room a player's own browser hosts, where the
+    // caps are what stands between that phone and the rest of the room.
+    const social = t === 'say' || t === 'react' || t === 'ev' && SPEECH.test(kind ?? '');
+    const preset = this.server && !social ? null : t === 'ev' ? EV_RATES[view ? (c.seat === null ? 'screen' : 'replica') : this.roleOf(c)] : (RATES[t] ?? RATES.other);
+    const limit = this.rates?.[t] ?? preset;
+    if (!(Number.isFinite(limit) && limit > 0)) return true;
     const rateKey = view ? `${t}:view` : t;
     const list = c.rates.get(rateKey) ?? [];
     while (list.length && list[0] <= now - 1000) list.shift();
@@ -797,7 +833,7 @@ export class NetRoom {
     return true;
   }
 
-  onMessage(c, text) {
+  onMessage(c, text, receivedAt) {
     if (this.clients.get(c.id) !== c) return;
     text = String(text);
     const now = this.now();
@@ -809,7 +845,7 @@ export class NetRoom {
     if (!m || typeof m.t !== 'string') return;
     if (!c.helloed) { if (m.t === 'hello' && bytes <= LIMITS.hello) this.hello(c, m); return; }
     const view = this.rules && !(c.rules && c.id === this.hostId && m.rules === true && RULES_FRAMES.includes(m.t));
-    if (!this.allow(c, m.t, bytes, view)) return;
+    if (!this.allow(c, m.t, bytes, view, receivedAt, m.t === 'ev' ? String(m.k ?? '') : null)) return;
     const isHost = c.id === this.hostId && !view;
     switch (m.t) {
       case 'rules-end': {
@@ -1816,9 +1852,9 @@ export class NetRoom {
   }
 
   /** The seat a slot names (its own, or the one its agent sits in), and what holds it. */
-  holderOf(seat) {
+  holderOf(seat, holders) {
     if (!Number.isInteger(seat)) return { kind: 'none' };
-    const c = this.live().find((o) => o.seat === seat);
+    const c = holders ? holders.get(seat) : this.live().find((o) => o.seat === seat);
     const s = this.seats.get(seat);
     if (c && c.agent) return { kind: 'agent', agent: c.agent, name: c.name };
     if (c) return { kind: 'human', name: c.name };
@@ -1832,21 +1868,29 @@ export class NetRoom {
    * slot with no seat is a bot; a slot naming a seat nobody holds is a bot; a person is never marked AI and never
    * named with an AI mark. A host's game cannot present an AI as a person.
    */
+  holderIndex() {
+    const holders = new Map();
+    for (const client of this.live()) if (!holders.has(client.seat)) holders.set(client.seat, client);
+    return holders;
+  }
+
   labelRoster(slots) {
-    return slots.map((raw) => this.labelOne(raw, false)).filter(Boolean);
+    const holders = this.holderIndex();
+    return slots.map((raw) => this.labelOne(raw, false, holders)).filter(Boolean);
   }
 
   /** A round's results, labelled the same way (`agent: true` on every AI's row). */
   labelResults(rows) {
-    return rows.slice(0, this.server || this.rules ? this.seatCap : 64).map((raw) => this.labelOne(raw, true)).filter(Boolean);
+    const holders = this.holderIndex();
+    return rows.slice(0, this.server || this.rules ? this.seatCap : 64).map((raw) => this.labelOne(raw, true, holders)).filter(Boolean);
   }
 
-  labelOne(raw, result) {
+  labelOne(raw, result, holders) {
     if (!raw || typeof raw !== 'object') return null;
     if (this.rules) {
       if (!Number.isInteger(raw.slot) || raw.slot < 0 || raw.slot >= this.seatCap) return null;
       raw = { ...raw, seat: raw.slot };
-      const holder = this.holderOf(raw.slot);
+      const holder = this.holderOf(raw.slot, holders);
       if (holder.kind !== 'human' && holder.kind !== 'agent') {
         if (raw.slot >= this.maxPlayers - this.reserve())
           raw.agent = { seat: null, role: raw.slot >= this.maxPlayers - this.policy.guides ? 'guide' : 'party', hands: 'host' };
@@ -1856,7 +1900,7 @@ export class NetRoom {
     const out = { ...raw };
     const seat = Number.isInteger(raw.seat) ? raw.seat : null;
     const agentSeat = !result && raw.agent && Number.isInteger(raw.agent.seat) ? raw.agent.seat : null;
-    const who = this.holderOf(seat ?? agentSeat);
+    const who = this.holderOf(seat ?? agentSeat, holders);
     const role = (a) => (['party', 'guide', 'player'].includes(a?.role) ? a.role : 'party');
     if (who.kind === 'agent') {
       out.name = who.name || aiName(raw.name);
@@ -2403,6 +2447,9 @@ export class NetRoom {
     const live = this.live();
     const agents = live.filter((c) => c.agent && c.seat !== null).length;
     return {
+      transport: [...new Set(this.live().map(c => c.conn.transportFacts).filter(Boolean))].map(f => f()),
+      toolkit: STUDIO_BUILD,
+      gates: this.gateFacts?.() ?? [],
       t: 'net', v: NET_VERSION, rev: NET_REVISION, room: this.code, st: now,
       host: this.hostRef(),
       openedAt: this.openedAt || null,
@@ -2448,6 +2495,28 @@ export class NetRoom {
     };
   }
 
+  /** What a measurement of a big room reads each second: its counts, clock and links, and nothing per player. */
+  diagnosticFacts() {
+    const now = this.now(), live = this.live();
+    while (this.snapTimes.length && this.snapTimes[0] < now - 1000) this.snapTimes.shift();
+    return {
+      toolkit: STUDIO_BUILD, room: this.code, st: now,
+      transport: [...new Set(live.map(c => c.conn.transportFacts).filter(Boolean))].map(f => f()),
+      counts: {
+        players: live.filter((c) => c.seat !== null && !c.agent).length,
+        agents: live.filter((c) => c.agent && c.seat !== null).length,
+        screens: live.filter((c) => c.seat === null).length,
+        waiting: live.filter((c) => c.waiting).length,
+        shells: this.watchers.size,
+        maxPlayers: this.maxPlayers,
+      },
+      snapHz: this.snapTimes.length,
+      ...(this.server ? { hosted: 'server', ticks: this.server.facts?.() ?? null } : {}),
+      stats: { ins: this.stats.ins, snaps: this.stats.snaps, drops: this.stats.drops, oversize: this.stats.oversize },
+      snapBytes: this.lastSnapText ? this.lastSnapText.length : 0,
+    };
+  }
+
   tellWatchers() {
     if (!this.watchers.size) return;
     const text = JSON.stringify(this.facts());

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.45.3';
+export const STUDIO_VERSION_TAG = '0.46.2';

package/worker/world-journal.mjs

@@ -0,0 +1,109 @@
+/** Absolute assignments, never increments: replay cannot mint value twice.
+ * Entity IDs are keys so removing one entity never rewrites the rest of a world.
+ * The snapshot format remains the host's validated format at the read boundary.
+ */
+const collections = [
+  [['host','core','ents'], row => row[0]], [['host','core','spawns'], row => row[0]],
+  [['host','characters'], row => row.account], [['host','names'], row => row[0]],
+  [['host','inputs'], row => row[0]], [['host','queues'], row => row[0]],
+  [['host','core','seats'], row => row[0]], [['net','seats'], row => row[0]],
+  [['host','core','queue'], row => `${row[3]}:${row[4]}`],
+  [['host','core','areas'], row => row[2]], [['host','core','asks'], row => row.n],
+];
+function collectionsOf(copy, encode) {
+  for (const [path, identity] of collections) {
+    let parent = copy;
+    for (const key of path.slice(0,-1)) parent = parent?.[key];
+    const key = path.at(-1), rows = parent?.[key];
+    if (rows) parent[key] = encode ? Object.fromEntries(rows.map(row => [`k${identity(row)}`,row])) : Object.values(rows);
+  }
+  return copy;
+}
+/** Keyed collections on a copied spine. The rows themselves are shared with `value`: callers that keep the result clone first. */
+export function normalizeWorld(value) {
+  const host = typeof value.host === 'string' ? JSON.parse(value.host) : value.host;
+  const copy = { ...value, host: { ...host, ...(host.core ? { core: { ...host.core } } : {}) }, ...(value.net ? { net: { ...value.net } } : {}) };
+  return collectionsOf(copy, true);
+}
+export function denormalizeWorld(value) {
+  return collectionsOf(structuredClone(value), false);
+}
+const isField = path => path[4] === 17 && path.length >= 6 || path[2] === 'shared' && path.length >= 4;
+/**
+ * One walk of both values, no serialising of what did not change: a tick's cost follows the durable state, and a
+ * record's size follows what changed in it. Arrays are diffed by cell, packed maps and lists included.
+ * `path` is where the two values sit; a patch is `[path, value]`, or `[path]` for a key that is gone.
+ */
+export function changes(before, after, path = [], out = []) {
+  walk(before, after, [...path], out);
+  return out;
+}
+/** `at` is one stack for the whole walk, copied only into a patch: nothing is allocated for what is equal. */
+function walk(before, after, at, out) {
+  if (before === after) return;
+  if (!before || !after || typeof before !== 'object' || typeof after !== 'object' || Array.isArray(before) !== Array.isArray(after)) { out.push([[...at], after]); return; }
+  const start = out.length;
+  if (Array.isArray(after)) {
+    // By index, as numbers: a cell past the shorter array's end is new, and the length patch drops what is gone.
+    for (let i = 0; i < after.length; i += 1) { at.push(i); walk(before[i], after[i], at, out); at.pop(); }
+    if (before.length !== after.length) out.push([[...at, 'length'], after.length]);
+  } else {
+    for (const key in before) if (!Object.hasOwn(after, key)) out.push([[...at, key]]);
+    for (const key in after) { at.push(key); walk(before[key], after[key], at, out); at.pop(); }
+  }
+  // A packed inventory whose every slot changes is smaller as one assignment.
+  // Never coalesce a projected entity or room (that would pull movement in).
+  if (out.length > start && isField(at) && JSON.stringify([at, after]).length < JSON.stringify(out.slice(start)).length) out.splice(start, out.length - start, [[...at], after]);
+}
+export function applyChanges(value, patches) {
+  for (const [path, next] of patches) {
+    if (!path.length) { value = structuredClone(next); continue; }
+    let target = value;
+    for (const key of path.slice(0,-1)) target = target[key];
+    const key = path.at(-1);
+    if (next === undefined) delete target[key];
+    else if (Array.isArray(target) && key === 'length') target.length = next;
+    else Object.defineProperty(target, key, {value:structuredClone(next),writable:true,enumerable:true,configurable:true});
+  }
+  return value;
+}
+/** Durable fields plus the causal machinery that can create/consume value.
+ * Movement, inputs, pose history and undeclared fields wait for a checkpoint.
+ * Takes a normalised world and leaves it untouched. The view it returns shares its leaves with that world: it is for
+ * comparing now, and `ownDurable` makes the copy that is kept.
+ */
+const POSE = [3, 7, 8, 9, 10, 15, 16, 18, 19];
+export function durableWorld(value, fields) {
+  const { at, ...v } = value, { inputs, queues, guideViews, agents, ...h } = v.host, { tick, rng, nextId, seq, history, collision, guideViews: views, ...c } = h.core;
+  if (v.net) { const { savedAt, ckpt, state, round, roster, ...net } = v.net; v.net = net; }
+  for (const key of ['ents', 'spawns']) {
+    const rows = {};
+    for (const [id, row] of Object.entries(c[key] ?? {})) {
+      const list = fields.kinds[row[2]] ?? [];
+      // Undeclared non-player entities (for example visual projectiles) belong
+      // to checkpoints. Seat-bearing bodies remain part of the ownership protocol.
+      if (!list.length && row[11] < 0) continue;
+      // Preserve membership and ownership; pose/motion rewind to the checkpoint.
+      const kept = row.slice();
+      for (const i of POSE) if (i < kept.length) kept[i] = null;
+      kept[17] = {};
+      for (const i of list) if (row[17][i] !== undefined) kept[17][i] = row[17][i];
+      rows[id] = kept;
+    }
+    c[key] = rows;
+  }
+  const shared = {};
+  for (const i of fields.shared) if (c.shared?.[i] !== undefined) shared[i] = c.shared[i];
+  c.shared = shared; h.core = c; v.host = h;
+  return v;
+}
+/** A durable view that shares nothing with the world it was taken from. */
+export const ownDurable = (value, fields) => JSON.parse(JSON.stringify(durableWorld(value, fields)));
+/** Ignore clocks when deciding if an unchanged room needs a checkpoint. */
+export function checkpointWorld(value) {
+  const v = structuredClone(value);
+  delete v.at; if(v.net) delete v.net.savedAt;
+  if(v.host?.core) { delete v.host.core.tick; delete v.host.core.history; delete v.host.core.collision; }
+  for(const [,q] of Object.values(v.host?.inputs ?? {})) delete q.lastFrameTick;
+  return v;
+}

package/worker/world-wire.mjs

@@ -0,0 +1,110 @@
+/**
+ * The world between the room and a Gate (0.46.2).
+ *
+ * The room used to send every Gate the whole world as JSON each tick: 150 KB for a thousand players, to sixteen
+ * Gates, each of which parsed it. Most of that text was six numbers a body (where it is, how fast, which way), and
+ * the rest (its fields, its seat) changes rarely. So the motion goes as one block of numbers, the same block for
+ * every Gate, and each Gate is told only the rest of a body when it has changed since that Gate last heard: about
+ * 33 KB a tick for a thousand players, and one string to read. The numbers are exact: 32-bit when every one of
+ * them is (a rules host's are), 64-bit when any is not. The block travels inside the frame, as base64: a frame
+ * of bytes beside the text would have to arrive just before it, and not every path between two objects keeps a
+ * binary frame and the text after it together (a local run of 300 players lost four links that way).
+ *
+ * `worldSource()` belongs to the room, one for all its Gate links. `worldSink()` belongs to a Gate.
+ */
+const sameValue = (a, b) => {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) { if (a.length !== b.length) return false; for (let i = 0; i < a.length; i++) if (!sameValue(a[i], b[i])) return false; return true; }
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+  return JSON.stringify(a) === JSON.stringify(b);
+};
+/** Everything of a body but its motion: the same unless a field, a revision, a seat or a driver changed. */
+const sameTail = (a, b) => {
+  if (a.length !== b.length || a[1] !== b[1] || a[2] !== b[2] || a[6] !== b[6]) return false;
+  for (let i = 7; i < a.length; i++) if (!sameValue(a[i], b[i])) return false;
+  return true;
+};
+const base64 = (bytes) => { let text = ''; for (let i = 0; i < bytes.length; i += 0x8000) text += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000)); return btoa(text); };
+const bytesOf = (text) => { const raw = atob(text), out = new Uint8Array(raw.length); for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i); return out; };
+const numbers = (v) => Array.isArray(v) && v.every((n) => typeof n === 'number' && Number.isFinite(n));
+
+export function worldSource() {
+  const known = new Map();
+  let seq = 0, orderSeq = 0, restSeq = 0, ids = null, restText = null, last = null, lastOut = null;
+  return {
+    /** Once a world, whichever link asks first: the block of motion, and what changed since the world before. */
+    encode(snap) {
+      if (snap === last) return lastOut;
+      const entities = snap.d?.[1];
+      // A world this cannot carry exactly (no bodies array, a body without three vectors of one size) goes as it is.
+      const dims = entities?.[0]?.[3]?.length ?? 2;
+      if (!Array.isArray(entities) || !entities.every((e) => Array.isArray(e) && e.length >= 9 && typeof e[0] === 'string' && numbers(e[3]) && numbers(e[4]) && numbers(e[5]) && e[3].length === dims && e[4].length === dims && e[5].length === dims)) { last = snap; lastOut = null; return null; }
+      seq += 1;
+      const n = entities.length, width = dims * 3, wide = new Float64Array(n * width), order = new Array(n), changed = [];
+      let same = ids !== null && ids.length === n, narrow = true;
+      for (let i = 0; i < n; i++) {
+        const e = entities[i], id = e[0]; order[i] = id;
+        if (same && ids[i] !== id) same = false;
+        for (let a = 0; a < dims; a++) { wide[i * width + a] = e[3][a]; wide[i * width + dims + a] = e[4][a]; wide[i * width + 2 * dims + a] = e[5][a]; }
+        const held = known.get(id);
+        if (!held) { known.set(id, { row: e, changed: seq }); changed.push(i); }
+        else { if (held.row !== e && !sameTail(held.row, e)) { held.changed = seq; changed.push(i); } held.row = e; }
+      }
+      if (!same) {
+        orderSeq = seq;
+        if (known.size > n) { const live = new Set(order); for (const id of known.keys()) if (!live.has(id)) known.delete(id); }
+      }
+      ids = order;
+      for (let i = 0; i < wide.length; i++) if (Math.fround(wide[i]) !== wide[i]) { narrow = false; break; }
+      const text = snap.d.length > 2 ? JSON.stringify(snap.d.slice(2)) : '';
+      if (text !== restText) { restText = text; restSeq = seq; }
+      last = snap;
+      const motion = narrow ? Float32Array.from(wide).buffer : wide.buffer;
+      lastOut = { seq, n, dims, narrow, motion, block: base64(new Uint8Array(motion)), entities, changed, control: new Map((snap.c ?? []).map((row) => [row[0], row])), snap };
+      return lastOut;
+    },
+    /** What one Gate needs beside the block: the bodies whose rest changed since world `synced`, and its own players' control rows. */
+    header(world, synced, seats) {
+      const { snap, entities } = world, tails = [];
+      const tail = (i) => { const e = entities[i].slice(); e[3] = e[4] = e[5] = 0; tails.push([i, e]); };
+      if (synced === world.seq - 1) for (const i of world.changed) tail(i);
+      else for (let i = 0; i < entities.length; i++) if (known.get(entities[i][0]).changed > synced) tail(i);
+      const c = [];
+      for (const seat of seats) { const row = world.control.get(seat); if (row) c.push(row); }
+      return {
+        k: snap.k, st: snap.st, ...(snap.e !== undefined ? { e: snap.e } : {}), round: snap.d[0], c,
+        w: { seq: world.seq, n: world.n, dims: world.dims, narrow: world.narrow, ...(orderSeq > synced ? { ids } : {}), tails, ...(restSeq > synced ? { rest: snap.d.slice(2) } : {}) },
+      };
+    },
+  };
+}
+
+export function worldSink() {
+  let ids = [], tails = [], rest = [];
+  return {
+    /** The world a header and its block describe, as the room held it. Throws when they do not fit each other. */
+    decode(header, block64) {
+      const w = header.w;
+      if (w.ids) {
+        const held = new Map(ids.map((id, i) => [id, tails[i]]));
+        ids = w.ids; tails = ids.map((id) => held.get(id));
+      }
+      for (const [i, tail] of w.tails) tails[i] = tail;
+      if (w.rest) rest = w.rest;
+      const width = w.dims * 3, bytes = typeof block64 === 'string' ? bytesOf(block64) : null;
+      if (!bytes || ids.length !== w.n || bytes.length !== w.n * width * (w.narrow ? 4 : 8)) throw new Error(`world block does not fit its header (${bytes?.length} bytes for ${w.n} bodies, ${ids.length} known)`);
+      const block = bytes.buffer;
+      const a = w.narrow ? new Float32Array(block) : new Float64Array(block), entities = new Array(w.n), d = w.dims;
+      for (let i = 0; i < w.n; i++) {
+        const tail = tails[i];
+        if (!tail) throw new Error('world names a body this Gate was never told of');
+        const row = tail.slice(), o = i * width;
+        row[3] = d === 2 ? [a[o], a[o + 1]] : [a[o], a[o + 1], a[o + 2]];
+        row[4] = d === 2 ? [a[o + d], a[o + d + 1]] : [a[o + d], a[o + d + 1], a[o + d + 2]];
+        row[5] = d === 2 ? [a[o + 2 * d], a[o + 2 * d + 1]] : [a[o + 2 * d], a[o + 2 * d + 1], a[o + 2 * d + 2]];
+        entities[i] = row;
+      }
+      return { k: header.k, st: header.st, ...(header.e !== undefined ? { e: header.e } : {}), d: [header.round, entities, ...rest], c: header.c };
+    },
+  };
+}