@homie-rocks/studio 0.54.0 → 0.55.0

package/worker/lazy-objects.mjs

@@ -0,0 +1,40 @@
+/** Generated standard entries load room engines only when their object is used.
+ * Custom subclasses retain their own exports and do not use this adapter. */
+export class Table {
+  constructor(ctx,env) {
+    this.ready=ctx.blockConcurrencyWhile(async()=>{this.room=new (await import('./table.mjs')).Table(ctx,env);});
+  }
+  async fetch(request) {await this.ready;return this.room.fetch(request);}
+  async alarm() {await this.ready;return this.room.alarm();}
+  async webSocketMessage(...args) {await this.ready;return this.room.webSocketMessage(...args);}
+  async webSocketClose(...args) {await this.ready;return this.room.webSocketClose(...args);}
+  async webSocketError(...args) {await this.ready;return this.room.webSocketError(...args);}
+}
+export class Lobby {
+  constructor(ctx,env) {
+    this.ready=ctx.blockConcurrencyWhile(async()=>{this.lobby=new (await import('./lobby.mjs')).Lobby(ctx,env);});
+  }
+  async fetch(request) {await this.ready;return this.lobby.fetch(request);}
+  async alarm() {await this.ready;return this.lobby.alarm();}
+}
+
+export class Gate {
+  constructor(ctx,env) {
+    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);}
+}
+export class Concentrator extends Gate {}
+
+export class AppRecordHub {
+  constructor(ctx,env) {
+    this.ready=ctx.blockConcurrencyWhile(async()=>{this.hub=new (await import('./stream-objects.mjs')).AppRecordHub(ctx,env);});
+  }
+  async fetch(request) {await this.ready;return this.hub.fetch(request);}
+}
+export class EventHub {
+  constructor(ctx,env) {
+    this.ready=ctx.blockConcurrencyWhile(async()=>{this.hub=new (await import('./stream-objects.mjs')).EventHub(ctx,env);});
+  }
+  async fetch(request) {await this.ready;return this.hub.fetch(request);}
+}

package/worker/lobby-limits.mjs

@@ -0,0 +1,2 @@
+export const LOBBY_APP_VERSIONS = 8;
+export const LOBBY_ROOMS_MAX = 512;

package/worker/lobby.mjs

@@ -0,0 +1,251 @@
+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;
+
+export class Lobby {
+  constructor(ctx, env) {
+    this.ctx = ctx;
+    this.env = env;
+    this.rooms = new Map();
+    /** 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. */
+    this.live = new Map();
+    this.peak = { day: null, players: 0, room: 0 };
+    /** Every room with somebody seated, public or named, for the owner's office; and the rooms the owner closed (until when). */
+    this.seen = new Map();
+    this.closed = new Map();
+    ctx.blockConcurrencyWhile(async () => {
+      const saved = await ctx.storage.get('lobby');
+      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 [name, until] of saved.closed ?? []) if (until > Date.now()) this.closed.set(name, until);
+      }
+    });
+  }
+
+  /**
+   * The day's peak for this game, all rooms together and in one room: a counter write only when a new high is
+   * reached (in memory per day; after an eviction the stored max still wins), so at most a few a day.
+   */
+  notePeak(room, players, game) {
+    const now = Date.now();
+    if (players > 0) this.live.set(room, { players, at: now }); else this.live.delete(room);
+    for (const [name, r] of this.live) if (now - r.at > 180_000) this.live.delete(name); // a room that stopped reporting
+    const day = today();
+    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;
+    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(() => {}));
+  }
+
+  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(() => {}); }
+
+  prune(now) {
+    for (const [name, r] of this.rooms) {
+      r.pending = r.pending.filter((t) => now - t < 20_000);
+      r.agentPending = (r.agentPending ?? []).filter((t) => now - t < 20_000);
+      if (r.players === 0 && !r.pending.length && now - r.at > 120_000) this.rooms.delete(name);
+    }
+  }
+
+  /** 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==='/__app_records') {
+      const {AppRecordStreams}=await import('./app-streams.mjs');
+      this.appStreams??=new AppRecordStreams(this.env,this.ctx);
+      const input=await request.json();
+      return input.op==='open'?this.appStreams.open(input):this.appStreams.wake(input.meta);
+    }
+    if(new URL(request.url).pathname==='/__studio_events') {
+      const {EventStreams}=await import('./event-resources.mjs');
+      this.eventStreams??=new EventStreams(this.env,this.ctx);
+      return this.eventStreams.fetch(request);
+    }
+    try { return await this.answer(request); } 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 */ }
+      return json({ ok: false, error: 'lobby' }, 500);
+    }
+  }
+
+  async answer(request) {
+    const url = new URL(request.url);
+    const now = Date.now();
+    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') {
+      // 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.
+      const host = url.searchParams.get('host');
+      if ((host === 'server' || host === 'browser') && (this.current?.host !== host || this.current?.ver !== ver)) {
+        this.current = { host, ver };
+        for (const [name, r] of this.rooms) if (
+          host === 'server' ? (r.host ?? 'browser') !== host || (r.ver ?? '') !== ver : r.host === 'server'
+        ) { this.rooms.delete(name); this.seen.delete(name); this.live.delete(name); }
+        this.save();
+      }
+      const max = seatCount(url.searchParams.get('max'));
+      const sid = url.searchParams.get('server') ?? 'public';
+      const server = sid === 'public' || SERVER_ID.test(sid) ? sid : 'public';
+      const roomsMax = Math.max(1, Math.min(16, Math.floor(Number(url.searchParams.get('rooms'))) || 16));
+      // A room the owner closed, or one this visitor is held out of (`not`), is never the answer.
+      const not = new Set(String(url.searchParams.get('not') ?? '').split(',').filter(Boolean));
+      for (const [name, until] of this.closed) if (until <= now) this.closed.delete(name);
+      // Every room of the server counts toward its `rooms_max` and its numbering; only this build's rooms are matched.
+      const everyRoom = [...this.rooms.values()].filter((r) => (r.server ?? 'public') === server);
+      const ofServer = everyRoom.filter((r) => !not.has(r.name) && !this.closed.has(r.name));
+      const pool = ofServer.filter((r) => (r.ver ?? '') === ver);
+      // A standalone copy names its own build (the Worker says `app=1`), and anybody can claim to be one: only a few
+      // builds besides the live one ever have rooms here, so a caller that invents a build a request makes no pool.
+      const app = url.searchParams.get('app') === '1';
+      if (app && !everyRoom.some((r) => (r.ver ?? '') === ver) && new Set(everyRoom.map((r) => r.ver ?? '')).size > LOBBY_APP_VERSIONS) {
+        return json({ ok: false, room: null, error: 'versions', message: 'Too many versions of this game are being played at once: play offline for now.' }, 503);
+      }
+      if (url.searchParams.get('agent') === '1') {
+        // An AI: a room of this pool with people in it and an AI seat free (the most people first). Never a new room.
+        const reserve = Math.max(0, Math.floor(Number(url.searchParams.get('ai'))) || 0);
+        let best = null;
+        for (const r of pool) {
+          const agents = (r.agents ?? 0) + (r.agentPending ?? []).length;
+          if (!(r.players > 0) || (reserve ? agents >= reserve : r.players + r.pending.length + agents >= max)) continue;
+          if (!best || r.players > best.players || (r.players === best.players && r.name < best.name)) best = r;
+        }
+        if (!best) return json({ room: null, players: 0, max });
+        (best.agentPending ??= []).push(now);
+        return json({ room: best.name, players: best.players, max });
+      }
+      let best = null;
+      for (const r of pool) {
+        const fill = r.players + r.pending.length;
+        if (fill >= max) continue;
+        if (!best || fill > best.fill || (fill === best.fill && r.name < best.r.name)) best = { r, fill };
+      }
+      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]);
+      if (!room && server !== 'public' && everyRoom.length >= roomsMax) {
+        // Every room this server may have exists, whatever build each runs: the fullest one of this build, where the
+        // visitor waits for a seat; with none of this build, the fullest of the server (its players are told a newer
+        // build is live, and the visitor is let in when they have it). Never a room past the server's own number.
+        const from = pool.length ? pool : ofServer;
+        if (!from.length) return json({ ok: false, room: null, error: 'full', message: 'Every room of this server is taken.' }, 503);
+        room = fullest(from);
+        full = true;
+      }
+      if (!room && this.rooms.size >= LOBBY_ROOMS_MAX) {
+        // The Lobby keeps a bounded list (it is one stored value): rooms nobody is seated in go first, the oldest
+        // first. When every room has people in it, nobody gets a new one: this build's fullest, or no room at all.
+        const empty = [...this.rooms.values()].filter((r) => r.players === 0).sort((a, b) => a.at - b.at);
+        for (const r of empty) { if (this.rooms.size < LOBBY_ROOMS_MAX) break; this.rooms.delete(r.name); }
+        if (this.rooms.size >= LOBBY_ROOMS_MAX) {
+          if (!pool.length) return json({ ok: false, room: null, error: 'busy', message: 'Every room is taken right now.' }, 503);
+          room = fullest(pool);
+          full = true;
+        }
+      }
+      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;
+        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.rooms.set(room.name, room);
+      }
+      room.pending.push(now);
+      this.save();
+      return json({ room: room.name, players: room.players, max, server, ...(full ? { full: true } : {}) });
+    }
+    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 }); }
+      // 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.closed.set(body.room, body.closed); this.rooms.delete(body.room); } else this.closed.delete(body.room);
+        this.seen.delete(body.room);
+        this.save();
+        return json({ ok: true, closed: body.closed > now });
+      }
+      // A retiring isolate may send its last report after the new pool was
+      // selected. It cannot resurrect an incompatible public room.
+      if (pooledRoom(body.room) && this.current && (this.current.host === 'server'
+        ? (body.host ?? 'browser') !== 'server' || (body.ver ?? '') !== this.current.ver
+        : body.host === 'server')) return json({ ok: true, retired: true });
+      const seated = Math.max(0, Math.floor(Number(body.players) || 0));
+      const agents = Math.max(0, Math.floor(Number(body.agents) || 0));
+      const ai = Math.max(agents, Math.floor(Number(body.ai) || 0));
+      if (seated > 0) this.seen.set(body.room, { room: body.room, players: seated, people: Math.max(0, Math.floor(Number(body.people ?? seated) || 0)), agents, ai, at: now });
+      else this.seen.delete(body.room);
+      if (this.closed.has(body.room)) return json({ ok: true, closed: true });
+      this.notePeak(body.room, Math.max(0, Math.floor(Number(body.people ?? body.players) || 0)), url.searchParams.get('game'));
+      // Only rooms of a pool are matched with strangers (pub-N, s-<id>-<n>); a named room (?room=) stays private.
+      if (!this.rooms.has(body.room) && !pooledRoom(body.room)) return json({ ok: true, private: true });
+      const r = this.rooms.get(body.room) ?? { name: body.room, server: roomServer(body.room), players: 0, agents: 0, ai: 0, at: now, ver: '', pending: [], agentPending: [] };
+      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;
+      r.ver = rver;
+      if (body.host === 'server' || body.host === 'browser') r.host = body.host;
+      r.pending.splice(0, 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
+      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 })) });
+    if (url.pathname === '/busiest') {
+      // The pooled room with the most players now, for a watcher (section 16): it reserves nothing, as a watcher takes
+      // no seat. A closed room, one named in `not`, or one of a pool not in `pools` (a server with a door) is never it.
+      const not = new Set(String(url.searchParams.get('not') ?? '').split(',').filter(Boolean));
+      const pools = url.searchParams.has('pools') ? new Set(String(url.searchParams.get('pools')).split(',').filter(Boolean)) : null;
+      let best = null;
+      for (const r of this.rooms.values()) {
+        if (r.players <= 0 || not.has(r.name) || (this.closed.get(r.name) ?? 0) > now || (pools && !pools.has(r.server ?? 'public'))) continue;
+        // A watcher's page runs the live build: a room still on an older one would turn it away.
+        if (url.searchParams.has('ver') && (r.ver ?? '') !== ver) continue;
+        if (!best || r.players > best.players || (r.players === best.players && r.name < best.name)) best = r;
+      }
+      return json({ room: best?.name ?? null, players: best?.players ?? 0 });
+    }
+    if (url.pathname === '/office') {
+      // The owner's office: every room with somebody seated in the last 3 minutes, public or named, and closed ones.
+      for (const [name, r] of this.seen) if (now - r.at > 180_000) this.seen.delete(name);
+      const rooms = new Map([...this.seen.values()].map((r) => [r.room, r]));
+      for (const r of this.rooms.values()) if (r.players > 0 && !rooms.has(r.name)) rooms.set(r.name, { room: r.name, players: r.players, people: r.players, agents: r.agents ?? 0, ai: r.ai ?? 0, at: r.at });
+      for (const [name, until] of this.closed) if (until > now && !rooms.has(name)) rooms.set(name, { room: name, players: 0, people: 0, at: now, closedUntil: until });
+      return json({ rooms: [...rooms.values()].map((r) => ({ ...r, server: roomServer(r.room) })).sort((a, b) => b.players - a.players).slice(0, 100) });
+    }
+    if (url.pathname === '/now') {
+      let players = 0;
+      for (const [name, r] of this.live) { if (Date.now() - r.at > 180_000) this.live.delete(name); else players += r.players; }
+      return json({ players, rooms: this.live.size, peak: this.peak.day === today() ? { players: this.peak.players, room: this.peak.room } : { players: 0, room: 0 } });
+    }
+    return json({ error: 'not found' }, 404);
+  }
+}

package/worker/lounge.mjs

@@ -28,7 +28,7 @@ import { encodeFacts } from './agents.mjs';
 import { PUBLIC_SERVER, policyOf } from './servers.mjs';
 import { players } from './players.mjs';
 import { signControl } from './office.mjs';
-import { LOUNGE_JS, loungePage } from './lounge-page.mjs';
+
 import { STUDIO_VERSION_TAG } from './version.mjs';
 
 const json = (body, status = 200, extra = {}) => new Response(`${JSON.stringify(body)}\n`, {
@@ -262,14 +262,14 @@ export async function loungeRoutes(request, env, ctx, url, { catalogueOf, roomsO
   const cat = await catalogueOf();
   const L = loungeOf(cat);
   if (!L) return null;
-  if (path === '/_homie/lounge.js') return new Response(LOUNGE_JS, { headers: { 'content-type': 'text/javascript; charset=utf-8', 'cache-control': url.searchParams.get('v') === STUDIO_VERSION_TAG ? 'public, max-age=31536000, immutable' : 'public, max-age=300', 'x-content-type-options': 'nosniff' } });
+  if (path === '/_homie/lounge.js') return new Response((await import('./lounge-page.mjs')).LOUNGE_JS, { headers: { 'content-type': 'text/javascript; charset=utf-8', 'cache-control': url.searchParams.get('v') === STUDIO_VERSION_TAG ? 'public, max-age=31536000, immutable' : 'public, max-age=300', 'x-content-type-options': 'nosniff' } });
   if (path === '/lounge' && read) return Response.redirect(`${url.origin}/lounge/${url.search}`, 301);
   if (!env.TABLE || !env.DB) return path.startsWith('/lounge/api/') ? json({ ok: false, error: 'no-rooms', message: 'This studio has no rooms or database bound yet: `npm run deploy` sets them up.' }, 503) : null;
   const local = /^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(url.origin);
 
   if (path === '/lounge/' && read) {
     const [who, rules, nights] = await Promise.all([whoOf(request, env), loungeRules(env, cat), nightsOf(env)]);
-    return loungePage(cat, { origin: url.origin, who, rules: publicChat(rules), nights: nights.map((n) => nightView(n, cat, url.origin)) });
+    return (await import('./lounge-page.mjs')).loungePage(cat, { origin: url.origin, who, rules: publicChat(rules), nights: nights.map((n) => nightView(n, cat, url.origin)) });
   }
 
   if (path === '/lounge/__watch') {

package/worker/mcp-event-streams.mjs

@@ -4,7 +4,7 @@ import {EVENT_ERRORS,terminalEventError,EventsError,eventError,notification,sseF
 /** Connection-scoped push subscriptions hosted by the existing per-connection Lobby. */
 export class McpEventStreams {
   constructor(env,ctx){this.env=env;this.ctx=ctx;this.streams=new Set();}
-  close(stream){if(stream.closed)return;stream.closed=true;clearInterval(stream.timer);stream.resume?.();try{stream.controller.close();}catch{}this.streams.delete(stream);if(stream.registryKey)this.ctx.waitUntil(this.env.DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind(stream.registryKey).run().catch(()=>{}));}
+  close(stream){if(stream.closed)return;stream.closed=true;clearInterval(stream.timer);stream.resume?.();try{stream.controller.close();}catch{/* The reader already cancelled or the stream already closed. */}this.streams.delete(stream);if(stream.registryKey)this.ctx.waitUntil(this.env.DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind(stream.registryKey).run().catch(error=>console.warn("MCP stream cleanup deferred to expiry:",error.message)));}
   async write(stream,value,authorize){
     if(stream.closed)return false;
     if(stream.controller.desiredSize<=0)await new Promise(resolve=>{stream.resume=resolve;});
@@ -19,7 +19,7 @@ export class McpEventStreams {
       const caller=await eventCaller(this.env,input.connection);const feed=await checkEvent(this.env,input.cat,caller,input.params);
       const start=await eventStart(this.env,input.params);
       const registryKey='mcp-event-stream:'+input.connection+':'+crypto.randomUUID();
-      await this.env.DB.prepare('INSERT INTO mcp_kv(key,value,expires) VALUES(?1,?2,?3)').bind(registryKey,JSON.stringify({connection:input.connection}),Date.now()+60000).run();
+      await this.env.DB.prepare('INSERT INTO mcp_kv(key,value,expires) VALUES(?1,?2,?3)').bind(registryKey,JSON.stringify({connection:input.connection}),Math.floor(Date.now()/1000)+60).run();
       const stream={...input,registryKey,source:eventSource(feed),cursor:cursorOf(input.params.name,start.after),closed:false,busy:false};
       const body=new ReadableStream({start:controller=>{stream.controller=controller;controller.enqueue(sseFrame(notification('active',{cursor:stream.cursor,truncated:start.truncated},stream.id)));},pull:()=>{const resume=stream.resume;stream.resume=null;resume?.();},cancel:()=>this.close(stream)});
       this.streams.add(stream);
@@ -46,7 +46,7 @@ export class McpEventStreams {
         }
         stream.cursor=page.cursor;more=page.hasMore;
       }
-      await this.env.DB.prepare('UPDATE mcp_kv SET expires=?2 WHERE key=?1').bind(stream.registryKey,Date.now()+60000).run();
+      await this.env.DB.prepare('UPDATE mcp_kv SET expires=?2 WHERE key=?1').bind(stream.registryKey,Math.floor(Date.now()/1000)+60).run();
       await this.write(stream,notification('heartbeat',{cursor:stream.cursor},stream.id));
     }catch(error){
       const details=eventError(error);

package/worker/mcp-events.mjs

@@ -78,7 +78,7 @@ export async function subscribeEvents(env,cat,caller,params,{now=Date.now}={}){
   const id=await subId(caller,params,url),previous=await stored(env,id),live=previous&&previous.expires>now();
   if(live&&previous.source!==eventSource(feed)){await removeEventHook(env,id);throw new EventsError(EVENT_ERRORS.unsupported,{feature:'payloadSchema',reason:'schema_changed'});}
   if(previous&&!live)await removeEventHook(env,id);
-  if(!live&&feed.maxSubscriptions!==undefined){const rows=(await env.DB.prepare("SELECT value FROM mcp_kv WHERE key LIKE 'mcp-event-hook:%'").all()).results;if(rows.filter(row=>{const sub=JSON.parse(row.value);return sub.name===params.name&&sub.expires>now();}).length>=feed.maxSubscriptions)throw new EventsError(EVENT_ERRORS.exhausted,{limit:'subscriptions',max:feed.maxSubscriptions});}
+  if(!live&&feed.maxSubscriptions!==undefined){const rows=(await env.DB.prepare("SELECT value FROM mcp_kv WHERE (key >= 'mcp-event-hook:' AND key < 'mcp-event-hook;')").all()).results;if(rows.filter(row=>{const sub=JSON.parse(row.value);return sub.name===params.name&&sub.expires>now();}).length>=feed.maxSubscriptions)throw new EventsError(EVENT_ERRORS.exhausted,{limit:'subscriptions',max:feed.maxSubscriptions});}
   const start=await eventStart(env,params,now());
   const sub={id,name:params.name,source:eventSource(feed),url,secret,principal:caller.id,connection:caller.connection??'local-test-owner',start:live?previous.start:start.after,expires:now()+Math.min(params.ttlMs??3600000,86400000)};
   if(live){if(previous.secret!==secret){sub.previous=previous.secret;sub.rotateUntil=now()+300000;}else if(previous.rotateUntil>now()){sub.previous=previous.previous;sub.rotateUntil=previous.rotateUntil;}}
@@ -98,15 +98,15 @@ export async function unsubscribeEvents(env,caller,params){
 /** Dynamic hooks become ordinary durable function deliveries: one queue and retry engine. */
 export async function eventHookSubscriptions(env,cat,options={}){
   const now=options.now??Date.now,definitions=[];let after='';
-  for(;;){const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE key LIKE 'mcp-event-hook:%' AND key>?1 ORDER BY key LIMIT 100").bind(after).all()).results;
+  for(;;){const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE (key >= 'mcp-event-hook:' AND key < 'mcp-event-hook;') AND key>?1 ORDER BY key LIMIT 100").bind(after).all()).results;
     for(const row of rows){const sub=JSON.parse(row.value);if(sub.expires<=now()){await removeEventHook(env,sub.id);continue;}
       let feed;
       try{feed=await checkEvent(env,cat,await eventCaller(env,sub.connection),{name:sub.name});if(!permittedCallback(env,sub.name,sub.url))throw new EventsError(EVENT_ERRORS.forbidden);if(sub.source!==eventSource(feed))throw new EventsError(EVENT_ERRORS.unsupported,{feature:'payloadSchema',reason:'schema_changed'});}
-      catch(error){try{await send(env,sub,control('terminated',{error:eventError(error)}),'msg_terminated_'+crypto.randomUUID(),options);}catch{}await removeEventHook(env,sub.id);continue;}
+      catch(error){try{await send(env,sub,control('terminated',{error:eventError(error)}),'msg_terminated_'+crypto.randomUUID(),options);}catch{/* Termination is best effort; the failed subscription is already being retired. */}await removeEventHook(env,sub.id);continue;}
       definitions.push({name:hookFunction(sub.id),event:feed.event,webhook:true,mcpEvent:true,matches:event=>matchesFeed(feed,event),async handler(event){
         const fresh=await stored(env,sub.id);if(!fresh||fresh.expires<=now())return;
         try{await checkEvent(env,cat,await eventCaller(env,fresh.connection),{name:fresh.name});}
-        catch(error){try{await send(env,fresh,control('terminated',{error:eventError(error)}),'msg_terminated_'+crypto.randomUUID(),options);}catch{}await removeEventHook(env,fresh.id);return;}
+        catch(error){try{await send(env,fresh,control('terminated',{error:eventError(error)}),'msg_terminated_'+crypto.randomUUID(),options);}catch{/* Termination is best effort; the failed subscription is already being retired. */}await removeEventHook(env,fresh.id);return;}
         try{await send(env,fresh,occurrence(fresh.name,event,await watermark(env,fresh)),event.id,options);}
         catch(error){const failure=new WebhookFailure(deliveryCategory(error));failure.permanent=error.status===410||error.status===413;throw failure;}
       }});

package/worker/mcp-store.mjs

@@ -1,3 +1,4 @@
+/** mcp_kv.expires is Unix seconds for ALL rows (OAuth, webhook dedupe and streams); NULL never expires. */
 /** OAuth's KV contract on the studio's existing D1. No new Cloudflare resource. */
 export const MCP_MIGRATION_FILE = '0017_studio_mcp.sql';
 export const MCP_MIGRATION = `CREATE TABLE IF NOT EXISTS mcp_kv (key TEXT PRIMARY KEY, value TEXT NOT NULL, expires INTEGER);
@@ -6,6 +7,15 @@ CREATE TABLE IF NOT EXISTS mcp_audit (id INTEGER PRIMARY KEY AUTOINCREMENT, pers
 CREATE TABLE IF NOT EXISTS mcp_limits (caller TEXT NOT NULL, minute INTEGER NOT NULL, n INTEGER NOT NULL, PRIMARY KEY(caller, minute));
 CREATE TABLE IF NOT EXISTS tool_data (namespace TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY(namespace,key));
 `;
+/** Exclusive bound in SQLite's binary text order; null means no upper bound. */
+export function prefixEnd(prefix) {
+  const points=Array.from(prefix, c=>c.codePointAt(0));
+  while(points.length) {
+    const last=points.pop();
+    if(last<0x10ffff)return String.fromCodePoint(...points,last===0xd7ff?0xe000:last+1);
+  }
+  return null;
+}
 export function oauthStorage(DB) {
   return {
     async get(key, options) {
@@ -19,7 +29,8 @@ export function oauthStorage(DB) {
     async delete(key) { await DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind(key).run(); },
     async list({prefix = '', cursor = '', limit = 1000} = {}) {
       const n = Math.max(1,Math.min(1000,limit));
-      const rows = (await DB.prepare('SELECT key,expires FROM mcp_kv WHERE substr(key,1,?1)=?2 AND key>?3 AND (expires IS NULL OR expires>?4) ORDER BY key LIMIT ?5').bind(prefix.length,prefix,cursor,Math.floor(Date.now()/1000),n+1).all()).results;
+      const end=prefixEnd(prefix);
+      const rows = (await DB.prepare(`SELECT key,expires FROM mcp_kv WHERE key>=?1 ${end===null?'':'AND key<?2'} AND key>?3 AND (expires IS NULL OR expires>?4) ORDER BY key LIMIT ?5`).bind(prefix,end,cursor,Math.floor(Date.now()/1000),n+1).all()).results;
       return { keys: rows.slice(0,n).map(r=>({name:r.key,...(r.expires ? {expiration:r.expires}: {})})), list_complete: rows.length<=n, cursor: rows.length>n ? rows[n-1].key : '' };
     },
   };

package/worker/mcp.mjs

@@ -52,7 +52,11 @@ export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
     }
     const cat=await catalogueOf();
     const tools=[...builtins(env,cat,origin),...definitions];
-    await pushToolList(env,cat,tools,origin);
+    // Catalogue notifications update existing streams; the caller's response
+    // uses the catalogue above and does not depend on that delivery finishing.
+    const refresh=pushToolList(env,cat,tools,origin);
+    if(ctx?.waitUntil)ctx.waitUntil(refresh);
+    else await refresh;
     if(request.method==='GET'&&env.LOBBY) {
       if(!request.headers.get('accept')?.includes('text/event-stream'))return json({error:'Accept text/event-stream required'},406);
       const connection=caller.connection??'public:'+crypto.randomUUID();

package/worker/office.mjs

@@ -63,13 +63,13 @@ import { toolIdentity } from './tool-identity.mjs';
  * from an office key it is ALWAYS an ask (the AI may only propose one).
  */
 import { seatsOf } from './seats.mjs';
-import { diagnosticsOf, gatePlayers, roomLayout } from './gate.mjs';
+import { diagnosticsOf, gatePlayers, roomLayout } from './gate-routing.mjs';
 import { PUBLIC_SERVER, SERVER_LIMITS, checkServer, levelName, narrows, policyOf, roomServer, rowFor, serverView, serversOf, serverPassCookie, writeServer } from './servers.mjs';
 import { BRAIN_BUDGET, aiName, brainFor, fillSpot, passById, passCreate, passList, passRevoke, think } from './agents.mjs';
 import { DEFAULT_MODEL, NEURONS_PER_M, OWNER_MODEL, vocabularyOf } from './brain.mjs';
 import { OWNER_COOKIE, cookieValues, counter, ownerAllowed, ownerSession, today } from './stats.mjs';
 import { esc, layout, notFoundPage } from './site.mjs';
-import { confirmPage, lockedPage, officePage } from './office-page.mjs';
+
 import { CHAT_MODES, CHAT_WHO, checkChatRules, publicChat } from './chat.mjs';
 import { chatDay, chatOf, chatRowsOf, clearChatRules, dismissReport, reportsOf, writeChatRules } from './chat-store.mjs';
 import { checkRelease, performRelease, checkRefund, describeRefund, officeShopPage, ordersCsv, performRefund, shopOffice } from './shop.mjs';
@@ -142,12 +142,8 @@ export function canonical(v) {
 
 /* ------------------------------------------------------------------ player accounts (a seam) */
 
-let players = null;
-/**
- * The player-accounts API, handed over once by a studio's Worker that has it:
- * `{ get(id, env), of?(request, env), isOwner?(request, env) }` (worker/players.mjs `players` is exactly this).
- */
-export function usePlayers(api) { players = api && typeof api === 'object' ? api : null; }
+import {players} from './player-registry.mjs';
+export {usePlayers} from './player-registry.mjs';
 
 async function playerOf(env, id) {
   if (!players?.get || !id) return null;
@@ -554,7 +550,7 @@ export async function agentsTry(env, cat, body) {
     const n = Math.round(t.cost.neurons);
     if (n > 0) rows.push(counter(env, { metric: 'brain-neurons', subject: meta.id, n }));
     if (t.cost.micros >= 1) rows.push(counter(env, { metric: 'brain-microdollars', subject: meta.id, n: Math.round(t.cost.micros) }));
-    await env.DB.batch(rows.filter(Boolean)).catch(() => {});
+    await env.DB.batch(rows.filter(Boolean));
   }
   return {
     ok: true, game: meta.id, mode, model: t.model ?? (mode === 'workers-ai' ? e.HOMIE_BRAIN_MODEL || DEFAULT_MODEL : null), engine: t.engine, provider: t.provider,
@@ -1118,7 +1114,7 @@ export async function perform(env, cat, a) {
       if (a.budget !== undefined) {
         const day = await brainDay(env);
         const next = { neurons: day.budget.neurons, usd: day.budget.usd, ...(a.mode === 'workers-ai' ? { neurons: Math.round(a.budget) } : { usd: Math.round(a.budget * 100) / 100 }) };
-        await env.DB.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('brain_budget', ?1)").bind(JSON.stringify(next)).run().catch(() => {});
+        await env.DB.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('brain_budget', ?1)").bind(JSON.stringify(next)).run();
       }
       await pushPolicy(env, meta, settings, sv);
       const day = await brainDay(env);
@@ -1342,42 +1338,42 @@ export async function officeRoutes(request, env, url, { catalogueOf }) {
   if (path === '/_studio/office' || path === '/_studio/office/') {
     const cat = await catalogueOf();
     if (request.method !== 'GET') return new Response('method', { status: 405 });
-    if (!(await isOwner(request, env))) return lockedPage(cat, { what: 'office' });
+    if (!(await isOwner(request, env))) return (await import('./office-page.mjs')).lockedPage(cat, { what: 'office' });
     // A session from before 0.13.0 lives only under /_studio/: carry it to / so the owner's games know them too.
     const session = await ownerSession(request, env);
     const secure = url.protocol === 'https:' ? '; Secure' : '';
-    return officePage(cat, session ? { 'set-cookie': `${OWNER_COOKIE}=${session}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${30 * 24 * 3600}${secure}` } : {});
+    return (await import('./office-page.mjs')).officePage(cat, session ? { 'set-cookie': `${OWNER_COOKIE}=${session}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${30 * 24 * 3600}${secure}` } : {});
   }
   if (path === '/_studio/office/shop' || path === '/_studio/office/shop/') {
     const cat = await catalogueOf();
     if (request.method !== 'GET') return new Response('method', { status: 405 });
-    if (!(await isOwner(request, env))) return lockedPage(cat, { what: 'office' });
+    if (!(await isOwner(request, env))) return (await import('./office-page.mjs')).lockedPage(cat, { what: 'office' });
     return officeShopPage(cat);
   }
   const confirm = /^\/_studio\/confirm\/(ask_[a-f0-9]{16})\/?$/.exec(path);
   if (confirm) {
     const cat = await catalogueOf();
-    if (!(await isOwner(request, env))) return lockedPage(cat, { what: 'confirm', ask: confirm[1] });
+    if (!(await isOwner(request, env))) return (await import('./office-page.mjs')).lockedPage(cat, { what: 'confirm', ask: confirm[1] });
     const row = await readAsk(env, confirm[1]);
-    if (!row) return confirmPage(cat, null, { missing: true });
+    if (!row) return (await import('./office-page.mjs')).confirmPage(cat, null, { missing: true });
     const ask = askView(row, cat, url.origin);
-    if (request.method === 'GET') return confirmPage(cat, ask);
+    if (request.method === 'GET') return (await import('./office-page.mjs')).confirmPage(cat, ask);
     if (request.method !== 'POST' || !sameOrigin(request, url)) return new Response('Not allowed', { status: 403 });
     let yes = false;
     try { yes = String((await request.formData()).get('do') ?? '') === 'yes'; } catch { yes = false; }
-    if (ask.state !== 'pending') return confirmPage(cat, ask);
+    if (ask.state !== 'pending') return (await import('./office-page.mjs')).confirmPage(cat, ask);
     if (!yes) {
       await env.DB.prepare("UPDATE office_asks SET state = 'cancelled' WHERE id = ?1 AND state = 'pending'").bind(ask.id).run();
-      return confirmPage(cat, { ...ask, state: 'cancelled' });
+      return (await import('./office-page.mjs')).confirmPage(cat, { ...ask, state: 'cancelled' });
     }
     // Claim it first, so a double tap does it once.
     await env.DB.prepare("UPDATE office_asks SET state = 'working' WHERE id = ?1 AND state = 'pending'").bind(ask.id).run();
     const claimed = await readAsk(env, ask.id);
-    if (claimed?.state !== 'working') return confirmPage(cat, askView(claimed ?? row, cat, url.origin));
+    if (claimed?.state !== 'working') return (await import('./office-page.mjs')).confirmPage(cat, askView(claimed ?? row, cat, url.origin));
     if (ask.action.op === 'shop-release') ask.action.by = await releaseIdentity(request, env);
     const result = await perform(env, cat, ask.action);
     await env.DB.prepare('UPDATE office_asks SET state = ?2, result = ?3 WHERE id = ?1').bind(ask.id, result.ok ? 'done' : 'failed', JSON.stringify(result).slice(0, 4000)).run();
-    return confirmPage(cat, { ...ask, state: result.ok ? 'done' : 'failed', result });
+    return (await import('./office-page.mjs')).confirmPage(cat, { ...ask, state: result.ok ? 'done' : 'failed', result });
   }
   return null;
 }

package/worker/operational-schema.mjs

@@ -28,3 +28,17 @@ ${['INSERT','UPDATE','DELETE'].map(op=>{const row=op==='DELETE'?'OLD':'NEW';retu
  ${op==='UPDATE'?`INSERT INTO tool_data_revisions SELECT OLD.namespace,1 WHERE OLD.namespace!=NEW.namespace ON CONFLICT(namespace) DO UPDATE SET revision=revision+1;`:''}
 END;`;}).join('\n')}
 `;
+
+export const RUNTIME_INDEX_MIGRATION_FILE='0034_runtime_indexes.sql';
+export const RUNTIME_INDEX_MIGRATION=`-- Older stream registrations used milliseconds; OAuth and dedupe already use seconds.
+UPDATE mcp_kv SET expires=CAST(expires / 1000 AS INTEGER) WHERE expires>100000000000 AND (key GLOB 'tools-stream:*' OR key GLOB 'mcp-event-stream:*');
+CREATE INDEX IF NOT EXISTS mcp_kv_expires ON mcp_kv(expires) WHERE expires IS NOT NULL;
+`;
+
+export const EXTRA_RUNTIME_MIGRATIONS={
+  "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;
+CREATE INDEX IF NOT EXISTS shop_events_at ON shop_events(at);
+`,
+};

package/worker/page-policy.mjs

@@ -0,0 +1,29 @@
+import {STUDIO_VERSION_TAG} from './version.mjs';
+import {playerAncestors} from './embed.mjs';
+export function shellKey(g) {
+  // Never what names a build (the rules' build and state hashes, the bundle's version): those change with every
+  // edit, and a newer build of the same game inside the same page is exactly what the frame's own reload is for.
+  const { build: _build, stateHash: _state, ...room } = g?.room ?? {};
+  const { version: _version, ...netplay } = g?.netplay ?? {};
+  const text = JSON.stringify([g?.kind ?? null, g?.players ?? null, room, g?.saves ?? null, g?.agents ?? null, g?.screen ?? null, netplay, g?.launch ?? null]);
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i += 1) { h ^= text.charCodeAt(i); h = Math.imul(h, 16777619); }
+  return `${STUDIO_VERSION_TAG}-${(h >>> 0).toString(36)}`;
+}
+export function shellStandIn(room, key) {
+  const message = key ? { t: 'homie-net', what: 'shell', key } : { t: 'homie-net', what: 'rematch', room };
+  return `<!doctype html><meta charset="utf-8"><title>Updating</title><body style="margin:0;background:#0b0d14;color:#cfd6e6;font:15px system-ui;display:grid;place-items:center;height:100vh"><p>This game was updated. Loading it again…</p><script>try{parent.postMessage(${JSON.stringify(message).replace(/</g, '\\u003c')},'*');}catch(e){}</script>`;
+}
+export const ROOM_ID = /^[A-Za-z0-9_-]{1,32}$/;
+export function frameAncestors(cat) {
+  const extra = (Array.isArray(cat?.studio?.site?.frameAncestors) ? cat.studio.site.frameAncestors : [])
+    .map((o) => { try { const u = new URL(String(o)); return u.protocol === 'https:' && u.origin === String(o).replace(/\/+$/, '') ? u.origin : null; } catch { return null; } })
+    .filter(Boolean).slice(0, 8);
+  return ["'self'", ...extra].join(' ');
+}
+export function embedAncestors(cat, origin, preview = false) {
+  const normal = playerAncestors(cat);
+  if (!preview || !/^http:\/\/(?:localhost|127\.0\.0\.1)(?::\d+)?$/.test(origin)) return normal;
+  const port = new URL(origin).port;
+  return `${normal === "'none'" ? '' : normal} http://localhost${port ? ':' + port : ''} http://127.0.0.1${port ? ':' + port : ''}`.trim();
+}