@homie-rocks/studio 0.55.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';
@@ -38,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 { /* The peer already closed; local shutdown still runs. */ } };
-  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 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;
@@ -79,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 {
@@ -124,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,
@@ -133,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 = [];
@@ -176,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]); },
@@ -196,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);
@@ -227,7 +237,7 @@ export function multiplexSession(socket, connect, { onMetrics = () => {}, delay
   });
   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());
@@ -285,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() {
@@ -294,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?.();
   }
@@ -315,15 +336,25 @@ 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() }));
@@ -338,16 +369,21 @@ export class Gate {
         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 { /* 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 { /* The peer already closed; local shutdown still runs. */ } }
       });
@@ -359,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; }
   }
@@ -369,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);
@@ -409,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 { /* 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
@@ -431,9 +471,11 @@ export class Gate {
       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);
@@ -509,13 +551,42 @@ 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 });
   }
 }

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

package/worker/index.mjs

@@ -12,6 +12,8 @@ import { appCors, isAppOrigin } from './standalone.mjs';
 
 import {json,finish} from './responses.mjs';
 
+export {useRoutes} from './custom-routes.mjs';
+export {isOwner,hasRole,requireSameOrigin} from './route-auth.mjs';
 export { useFunctions } from './function-registry.mjs';
 export { Gate, Concentrator } from './gate.mjs';
 export { seatCount, SEAT_MAX } from './seats.mjs';

package/worker/lazy-objects.mjs

@@ -23,6 +23,9 @@ export class Gate {
     this.ready=ctx.blockConcurrencyWhile(async()=>{this.gate=new (await import('./gate.mjs')).Gate(ctx,env);});
   }
   async fetch(request) {await this.ready;return this.gate.fetch(request);}
+  async webSocketMessage(...args) {await this.ready;return this.gate.webSocketMessage(...args);}
+  async webSocketClose(...args) {await this.ready;return this.gate.webSocketClose(...args);}
+  async webSocketError(...args) {await this.ready;return this.gate.webSocketError(...args);}
 }
 export class Concentrator extends Gate {}
 

package/worker/lobby-peak.mjs

@@ -0,0 +1,44 @@
+import {counter,today} from './stats.mjs';
+
+// One total per bookkeeping shard, never a sum of independent historical peaks.
+// Reports carry their observation time so a delayed request cannot rewind a shard.
+export class LobbyPeak {
+  constructor(ctx,env) {this.ctx=ctx;this.env=env;this.chain=Promise.resolve();}
+  fetch(request) {
+    const task=this.chain.then(()=>this.answer(request));this.chain=task.catch(()=>{});return task;
+  }
+  async flush() {
+    const state=this.state;
+    const writes=[state.players>(state.publishedPlayers??0)&&counter(this.env,{metric:'peak',subject:this.subject,n:state.players}),state.room>(state.publishedRoom??0)&&counter(this.env,{metric:'peak-room',subject:this.subject,n:state.room})].filter(Boolean);
+    if(writes.length)await this.env.DB.batch(writes);
+    // Current totals are volatile. Reusing an old high-water snapshot's shard
+    // counts after eviction would incorrectly add players who already left.
+    await this.ctx.storage.put('concurrent-peak',{day:state.day,players:state.players,room:state.room,publishedPlayers:state.players,publishedRoom:state.room});
+    state.publishedPlayers=state.players;state.publishedRoom=state.room;this.dirty=false;
+  }
+  schedule() {
+    if(this.flushing)return;
+    const task=new Promise(resolve=>setTimeout(resolve,1000)).then(()=>{
+      const flush=this.chain.then(()=>this.flush());this.chain=flush.catch(()=>{});return flush;
+    }).catch(error=>{this.dirty=true;console.warn('Lobby peak write will retry:',error.message);}).finally(()=>{this.flushing=null;});
+    this.flushing=task;this.ctx.waitUntil(task);
+  }
+  async answer(request) {
+    if(!this.state)this.state={...await this.ctx.storage.get('concurrent-peak')??{day:today(),players:0,room:0},shards:{}};
+    const state=this.state;
+    if(state.day!==today()){state.day=today();state.players=0;state.room=0;state.publishedPlayers=0;state.publishedRoom=0;this.dirty=true;}
+    if(request.method==='POST') {
+      const row=await request.json(),prior=state.shards[row.shard];
+      if(!Number.isInteger(row.shard)||row.shard<0||row.shard>=16||!Number.isFinite(row.at)||!Number.isFinite(row.players)||row.players<0)return Response.json({error:'report'},{status:400});
+      if(!prior||row.at>prior.at){
+        state.shards[row.shard]={players:row.players,at:row.at};
+        const concurrent=Object.values(state.shards).filter(r=>r.at>Date.now()-180000).reduce((n,r)=>n+r.players,0);
+        const players=Math.max(state.players,concurrent),room=Math.max(state.room,Number(row.room)||0);
+        if(players>state.players||room>state.room)this.dirty=true;
+        state.players=players;state.room=room;this.subject=new URL(request.url).searchParams.get('game');
+      }
+    }
+    if(this.dirty){if(this.ctx.waitUntil)this.schedule();else await this.flush();}
+    return Response.json({players:state.players,room:state.room});
+  }
+}

package/worker/lobby-shards.mjs

@@ -0,0 +1,43 @@
+import {roomServer} from './servers.mjs';
+export const LOBBY_SHARDS=16;
+export const SHARDED_ROOM_BASE=100000000;
+export function lobbyShard(key) {
+  let hash=2166136261;for(const c of String(key))hash=Math.imul(hash^c.charCodeAt(0),16777619);
+  return (hash>>>0)%LOBBY_SHARDS;
+}
+export function roomShard(room) {
+  const server=roomServer(room);
+  if(server!=='public')return lobbyShard(server);
+  const n=/^pub-(\d+)$/.exec(room)?.[1];
+  return n ? Number(n)>=SHARDED_ROOM_BASE?(Number(n)-SHARDED_ROOM_BASE)%LOBBY_SHARDS:0 : lobbyShard(room);
+}
+export function lobbyFor(env,game,identity='') {
+  const stub=shard=>env.LOBBY.get(env.LOBBY.idFromName(shard?`${game}/shard/${shard}`:game));
+  const send=(shard,url,init)=>{const target=new URL(url);target.searchParams.set('shard',String(shard));return stub(shard).fetch(target.toString(),init);};
+  return {async fetch(input,init) {
+    const url=new URL(typeof input==='string'?input:input.url??input);
+    if(url.pathname==='/join') {
+      const server=url.searchParams.get('server')??'public';
+      const key=identity||url.searchParams.get('b')||crypto.randomUUID();
+      const shard=lobbyShard(server==='public'?key:server);
+      url.searchParams.set('reservation',key.slice(0,128));
+      if(server==='public'){url.pathname='/match';url.searchParams.set('game',game);return env.LOBBY.get(env.LOBBY.idFromName(`${game}/match/${shard}`)).fetch(url.toString(),init);}
+      return send(shard,url,init);
+    }
+    if(url.pathname==='/report') {
+      const body=JSON.parse(init?.body??await input.clone().text());
+      return send(roomShard(body.room),url,init??{method:'POST',body:JSON.stringify(body)});
+    }
+    const rows=await Promise.all(Array.from({length:LOBBY_SHARDS},async(_,shard)=>{
+      const response=await send(shard,url,init);if(!response.ok)throw Error('Lobby shard unavailable');return response.json();
+    }));
+    if(url.pathname==='/busiest')return Response.json(rows.sort((a,b)=>b.players-a.players||String(a.room).localeCompare(String(b.room)))[0]);
+    if(url.pathname==='/now'){
+      const target=new URL('https://lobby/peak');target.searchParams.set('game',game);
+      const response=await env.LOBBY.get(env.LOBBY.idFromName(game+'/peak')).fetch(target);
+      if(!response.ok)throw Error('Lobby peak unavailable');
+      return Response.json({players:rows.reduce((n,r)=>n+r.players,0),rooms:rows.reduce((n,r)=>n+r.rooms,0),peak:await response.json()});
+    }
+    return Response.json({rooms:[...new Map(rows.flatMap(r=>r.rooms??[]).map(r=>[r.name??r.room,r])).values()].sort((a,b)=>b.players-a.players)});
+  }};
+}

package/worker/lobby-store.mjs

@@ -0,0 +1,35 @@
+/** Row storage keeps a seat update from rewriting every room. The legacy snapshot
+ * is imported once in the same SQLite transaction as the migration marker. */
+export function lobbyStore(storage) {
+  const sql=storage.sql;
+  if(!sql)return {load:()=>storage.get('lobby'),save:value=>storage.put('lobby',value)};
+  let previous=new Map(),previousMeta;
+  const write=value=>{
+    const rooms=new Map(value.rooms.map(room=>[room.name,JSON.stringify(room)]));
+    const meta=JSON.stringify({current:value.current,next:value.next,closed:value.closed});
+    storage.transactionSync(()=>{
+      for(const [name,body] of rooms)if(previous.get(name)!==body)sql.exec('INSERT INTO matchmaking_rooms(name,body) VALUES(?,?) ON CONFLICT(name) DO UPDATE SET body=excluded.body',name,body);
+      for(const name of previous.keys())if(!rooms.has(name))sql.exec('DELETE FROM matchmaking_rooms WHERE name=?',name);
+      if(meta!==previousMeta)sql.exec("INSERT INTO matchmaking_meta(id,body) VALUES(1,?) ON CONFLICT(id) DO UPDATE SET body=excluded.body",meta);
+    });
+    previous=rooms;previousMeta=meta;
+  };
+  return {
+    async load() {
+      sql.exec('CREATE TABLE IF NOT EXISTS matchmaking_rooms(name TEXT PRIMARY KEY,body TEXT NOT NULL)');
+      sql.exec('CREATE TABLE IF NOT EXISTS matchmaking_meta(id INTEGER PRIMARY KEY CHECK(id=1),body TEXT NOT NULL)');
+      const meta=sql.exec('SELECT body FROM matchmaking_meta WHERE id=1').toArray()[0];
+      if(!meta) {
+        const legacy=await storage.get('lobby');
+        write(legacy??{current:null,next:{public:1},closed:[],rooms:[]});
+        // A crash before deletion is harmless: the SQLite marker wins next time.
+        await storage.delete('lobby');
+      } else {
+        previousMeta=meta.body;
+        previous=new Map(sql.exec('SELECT name,body FROM matchmaking_rooms').toArray().map(r=>[r.name,r.body]));
+      }
+      return {...JSON.parse(previousMeta),rooms:[...previous.values()].map(body=>JSON.parse(body))};
+    },
+    save:write,
+  };
+}

package/worker/lobby-summary.mjs

@@ -0,0 +1,28 @@
+export const LIVE_ROOMS_QUERY='SELECT game,rooms,updated FROM lobby_summaries ORDER BY game LIMIT 500';
+/** Queue order is not guaranteed. An older snapshot must never replace a newer one. */
+export async function storeLobbySummary(env, message) {
+  if(!/^[a-z0-9][a-z0-9-]{0,39}$/.test(message.game)||!Array.isArray(message.rooms)||message.rooms.length>512||!Number.isFinite(message.at))throw new Error('Invalid lobby snapshot');
+  const shard=message.shard??0;
+  if(!Number.isInteger(shard)||shard<0||shard>=16)throw new Error('Invalid lobby shard');
+  await env.DB.prepare(`INSERT INTO lobby_summaries(game,rooms,updated) VALUES(?1,?2,?3)
+    ON CONFLICT(game) DO UPDATE SET rooms=excluded.rooms,updated=excluded.updated WHERE excluded.updated>lobby_summaries.updated`)
+    .bind(shard?`${message.game}~${shard}`:message.game,JSON.stringify(message.rooms),message.at).run();
+}
+export async function liveRoomSummaries(env) {
+  if(!env.BACKGROUND||!env.DB)return null; // Older wrappers still query their Lobby.
+  const result=new Map(),since=Date.now()-180000;
+  let cursor=null;
+  for(;;){
+    const query=cursor===null?env.DB.prepare(LIVE_ROOMS_QUERY):env.DB.prepare('SELECT game,rooms,updated FROM lobby_summaries WHERE game>? ORDER BY game LIMIT 500').bind(cursor);
+    const rows=(await query.all()).results??[];
+    for(const row of rows){
+      const game=row.game.split('~')[0],rooms=result.get(game)??[];
+      if(row.updated>since)rooms.push(...JSON.parse(row.rooms).filter(room=>room.at>since));
+      result.set(game,rooms);
+    }
+    if(rows.length<500)break;
+    cursor=rows.at(-1).game;
+  }
+  for(const [game,rooms] of result)result.set(game,[...new Map(rooms.map(room=>[room.name,room])).values()]);
+  return result;
+}