@homie-rocks/studio 0.46.0 → 0.46.2

package/worker/index.mjs

@@ -105,7 +105,8 @@ import { forgetLines, historyOf, keepLines, keptLine } from './lounge-store.mjs'
 import { isLoungePath, loungeRoutes } from './lounge.mjs';
 import { doorPage, serverPage, serversPage } from './site.mjs';
 import { isLocalOrigin, qrSvg } from './qr.mjs';
-import { acceptMultiplex, gateFor } from './gate.mjs';
+import { acceptMultiplex, diagnosticsOf, gateFor, nextGate } from './gate.mjs';
+import { worldSource } from './world-wire.mjs';
 export { Gate, Concentrator } from './gate.mjs';
 import { seatCount, paramsFrom, perAddress, seatsOf } from './seats.mjs';
 import {
@@ -123,6 +124,7 @@ import {
 // The back office knows the studio's player accounts: a signed-in player is named in the office and held by a kick on
 // every device, and the owner's own account (`homie-studio players owner`) counts as the owner.
 usePlayers(playerAccounts);
+import { STUDIO_BUILD } from './build-id.mjs';
 import { STUDIO_VERSION_TAG } from './version.mjs';
 import { reconcileOrders, readiness, roomBadge, shellShop, shopOf, shopRoutes } from './shop.mjs';
 import { DISCOVERY_FILES, discoveryResponse, llmsTxt, robotsTxt, sitemapXml } from './discover.mjs';
@@ -712,6 +714,7 @@ async function route(request, env, ctx) {
     return json({
       v: 1,
       kind: 'homie-studio',
+      toolkit: STUDIO_BUILD,
       name: cat.studio?.name ?? env.STUDIO_NAME ?? 'Studio',
       slug: cat.studio?.slug ?? null,
       ...(cat.studio?.tagline ? { tagline: cat.studio.tagline } : {}),
@@ -1327,6 +1330,10 @@ export class Table {
     this.hostRt = null;
     this.characterGrants = new Map();
     this.accountTokens = {};
+    this.inputTransit = [];
+    this.relayed = false;
+    this.gateHeld = new Map();
+    this.gatePromised = new Map();
     this.roomAlarmAt = 0;
     this.durable = null;
     this.roomSave = null;
@@ -1354,7 +1361,21 @@ export class Table {
       maxPlayers: max,
       perIp: perAddress(max),
       store: {
-        save: (o) => { if (this.hostRt) this.saveRoom(this.hostRt.save()); else if (!hostedGame(game)) storage.put('net', o).catch(() => {}); },
+        save: (o) => {
+          if (this.hostRt && !this.relayFrame) this.saveRoom(this.hostRt.save());
+          else if (this.hostRt) {
+            // All admissions in one relay turn share a checkpoint. The microtask
+            // runs before the relay's timer flush, retaining the storage output gate.
+            if (!this.admissionSaveQueued) {
+              this.admissionSaveQueued = true;
+              const host = this.hostRt;
+              queueMicrotask(() => {
+                this.admissionSaveQueued = false;
+                if (this.hostRt === host) { try { this.saveRoom(host.save()); } catch (error) { this.storageProblem(error); } }
+              });
+            }
+          } else if (!hostedGame(game)) storage.put('net', o).catch(() => {});
+        },
         clear: () => { this.clearRoom(); },
       },
       // The room's lifecycle, one line each with its time and room (worker/room.mjs `log`): a hello, a leave, an
@@ -1362,6 +1383,7 @@ export class Table {
       // are told apart by these. HOMIE_ROOM_LOG=0 keeps only the failures.
       log: (line) => this.say(line),
     });
+    this.room.gateFacts = () => [...(this.gateMetrics?.values() ?? [])];
     if (this.saved && !hostedGame(game)) this.room.restore(this.saved);
     if (this.officeSaved) this.room.restoreOffice(this.officeSaved);
     this.vocabRead = this.readVocab(game).catch(() => false);
@@ -2072,8 +2094,26 @@ export class Table {
       if (body.op === 'return') return json(this.characters.return(body.game, body.holder, body.lease, body.character));
       return json({ ok: false }, 400);
     }
-    if (new URL(request.url).pathname === '/__multiplex') {
-      return acceptMultiplex(request, (req, socket) => this.connect(req, socket));
+    const path = new URL(request.url).pathname;
+    if (path === '/__gate') {
+      // The door asks which Gate takes the next player (worker/gate.mjs, nextGate): the lowest with room, counting
+      // players sent to a Gate in the last ten seconds who have not reached it yet.
+      const gates = Number(new URL(request.url).searchParams.get('gates')) || 1, now = Date.now(), promised = new Map();
+      for (const [index, due] of this.gatePromised) { const live = due.filter((at) => at > now); if (live.length) { this.gatePromised.set(index, live); promised.set(index, live.length); } else this.gatePromised.delete(index); }
+      const gate = nextGate(gates, this.gateHeld, promised);
+      if (!this.gatePromised.has(gate)) this.gatePromised.set(gate, []);
+      this.gatePromised.get(gate).push(now + 10_000);
+      return json({ gate });
+    }
+    if (path === '/__multiplex') {
+      this.relayed = true;
+      const index = Number(new URL(request.url).searchParams.get('gate'));
+      // One encoding of each world for every Gate link (worker/world-wire.mjs).
+      return acceptMultiplex(request, (req, socket) => this.connect(req, socket), { source: (this.worldSource ??= worldSource()), onCount: (n) => {
+        // A player arrived: a promise to that Gate is kept. The Gate's count is what the next join is placed by.
+        if (n > (this.gateHeld.get(index) ?? 0)) this.gatePromised.get(index)?.shift();
+        if (n > 0) this.gateHeld.set(index, n); else this.gateHeld.delete(index);
+      } });
     }
     return this.connect(request);
   }
@@ -2109,7 +2149,7 @@ export class Table {
     }
     // The back office (worker/office.mjs), from the studio's Worker only: the room as its owner sees it, and the
     // owner's signed controls, which this room verifies before it applies one (NETPLAY.md section 15).
-    if (url.pathname === '/__facts') return json({ ...room.officeFacts(), durability: this.storageHealth ?? { ok: true }, ...(this.house ? { brains: this.house.facts() } : {}) });
+    if (url.pathname === '/__facts') return json({ ...room.officeFacts(), gates: [...(this.gateMetrics?.values() ?? [])], durability: this.storageHealth ?? { ok: true }, ...(this.house ? { brains: this.house.facts() } : {}) });
     // A chat line as the room keeps it (section 19), for a report: the Worker files the room's own copy, never a reporter's.
     if (url.pathname === '/__chat') {
       const id = url.searchParams.get('id');
@@ -2206,7 +2246,9 @@ export class Table {
       ...(url.pathname === '/__watch' && url.searchParams.get('mod') === '1' ? { mod: true } : {}),
       send: (text) => { try { server.send(text); } catch { /* closed */ } },
       close: (c, r) => { try { server.close(c, r); } catch { /* closed */ } },
-      buffered: () => 0,
+      buffered: () => server.buffered?.() ?? 0,
+      ...(server.snapshotGroup ? { snapshotGroup: server.snapshotGroup, subscribe: seat => server.subscribe(seat) } : {}),
+      ...(server.snapshot ? { snapshot: (...args) => server.snapshot(...args), transportFacts: server.transportFacts } : {}),
     };
     if (url.pathname === '/__watch') {
       // Watching shells are cheap (outgoing is free) but not free: a room holds at most 256, and 24 from one address
@@ -2227,14 +2269,18 @@ export class Table {
       // seats, so it is not counted twice). One counter write per room.
       const fresh = room.seats.size === 0;
       server.addEventListener('message', (e) => {
+        this.relayFrame = Boolean(server.snapshot);
+        try {
         let text = typeof e.data === 'string' ? e.data : '';
         if (hostedBuild(game)?.settings.characters && account) {
           try { const message = JSON.parse(text); if (message.t === 'hello') { delete message.token; if (this.accountTokens[account]) message.token = this.accountTokens[account]; text = JSON.stringify(message); } } catch { /* normal parser diagnoses it */ }
         }
-        h.onMessage(text);
+        if (Number.isFinite(e.receivedAt)) this.inputTransit.push(Math.max(0, Date.now() - e.receivedAt));
+        h.onMessage(text, this.relayFrame ? e.receivedAt : undefined);
         if (hostedBuild(game)?.settings.characters && account) { const joined = room.clients.get(h.id); if (joined?.token) this.accountTokens[account] = joined.token; }
+        } finally { this.relayFrame = false; }
         // A newcomer: the Lobby hears of the room at once, so the owner's office (and a launch change) never misses it.
-        if (typeof e.data === 'string' && e.data.startsWith('{"t":"hello"')) this.report();
+        if (typeof e.data === 'string' && e.data.startsWith('{"t":"hello"')) this.scheduleReport();
         if (fresh && !this.openCounted && room.seats.size > 0) {
           this.openCounted = true;
           if (conn.qa) return;
@@ -2250,7 +2296,7 @@ export class Table {
         }
         // The room says the departure itself (its `leave` line: who, which seat, host or not, how many are left).
         h.onClose(via);
-        try { this.report(); } catch (error) { this.say({ ev: 'failed', op: 'report', error: errorLine(error) }); }
+        try { this.scheduleReport(); } catch (error) { this.say({ ev: 'failed', op: 'report', error: errorLine(error) }); }
       };
       server.addEventListener('close', () => left('close'));
       // A lost network arrives here, not as a close: said as what it is, with the client it was, then handled as the
@@ -2279,7 +2325,7 @@ export class Table {
       // A launch change the room applied by itself (after its round): its stored state says so too.
       if (room.officeDirty) { room.officeDirty = false; this.ctx.storage.put('office', room.officeSaved()).catch(() => {}); }
       n += 1;
-      if (n % 4 === 0) { room.tellWatchers(); this.report(); this.recordRound(); this.syncHouse(); }
+      if (n % 4 === 0) { this.publishDiagnostics(); room.tellWatchers(); this.report(); this.recordRound(); this.syncHouse(); }
       // Room chat's counts, once a minute (section 19).
       if (n % 240 === 0) this.ctx.waitUntil(this.flushChat().catch(() => {}));
       // A server-hosted room in play keeps its alarm ahead of it (re-armed every five minutes of play).
@@ -2314,6 +2360,40 @@ export class Table {
     this.ctx.waitUntil(lobby.fetch(`https://lobby/report?game=${encodeURIComponent(this.game)}`, { method: 'POST', body: JSON.stringify({ room: this.code, players: 0, people: 0, ...extra }) }).catch(() => {}));
   }
 
+  /**
+   * A big room's diagnostics leave it once a second for the object that answers readers (worker/gate.mjs,
+   * `diagnosticsFetch`): nothing per player, one post outstanding at most, never awaited by a tick or an admission.
+   * A room that every player reaches directly (one Gate's worth of seats) answers for itself and posts nothing.
+   */
+  publishDiagnostics() {
+    const transit = this.inputTransit.sort((a, b) => a - b); this.inputTransit = [];
+    if (!this.env.GATE || !this.relayed || this.diagnosticsPending || !this.room) return;
+    const facts = this.room.diagnosticFacts(), now = Date.now(), last = this.diagnosticsLast;
+    const at = (p) => transit.length ? transit[Math.min(transit.length - 1, Math.floor(transit.length * p))] : null;
+    const tick = facts.ticks?.tick ?? null;
+    this.diagnosticsLast = { now, tick };
+    this.diagnosticsPending = true;
+    const body = JSON.stringify({
+      ...facts,
+      // Ticks the rules ran per second of this object's clock since the last post.
+      tickRate: last && tick !== null && last.tick !== null && now > last.now ? Math.round((tick - last.tick) / (now - last.now) * 100000) / 100 : null,
+      // A Gate's stamp on a player's message to this object handling it, ms.
+      inputTransitMs: { n: transit.length, p50: at(0.5), p95: at(0.95), max: transit.at(-1) ?? null },
+      durability: this.storageHealth ?? { ok: true },
+    });
+    const work = diagnosticsOf(this.env, this.game, this.code).fetch('https://diagnostics/__diagnostics', { method: 'POST', body })
+      .then((r) => r.body?.cancel?.())
+      .catch((error) => { this.say({ ev: 'diagnostics-publish-failed', error: errorLine(error) }); })
+      .finally(() => { this.diagnosticsPending = false; });
+    this.ctx.waitUntil(work);
+  }
+
+  scheduleReport() {
+    if (this.reportQueued) return;
+    this.reportQueued = true;
+    queueMicrotask(() => { this.reportQueued = false; this.report(); });
+  }
+
   /** Tell the Lobby how many players this room has, when it changes. */
   report() {
     const room = this.room;

package/worker/office-page.mjs

@@ -722,6 +722,17 @@ export const OFFICE_SCRIPT = String.raw`(function () {
   function room(g, r, now) {
     var box = el('div', 'room');
     var key = g.id + '/' + r.room;
+    if (r.telemetry) {
+      if (r.telemetry.toolkit) box.appendChild(el('div', 'faint', 'Toolkit ' + r.telemetry.toolkit.version + ' · build ' + r.telemetry.toolkit.sha256));
+      var timing = r.telemetry.ticks && r.telemetry.ticks.timing;
+      var stages = timing && timing.ms || {};
+      box.appendChild(el('div', 'faint', 'Server telemetry · ' + Object.keys(stages).map(function(k) { return k + ' p95 ' + (stages[k] ? stages[k].p95.toFixed(2) + ' ms' : 'unavailable'); }).join(' · ') + ' · queued relay rows ' + (r.telemetry.transport || []).reduce(function(n, t) { return n + t.queueRows; }, 0)));
+      (r.telemetry.gates || []).forEach(function(g) {
+        var stages = g.view && g.view.ms || {};
+        var timing = ['view','encode','send'].map(function(k) { return k + ' p95 ' + (stages[k] ? stages[k].p95.toFixed(2) + ' ms' : 'unavailable'); }).join(' · ');
+        box.appendChild(el('div', 'faint', g.id + ' · ' + g.clients + ' clients · ' + timing + ' · queue ' + g.queueRows + ' reliable / ' + g.pendingViews + ' views · receipt ' + g.ackMs + ' ms'));
+      });
+    }
     var head = el('div', 'rhead');
     head.onclick = function (e) { if (e.target.closest('button,select')) return; S.open[key] = !S.open[key]; render(); };
     var round = r.round ? 'Round ' + (r.round.n || '?') + (r.round.phase === 'live' && r.round.endsAt ? ' · ' + clock(r.round.endsAt - now) + ' left' : r.round.phase === 'over' ? ' · results' : '') : 'no round yet';

package/worker/office.mjs

@@ -62,6 +62,7 @@ import { toolIdentity } from './tool-identity.mjs';
  * from an office key it is ALWAYS an ask (the AI may only propose one), and so is marking a referrer paid.
  */
 import { seatsOf } from './seats.mjs';
+import { diagnosticsOf, roomLayout } from './gate.mjs';
 import { PUBLIC_SERVER, SERVER_LIMITS, checkServer, levelName, narrows, policyOf, roomServer, rowFor, serverView, serversOf, serverPassCookie, writeServer } from './servers.mjs';
 import { BRAIN_BUDGET, aiName, brainFor, fillSpot, passById, passCreate, passList, passRevoke, think } from './agents.mjs';
 import { DEFAULT_MODEL, NEURONS_PER_M, OWNER_MODEL, vocabularyOf } from './brain.mjs';
@@ -424,6 +425,24 @@ async function roomFacts(env, game, room, max) {
   } catch { return null; }
 }
 
+/**
+ * One named room's diagnostics, for a measurement that polls it. A room big enough to run behind Gates is read from
+ * the object its room and Gates post to each second, so a poll neither waits behind the room's ticks nor costs them
+ * one; the answer carries its age. Only when that copy is missing or old is the room asked, and not for long. A
+ * small room answers for itself, as it always has.
+ */
+export async function roomDiagnostics(env, game, room, max) {
+  if (!env.GATE || roomLayout(max).gates === 1) return roomFacts(env, game, room, max);
+  let kept = null;
+  try {
+    const res = await diagnosticsOf(env, game, room).fetch(`https://diagnostics/__diagnostics?room=${enc(room)}`);
+    kept = res.ok ? await res.json() : null;
+  } catch { /* the room is asked below */ }
+  if (kept?.diagnostics?.ageMs != null && kept.diagnostics.ageMs < 5000) return kept;
+  const direct = await Promise.race([roomFacts(env, game, room, max), new Promise((done) => setTimeout(() => done(null), 1500))]);
+  return direct ? { ...direct, gates: kept?.gates?.length ? kept.gates : direct.gates, diagnostics: { cached: false, at: direct.st ?? null, ageMs: 0 } } : kept;
+}
+
 /** Hand one room one signed control; what the room says back. */
 async function roomControl(env, meta, settings, room, op, args) {
   const ctl = await signControl(env, { op, game: meta.id, room, args });
@@ -471,6 +490,7 @@ async function roomRow(env, meta, room, max) {
     round: f.round && typeof f.round === 'object' ? { n: f.round.n ?? null, phase: f.round.phase ?? null, startedAt: f.round.startedAt ?? null, endsAt: f.round.endsAt ?? null } : null,
     openedAt: office.openedAt ?? f.openedAt ?? null, closedUntil: office.closedUntil ?? null, snapHz: f.snapHz ?? 0,
     regate: office.regate ?? null,
+    telemetry: { source: 'server', toolkit: f.toolkit ?? null, ticks: f.ticks ?? null, transport: f.transport ?? [], gates: f.gates ?? [] },
     host: f.host ?? null, announce: f.announce ?? null,
     slots: slots.map((s) => ({ slot: s.slot, seat: s.seat ?? null, name: oneLine(s.name, 40), bot: Boolean(s.bot), ...(s.agent ? { agent: { role: s.agent.role ?? 'party', seat: s.agent.seat ?? null } } : {}) })),
     clients, bans: office.bans ?? [], mutes: office.mutes ?? [],
@@ -1213,6 +1233,13 @@ async function api(request, env, url, cat) {
     if (!body || typeof body !== 'object' || Array.isArray(body)) return json({ ok: false, error: 'json' }, 400);
   } else if (request.method !== 'GET') return json({ ok: false, error: 'method' }, 405);
 
+  if (path === '/_studio/api/room' && request.method === 'GET') {
+    const game = url.searchParams.get('game'), room = url.searchParams.get('room');
+    const meta = (cat.games ?? []).find(g => g.id === game);
+    if (!meta || !ROOM_ID.test(room ?? '')) return json({ ok: false, error: 'room' }, 400);
+    const facts = await roomDiagnostics(env, game, room, seatsFor(meta, await settingsOf(env)));
+    return json({ ok: Boolean(facts), facts });
+  }
   if (path === '/_studio/api/office' && request.method === 'GET') {
     try { return json({ ...(await officeView(env, cat, url.origin)), by: who }); } catch (error) {
       return json({ ok: false, error: 'no-office', message: `The office is not in this studio's D1 yet: \`npm run deploy\` applies migration 0005_studio_office.sql. (${String(error?.message ?? error).slice(0, 120)})` }, 503);

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.46.0';
+export const STUDIO_VERSION_TAG = '0.46.2';

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 };
+    },
+  };
+}