@homie-rocks/studio 0.53.0 → 0.55.0

package/worker/chat-page.mjs

@@ -21,7 +21,7 @@
  */
 import { REACTIONS } from './chat.mjs';
 import { REPORT_REASONS, REPORT_WORDS } from './chat-store.mjs';
-import { NET_PALETTE } from './room.mjs';
+import { NET_PALETTE } from './room-protocol.mjs';
 
 /** Where room chat's strip of new lines may sit: a corner, or the middle of the top or bottom edge. */
 export const CHAT_PLACES = ['top-left', 'top-center', 'top-right', 'bottom-left', 'bottom-center', 'bottom-right'];

package/worker/chat-store.mjs

@@ -1,3 +1,4 @@
+import {databaseBinding, ORIGINAL_DB} from './request-db.mjs';
 /**
  * ROOM CHAT IN THE STUDIO'S OWN D1 (@homie-rocks/studio 0.23.0, NETPLAY.md section 19): the owner's chat rules per game
  * and per server, and the reports players make. Never the chat itself: what people say lives a few minutes in the
@@ -51,8 +52,8 @@ const cache = new WeakMap();
 /** Every chat rule row (D1), read at most every 5 s per Worker instance; empty before migration 0007. */
 export async function chatRowsOf(env, { fresh = false } = {}) {
   if (!env?.DB || env.HOMIE_PREVIEW === '1') return new Map();
-  const hit = cache.get(env.DB);
-  if (!fresh && hit && Date.now() - hit.at < 5000) return hit.map;
+  const hit = cache.get(databaseBinding(env.DB));
+  if (!env.DB[ORIGINAL_DB] && !fresh && hit && Date.now() - hit.at < 5000) return hit.map;
   let map = new Map();
   try {
     const { results } = await env.DB.prepare('SELECT game, server, rules, updated_at FROM chat_rules LIMIT 1000').all();
@@ -62,10 +63,10 @@ export async function chatRowsOf(env, { fresh = false } = {}) {
       if (rules && typeof rules === 'object') map.set(`${r.game}/${r.server ?? ''}`, { ...rules, at: Number(r.updated_at) || 0 });
     }
   } catch { map = new Map(); }
-  cache.set(env.DB, { at: Date.now(), map });
+  cache.set(databaseBinding(env.DB), { at: Date.now(), map });
   return map;
 }
-export const forgetChat = (env) => { if (env?.DB) cache.delete(env.DB); };
+export const forgetChat = (env) => { if (env?.DB) cache.delete(databaseBinding(env.DB)); };
 
 /**
  * A room's chat rules: the game's game.json "chat", the owner's rules for the game, then for this server (a server's

package/worker/embed.mjs

@@ -61,7 +61,7 @@ export function playerOrigins(value) {
       const origin = 'https://' + (wildcard ? '*.' : '') + u.host;
       if (!origins.includes(origin)) origins.push(origin);
       if (origins.length === 8) break;
-    } catch {}
+    } catch { /* Invalid configured origins grant no framing permission. */ }
   }
   return origins;
 }

package/worker/event-resources.mjs

@@ -1,3 +1,4 @@
+import {databaseBinding} from './request-db.mjs';
 import {McpEventStreams} from './mcp-event-streams.mjs';
 import {listEvents} from './mcp-events.mjs';
 import {notification,sseFrame} from './mcp-events-wire.mjs';
@@ -49,14 +50,14 @@ export async function subscribeFeed(env,cat,caller,uri,remove=false) {
     await env.DB.prepare('INSERT OR IGNORE INTO mcp_kv(key,value,expires) VALUES(?1,?2,NULL)').bind(key(caller.connection,name),JSON.stringify({connection:caller.connection,name,after:seq})).run();
   }
 }
-export function eventHub(env,connection) {return env.LOBBY.get(env.LOBBY.idFromName('@studio-events/'+connection));}
+export function eventHub(env,connection) {const ns=env.EVENTS??env.LOBBY;return ns.get(ns.idFromName('@studio-events/'+connection));}
 export async function pushEvents(env,cat,origin) {
-  if(!env.LOBBY||!Object.keys(eventFeeds(env)).length)return;
-  // Page subscriptions, without a studio-wide subscription or delivery cap.
-  await env.DB.prepare("DELETE FROM mcp_kv WHERE key LIKE 'mcp-event-stream:%' AND expires<?1").bind(Date.now()).run();
+  if(!(env.EVENTS??env.LOBBY)||!Object.keys(eventFeeds(env)).length)return;
+  // Wake only active streams. Durable subscriptions without a connection replay
+  // their cursor when they reconnect; they never need an idle object wake.
   let after='';const seen=new Set();
   for(;;){
-    const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE (key LIKE 'event-sub:%' OR key LIKE 'mcp-event-stream:%' OR key LIKE 'tools-stream:%') AND key>?1 ORDER BY key LIMIT 100").bind(after).all()).results;
+    const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE ((key >= 'mcp-event-stream:' AND key < 'mcp-event-stream;') OR (key >= 'tools-stream:' AND key < 'tools-stream;')) AND key>?1 AND (expires IS NULL OR expires>?2) ORDER BY key LIMIT 100").bind(after,Math.floor(Date.now()/1000)).all()).results;
     for(const row of rows){const {connection}=JSON.parse(row.value);if(seen.has(connection))continue;seen.add(connection);
       const response=await eventHub(env,connection).fetch('https://events/__studio_events',{method:'POST',body:JSON.stringify({op:'wake',connection,cat,origin})});
       if(!response.ok)throw new Error('Event stream wake failed');
@@ -69,7 +70,7 @@ export async function pushEvents(env,cat,origin) {
 const streamCaller=(env,connection)=>connection.startsWith('public:')?Promise.resolve({id:null,owner:false,client:null,connection}):currentCaller(env,{connection});
 export class EventStreams {
   constructor(env,ctx){this.env=env;this.ctx=ctx;this.stream=null;this.tail=Promise.resolve();this.extensions=new McpEventStreams(env,ctx);}
-  close(stream){stream.cancelled=true;stream.resume?.();try{stream.controller.close();}catch{}if(this.stream===stream){this.stream=null;this.ctx.waitUntil(this.env.DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind('tools-stream:'+stream.connection).run().catch(()=>{}));}}
+  close(stream){stream.cancelled=true;clearTimeout(stream.reconnect);stream.resume?.();try{stream.controller.close();}catch{/* The reader already cancelled or the stream already closed. */}if(this.stream===stream){this.stream=null;this.ctx.waitUntil(this.env.DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind('tools-stream:'+stream.connection).run().catch(error=>console.warn("MCP stream task failed:",error.message)));}}
   background(input){this.ctx.waitUntil(this.wake(input).catch(error=>{if(this.stream)this.close(this.stream);console.error('Event stream delivery failed',error);}));}
   async fetch(request) {
     const input=await request.json();
@@ -81,7 +82,7 @@ export class EventStreams {
       if(this.stream)this.close(this.stream);
       await this.tail;
       const {connection,lastId}=input;
-      const subscriptions=(await this.env.DB.prepare("SELECT value FROM mcp_kv WHERE key LIKE ?1").bind('event-sub:'+connection+':%').all()).results;
+      const subscriptions=(await this.env.DB.prepare("SELECT value FROM mcp_kv WHERE key >= ?1 AND key < ?2").bind('event-sub:'+connection+':','event-sub:'+connection+';').all()).results;
       let after=subscriptions.length?Math.min(...subscriptions.map(r=>JSON.parse(r.value).after)):(await this.env.DB.prepare('SELECT COALESCE(MAX(seq),0) seq FROM studio_events').first()).seq,name='';
       if(lastId){const parts=lastId.split('/');if(parts.length!==3||parts[0]!==connection||!/^\d+$/.test(parts[1]))return new Response('Invalid Last-Event-ID',{status:400});after=Number(parts[1]);name=parts[2];}
       const stream={...input,after,name,controller:null,cancelled:false,resume:null};
@@ -91,7 +92,9 @@ export class EventStreams {
       if(!caller){this.close(stream);return new Response('Unauthorized',{status:401});}
       stream.toolSignature=await this.toolSignature(input.tools??[],caller);
       stream.eventSignature=JSON.stringify(await listEvents(this.env,input.cat,caller));
-      await this.env.DB.prepare('INSERT INTO mcp_kv(key,value) VALUES(?1,?2) ON CONFLICT(key) DO UPDATE SET value=excluded.value').bind('tools-stream:'+connection,JSON.stringify({connection})).run();
+      await this.env.DB.prepare('INSERT INTO mcp_kv(key,value,expires) VALUES(?1,?2,?3) ON CONFLICT(key) DO UPDATE SET value=excluded.value,expires=excluded.expires').bind('tools-stream:'+connection,JSON.stringify({connection}),Math.floor(Date.now()/1000)+300).run();
+      stream.reconnect=setTimeout(()=>this.close(stream),240000);
+      stream.reconnect?.unref?.();
       // Replay and later wakes share one ordered pump. Backpressure must not
       // hold up the writer's request or a function handler.
       this.background(input);
@@ -99,7 +102,7 @@ export class EventStreams {
     }
     this.background(input);return new Response(null,{status:204});
   }
-  wake(input){const work=this.tail.then(()=>this.deliver(input));this.tail=work.catch(()=>{});return work;}
+  wake(input){const work=this.tail.then(()=>this.deliver(input));this.tail=work.catch(error=>console.warn("MCP stream task failed:",error.message));return work;}
   async toolSignature(tools,caller) {const visible=[];for(const tool of tools)if(await allowed(tool.audience,caller,this.env))visible.push(tool);return JSON.stringify(visible);}
   async deliver(input) {
     const stream=this.stream;if(!stream)return;
@@ -112,7 +115,7 @@ export class EventStreams {
       const signature=await this.toolSignature(input.tools,caller);
       if(stream.toolSignature!==signature){stream.toolSignature=signature;stream.controller.enqueue(new TextEncoder().encode('event: message\ndata: '+JSON.stringify({jsonrpc:'2.0',method:'notifications/tools/list_changed'})+'\n\n'));}
     }
-    const rows=(await this.env.DB.prepare("SELECT value FROM mcp_kv WHERE key LIKE ?1").bind('event-sub:'+caller.connection+':%').all()).results;
+    const rows=(await this.env.DB.prepare("SELECT value FROM mcp_kv WHERE key >= ?1 AND key < ?2").bind('event-sub:'+caller.connection+':','event-sub:'+caller.connection+';').all()).results;
     const subscriptions=[];
     for(const row of rows){const sub=JSON.parse(row.value);if(await readableFeed(this.env,input.cat,caller,sub.name))subscriptions.push(sub);}
     const through=(await this.env.DB.prepare('SELECT COALESCE(MAX(seq),0) seq FROM studio_events').first()).seq;
@@ -141,18 +144,32 @@ export class EventStreams {
   }
 }
 
+const toolCatalogues=new WeakMap();
 /** Refresh active streams whenever this Worker observes a new tool catalogue. */
 export async function pushToolList(env,cat,tools,origin) {
   if(!env.LOBBY)return;
   const publicShape=tools.map(({name,description,inputSchema,audience,kind})=>({name,description,inputSchema,audience,kind}));
   const signature=JSON.stringify([publicShape,eventFeeds(env)]);
+  const binding=databaseBinding(env.DB);
+  if(toolCatalogues.get(binding)===signature)return;
   const previous=await env.DB.prepare("SELECT value FROM mcp_kv WHERE key='tools-catalogue'").first();
-  if(previous?.value===signature)return;
+  if(previous?.value===signature){toolCatalogues.set(binding,signature);return;}
   await env.DB.prepare("INSERT INTO mcp_kv(key,value) VALUES('tools-catalogue',?1) ON CONFLICT(key) DO UPDATE SET value=excluded.value").bind(signature).run();
   let after='';
   for(;;){
-    const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE key LIKE 'tools-stream:%' AND key>?1 ORDER BY key LIMIT 100").bind(after).all()).results;
+    const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE (key >= 'tools-stream:' AND key < 'tools-stream;') AND key>?1 AND (expires IS NULL OR expires>?2) ORDER BY key LIMIT 100").bind(after,Math.floor(Date.now()/1000)).all()).results;
     for(const row of rows){const connection=JSON.parse(row.value).connection;await eventHub(env,connection).fetch('https://events/__studio_events',{method:'POST',body:JSON.stringify({op:'tools',connection,cat,tools:publicShape,origin})});}
     if(rows.length<100)break;after=rows.at(-1).key;
   }
+  toolCatalogues.set(binding,signature);
+}
+
+/** Bounded expiry work belongs to cron, never to each mutation or page. */
+export async function pruneMcpKeys(env) {
+  if(!env.DB)return;
+  try { await env.DB.prepare('DELETE FROM mcp_kv WHERE key IN (SELECT key FROM mcp_kv WHERE expires IS NOT NULL AND expires<?1 ORDER BY expires LIMIT 1000)').bind(Math.floor(Date.now()/1000)).run(); }
+  catch(error) {
+    // Older embedded shop workers have no MCP schema to prune.
+    if(!/no such table: mcp_kv/i.test(String(error?.message)))throw error;
+  }
 }

package/worker/function-registry.mjs

@@ -0,0 +1,4 @@
+// Studio declarations register synchronously; their implementation loads on demand.
+let load=async()=>[];
+export function useFunctions(loader) {load=loader;}
+export const loadFunctions=()=>load();

package/worker/functions.mjs

@@ -6,8 +6,8 @@ import {feedSubscriptions,pushEvents} from './event-resources.mjs';
 import { services } from './mcp-tools.mjs';
 import { isOwner, sameOrigin } from './office.mjs';
 import { esc } from './site.mjs';
-let load = async () => [];
-export function useFunctions(loader) { load = loader; }
+import {loadFunctions as load} from './function-registry.mjs';
+export {useFunctions} from './function-registry.mjs';
 export async function hasFunctionType(type,env={}) { return [...await load(),...feedSubscriptions(env)].some(fn=>fn.event===type); }
 export async function syncFunctions(env, definitions = null, now = Date.now()) {
   definitions ??= await load();
@@ -52,8 +52,10 @@ export async function runFunctions(env, cat, origin, {definitions, now = Date.no
   if(typeof cat==='function')cat=await cat();
   definitions=definitions.filter(fn=>!fn.webhook).concat(webhookSubscriptions(env,cat,webhookOptions),env.STUDIO_EVENT_FEEDS?await eventHookSubscriptions(env,cat,{...webhookOptions,now}):[]);
   // An AI notification must not wait behind a slow function handler.
-  const notify=()=>pushEvents(env,cat,origin).catch(error=>console.error('Event notification wake failed',error));
-  const notifications=notify();
+  const notify=()=>pushEvents(env,cat,origin);
+  // A final pass retries an early failed wake. If that also fails the queue
+  // consumer retries the batch; it must never acknowledge a lost notification.
+  const notifications=notify().catch(error=>console.warn('Early event wake failed; retrying after functions',error));
   let more;
   do {
     more=false;
@@ -151,7 +153,7 @@ export async function functionRuns(env,{name,errors=false,before}={}) {
     WHERE (?1 IS NULL OR function=?1) AND (?2=0 OR outcome IN ('failed','interrupted')) AND (?3 IS NULL OR seq<?3)
     ORDER BY seq DESC LIMIT 101`).bind(name??null,errors?1:0,before??null).all()).results;
   const page=rows.slice(0,100),definitions=await load();
-  let crons=[];try {crons=JSON.parse(env.STUDIO_FUNCTION_CRONS??'[]');if(!Array.isArray(crons))crons=[];}catch {}
+  let crons=[];try {crons=JSON.parse(env.STUDIO_FUNCTION_CRONS??'[]');if(!Array.isArray(crons))crons=[];}catch(error) {console.warn('Invalid STUDIO_FUNCTION_CRONS:',error.message);}
   const schedules=scheduleStatus(definitions.filter(f=>!name||f.name===name),crons);
   const tick=await env.DB.prepare("SELECT value FROM meta WHERE key='function-last-scheduled'").first();
   return {runs:page.map(r=>({...r,started:new Date(r.started).toISOString(),finished:r.finished===null?null:new Date(r.finished).toISOString()})),next:rows.length>100?page.at(-1).seq:null,schedules,crons,lastScheduled:tick?JSON.parse(tick.value):null,triggerEvidence:'Generated deployment configuration; lastScheduled proves an observed tick. Provider dashboard changes are not queried.'};

package/worker/gate-routing.mjs

@@ -0,0 +1,61 @@
+/** Admission routing without loading transport encoding or crowd simulation. */
+/** 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 function diagnosticsOf(env, game, room) { return env.GATE.get(env.GATE.idFromName(`${game}/${room}/diagnostics`)); }

package/worker/gate.mjs

@@ -27,64 +27,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) {
@@ -99,7 +43,7 @@ export function batchLink(socket, { setTimer = setTimeout, clearTimer = clearTim
   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 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 flush = () => {
     if (timer !== null) clearTimer(timer); timer = null;
@@ -279,7 +223,7 @@ 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);
@@ -385,10 +329,10 @@ export class Gate {
         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 {
@@ -400,12 +344,12 @@ export class Gate {
               if (op === 'seat') { if (client) { client.seat = value; client.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 (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
@@ -470,7 +414,7 @@ export class Gate {
     let opened = false;
     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);
     server.addEventListener('message', event => {
@@ -481,7 +425,7 @@ 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) {
@@ -545,7 +489,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
@@ -576,6 +520,6 @@ export class Gate {
   }
 }
 /** 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) {