@homie-rocks/studio 0.54.0 → 0.56.0

package/worker/gate.mjs

@@ -1,3 +1,6 @@
+import {WatchSockets} from './watch-sockets.mjs';
+import {isQa} from './stats.mjs';
+import {relayChannel,readRelay,retryRelay} from './relay-channel.mjs';
 import { STUDIO_BUILD } from './build-id.mjs';
 import { stageTimings } from '../rules/timing.mjs';
 import { crowdView, crowdWorlds, scheduledView, snapshotEncoder, snapshotText } from '../rules/interest.mjs';
@@ -27,64 +30,8 @@ function parseFrame(event) {
  * sockets: clients resume with their existing seat tokens and a fresh keyframe.
  * Inputs and commands are batched together, never overwritten or reordered.
  */
-/** Players a Gate holds in a room too big for its Table to hold directly.
- *
- * Two trials on Cloudflare set it. A Gate of 60 dense players that selected and encoded each one's view from
- * scratch (0.45.4) could not keep 20 frames a second; the same work now costs a third as much. But twenty to a
- * Gate (the first 0.46.2 build) made a room of 600 fifty channels, and the room spent its time on messages, not
- * rules: what the room's one thread can bear is counted in messages, and a channel is two a tick. So a Gate is
- * as full as it can serve, and a room opens only the Gates its players fill.
- * A studio chooses its room's size and nothing else. */
-export const GATE_PLAYERS = 50;
-/** `per`: players a Gate, for a trial that is finding the right number (`HOMIE_GATE_PLAYERS` on the Worker). A studio never sets it. */
-export const gatePlayers = (env) => { const n = Number(env?.HOMIE_GATE_PLAYERS); return Number.isInteger(n) && n >= 4 && n <= 200 ? n : GATE_PLAYERS; };
-export function roomLayout(seats, per = GATE_PLAYERS) {
-  // A room of up to 64 is its Table alone, as it has been since 0.45.0.
-  const gates = seats <= 64 ? 1 : Math.ceil(seats / per);
-  return { gates, concentrators: 0 };
-}
-/** The Gate a key lands on when the room cannot be asked: spread evenly, as 0.45.0 did. */
-function hashedGate(key, gates) {
-  let hash = 2166136261;
-  for (const c of key || crypto.randomUUID()) hash = Math.imul(hash ^ c.charCodeAt(0), 16777619) >>> 0;
-  return hash % gates;
-}
-/**
- * Which Gate takes the next player: the lowest one with room. A room of 50 players in a 1,000-seat game is one
- * Gate, not twenty with two or three players each, every one of them costing the room a channel. `held` is each
- * Gate's players now and `promised` those sent to it who have not arrived yet.
- */
-export function nextGate(gates, held, promised = new Map(), per = GATE_PLAYERS) {
-  let least = 0, fewest = Infinity;
-  for (let i = 0; i < gates; i++) {
-    const n = (held.get(i) ?? 0) + (promised.get(i) ?? 0);
-    if (n < per) return i;
-    if (n < fewest) { fewest = n; least = i; }
-  }
-  return least;
-}
-export function gateFor(env, game, room, seats, key) {
-  const layout = roomLayout(seats, gatePlayers(env));
-  // One logical Gate is embedded in the Table for a small room. Same relay,
-  // admission and delivery protocol; no extra Durable Object or seat clamp.
-  const table = () => env.TABLE.get(env.TABLE.idFromName(`${game}/${room}`));
-  if (layout.gates === 1) return table();
-  return { async fetch(request) {
-    const url = new URL(request.url);
-    // The room says which Gate has room (one short question a join; a join is the room's work anyway). If it
-    // cannot be asked in time the key's hash chooses, as before.
-    let index = null;
-    try {
-      const asked = await Promise.race([table().fetch(`https://table/__gate?game=${encodeURIComponent(game)}&room=${encodeURIComponent(room)}&max=${seats}&gates=${layout.gates}`), new Promise(done => setTimeout(() => done(null), 2000))]);
-      const said = asked?.ok ? await asked.json() : null;
-      if (Number.isInteger(said?.gate) && said.gate >= 0 && said.gate < layout.gates) index = said.gate;
-    } catch { /* the hash chooses */ }
-    index ??= hashedGate(key, layout.gates);
-    url.searchParams.set('gate', String(index));
-    url.searchParams.set('gates', String(layout.gates));
-    return env.GATE.get(env.GATE.idFromName(`${game}/${room}/${index}`)).fetch(new Request(url, request));
-  } };
-}
+export {GATE_PLAYERS,gatePlayers,roomLayout,nextGate,gateFor,diagnosticsOf} from './gate-routing.mjs';
+import {diagnosticsOf} from './gate-routing.mjs';
 
 export function* expandBatch(rows) {
   for (const row of rows) {
@@ -94,13 +41,13 @@ export function* expandBatch(rows) {
   }
 }
 export function batchLink(socket, { setTimer = setTimeout, clearTimer = clearTimeout, delay = 1, receipts = false, maxFrames = 4, maxBytes = 4 * 1024 * 1024, onWritable = () => {}, autoReceipt = true, now = Date.now, world = null, onAck = () => {} } = {}) {
-  let queue = [], views = new Map(), strings = new Set(), timer = null, closed = false, bytes = 0, sequence = 0, inFlightBytes = 0, blockedByBytes = false, receipt = 0, receiptAt = 0, stamp = null, lastSentAt = -Infinity;
+  let queue = [], views = new Map(), strings = new Set(), timer = null, closed = false, bytes = 0, sequence = 0, inFlightBytes = 0, blockedByBytes = false, blockedByTransport = false, receipt = 0, receiptAt = 0, stamp = null, lastSentAt = -Infinity;
   const pending = new Map();
   const timing = stageTimings();
   const stats = { frames: 0, rows: 0, bytes: 0, peakQueueBytes: 0, coalesced: 0, ackMs: 0, maxAckMs: 0, rttMs: 0 };
   const close = () => { closed = true; queue = []; views.clear(); strings.clear(); pending.clear(); inFlightBytes = 0; bytes = 0; if (timer !== null) clearTimer(timer); timer = null; };
-  const fail = (reason) => { close(); try { socket.close(1011, reason); } catch {} };
-  const schedule = () => { if (!closed && (receipt || pending.size < maxFrames && !blockedByBytes && (queue.length || views.size)) && timer === null) timer = setTimer(flush, delay > 1 ? Math.max(0, lastSentAt + delay - now()) : delay); };
+  const fail = (reason) => { close(); try { socket.close(1011, reason); } catch { /* The peer already closed; local shutdown still runs. */ } };
+  const schedule = () => { if (!closed && (receipt || pending.size < maxFrames && !blockedByBytes && !blockedByTransport && (queue.length || views.size)) && timer === null) timer = setTimer(flush, delay > 1 ? Math.max(0, lastSentAt + delay - now()) : delay); };
   const flush = () => {
     if (timer !== null) clearTimer(timer); timer = null;
     if (closed) return;
@@ -135,12 +82,14 @@ export function batchLink(socket, { setTimer = setTimeout, clearTimer = clearTim
     const size = text.length;
     if (size > maxBytes) { fail('room link frame limit'); return; }
     if (receipts && inFlightBytes + size > maxBytes) { blockedByBytes = true; return; }
+    if(socket.canSend && !socket.canSend(size,text)){blockedByTransport=true;return;}
     queue = []; views.clear(); strings.clear(); bytes = 0; receipt = 0;
     if (receipts && hasPayload) { pending.set(++sequence, { at: now(), bytes: size }); inFlightBytes += size; }
     stats.frames++; stats.rows += rows.length; stats.bytes += size;
     const sendAt = timing.now();
     try { lastSentAt = now(); socket.send(text); if (worldSeq) world.sent(worldSeq); timing.record('send', sendAt); onWritable(); } catch { fail('room link send failed'); }
   };
+  socket.addEventListener('drain',()=>{blockedByTransport=false;schedule();});
   if (receipts) socket.addEventListener('message', event => {
     if (typeof event.data !== 'string') return;
     try {
@@ -180,6 +129,7 @@ export function batchLink(socket, { setTimer = setTimeout, clearTimer = clearTim
       if (inMs !== null && !closed) { if (timer !== null) clearTimer(timer); timer = setTimer(flush, Math.max(0, inMs)); }
       else schedule();
     },
+    reset() { pending.clear(); sequence=0; receipt=0; inFlightBytes=0; blockedByBytes=false; schedule(); },
     flush, close, forget: id => views.delete(id), buffered: () => bytes,
     /** This link's recent round trip, ms: the newest receipt's, or a larger recent one fading out. */
     rtt: () => stats.rttMs,
@@ -189,12 +139,12 @@ export function batchLink(socket, { setTimer = setTimeout, clearTimer = clearTim
 }
 
 /** Adapt one upstream socket into the same transport the Table accepts locally. */
-export function multiplexSession(socket, connect, { onMetrics = () => {}, delay = 60, source = worldSource(), onCount = () => {} } = {}) {
+export function multiplexSession(socket, connect, { onMetrics = () => {}, delay = 60, source = worldSource(), onCount = () => {}, receipts = true, lastPing = () => 0, resume = () => null, remember = () => {} } = {}) {
   // Eight frames may be unacknowledged: 400 ms of 20 Hz worlds. Past that the newest world replaces an unsent one.
   // This link's Gate has every world up to `synced`, and holds the players in these seats.
   let synced = 0; const seats = new Map();
   const world = Object.assign((row) => { const w = source.encode(row[2]); return w ? { row: ['world', '*', source.header(w, synced, seats.values()), row[3], row[4], w.block], seq: w.seq } : null; }, { sent(seq) { synced = seq; } });
-  const out = batchLink(socket, { receipts: true, delay, maxFrames: 8, autoReceipt: false, world, onWritable: () => scheduleAdmission() }), clients = new Map();
+  const out = batchLink(socket, { receipts, delay, maxFrames: 8, autoReceipt: false, world, onWritable: () => scheduleAdmission() }), clients = new Map();
   let chain = Promise.resolve(), closed = false;
   const group = { snapshot(snap, settings, hz) { out.send(['world', '*', snap, settings, hz]); out.flush(); }, subscribe(id, seat) { seats.set(id, seat); out.send(['seat', id, seat]); }, facts: () => out.facts() };
   const pending = new Set(), admissions = [];
@@ -232,12 +182,16 @@ export function multiplexSession(socket, connect, { onMetrics = () => {}, delay
       if (!Array.isArray(rows)) throw new Error('invalid multiplex batch');
       heard.frames += 1; heard.rows += rows.length; heard.bytes += event.data.length;
       for (const [op, id, value, ip, agent] of expandBatch(rows)) {
+        if (op === 'resync') { synced=0; continue; }
         if (op === 'metrics') { onMetrics(id, value); continue; }
         if (op === 'open') {
           if (clients.has(id)) throw new Error('duplicate multiplex client');
           const handlers = new Map();
           const client = {
             accept() {},
+            resume: resume(id),
+            lastPing: () => lastPing(id),
+            remember(clientId) { remember(id, clientId, value, ip, agent); },
             addEventListener(name, fn) { const list = handlers.get(name) ?? []; list.push(fn); handlers.set(name, list); },
             emit(name, event) { for (const fn of handlers.get(name) ?? []) fn(event); },
             send(text) { out.send(['data', id, text]); },
@@ -252,7 +206,7 @@ export function multiplexSession(socket, connect, { onMetrics = () => {}, delay
           client.ready = new Promise((resolve, reject) => {
             const admit = async () => {
               if (closed || !clients.has(id)) { resolve(); return; }
-              try { await connect(new Request(value, { headers: { Upgrade: 'websocket', ...(ip ? { 'cf-connecting-ip': ip } : {}), ...(agent ? { 'user-agent': agent } : {}) } }), client); client.attached = true; resolve(); }
+              try { const response=await connect(new Request(value, { headers: { Upgrade: 'websocket', ...(ip ? { 'cf-connecting-ip': ip } : {}), ...(agent ? { 'user-agent': agent } : {}) } }), client); if(response!=null)client.close(1012,'room restore rejected');else client.attached = true; resolve(); }
               catch (error) { reject(error); }
             };
             admit.cancel = resolve; admissions.push(admit);
@@ -279,11 +233,11 @@ export function multiplexSession(socket, connect, { onMetrics = () => {}, delay
       }
       out.consumed(rows);
       if (admissions.length && !attaching) { if (admissionTimer !== null) clearTimeout(admissionTimer); pump(); }
-    }).catch(error => { console.log(JSON.stringify({ ev: 'room-link-failed', stage: 'receive', error: String(error?.message ?? error).slice(0,160) })); shutdown(); try { socket.close(1011, 'room link failed'); } catch {} });
+    }).catch(error => { console.log(JSON.stringify({ ev: 'room-link-failed', stage: 'receive', error: String(error?.message ?? error).slice(0,160) })); shutdown(); try { socket.close(1011, 'room link failed'); } catch { /* The peer already closed; local shutdown still runs. */ } });
   });
   socket.addEventListener('close', shutdown);
   socket.addEventListener('error', shutdown);
-  return { group, shutdown, settled: async () => { await chain; await Promise.allSettled([...pending]); } };
+  return { group, shutdown, flush:out.flush, reset() { synced=0;out.reset();for(const [id,seat] of seats)out.send(['seat',id,seat]); }, settled: async () => { await chain; await Promise.allSettled([...pending]); } };
 }
 export function acceptMultiplex(request, connect, options) {
   const [client, server] = Object.values(new WebSocketPair());
@@ -341,7 +295,16 @@ const COASTS = /^\{"t":"hello".{0,2000}?"coast":1[,}]/;
 const percentile = (sorted, p) => sorted.length ? sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))] : null;
 
 export class Gate {
-  constructor(ctx, env) { this.ctx = ctx; this.env = env; this.clients = new Map(); this.admissions = new Map(); this.sequence = 0; this.link = null; this.opening = null; this.timing = stageTimings(); this.metricsAt = 0; this.window = this.freshWindow(); this.worldTick = null; this.behind = new Set(); this.idle = null; }
+  constructor(ctx, env) { this.ctx = ctx; this.env = env; this.clients = new Map(); this.admissions = new Map(); this.sequence = 0; this.link = null; this.opening = null; this.timing = stageTimings(); this.metricsAt = 0; this.window = this.freshWindow(); this.worldTick = null; this.behind = new Set(); this.idle = null;
+    this.relayEpoch = crypto.randomUUID();
+    this.watchSockets = new WatchSockets(ctx);
+    ctx.blockConcurrencyWhile?.(async () => {
+      await this.watchSockets.restore(async (request, transport, attachment) => {
+        transport.gateState = attachment.gate;
+        await this.connect(request, transport);
+      });
+    });
+  }
   freshWindow() { return { worlds: 0, frames: 0, bytes: 0, skipped: 0, inputs: 0, worldAge: [], tickFrom: null, tickFromAt: 0, tickAt: 0, gapMax: 0, gaps: [0, 0, 0], late: 0, busy: 0 }; }
   /** This Gate's own lateness: a timer every 20 ms, and how long past it each one came. A Gate that is out of time is late to its own timer. */
   watchLoop() {
@@ -350,7 +313,9 @@ export class Gate {
     this.loopTimer = setInterval(() => {
       const now = Date.now(), late = Math.max(0, now - due); due = now + 20;
       this.window.late = Math.max(this.window.late, late); if (late > 20) this.window.busy += 1;
-      if (!this.link || !this.clients.size) { clearInterval(this.loopTimer); this.loopTimer = null; }
+      // Diagnostics need a clock only while worlds are being delivered. An
+      // idle audience must not keep fifty diagnostic callbacks a second alive.
+      if (!this.link || !this.clients.size || now - (this.worldAt ?? 0) > 1000) { clearInterval(this.loopTimer); this.loopTimer = null; }
     }, 20);
     this.loopTimer?.unref?.();
   }
@@ -371,41 +336,56 @@ export class Gate {
       // and was the first object to fall behind; sixteen channels of one frame
       // a tick each way are cheaper for the room than two of hundreds.
       const target = new URL(url); target.pathname = '/__multiplex';
-      const response = await this.env.TABLE.get(this.env.TABLE.idFromName(name)).fetch(new Request(target, { headers: { Upgrade: 'websocket' } }));
-      if (!response.webSocket) throw new Error('room link refused');
-      const socket = response.webSocket; socket.accept();
+      let socket;
+      if ((url.searchParams.get('relay') === '1' || url.searchParams.get('host') === 'server')) {
+        target.pathname = '/__relay';
+        const epoch = this.relayEpoch = crypto.randomUUID();
+        socket = relayChannel(this.ctx, (data,sequence) => this.env.TABLE.get(this.env.TABLE.idFromName(name)).fetch(target, {method:'POST',headers:{'x-homie-relay-epoch':epoch,'x-homie-relay-sequence':String(sequence)},body:data}));
+        this.relaySocket = socket;
+        socket.addEventListener('detached',()=>{ /* The next input or room alarm crosses the idle boundary. */ });
+      } else {
+        const response = await this.env.TABLE.get(this.env.TABLE.idFromName(name)).fetch(new Request(target, { headers: { Upgrade: 'websocket' } }));
+        if (!response.webSocket) throw new Error('room link refused');
+        socket = response.webSocket; socket.accept();
+      }
       // What players send leaves this Gate as one frame at most every 50 ms: at once when the channel has been
       // quiet, else with whatever arrived since the last. The room's one thread is spent by the message, so a
       // Gate costs it one a tick each way. (Timing that frame to land just before the room's tick was tried twice
       // and failed twice on Cloudflare: the round trip to the room varies by more than the window it aims for.)
-      const link = batchLink(socket, { receipts: true, delay: 50, maxFrames: 8, autoReceipt: false, onAck: (waited, clock) => { if (clock) this.roomClock(clock); } });
-      const sink = worldSink();
+      const link = batchLink(socket, { receipts: socket !== this.relaySocket, delay: 50, maxFrames: 8, autoReceipt: false, onAck: (waited, clock) => { if (clock) this.roomClock(clock); } });
+      let sink = worldSink(), worldReady = false;
+      socket.addEventListener('reset',()=>{link.reset();sink=worldSink();worldReady=false;this.worlds=null;for(const client of this.clients.values()){client.snapEncoder=null;client.crowd=null;}link.send(['resync']);});
       const lost = (event = {}) => {
         if (this.link !== link) return;
         console.log(JSON.stringify({ ev: 'room-link-lost', room: name, gate: url.searchParams.get('gate'), layer: 'gate', code: event.code ?? null, reason: event.reason ?? null, error: event.error?.message ?? null, clients: this.clients.size, transport: link.facts() }));
         this.link = null; this.worlds = null; link.close();
         for (const timer of this.admissions.values()) clearTimeout(timer); this.admissions.clear();
-        for (const client of this.clients.values()) { try { client.close(1012, 'room link restarted'); } catch {} }
+        for (const client of this.clients.values()) { try { client.close(1012, 'room link restarted'); } catch { /* The peer already closed; local shutdown still runs. */ } }
         this.clients.clear();
       };
-      const drop = (id, client) => { this.clients.delete(id); link.send(['close', id]); try { client.close(1011, 'client connection ended'); } catch {} };
+      const drop = (id, client) => { this.clients.delete(id); link.send(['close', id]); try { client.close(1011, 'client connection ended'); } catch { /* The peer already closed; local shutdown still runs. */ } };
       socket.addEventListener('message', event => {
         if (typeof event.data !== 'string') return;
         try {
           const rows = parseFrame(event); let hz = null;
           for (const row of rows) {
-            if (row[0] === 'world') { hz = row[4]; const snap = row[2].w ? sink.decode(row[2], row[5]) : row[2]; this.deliver(snap, row[3], row[4], drop); continue; }
+            if(row[0]==='link-close'){lost({code:row[1],reason:row[2]});return;}
+            if (row[0] === 'world') { hz = row[4]; if(row[2].w && !worldReady && !row[2].w.ids){link.send(['resync']);continue;} worldReady=true; const snap = row[2].w ? sink.decode(row[2], row[5]) : row[2]; this.deliver(snap, row[3], row[4], drop); continue; }
             for (const [op, id, value, reason, settings, rate] of expandBatch([row])) {
               const client = this.clients.get(id);
-              if (op === 'seat') { if (client) { client.seat = value; client.subscribed = true; } }
+              if (op === 'seat') { if (client) { client.seat = value; client.subscribed = true; client.rememberGate?.({...client.gateState,seat:value,subscribed:true}); } }
               else if (op === 'view') { if (client) this.deliverOne(id, client, value, reason, settings, rate, drop); }
               else if (op === 'data') { try { client?.send(value); } catch { if (client) drop(id, client); } }
-              else if (op === 'close') { this.clients.delete(id); try { client?.close(value, reason); } catch {} }
+              else if (op === 'close') { this.clients.delete(id); try { client?.close(value, reason); } catch { /* The peer already closed; local shutdown still runs. */ } }
             }
           }
           link.consumed(rows);
+          if(socket===this.relaySocket)for(const [id,client] of this.clients){
+            const ping=client.lastPing?.()??0;
+            if(ping>(client.forwardedPing??0)){client.forwardedPing=ping;link.send(['data',id,JSON.stringify({t:'ping',c:ping})]);}
+          }
           if (hz && Date.now() - this.metricsAt >= 1000) this.publishMetrics(url, link);
-        } catch (error) { lost({ error, reason: 'invalid room frame' }); try { socket.close(1011, 'room link failed'); } catch {} }
+        } catch (error) { lost({ error, reason: 'invalid room frame' }); try { socket.close(1011, 'room link failed'); } catch { /* The peer already closed; local shutdown still runs. */ } }
       });
       socket.addEventListener('close', lost); socket.addEventListener('error', lost);
       // A Gate nobody is on gives its channel back after ten seconds: an open channel keeps the room and this Gate in
@@ -415,7 +395,7 @@ export class Gate {
         this.link = null; this.worlds = null; link.close();
         try { socket.close(1000, 'no players'); } catch { /* gone */ }
       };
-      this.link = link; return link;
+      this.link = link; if(socket===this.relaySocket)this.openRelay(url,socket); return link;
     })();
     try { return await this.opening; } finally { this.opening = null; }
   }
@@ -425,6 +405,7 @@ export class Gate {
     if (w.tickFrom === null) { w.tickFrom = this.worldTick ?? snap.k; w.tickFromAt = this.worldAt ?? now; }
     if (this.worldAt) { const gap = now - this.worldAt; w.gapMax = Math.max(w.gapMax, gap); if (gap > 75) w.gaps[0] += 1; if (gap > 150) w.gaps[1] += 1; if (gap > 300) w.gaps[2] += 1; }
     this.worldTick = snap.k; this.worldAt = now; w.tickAt = now;
+    this.watchLoop();
     // By this Gate's clock, corrected for what the room's clock is measured to differ by.
     if (Number.isFinite(snap.st)) w.worldAge.push(Math.max(0, now - snap.st + (this.clock?.offsetMs ?? 0)));
     for (const [id, client] of this.clients) if (client.subscribed) this.deliverOne(id, client, snap, client.seat, settings, hz, drop);
@@ -465,14 +446,17 @@ export class Gate {
   }
   async connect(request, server) {
     const link = await this.upstream(new URL(request.url));
-    const id = String(++this.sequence);
-    this.clients.set(id, server); clearTimeout(this.idle); this.idle = null; this.watchLoop();
-    let opened = false;
+    const id = server.gateState?.id ?? (server.rememberGate ? crypto.randomUUID() : String(++this.sequence));
+    if (server.gateState) Object.assign(server, server.gateState);
+    server.gateState ??= {id,opened:false};
+    server.rememberGate?.(server.gateState);
+    this.clients.set(id, server); clearTimeout(this.idle); this.idle = null;
+    let opened = server.gateState?.opened === true;
     const deadline = setTimeout(() => {
       this.admissions.delete(id);
-      if (!opened && this.clients.delete(id)) { try { server.close(4000, 'no-hello'); } catch {} }
+      if (!opened && this.clients.delete(id)) { try { server.close(4000, 'no-hello'); } catch { /* The peer already closed; local shutdown still runs. */ } }
     }, 5000);
-    deadline?.unref?.(); this.admissions.set(id, deadline);
+    deadline?.unref?.(); if (opened) clearTimeout(deadline); else this.admissions.set(id, deadline);
     server.addEventListener('message', event => {
       if (!this.clients.has(id) || typeof event.data !== 'string') return;
       // No legal public frame exceeds the largest checkpoint allowance
@@ -481,15 +465,17 @@ export class Gate {
       if (event.data.length > 128 * 1024) {
         clearTimeout(deadline); this.admissions.delete(id); this.clients.delete(id);
         if (opened) link.send(['close', id]);
-        try { server.close(1009, 'message too large'); } catch {}
+        try { server.close(1009, 'message too large'); } catch { /* The peer already closed; local shutdown still runs. */ }
         return;
       }
       if (!opened) {
         opened = true; clearTimeout(deadline); this.admissions.delete(id);
         server.coasts = COASTS.test(event.data);
+        server.gateState = {id,opened:true,coasts:server.coasts};
+        server.rememberGate?.(server.gateState);
         // Logical creation and the first frame share a batch: admission time at
         // the Table excludes the public handshake and relay transit.
-        link.send(['open', id, request.url, request.headers.get('cf-connecting-ip'), request.headers.get('user-agent')]);
+        link.send(['open', id, request.url, server.address ?? request.headers.get('cf-connecting-ip'), isQa(request)?'homie-house-qa':null]);
       }
       const now = Date.now();
       const said = REPORTED_TICK.exec(event.data);
@@ -545,7 +531,7 @@ export class Gate {
     this.metricsPending = true;
     const work = diagnosticsOf(this.env, url.searchParams.get('game'), url.searchParams.get('room')).fetch('https://diagnostics/__diagnostics', {
       method: 'POST', body: JSON.stringify({ kind: 'gate', id: `gate/${url.searchParams.get('gate')}`, at: now, ...facts }),
-    }).then(r => r.body?.cancel?.()).catch(() => {}).finally(() => { this.metricsPending = false; });
+    }).then(r => r.body?.cancel?.()).catch(error => console.warn("Gate diagnostic publication failed:",error.message)).finally(() => { this.metricsPending = false; });
     this.ctx.waitUntil?.(work);
   }
   /** The room's diagnostics, kept by an object that is neither the room nor a
@@ -565,17 +551,46 @@ export class Gate {
     const gates = [...(this.gateDiagnostics?.values() ?? [])].sort((a, b) => a.id.localeCompare(b.id, 'en', { numeric: true }));
     return Response.json({ toolkit: STUDIO_BUILD, room: url.searchParams.get('room'), ...this.diagnostics, gates, diagnostics: { cached: true, at: this.diagnostics?.st ?? null, ageMs: this.diagnostics ? at - this.diagnostics.st : null } });
   }
+  openRelay(url,socket) {
+    if(this.readingRelay){this.relayAgain=true;return;}
+    const target=new URL(url);target.pathname='/__relay-live';
+    const key=`${url.searchParams.get('game')}/${url.searchParams.get('room')}`;
+    this.readingRelay=retryRelay(async()=>{
+      const stub=this.env.TABLE.get(this.env.TABLE.idFromName(key));
+      let response=await stub.fetch(target,{headers:{Upgrade:'websocket','x-homie-relay-epoch':this.relayEpoch}});
+      if(!response.webSocket){target.pathname='/__relay-stream';response=await stub.fetch(target,{headers:{'x-homie-relay-epoch':this.relayEpoch}});} 
+      const epoch=response.headers.get('x-homie-relay-epoch');
+      if(this.remoteRelayEpoch!==epoch){this.remoteRelayEpoch=epoch;socket.emit('reset',{});}
+      if(response.webSocket){response.webSocket.accept();await socket.attachLive(response.webSocket);}
+      else await readRelay(response,socket);
+    },()=>this.relaySocket===socket && Boolean(this.link)).finally(()=>{
+      this.readingRelay=null;
+      if(this.relayAgain&&this.link){this.relayAgain=false;this.openRelay(url,socket);}
+    });
+    this.ctx.waitUntil(this.readingRelay);
+  }
+  webSocketMessage(socket, message) { this.watchSockets.message(socket,message); }
+  webSocketClose(socket) { return this.watchSockets.close(socket); }
+  webSocketError(socket,error) { return this.watchSockets.close(socket,error); }
   async fetch(request) {
     const url = new URL(request.url);
     if (url.pathname === '/__diagnostics') return this.diagnosticsFetch(request, url);
+    if (url.pathname === '/__relay-presence') {
+      return Response.json([...this.clients].map(([id,client])=>[id,client.lastPing?.()??0]));
+    }
+    if (url.pathname === '/__relay-wake') {
+      if(this.link)this.openRelay(url,this.relaySocket);else await this.upstream(url);
+      return new Response(null,{status:204});
+    }
     if (url.pathname === '/__multiplex') return acceptMultiplex(request, (req, socket) => this.connect(req, socket));
     const [client, server] = Object.values(new WebSocketPair());
-    server.accept();
-    await this.connect(request, server);
+    const transport = (url.searchParams.get('relay') === '1' || url.searchParams.get('host') === 'server') && this.ctx.acceptWebSocket ? await this.watchSockets.accept(server, request) : server;
+    transport.accept();
+    await this.connect(request, transport);
     return new Response(null, { status: 101, webSocket: client });
   }
 }
 /** The object that keeps one room's diagnostics (a Gate by class, never one with players). */
-export function diagnosticsOf(env, game, room) { return env.GATE.get(env.GATE.idFromName(`${game}/${room}/diagnostics`)); }
+
 /** Kept so a studio deployed with 0.45.0's Concentrator binding still loads; nothing opens one. */
 export class Concentrator extends Gate {}

package/worker/hosted-registry.mjs

@@ -0,0 +1,11 @@
+/** Declarations stay cheap to inspect on HTTP routes; the host engine loads in Table. */
+export const games=new Map();
+export const compiled=new Map();
+export function hostRules(table) {
+  games.clear();compiled.clear();
+  if(!table||typeof table!=='object')return 0;
+  for(const [id,entry] of Object.entries(table))if(entry&&typeof entry==='object'&&entry.rules)games.set(id,entry);
+  return games.size;
+}
+export const hostedGame=id=>games.has(id);
+export const hostedBuild=id=>games.get(id);

package/worker/hosted.mjs

@@ -16,23 +16,9 @@
 import { createHost } from '../rules/host.ts';
 import { compileMap, compileRules } from '../rules/rules.ts';
 
-/** game id → { rules, tune, map, settings, seats, build } as the build wrote it, and what compiling each gave. */
-const games = new Map();
-const compiled = new Map();
-const readiness = new WeakMap();
-
-/** The table of this studio's server-hosted games (the build's site/src/rules/index.mjs). Called once, at load. */
-export function hostRules(table) {
-  games.clear();
-  compiled.clear();
-  if (!table || typeof table !== 'object') return 0;
-  for (const [id, entry] of Object.entries(table)) if (entry && typeof entry === 'object' && entry.rules) games.set(id, entry);
-  return games.size;
-}
-
-/** Whether this Worker holds rules for a game. */
-export const hostedGame = (id) => games.has(id);
-export const hostedBuild = (id) => games.get(id);
+import {games,compiled} from './hosted-registry.mjs';
+export {hostRules,hostedGame,hostedBuild} from './hosted-registry.mjs';
+const readiness=new WeakMap();
 
 /** Optional engines load at room start. Ordinary games keep their synchronous startup path. */
 export function prepareHost(id) {

package/worker/idle-chat.mjs

@@ -0,0 +1,56 @@
+/** Keep the transient chat window and its moderation buckets across hibernation.
+ * These are room-local state, separate from an owner's optional history archive.
+ */
+export function idleChatSnapshot(table) {
+  const room=table.room;
+  if(!room)return null;
+  return structuredClone({
+    at:Date.now(),log:room.chatLog,buckets:room.chatBuckets,address:room.chatAddress,reacts:room.chatReacts,
+    stats:Object.fromEntries(Object.entries(room.stats).filter(([key])=>key.startsWith('chat'))),
+    sent:table.chatSent,pending:table.chatPend,flushAt:table.chatFlushAt,
+  });
+}
+export function restoreIdleChat(table,saved) {
+  if(!saved||!table.room)return;
+  table.room.chatLog=saved.log??[];
+  table.room.chatBuckets=saved.buckets??new Map();
+  table.room.chatAddress=saved.address??new Map();
+  table.room.chatReacts=saved.reacts??[];
+  Object.assign(table.room.stats,saved.stats??{});
+  table.chatFlushAt=saved.flushAt;
+  table.chatSent=saved.sent??table.chatSent;
+  table.chatPend=saved.pending??table.chatPend;
+}
+
+const lifetime=15*60_000;
+const previous=new WeakMap();
+const content=snapshot=>encode({...snapshot,at:0});
+const encode=value=>JSON.stringify(value,(_key,item)=>item instanceof Map?{__roomMap:[...item]}:item===-Infinity?{__roomInfinity:-1}:item);
+const decode=value=>JSON.parse(value,(_key,item)=>item?.__roomMap?new Map(item.__roomMap):item?.__roomInfinity===-1?-Infinity:item);
+export async function readIdleChat(storage) {
+  if(!storage.sql)return storage.get('watch-chat');
+  storage.sql.exec('CREATE TABLE IF NOT EXISTS idle_chat(id INTEGER PRIMARY KEY CHECK(id=1),body TEXT NOT NULL,expires INTEGER NOT NULL)');
+  storage.sql.exec('DELETE FROM idle_chat WHERE expires<=?',Date.now());
+  const row=storage.sql.exec('SELECT body FROM idle_chat WHERE id=1').toArray()[0];
+  const saved=row?decode(row.body):null;
+  if(saved)previous.set(storage,content(saved));else previous.delete(storage);
+  return saved;
+}
+export async function writeIdleChat(storage,snapshot) {
+  const key=content(snapshot);
+  if(previous.get(storage)===key)return;
+  if(storage.sql) {
+    storage.sql.exec('CREATE TABLE IF NOT EXISTS idle_chat(id INTEGER PRIMARY KEY CHECK(id=1),body TEXT NOT NULL,expires INTEGER NOT NULL)');
+    storage.sql.exec('INSERT INTO idle_chat VALUES(1,?,?) ON CONFLICT(id) DO UPDATE SET body=excluded.body,expires=excluded.expires',encode(snapshot),snapshot.at+lifetime);
+  } else await storage.put('watch-chat',snapshot);
+  previous.set(storage,key);
+  const alarm=await storage.getAlarm?.();
+  if(alarm==null||alarm>snapshot.at+lifetime)await storage.setAlarm?.(snapshot.at+lifetime);
+}
+export async function expireIdleChat(storage) {
+  if(!storage.sql)return;
+  storage.sql.exec('CREATE TABLE IF NOT EXISTS idle_chat(id INTEGER PRIMARY KEY CHECK(id=1),body TEXT NOT NULL,expires INTEGER NOT NULL)');
+  storage.sql.exec('DELETE FROM idle_chat WHERE expires<=?',Date.now());
+  const row=storage.sql.exec('SELECT expires FROM idle_chat WHERE id=1').toArray()[0];
+  if(row){const alarm=await storage.getAlarm();if(alarm==null||alarm>row.expires)await storage.setAlarm(row.expires);}
+}