@homie-rocks/studio 0.46.0 → 0.46.3

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';
@@ -141,6 +143,8 @@ export { usePlayers } from './office.mjs';
 export { countVisit } from './stats.mjs';
 /** Players and cloud saves (saves/SAVES.md): `players.list`, `players.get`, `players.isOwner`… for the back office. */
 export { players, cleanName } from './players.mjs';
+/** How a guest's saves combine with the account's when they sign in (saves/SAVES.md): the studio's Worker calls it once, at load. */
+export { mergeSaves } from './saves.mjs';
 
 const GAME_ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
 const POST_SLUG = /^[a-z0-9][a-z0-9-]{0,79}$/;
@@ -712,6 +716,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 +1332,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 +1363,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 +1385,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 +2096,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 +2151,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 +2248,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 +2271,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 +2298,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 +2327,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 +2362,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/players.mjs

@@ -28,7 +28,7 @@ import { toolIdentity } from './tool-identity.mjs';
 import { handleFor } from './room.mjs';
 import { isAiName } from './agents.mjs';
 import { cookieValue } from './stats.mjs';
-import { adoptStatements, bumpPlayerStats, dropPlayerData, fall, fallenList, getSave, listSaves, playerData, readPlayerStats, SAVE_LIMITS, savesSummary, wipeSaves, writeSaves } from './saves.mjs';
+import { adoptGuest, bumpPlayerStats, dropPlayerData, fall, fallenList, getSave, listSaves, playerData, readPlayerStats, SAVE_LIMITS, savesSummary, wipeSaves, writeSaves } from './saves.mjs';
 import { bytesToB64url, randomToken, sha256Hex, verifyAssertion, verifyRegistration } from './webauthn.mjs';
 import { ACCOUNT_JS, accountPage } from './account-page.mjs';
 import { adoptShopStatements, migrated as shopMigrated, forgetPlayerShop, livePurchases, shopDataOf } from './shop-store.mjs';
@@ -693,21 +693,19 @@ async function apiRoute(request, env, ctx, url, parts, { catalogueOf, read, f })
       session.statement,
     ];
     let adopted = null;
-    if (current && current.player.id !== key.player) {
-      writes.push(env.DB.prepare('DELETE FROM player_sessions WHERE hash = ?1').bind(current.hash));
-      // A guest signing in to their account: what only the guest had moves over, then the guest is gone.
-      if (current.player.guest) {
-        adopted = await adoptStatements(env, current.player.id, key.player);
-        writes.push(...adopted.statements, ...(await adoptShopStatements(env, current.player.id, key.player)),
-          env.DB.prepare('DELETE FROM player_sessions WHERE player = ?1').bind(current.player.id),
-          env.DB.prepare('DELETE FROM player_challenges WHERE player = ?1').bind(current.player.id),
-          env.DB.prepare('DELETE FROM players WHERE id = ?1 AND guest = 1').bind(current.player.id));
-      }
-    }
-    await env.DB.batch(writes);
-    if (adopted) await adopted.after();
+    if (current && current.player.id !== key.player) writes.push(env.DB.prepare('DELETE FROM player_sessions WHERE hash = ?1').bind(current.hash));
+    if (current && current.player.id !== key.player && current.player.guest) {
+      // A guest signing in to their account: what only the guest had moves over, what both have is combined by the
+      // game's rules (mergeSaves), then the guest is gone. One batch; read and tried again if a room wrote in between.
+      const guest = current.player.id;
+      const shop = await adoptShopStatements(env, guest, key.player);
+      adopted = await adoptGuest(env, guest, key.player, (statements) => [...writes, ...statements, ...shop,
+        env.DB.prepare('DELETE FROM player_sessions WHERE player = ?1').bind(guest),
+        env.DB.prepare('DELETE FROM player_challenges WHERE player = ?1').bind(guest),
+        env.DB.prepare('DELETE FROM players WHERE id = ?1 AND guest = 1').bind(guest)]);
+    } else await env.DB.batch(writes);
     const player = { id: key.player, name: key.name, named: Number(key.named) === 1, guest: false, owner: Number(key.owner) === 1, since: Number(key.created_at) };
-    return withCookies(json({ ok: true, player: await meOf(env, player), adoptedGuest: Boolean(adopted) }), [session.cookie]);
+    return withCookies(json({ ok: true, player: await meOf(env, player), adoptedGuest: Boolean(adopted), ...(adopted ? { adopted } : {}) }), [session.cookie]);
   }
 
   /* ---------------- a recovery email, signed out: the link in the mail is the proof */

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;
@@ -449,7 +452,8 @@ export class NetRoom {
         this.stats.evs += 1;
         const out = { t: 'ev', from: Number.isInteger(m.from) ? m.from : null, k: kind, d: m.d ?? null };
         const line = JSON.stringify(out);
-        if (Number.isInteger(m.to)) { for (const o of this.live()) if (o.seat === m.to) this.sendText(o.conn, line); return; }
+        // `to: -1` (0.46.3): everyone with no seat, a watcher. An effect with an audience reaches them whole.
+        if (Number.isInteger(m.to)) { for (const o of this.live()) if (m.to === -1 ? o.seat === null : o.seat === m.to) this.sendText(o.conn, line); return; }
         for (const o of this.live()) if (!this.lite(o) || this.liteHears(kind)) this.sendText(o.conn, line);
         return;
       }
@@ -457,6 +461,25 @@ export class NetRoom {
     }
   }
 
+  /**
+   * One measurement of a connection's round trip (0.46.3), and what the rules are told: a LOW PERCENTILE of the last ten
+   * seconds of them. A measurement is never shorter than the real round trip, so the low end of a window is close to
+   * it and one slow answer does not raise it; a window, so a connection that really got slower or faster is followed.
+   * A client can still pretend to be slower by answering late every time: what that buys is bounded by the game's
+   * `room.rewindSeconds`, and with acknowledgements on the input frames it has to send its input late as well.
+   */
+  latencySample(c, ms, now) {
+    if (!(ms >= 0 && ms <= 10000)) return;
+    const w = (c.rttWindow ??= []);
+    w.push([now, ms]);
+    while (w.length > 256 || (w.length > 1 && w[0][0] < now - 10000)) w.shift();
+    const sorted = w.map((x) => x[1]).sort((a, b) => a - b);
+    const low = sorted[Math.floor((sorted.length - 1) * 0.1)];
+    if (c.measuredRtt !== undefined && Math.abs(low - c.measuredRtt) < 2 && now - (c.rttToldAt ?? 0) < 1000) return;
+    c.measuredRtt = low; c.rttToldAt = now;
+    if (c.seat !== null) this.toServer({ t: 'latency', seat: c.seat, ms: low });
+  }
+
   /** A snapshot from the host (a browser's socket `c`, or the server: `c` null), kept for joiners and fanned out. */
   hostSnap(c, m, now, text = null) {
     // The server's stamp is this relay's own clock; a browser's is its estimate of it, and is checked.
@@ -465,6 +488,7 @@ export class NetRoom {
     // Revision 10: a rules game's snapshot names the room's epoch.
     if ((!c || this.rules && c.rules) && Number.isFinite(m.e)) snap.e = m.e;
     this.lastSnap = snap;
+    if (!c) { const sentAt = (this.snapAt ??= new Map()); sentAt.set(snap.k, now); if (sentAt.size > 128) sentAt.delete(sentAt.keys().next().value); }
     if (c) c.lastSnapAt = now;
     this.stats.snaps += 1;
     this.snapTimes.push(now);
@@ -474,12 +498,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 +526,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 +643,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 +706,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 +798,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 +809,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 +827,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 +854,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 +866,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': {
@@ -834,6 +891,9 @@ export class NetRoom {
         if (this.server) {
           if (!Array.isArray(m.s)) return;
           this.stats.ins += 1;
+          // 0.46.3: the frame names the newest snapshot this browser had when it sent it (`g`). From when that snapshot
+          // left here to when this input arrived is this connection's round trip, measured on the input's own path.
+          if (Number.isInteger(m.g)) { c.inBand = true; const sent = this.snapAt?.get(m.g); if (sent !== undefined) this.latencySample(c, now - sent, now); }
           this.toServer({ t: 'in', from: c.seat, e: Number(m.e) || 0, k: Number(m.k) || 0, s: m.s.slice(0, 64), r: Number(m.r) || 0 });
           return;
         }
@@ -873,7 +933,7 @@ export class NetRoom {
         const recipients = isHost && this.rules && c.rules ? this.live() : this.others(c);
         if (isHost) {
           if (typeof m.to === 'string') { const o = this.clients.get(m.to); if (o && o.helloed && (o !== c || (this.rules && c.rules))) this.send(o, out); }
-          else if (Number.isInteger(m.to)) { for (const o of recipients) if (o.seat === m.to) this.send(o, out); }
+          else if (Number.isInteger(m.to)) { for (const o of recipients) if (m.to === -1 ? o.seat === null : o.seat === m.to) this.send(o, out); }
           // An agent with no game client hears only what is addressed to its seat (the lite feed), and the party's lines.
           else for (const o of recipients) { if (!this.lite(o) || this.liteHears(kind)) this.send(o, out); }
         } else {
@@ -922,7 +982,8 @@ export class NetRoom {
       case 'probeAck': {
         if (c.probe && m.n === c.probe.n) {
           const ms = now - c.probe.at; c.probe = null;
-          if(ms>=0 && ms<=10000){ c.measuredRtt=Math.min(c.measuredRtt??Infinity,ms); if(c.seat!==null)this.toServer({t:'latency',seat:c.seat,ms:c.measuredRtt}); }
+          // A browser that acknowledges on its input frames is measured there; this separate answer is for one that does not.
+          if(ms>=0 && ms<=10000 && !c.inBand) this.latencySample(c, ms, now);
         }
         return;
       }
@@ -1816,9 +1877,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 +1893,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 +1925,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 +2472,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 +2520,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());