@homie-rocks/studio 0.55.0 → 0.56.0

package/worker/lobby.mjs

@@ -1,22 +1,25 @@
+import {LobbyPeak} from './lobby-peak.mjs';
+import {MatchRouter} from './match-router.mjs';
+import {LOBBY_SHARDS,SHARDED_ROOM_BASE} from './lobby-shards.mjs';
+import {json} from './responses.mjs';
+import {lobbyStore} from './lobby-store.mjs';
 import { errorLine, versionOf } from './room-protocol.mjs';
 import { ROOM_ID } from './page-policy.mjs';
 import { SERVER_ID, pooledRoom, roomCode, roomServer } from './servers.mjs';
 import { seatCount } from './seats.mjs';
 import { counter, today } from './stats.mjs';
 
-const json = (body, status = 200, extra = {}) => new Response(`${JSON.stringify(body)}\n`, {
-  status, headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', ...extra },
-});
-
-export const LOBBY_APP_VERSIONS = 8;
-
-export const LOBBY_ROOMS_MAX = 512;
+import {LOBBY_APP_VERSIONS, LOBBY_ROOMS_MAX} from './lobby-limits.mjs';
+export {LOBBY_APP_VERSIONS, LOBBY_ROOMS_MAX} from './lobby-limits.mjs';
 
 export class Lobby {
   constructor(ctx, env) {
     this.ctx = ctx;
     this.env = env;
+    this.store = lobbyStore(ctx.storage);
     this.rooms = new Map();
+    this.reservations=new Map();
+    ctx.storage.sql?.exec("CREATE TABLE IF NOT EXISTS matchmaking_reservations(id TEXT PRIMARY KEY,body TEXT NOT NULL,expires INTEGER NOT NULL)");
     /** Each pool's next room number: { public: n, <server>: n } (a store from before servers is public's). */
     this.next = { public: 1 };
     /** Every room of this game that reported players (public and named), for "playing now" and the day's peak. */
@@ -26,11 +29,16 @@ export class Lobby {
     this.seen = new Map();
     this.closed = new Map();
     ctx.blockConcurrencyWhile(async () => {
-      const saved = await ctx.storage.get('lobby');
+      const saved = await this.store.load();
       if (saved) {
         this.current = saved.current ?? null;
         this.next = typeof saved.next === 'number' ? { public: saved.next } : saved.next && typeof saved.next === 'object' ? { public: 1, ...saved.next } : { public: 1 };
         for (const r of saved.rooms ?? []) this.rooms.set(r.name, { ...r, server: r.server ?? roomServer(r.name), agents: r.agents ?? 0, ai: r.ai ?? 0, ver: typeof r.ver === 'string' ? r.ver : '', pending: [], agentPending: [] });
+        for(const r of this.rooms.values())if(r.players>0&&r.at>Date.now()-180000)this.live.set(r.name,{players:r.players,at:r.at});
+        if(ctx.storage.sql)for(const row of ctx.storage.sql.exec('SELECT body,expires FROM matchmaking_reservations WHERE expires>?',Date.now()).toArray()) {
+          const reservation=JSON.parse(row.body),room=this.rooms.get(reservation.room);
+          if(room && reservation.pending!==false)room.pending.push(row.expires-20000);
+        }
         for (const [name, until] of saved.closed ?? []) if (until > Date.now()) this.closed.set(name, until);
       }
     });
@@ -48,15 +56,23 @@ export class Lobby {
     if (this.peak.day !== day) this.peak = { day, players: 0, room: 0 };
     let all = 0;
     for (const r of this.live.values()) all += r.players;
+    if(this.env.LOBBY){
+      const subject=game??this.game??'';if(game)this.game=game;
+      const target=new URL('https://lobby/peak');target.searchParams.set('game',subject);
+      const at=this.peakReportAt=Math.max(now,(this.peakReportAt??0)+1);
+      const body=JSON.stringify({shard:this.shard??0,players:all,room:players,at});
+      this.ctx.waitUntil(this.env.LOBBY.get(this.env.LOBBY.idFromName(subject+'/peak')).fetch(target,{method:'POST',body}).then(r=>{if(!r.ok)throw Error('peak report failed');return r.body?.cancel();}).catch(error=>console.warn('Lobby peak report failed:',error.message)));
+      return;
+    }
     const writes = [];
     if (all > this.peak.players) { this.peak.players = all; writes.push(counter(this.env, { metric: 'peak', subject: game ?? this.game ?? '', n: all, day })); }
     if (players > this.peak.room) { this.peak.room = players; writes.push(counter(this.env, { metric: 'peak-room', subject: game ?? this.game ?? '', n: players, day })); }
     if (game) this.game = game;
     const list = writes.filter(Boolean);
-    if (list.length) this.ctx.waitUntil(this.env.DB.batch(list).catch(() => {}));
+    if (list.length) this.ctx.waitUntil(this.env.DB.batch(list).catch(error => { this.peak = {day, players:0, room:0}; console.warn('Lobby peak write will retry on report:',error.message); }));
   }
 
-  save() { this.ctx.storage.put('lobby', { current: this.current ?? null, next: this.next, rooms: [...this.rooms.values()].map(({ name, players, agents, ai, server, at, ver, host }) => ({ name, players, agents, ai, server, at, ...(host ? { host } : {}), ...(ver ? { ver } : {}) })), closed: [...this.closed] }).catch(() => {}); }
+  save() { const pending=this.store.save( { current: this.current ?? null, next: this.next, rooms: [...this.rooms.values()].map(({ name, players, agents, ai, server, at, ver, host }) => ({ name, players, agents, ai, server, at, ...(host ? { host } : {}), ...(ver ? { ver } : {}) })), closed: [...this.closed] }); if(pending)this.ctx.waitUntil(pending); }
 
   prune(now) {
     for (const [name, r] of this.rooms) {
@@ -68,6 +84,8 @@ export class Lobby {
 
   /** A request that throws is said with what it was (never its body) and answered as a failure, not left uncaught. */
   async fetch(request) {
+    if(new URL(request.url).pathname==='/peak')return (this.peakStore??=new LobbyPeak(this.ctx,this.env)).fetch(request);
+    if(['/match','/match-policy'].includes(new URL(request.url).pathname))return (this.matchRouter??=new MatchRouter(this.ctx,this.env)).fetch(request);
     if(new URL(request.url).pathname==='/__app_records') {
       const {AppRecordStreams}=await import('./app-streams.mjs');
       this.appStreams??=new AppRecordStreams(this.env,this.ctx);
@@ -79,7 +97,11 @@ export class Lobby {
       this.eventStreams??=new EventStreams(this.env,this.ctx);
       return this.eventStreams.fetch(request);
     }
-    try { return await this.answer(request); } catch (error) {
+    try {
+      const response=await this.answer(request),url=new URL(request.url);
+      if(response.ok && request.method==='POST' && url.pathname==='/report' && this.env?.BACKGROUND && url.searchParams.get('game')) await this.scheduleSummary(url.searchParams.get('game'),Number(url.searchParams.get('shard'))||0);
+      return response;
+    } catch (error) {
       let path = '';
       try { path = new URL(request.url).pathname; } catch { /* not an address */ }
       try { console.error(JSON.stringify({ at: new Date().toISOString(), ev: 'lobby-failed', game: this.game ?? null, path, error: errorLine(error) })); } catch { /* no console */ }
@@ -87,14 +109,52 @@ export class Lobby {
     }
   }
 
+  async scheduleSummary(game,shard=0) {
+    this.summaryShard=shard;
+    if(this.summaryGame!==game) {await this.ctx.storage.put('summary-game',{game,shard});this.summaryGame=game;}
+    if(!this.summaryDue) {
+      this.summaryDue=Date.now()+10000;
+      try {await this.ctx.storage.setAlarm(this.summaryDue);} catch(error) {this.summaryDue=null;throw error;}
+    }
+  }
+  async alarm() {
+    if(this.matchRouter)return this.matchRouter.alarm();
+    if((await this.ctx.storage.list?.({prefix:'match:',limit:1}))?.size)return (this.matchRouter??=new MatchRouter(this.ctx,this.env)).alarm();
+    this.summaryDue=null;
+    const saved=await this.ctx.storage.get('summary-game');
+    const game=this.summaryGame??(typeof saved==='string'?saved:saved?.game),shard=this.summaryShard??saved?.shard??0;
+    if(!game||!this.env.BACKGROUND)return;
+    const at=Date.now();
+    const rooms=[...this.rooms.values()].filter(r=>r.players>0&&r.at>at-180000).map(({name,players,agents,ai,server,at})=>({name,players,agents:agents??0,ai:ai??0,server:server??roomServer(name),at}));
+    await this.env.BACKGROUND.send({v:1,type:'lobby.snapshot',game,shard,at,rooms});
+  }
+
+  reservation(key,result) {
+    const sql=this.ctx.storage.sql,now=Date.now();
+    if(sql){
+      if(result){sql.exec('DELETE FROM matchmaking_reservations WHERE expires<=?',now);sql.exec('INSERT OR REPLACE INTO matchmaking_reservations VALUES(?,?,?)',key,JSON.stringify({...result,pending:true}),now+20000);return;}
+      const row=sql.exec('SELECT body FROM matchmaking_reservations WHERE id=? AND expires>?',key,now).toArray()[0];if(!row)return null;const {pending,...saved}=JSON.parse(row.body);return saved;
+    }
+    for(const [id,row] of this.reservations)if(row.expires<=now)this.reservations.delete(id);
+    if(result)this.reservations.set(key,{result,expires:now+20000});
+    else return this.reservations.get(key)?.result;
+  }
+
   async answer(request) {
     const url = new URL(request.url);
     const now = Date.now();
+    this.shard=Number(url.searchParams.get('shard'))||0;
     this.prune(now);
     // REVISIONS (section 23): rooms are matched within one build of the game. A room that never said its build is
     // the build of a game that names none ('').
     const ver = versionOf(url.searchParams.get('ver')) ?? '';
     if (url.pathname === '/join') {
+      const shard=url.searchParams.has('shard')?Number(url.searchParams.get('shard')):null;
+      if(shard!==null&&(!Number.isInteger(shard)||shard<0||shard>=LOBBY_SHARDS))return json({error:'shard'},400);
+      const identity=url.searchParams.get('reservation');
+      const reservation=identity?JSON.stringify([url.searchParams.get('server'),ver,url.searchParams.get('host'),identity.slice(0,128)]):null;
+      const prior=reservation&&this.reservation(reservation);
+      if(prior && this.rooms.has(prior.room) && !this.closed.has(prior.room) && !(url.searchParams.get('not')??'').split(',').includes(prior.room))return json(prior);
       // A server build can run only its current rules. Persisted browser rooms
       // (including pre-kind records) and old server revisions must not consume
       // the pool or become the fallback of a server with roomsMax=1.
@@ -142,6 +202,7 @@ export class Lobby {
         if (fill >= max) continue;
         if (!best || fill > best.fill || (fill === best.fill && r.name < best.r.name)) best = { r, fill };
       }
+      if(url.searchParams.get('peek')==='1')return json({room:best?.r.name??null});
       let room = best?.r;
       let full = false;
       const fullest = (list) => list.reduce((a, b) => (b.players + b.pending.length > a.players + a.pending.length ? b : a), list[0]);
@@ -166,22 +227,26 @@ export class Lobby {
         }
       }
       if (!room) {
-        let n = this.next[server] ?? 1;
-        while (not.has(roomCode(server, n)) || this.closed.has(roomCode(server, n)) || this.rooms.has(roomCode(server, n))) n += 1;
+        const step=server==='public'&&shard!==null?LOBBY_SHARDS:1;
+        let n = Math.max(this.next[server] ?? 1,step>1?SHARDED_ROOM_BASE+shard:1);
+        while (not.has(roomCode(server, n)) || this.closed.has(roomCode(server, n)) || this.rooms.has(roomCode(server, n))) n += step;
         room = { name: roomCode(server, n), server, players: 0, agents: 0, ai: 0, at: now, ver, ...(host ? { host } : {}), pending: [], agentPending: [] };
-        this.next[server] = n + 1;
+        this.next[server] = n + step;
         this.rooms.set(room.name, room);
       }
       room.pending.push(now);
       this.save();
-      return json({ room: room.name, players: room.players, max, server, ...(full ? { full: true } : {}) });
+      const result={ room: room.name, players: room.players, max, server, ...(full ? { full: true } : {}) };
+      if(reservation)this.reservation(reservation,result);
+      return json(result);
     }
     if (url.pathname === '/report' && request.method === 'POST') {
       const body = await request.json().catch(() => ({}));
       if (typeof body.room !== 'string' || !ROOM_ID.test(body.room)) return json({ ok: false }, 400);
-      if (body.ended === true) { this.rooms.delete(body.room); this.seen.delete(body.room); this.save(); return json({ ok: true }); }
+      if (body.ended === true) { this.notePeak(body.room,0,url.searchParams.get('game')); this.rooms.delete(body.room); this.seen.delete(body.room); this.save(); return json({ ok: true }); }
       // The owner closed this room: matched with nobody until then (and forgotten as a public room).
       if (Number.isFinite(body.closed)) {
+        if(body.closed>now)this.notePeak(body.room,0,url.searchParams.get('game'));
         if (body.closed > now) { this.closed.set(body.room, body.closed); this.rooms.delete(body.room); } else this.closed.delete(body.room);
         this.seen.delete(body.room);
         this.save();
@@ -205,17 +270,20 @@ export class Lobby {
       const grew = Math.max(0, seated - r.players);
       // The room says which build it runs (it changes only when nobody on the old one is left).
       const rver = typeof body.ver === 'string' ? versionOf(body.ver) ?? '' : r.ver ?? '';
-      const changed = !this.rooms.has(r.name) || r.players !== seated || (r.agents ?? 0) !== agents || (r.ai ?? 0) !== ai || (r.ver ?? '') !== rver;
+      const changed = now-r.at>=60000 || !this.rooms.has(r.name) || r.players !== seated || (r.agents ?? 0) !== agents || (r.ai ?? 0) !== ai || (r.ver ?? '') !== rver;
       r.ver = rver;
       if (body.host === 'server' || body.host === 'browser') r.host = body.host;
       r.pending.splice(0, grew);
+      // Retain retry ownership while retiring fulfilled seat holds. Otherwise
+      // eviction restores those holds on top of the already reported players.
+      if(grew && this.ctx.storage.sql)this.ctx.storage.sql.exec("UPDATE matchmaking_reservations SET body=json_set(body,'$.pending',json('false')) WHERE id IN (SELECT id FROM matchmaking_reservations WHERE json_extract(body,'$.room')=? AND json_extract(body,'$.pending') IS NOT 0 ORDER BY expires,id LIMIT ?)",body.room,grew);
       if ((r.agents ?? 0) < agents) (r.agentPending ?? []).splice(0, agents - (r.agents ?? 0));
       r.players = seated;
       r.agents = agents;
       r.ai = ai;
       r.at = now;
       this.rooms.set(r.name, r);
-      if (changed) this.save(); // the minute's "still here" report writes nothing
+      if (changed) this.save(); // Refresh durable presence at most once per minute.
       return json({ ok: true });
     }
     if (url.pathname === '/rooms') return json({ rooms: [...this.rooms.values()].map(({ name, players, agents, ai, server, at }) => ({ name, players, agents: agents ?? 0, ai: ai ?? 0, server: server ?? roomServer(name), at })) });

package/worker/lounge-store.mjs

@@ -116,7 +116,7 @@ export function recOf(r) {
 export async function historyOf(env, game, room, { days, before = null, limit = LOUNGE_LIMITS.page, now = Date.now() } = {}) {
   if (!env?.DB || !(days > 0)) return [];
   const since = now - days * DAY;
-  await env.DB.prepare('DELETE FROM chat_history WHERE game = ?1 AND room = ?2 AND at < ?3').bind(game, room, since).run().catch(() => {});
+  await env.DB.prepare('DELETE FROM chat_history WHERE game = ?1 AND room = ?2 AND at < ?3').bind(game, room, since).run().catch(error => console.warn("Lounge retention deferred:",error.message));
   const n = Math.max(1, Math.min(LOUNGE_LIMITS.page, Math.floor(Number(limit) || LOUNGE_LIMITS.page)));
   const q = Number.isFinite(Number(before)) && before !== null
     ? env.DB.prepare('SELECT * FROM chat_history WHERE game = ?1 AND room = ?2 AND at >= ?3 AND at < ?4 ORDER BY at DESC LIMIT ?5').bind(game, room, since, Number(before), n)
@@ -192,7 +192,7 @@ export async function removeNight(env, id) {
 export async function nightsOf(env, { now = Date.now(), limit = 6 } = {}) {
   if (!env?.DB) return [];
   try {
-    await env.DB.prepare('DELETE FROM lounge_nights WHERE starts_at + minutes * 60000 < ?1').bind(now - DAY).run().catch(() => {});
+    await env.DB.prepare('DELETE FROM lounge_nights WHERE starts_at + minutes * 60000 < ?1').bind(now - DAY).run().catch(error => console.warn("Lounge retention deferred:",error.message));
     const { results } = await env.DB.prepare('SELECT * FROM lounge_nights WHERE starts_at + minutes * 60000 >= ?1 ORDER BY starts_at ASC LIMIT ?2').bind(now, Math.max(1, Math.min(LOUNGE_LIMITS.nights, limit))).all();
     return (results ?? []).map((r) => ({ id: r.id, title: r.title, at: Number(r.starts_at), minutes: Number(r.minutes), note: r.note ?? null, game: r.game ?? null, on: Number(r.starts_at) <= now }));
   } catch { return []; }

package/worker/match-router.mjs

@@ -0,0 +1,74 @@
+import {lobbyShard,LOBBY_SHARDS} from './lobby-shards.mjs';
+
+// Entry objects partition reservation ownership. They lease 8 routing decisions
+// at a time, so the policy object sees 1/8 of join traffic, never room reports.
+// A quiet game refills existing pools before opening shard zero. Spread above
+// 128 observed joins/s: below half the slowest single-coordinator throughput
+// measured by the deployed fixture (1024 durable joins, 32 concurrent).
+// Count consumed leases, not all eight slots in a newly issued lease.
+export class MatchRouter {
+  constructor(ctx,env) { this.ctx=ctx;this.env=env;this.pending=new Map();this.routes=new Map(); }
+  async fetch(request) {
+    const url=new URL(request.url),now=Date.now();
+    if(url.pathname==='/match-policy') {
+      this.demand=(this.demand??[]).filter(row=>now-row.at<1000);
+      this.demand.push({at:now,joins:Math.max(1,Math.min(8,Number(url.searchParams.get('used'))||1))});
+      return Response.json({wide:this.demand.reduce((n,row)=>n+row.joins,0)>128,until:now+1000});
+    }
+    const identity=url.searchParams.get('reservation');
+    const key=JSON.stringify([identity,url.searchParams.get('ver'),url.searchParams.get('host'),url.searchParams.get('not')]);
+    if(this.pending.has(key))return Response.json(await this.pending.get(key));
+    const task=this.join(url,key,now);this.pending.set(key,task);
+    try{return Response.json(await task);}finally{this.pending.delete(key);}
+  }
+  async join(url,key,now) {
+    const game=url.searchParams.get('game');
+    for(const [id,row] of this.routes)if(row.until<=now)this.routes.delete(id);
+    let route=this.routes.get(key)??await this.ctx.storage.get('match:'+key);
+    if(!route||route.until<=now) {
+      // Serialize lease consumption, not requests to the matching shards.
+      const previous=this.leasing??Promise.resolve();
+      const lease=previous.then(async()=>{
+        if(!this.policy||this.policy.until<=now||!this.remaining){
+          const target=new URL('https://lobby/match-policy');target.searchParams.set('game',game);target.searchParams.set('used',String(this.policy?8-this.remaining:1));
+          const response=await this.env.LOBBY.get(this.env.LOBBY.idFromName(game+'/match-policy')).fetch(target);
+          if(!response.ok)throw Error('Matching policy unavailable');
+          this.policy=await response.json();this.remaining=8;
+        }
+        this.remaining--;
+        return this.policy.wide?lobbyShard(url.searchParams.get('reservation')):null;
+      });
+      this.leasing=lease.then(()=>{},()=>{});
+      let shard=await lease;
+      if(shard===null) {
+        // Read-only discovery: persist ownership before reserving a seat. Quiet
+        // joins may refill any pool left open by a burst, including after eviction.
+        shard=0;
+        for(let candidate=0;candidate<LOBBY_SHARDS;candidate++){
+          const target=new URL(url);target.pathname='/join';target.searchParams.set('peek','1');target.searchParams.set('shard',String(candidate));
+          const name=candidate?`${game}/shard/${candidate}`:game;
+          const response=await this.env.LOBBY.get(this.env.LOBBY.idFromName(name)).fetch(target);
+          if(!response.ok)throw Error('Matching discovery unavailable');
+          if((await response.json()).room){shard=candidate;break;}
+        }
+      }
+      route={shard,until:now+20000};
+      // Persist ownership before forwarding: a lost response or entry eviction
+      // must retry the same shard, even while the game changes routing policy.
+      await this.ctx.storage.put('match:'+key,route);this.routes.set(key,route);
+      await this.ctx.storage.setAlarm?.(now+20000);
+    }
+    url.pathname='/join';url.searchParams.set('shard',String(route.shard));
+    const name=route.shard?`${game}/shard/${route.shard}`:game;
+    const response=await this.env.LOBBY.get(this.env.LOBBY.idFromName(name)).fetch(url);
+    if(!response.ok)throw Error('Matching shard unavailable');
+    return response.json();
+  }
+  async alarm() {
+    const now=Date.now();let next=Infinity;
+    for(const [key,row] of await this.ctx.storage.list({prefix:'match:'})) {
+      if(row.until<=now)await this.ctx.storage.delete(key);else next=Math.min(next,row.until);
+    }
+    if(Number.isFinite(next))await this.ctx.storage.setAlarm(next);
+  }
+}

package/worker/mcp-room.mjs

@@ -1,3 +1,4 @@
+import {lobbyFor} from './lobby-shards.mjs';
 import {signControl,settingsOf,launchOf,seatsFor} from './office.mjs';
 import {appAccess} from './app-records.mjs';
 import {withToolIdentity} from './tool-identity.mjs';
@@ -23,7 +24,7 @@ export async function remoteSeat(env,cat,caller,op,args) {
   if(refusal)throw new Error(refusal.message);
   let room=args.room;
   if(!room&&op==='sit'){
-    const joined=await env.LOBBY.get(env.LOBBY.idFromName(meta.id)).fetch(`https://lobby/join?max=${max}&server=${serverId}&agent=1&ai=${policy.aiSeats+policy.guides}`,{method:'POST'});room=(await joined.json()).room;
+    const joined=await lobbyFor(env,meta.id).fetch(`https://lobby/join?max=${max}&server=${serverId}&agent=1&ai=${policy.aiSeats+policy.guides}`,{method:'POST'});room=(await joined.json()).room;
   }
   if(!/^[A-Za-z0-9_-]{1,32}$/.test(room??''))throw new Error('No room with people; an AI never starts a room');
   const ctl=await signControl(env,{op:'mcp-seat',game:meta.id,room,args:{...args,operation:op,connection:caller.connection,person:caller.id,name:caller.name??'Studio AI'}});

package/worker/mcp-tools.mjs

@@ -78,8 +78,10 @@ export function services(env, cat, origin, caller, namespace, definition = {}) {
     fetch:globalThis.fetch.bind(globalThis),
     // A named secret may authenticate an HTTPS request; its value is never returned.
     async fetchWithSecret(name,url,init={}) {
-      const rule=cat.studio?.mcp?.secrets?.[name]; const target=new URL(url);
-      if(!rule || target.protocol!=='https:' || target.origin!==rule.origin || (!caller.owner&&!rule.tools?.includes(definition.name))) throw new Error('secret capability refused');
+      const rule=cat.studio?.mcp?.secrets?.[name];
+      const permittedOrigin=rule?.origin==='self'?new URL(origin).origin:rule?.origin;
+      const target=new URL(url,rule?.origin==='self'?permittedOrigin:undefined);
+      if(!rule || target.protocol!=='https:' || target.username || target.password || target.origin!==permittedOrigin || (!caller.owner&&!rule.tools?.includes(definition.name))) throw new Error('secret capability refused');
       const secret=env[name];if(typeof secret!=='string')throw new Error('secret unavailable');
       const headers=new Headers(init.headers);headers.set(rule.header??'authorization',`${rule.prefix??'Bearer '}${secret}`);
       const res=await fetch(target,{...init,headers,redirect:'error'});

package/worker/office.mjs

@@ -1,3 +1,4 @@
+import {lobbyFor} from './lobby-shards.mjs';
 import {databaseBinding, ORIGINAL_DB} from './request-db.mjs';
 import { selling } from './extensions.mjs';
 import { purchaseOrderIfPresent } from './shop.mjs';
@@ -410,7 +411,7 @@ export async function redeemInvite(request, env, url, cat, meta, settings) {
 
 /* ------------------------------------------------------------------ talking to rooms */
 
-const lobbyOf = (env, game) => env.LOBBY.get(env.LOBBY.idFromName(game));
+const lobbyOf = (env, game) => lobbyFor(env,game);
 const tableOf = (env, game, room) => env.TABLE.get(env.TABLE.idFromName(`${game}/${room}`));
 
 /** The rooms of one game with people in them now, as its Lobby last heard (public and named). */

package/worker/operational-schema.mjs

@@ -36,6 +36,8 @@ CREATE INDEX IF NOT EXISTS mcp_kv_expires ON mcp_kv(expires) WHERE expires IS NO
 `;
 
 export const EXTRA_RUNTIME_MIGRATIONS={
+  "0036_lobby_summaries.sql":`CREATE TABLE IF NOT EXISTS lobby_summaries(game TEXT PRIMARY KEY,rooms TEXT NOT NULL,updated INTEGER NOT NULL);
+`,
   "0035_payment_delivery.sql":`CREATE TABLE IF NOT EXISTS stripe_intake(id TEXT PRIMARY KEY,payload TEXT NOT NULL,origin TEXT NOT NULL,received INTEGER NOT NULL,lease INTEGER NOT NULL DEFAULT 0,done INTEGER);
 CREATE INDEX IF NOT EXISTS stripe_intake_pending ON stripe_intake(lease,received,id) WHERE done IS NULL;
 CREATE INDEX IF NOT EXISTS stripe_intake_done ON stripe_intake(done) WHERE done IS NOT NULL;

package/worker/pages.mjs

@@ -983,7 +983,7 @@ const SHELL_JS = String.raw`${BUILD_RETRY_JS}(function () {
     try { arrived = performance.getEntriesByType('navigation')[0].type; } catch (e) {}
     askedRoom = kept && (arrived === 'reload' || arrived === 'back_forward') && EMBED_ROOM.test(kept.room || '') ? kept.room : null;
   }
-  var lobbyQ = [];
+  var lobbyQ = ['b=' + encodeURIComponent(roomKey)];
   if (state.server) lobbyQ.push('server=' + encodeURIComponent(state.server.id));
   if (/^[A-Za-z0-9_,-]{1,140}$/.test(params.get('not') || '')) lobbyQ.push('not=' + encodeURIComponent(params.get('not')));
   // Once the game has the screen, the chip says the room's facts for a few seconds, then gets out of the way.

package/worker/relay-channel.mjs

@@ -0,0 +1,119 @@
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+// Retry transport failures in order. Queue limits still bound memory during outages.
+export async function retryRelay(work, alive = () => true, wait = sleep) {
+  for (let attempt = 0; alive(); attempt++) {
+    try { return await work(); } catch (error) {
+      if (!alive()) return;
+      await wait(Math.min(5000, 100 * 2 ** Math.min(attempt, 6)));
+    }
+  }
+}
+
+/** Ordered input batches over bindings. A completed request holds no connection;
+ * output travels on a separate stream, never a recursive callback chain. */
+export function relayChannel(ctx, deliver, {sleep: wait = sleep} = {}) {
+  const listeners = new Map();
+  let chain = Promise.resolve(), closed = false, pending = 0, pendingBytes = 0, live = null, sequence = 0;
+  const emit = (name, event) => { for (const fn of listeners.get(name) ?? []) fn(event); };
+  return {
+    accept() {},
+    addEventListener(name, fn) { const list = listeners.get(name) ?? []; list.push(fn); listeners.set(name, list); },
+    emit,
+    async attachLive(socket) {
+      socket.addEventListener('message',event=>emit('message',event));
+      socket.addEventListener('close',()=>{try{socket.close(1000,'detached');}catch{}if(live===socket){live=null;emit('detached',{});}});
+      socket.addEventListener('error',()=>{if(live===socket){live=null;emit('detached',{});}});
+      await chain;
+      if(closed){socket.close(1000,'closed');return;}
+      if(socket.readyState!==1)return;
+      live=socket;
+      emit('drain',{});
+    },
+    isLive:()=>Boolean(live),
+    canSend(size) { return Boolean(live) || pendingBytes+size<=4*1024*1024; },
+    send(data) {
+      if(live){try{if(live.readyState===1){live.send(data);return;}}catch{ /* Retry over the idle transport. */ }live=null;}
+      if (closed) throw new Error('Relay channel closed');
+      const size=data.length;
+      if (pendingBytes+size>4*1024*1024) throw new Error('Relay channel queue limit');
+      pending++;pendingBytes+=size;
+      const id = ++sequence;
+      chain = chain.then(async () => {
+        if (closed) return;
+        await retryRelay(async () => {
+          const response = await deliver(data, id);
+          await response.body?.cancel();
+          if (!response.ok) throw new Error('Relay delivery failed: ' + response.status);
+        }, () => !closed, wait);
+      }).catch(error => { if (!closed) { closed = true; emit('error', {error}); } }).finally(() => { pending--;pendingBytes-=size;emit('drain',{}); });
+      ctx.waitUntil(chain);
+    },
+    close(code, reason) { if (!closed) { closed = true;live?.close(code,reason);live=null;emit('close', {code, reason}); } },
+  };
+}
+
+/** A Table's output is ordered on one stream while active. Closing the stream
+ * detaches transport, not logical players. An alarm or a player's next message
+ * can request another stream without sending a new welcome. */
+export function relayStream(ctx, wake, {sleep: wait = sleep} = {}) {
+  const listeners = new Map(), encoder = new TextEncoder();
+  const limit = 4 * 1024 * 1024;
+  let controller = null, live = null, queued = [], bytes = 0, waking = false, closed = false;
+  const emit = (name, event) => { for (const fn of listeners.get(name) ?? []) fn(event); };
+  const request = () => {
+    if (waking || closed) return;
+    waking = true;
+    ctx.waitUntil(retryRelay(wake, () => !closed && waking, wait));
+  };
+  return {
+    accept() {}, emit,
+    canSend(size, data) {
+      const needed=data===undefined?size*3+1:encoder.encode(data+'\n').byteLength;
+      return !closed && (Boolean(live) || needed+(controller?limit-controller.desiredSize:bytes)<=limit);
+    },
+    addEventListener(name, fn) { const list=listeners.get(name)??[];list.push(fn);listeners.set(name,list); },
+    send(data) {
+      if(live){try{if(live.readyState===1){live.send(data);return;}}catch{ /* Retry over the idle transport. */ }live=null;}
+      const chunk = encoder.encode(data+'\n');
+      if (chunk.byteLength + (controller ? limit-controller.desiredSize : bytes) > limit) throw new Error('Relay output queue limit');
+      if (controller) controller.enqueue(chunk);
+      else { queued.push(chunk);bytes+=chunk.byteLength;request(); }
+    },
+    attachLive(socket) {
+      controller?.close();controller=null;live?.close(1000,'replaced');live=socket;waking=false;emit('drain',{});
+      for(const chunk of queued)socket.send(new TextDecoder().decode(chunk).trimEnd());queued=[];bytes=0;
+      socket.addEventListener('close',()=>{try{socket.close(1000,'detached');}catch{}if(live===socket)live=null;});
+      socket.addEventListener('error',()=>{if(live===socket)live=null;});
+    },
+    open() {
+      controller?.close();
+      let owned;
+      return new ReadableStream({
+        start(next) { owned=next;controller=next;waking=false;for(const chunk of queued)next.enqueue(chunk);queued=[];bytes=0; },
+        pull() { emit('drain',{}); },
+        cancel() { if(controller===owned)controller=null; },
+      },{highWaterMark:limit,size:chunk=>chunk.byteLength});
+    },
+    sleep() { controller?.close();controller=null;const socket=live;live=null;socket?.close(1000,'room idle'); },
+    close(code,reason) {
+      if(closed)return;closed=true;
+      if(live){try{live.send(JSON.stringify([['link-close',code,reason]]));}catch{}live.close(code,reason);live=null;}
+      if(controller){controller.enqueue(encoder.encode(JSON.stringify([['link-close',code,reason]])+'\n'));controller.close();}
+      controller=null;queued=[];bytes=0;emit('close',{code,reason});
+    },
+  };
+}
+
+export async function readRelay(response, socket) {
+  if (!response.ok || !response.body) throw new Error('Relay stream refused');
+  const reader=response.body.getReader(),decoder=new TextDecoder();let pending='';
+  try {
+    for (;;) {
+      const {value,done}=await reader.read();if(done)break;
+      pending+=decoder.decode(value,{stream:true});
+      let end;while((end=pending.indexOf('\n'))>=0){if(end>4*1024*1024)throw new Error('Relay frame limit');const data=pending.slice(0,end);pending=pending.slice(end+1);socket.emit('message',{data});}
+      if(pending.length>4*1024*1024)throw new Error('Relay frame limit');
+    }
+    if(pending)throw new Error('Incomplete relay frame');
+  } finally { await reader.cancel().catch(()=>{}); }
+}

package/worker/request-db.mjs

@@ -1,3 +1,4 @@
+import {LIVE_ROOMS_QUERY} from './lobby-summary.mjs';
 export const METADATA_REVISION=Symbol('metadata revision');
 export const ORIGINAL_DB=Symbol('original database');
 export const MUTATIONS=Symbol('request mutations');
@@ -15,7 +16,7 @@ export function requestDatabase(DB, request, state={mutated:false}, binding=data
  // any bookmark returned by an earlier request without trusting stale auth.
  if(DB===binding&&typeof DB.withSession==='function')DB=DB.withSession('first-primary');
  let revision,records,rows,liveRooms;
- const prefetchRooms=false;
+ const prefetchRooms=state.summaries&&/^\/(?:api\/(?:rooms|games)|\.well-known\/homie-studio\.json)?\/?$/.test(new URL(request.url).pathname);
  const url=new URL(request.url),match=request.method==='GET'&&/^\/([a-z0-9][a-z0-9-]{0,39})\/api\/app\/records\/([a-z][a-z0-9-]{0,39})(?:\/([A-Za-z0-9_-]{1,64}))?$/.exec(url.pathname);
  const recordQuery=match&&(match[3]?'SELECT id, value, version, updated_at FROM app_records WHERE app = ?1 AND collection = ?2 AND id = ?3':'SELECT id, value, version, updated_at FROM app_records WHERE app = ?1 AND collection = ?2 ORDER BY updated_at, id');
  const stamp=()=>revision??=(async()=>{
@@ -27,7 +28,7 @@ export function requestDatabase(DB, request, state={mutated:false}, binding=data
   const cold=!cached;
   const statements=[query,...(cold?queries.map(sql=>DB.prepare(sql)):[])];
   if(recordQuery)statements.push(DB.prepare(recordQuery).bind(...match.slice(1).filter(x=>x!==undefined)));
-  if(prefetchRooms)statements.push(DB.prepare('SELECT game,rooms,updated FROM lobby_summaries LIMIT 500'));
+  if(prefetchRooms)statements.push(DB.prepare(LIVE_ROOMS_QUERY));
   const result=await DB.batch(statements);
   if(prefetchRooms)liveRooms=result.at(-1);
   let version=result[0].results?.[0]?.value??null;
@@ -46,7 +47,7 @@ export function requestDatabase(DB, request, state={mutated:false}, binding=data
  const prepare=(sql,args=[])=>{
   const original=()=>{const stmt=DB.prepare(sql);return args.length?stmt.bind(...args):stmt;};
   const read=async()=>{
-   if(sql==='SELECT game,rooms,updated FROM lobby_summaries LIMIT 500'&&prefetchRooms){await stamp();return liveRooms;}
+   if(sql===LIVE_ROOMS_QUERY&&prefetchRooms){await stamp();return liveRooms;}
    if(sql===recordQuery&&JSON.stringify(args)===JSON.stringify(match.slice(1).filter(x=>x!==undefined))){await stamp();return records;}
    if(!metadataQueries.has(sql))return original().all();
    await stamp();

package/worker/room-chat.mjs

@@ -130,7 +130,7 @@ onChat({ client = null, conn = null }, m) {
       if (this.room.chatPending >= CHAT_LIMITS.pending) return reply('busy');
       this.room.chatPending += 1;
       const t0 = now;
-      Promise.resolve()
+      const reviewing=Promise.resolve()
         .then(() => this.room.review(rec.text, { room: this.room.code, links: rules.links }))
         .then((v) => v, (error) => ({ ok: true, by: 'error', error: String(error?.message ?? error).slice(0, 120) }))
         .then((v) => {
@@ -150,6 +150,7 @@ onChat({ client = null, conn = null }, m) {
           if (this.room.muteOf({ token: who.token, browser: who.browser, player: who.player })) { reply('muted'); return; }
           this.room.publishChat(rec, who.conn, n);
         });
+      this.room.waitUntil?.(reviewing);
       return { ok: true, pending: true };
     }
     return this.room.publishChat(rec, who.conn, n);

package/worker/room-sessions.mjs

@@ -0,0 +1,65 @@
+/** Hibernation keeps transports outside JavaScript. Only data crosses this
+ * boundary; callbacks, bindings and sockets are reconstructed by the Table.
+ */
+// Only protocol identity, admission, controls and round deadlines survive here.
+// World snapshots/checkpoints belong to the existing host/room save, not sessions.
+const fields = new Set(`rawVocab vocab snapAt rates agentsAloneMs voteMs voteCooldownMs autoVoteMs policy level levelBy caps vote lastVoteOpen lastAutoVote lastHumanAt agentsOut officeDirty endedMatch code rules tickHz seatCap maxPlayers maxScreens perIp stallMs silentMs idleMs holdMs forgetMs persistMs gameVer currentVer occSeq seats hostId hostSince lastJoinAt lastRound lastRoster emptySince preferHost seatsDirty persistDirty lastPersistAt bans mutes announcement closedUntil closedWhy openedAt askedMax regate decideTimes defaultChat`.split(' '));
+function urlDelta(base, value) {
+  const a=new URL(base),b=new URL(value),changes=[];
+  for(const key of new Set([...a.searchParams.keys(),...b.searchParams.keys()])) {
+    const x=a.searchParams.getAll(key),y=b.searchParams.getAll(key);
+    if(JSON.stringify(x)!==JSON.stringify(y))changes.push([key,y]);
+  }
+  return {path:b.pathname,changes};
+}
+function clientURL(base, delta) {
+  const url=new URL(base);url.pathname=delta.path;
+  for(const [key,values] of delta.changes){url.searchParams.delete(key);for(const value of values)url.searchParams.append(key,value);}
+  return url.toString();
+}
+import {isQa} from './stats.mjs';
+const qa = agent => isQa({headers:new Headers({'user-agent':agent??''})})?'homie-house-qa':null;
+import {encodeSession as encode,decodeSession as decode} from './session-codec.mjs';
+const legacyDecode=value=>JSON.parse(value,(_key,item)=>item?.__roomMap?new Map(item.__roomMap):item?.__roomSet?new Set(item.__roomSet):item?.__roomNumber?item.__roomNumber*Infinity:item);
+export function roomSessions(storage) {
+  const sql=storage.sql;let previous=new Map();
+  return {
+    read() {
+      if(!sql)return null;
+      sql.exec('CREATE TABLE IF NOT EXISTS room_sessions(key TEXT PRIMARY KEY,value TEXT NOT NULL)');
+      previous=new Map(sql.exec('SELECT key,value FROM room_sessions').toArray().map(row=>[row.key,row.value]));
+      if(!previous.has('version'))return null;
+      if(!['1','2','3'].includes(previous.get('version')))throw new Error('Unsupported room session snapshot');
+      const read=previous.get('version')==='1'?legacyDecode:decode;
+      const table=previous.has('table')?read(previous.get('table')):{};
+      if(previous.get('version')==='3')table.relayDescriptors=[...previous].filter(([key])=>key.startsWith('relay:')).map(([key,value])=>{
+        const relay=read(value),prefix='relay-client:'+key.slice(6)+':';
+        relay.clients=[...previous].filter(([key])=>key.startsWith(prefix)).map(([,value])=>{const [id,clientId,delta,ip,agent]=read(value);return [id,clientId,clientURL(relay.url,delta),ip,qa(agent)];});
+        return relay;
+      });
+      return {table,fields:new Map([...previous].filter(([key])=>key.startsWith('room:')).map(([key,value])=>[key.slice(5),read(value)])),clients:new Map([...previous].filter(([key])=>key.startsWith('client:')).map(([key,value])=>[key.slice(7),read(value)]))};
+    },
+    write(room,table = {}) {
+      if(!sql)throw new Error('Room hibernation requires SQLite storage');
+      const {relayDescriptors=[],...metadata}=table;
+      const next=new Map([['version','3'],['table',encode(metadata)]]);
+      relayDescriptors.forEach((relay,index)=>{
+        next.set('relay:'+index,encode({url:relay.url}));
+        for(const [id,clientId,url,ip,agent] of relay.clients)next.set('relay-client:'+index+':'+id,encode([id,clientId,urlDelta(relay.url,url),ip,qa(agent)]));
+      });
+      for(const [key,value] of Object.entries(room))if(fields.has(key)&&value!==undefined&&typeof value!=='function')next.set('room:'+key,encode(value));
+      for(const [id,client] of room.clients){const {conn,lastSeen,probe,readyAt,ingressRateAt,rttWindow,rttReadAt,rttToldAt,measuredRtt,...state}=client;
+        if(state.rates instanceof Map)state.rates=new Map([...state.rates].filter(([key])=>key!=='ping'&&key!=='ping:view'));next.set('client:'+id,encode(state));}
+      storage.transactionSync(()=>{
+        for(const [key,value] of next)if(previous.get(key)!==value)sql.exec('INSERT INTO room_sessions VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value',key,value);
+        for(const key of previous.keys())if(!next.has(key))sql.exec('DELETE FROM room_sessions WHERE key=?',key);
+      });
+      previous=next;
+    },
+    clear() {if(sql&&previous.size){sql.exec('DELETE FROM room_sessions');previous.clear();}},
+  };
+}
+export function restoreRoomFields(room,snapshot) {
+  if(!snapshot)return;
+  for(const [key,value] of snapshot.fields)if(fields.has(key)&&Object.hasOwn(room,key)&&typeof room[key]!=='function')room[key]=value;
+}