@homie-rocks/studio 0.54.0 → 0.56.0

package/rules/host.ts

@@ -87,6 +87,8 @@ export interface HostOptions {
   restoreEpoch?: number;
   startDelayMs?: number;
   onTick?(): void;
+  /** Suspend settled round breaks; the owner persists and wakes this deadline. */
+  onRoundIdle?(until: number): void;
   /** Only the shared server isolate can attribute timer lateness to another tick. */
   enforceOverrun?: boolean;
   log?(line: Record<string, unknown>): void;
@@ -111,6 +113,8 @@ export interface Host {
   readonly epoch: number;
   readonly running: boolean;
   readonly paused: boolean;
+  readonly roundIdleUntil: number | null;
+  wakeRound(): void;
   readonly people: number;
   readonly viewRadiusM: number | null;
   readonly privateDelivery: boolean;
@@ -199,13 +203,14 @@ export function createHost(o: HostOptions): Host {
   // A log that throws takes nothing down with it.
   const log = (line: Record<string, unknown>): void => { try { o.log?.(line); } catch { /* nothing to say it with */ } };
   const random = o.random ?? Math.random;
-  const saved = o.restore ? fromBytes(o.restore) as { v: number; characters?: CharacterLease[]; core: SavedCore; names: [number, string][]; agents?: AgentsSaved; guideViews?: [number, { id: string; at: number; value: Record<string, unknown> }][]; queues: [number, Record<string, unknown>, StepInput['claim'], number, number][]; inputs?: [number, SeatIn][] } : null;
+  const saved = o.restore ? fromBytes(o.restore) as { v: number; roundIdleUntil?: number; characters?: CharacterLease[]; core: SavedCore; names: [number, string][]; agents?: AgentsSaved; guideViews?: [number, { id: string; at: number; value: Record<string, unknown> }][]; queues: [number, Record<string, unknown>, StepInput['claim'], number, number][]; inputs?: [number, SeatIn][] } : null;
   if (o.restore && (!saved || typeof saved !== 'object' || Array.isArray(saved))) throw new Error('saved host is not an object');
   if (saved) {
     const check = (ok: unknown): void => { if (!ok) throw new Error('saved host inputs are invalid'); };
     const uint = (n: unknown): boolean => Number.isSafeInteger(n) && (n as number) >= 0;
-    check(Object.keys(saved).every(k => ['v', 'core', 'names', 'agents', 'guideViews', 'queues', 'inputs', 'characters'].includes(k)));
+    check(Object.keys(saved).every(k => ['v', 'core', 'names', 'agents', 'guideViews', 'queues', 'inputs', 'characters', 'roundIdleUntil'].includes(k)));
     check(saved.core && Array.isArray(saved.names) && Array.isArray(saved.queues));
+    if (saved.roundIdleUntil !== undefined) check(Number.isFinite(saved.roundIdleUntil) && saved.roundIdleUntil >= 0 && saved.core.round[1] === 0 && !saved.core.overAt);
     if (saved.characters !== undefined) {
       check(c.settings.characters && Array.isArray(saved.characters));
       check(new Set(saved.characters.map(c => c.account)).size === saved.characters.length);
@@ -396,6 +401,7 @@ export function createHost(o: HostOptions): Host {
       core.goal(b.seat, g?.state === 'active' ? { goal: g.goal, args: g.args, from: g.from, at: Math.round(g.at / period), asked: g.asked === true } : null);
     }
   }
+  let roundIdleUntil: number | null = o.onRoundIdle && Number.isFinite(saved?.roundIdleUntil) ? saved!.roundIdleUntil! : null;
   let running = false;
   let paused = Boolean(saved && (o.startPaused ?? o.restoreEpoch !== undefined));
   let ended = false;
@@ -594,7 +600,7 @@ export function createHost(o: HostOptions): Host {
           core.seatLeave(held.seat);
           tick(o.clock.now());
         } else core.seatAway(m.seat as number, true);
-        if (running && people() === 0) pause();
+        if ((running || roundIdleUntil !== null) && people() === 0) pause();
         return;
       }
       case 'free': {
@@ -832,7 +838,17 @@ export function createHost(o: HostOptions): Host {
     }
     timing.record('tick', tickAt);
     if (ended) return;
-    if (!faulted && core.stats.ticksCut === cut) { failingSince = null; return; }
+    if (!faulted && core.stats.ticksCut === cut) {
+      failingSince = null;
+      const round = core.round();
+      if (o.onRoundIdle && running && round.phase === 'over' && round.results && round.endsAt > core.tick) {
+        roundIdleUntil = now + (round.endsAt - core.tick) * period;
+        running = false; disarm();
+        try { o.store?.save(save()); o.onRoundIdle(roundIdleUntil); }
+        catch (error) { fault('round-idle', error); stop(); o.onEnd?.('storage-or-tick-failed', { tick: core.tick }); }
+      }
+      return;
+    }
     if (failingSince === null) failingSince = now;
     if (now - failingSince < FAIL_MS) return;
     if (faulted) end('fault', { error: stats.lastFault, faults: stats.faults });
@@ -913,7 +929,7 @@ export function createHost(o: HostOptions): Host {
   const self = { blame: (): void => { blamed = true; } };
 
   function start(): void {
-    if (running || ended) return;
+    if (running || ended || roundIdleUntil !== null) return;
     running = true; paused = false;
     try {
       base = { ms: o.clock.now() + (firstTick ? o.startDelayMs ?? 0 : 0), tick: core.tick };
@@ -926,26 +942,37 @@ export function createHost(o: HostOptions): Host {
     } catch (error) { fault('start', error); } finally { keepTime(); }
   }
   function pause(): void {
-    if (!running) return;
+    if (!running) {
+      if (roundIdleUntil !== null && !paused) { paused = true; checkpoint(true); o.onPause?.(); }
+      return;
+    }
     running = false; paused = true;
     // A pending timer would keep the object in memory and billed: the pause clears it.
     disarm();
     log({ ev: 'host-pause', game: o.game, tick: core.tick });
     try { checkpoint(true); o.onPause?.(); } catch (error) { fault('onPause', error); if (persistent) { stop(); o.onEnd?.('storage-or-tick-failed', { tick: core.tick }); } }
   }
-  function resume(): void {
-    if (running || ended || !paused) return;
+  function resume(announceRound = true): void {
+    if (running || ended || !paused || roundIdleUntil !== null) return;
     running = true; paused = false;
     try {
       // The room resumes at the tick it paused on: no tick is skipped and no timer fires for the gap.
       base = { ms: o.clock.now() + (firstTick ? o.startDelayMs ?? 0 : 0), tick: core.tick };
       overSince = null; blamed = false; failingSince = null; lastStart = base.ms;
-      handle([core.round()], base.ms);
+      if (announceRound) handle([core.round()], base.ms);
       for (const q of queues.values()) q.lastFrameTick = core.tick;
       log({ ev: 'host-resume', game: o.game, tick: core.tick });
       o.onResume?.();
     } catch (error) { fault('resume', error); } finally { keepTime(); }
   }
+  function wakeRound(): void {
+    if (roundIdleUntil === null || o.clock.now() < roundIdleUntil || ended) return;
+    if (!core.resumeRound()) throw new Error('Round is not settled');
+    roundIdleUntil = null;
+    handle(core.drain(), o.clock.now());
+    if (people() > 0) { paused = true; resume(false); }
+    else { paused = true; checkpoint(true); }
+  }
   /** What a relay keeps for whoever joins next, said again: the round with its results, the roster, the shared state, the capabilities. */
   function announce(): void {
     if (ended) return;
@@ -975,7 +1002,7 @@ export function createHost(o: HostOptions): Host {
 
   function save(): Uint8Array {
     const reserved = new Set(core.bodies().filter(b => b.owner === 'reserved').map(b => b.seat));
-    return toBytes({ v: 1, ...(characters.size ? { characters: [...characters.values()] } : {}), core: core.save(), guideViews: [...guideViews], ...(agents ? { agents: agents.save() } : savedAgents ? { agents: savedAgents } : {}), names: [...names].filter(([seat]) => !reserved.has(seat)), queues: [...queues].map(([seat, q]) => [seat, q.held, q.claim, q.newest, q.ack]), inputs: [...queues] });
+    return toBytes({ v: 1, ...(roundIdleUntil !== null ? { roundIdleUntil } : {}), ...(characters.size ? { characters: [...characters.values()] } : {}), core: core.save(), guideViews: [...guideViews], ...(agents ? { agents: agents.save() } : savedAgents ? { agents: savedAgents } : {}), names: [...names].filter(([seat]) => !reserved.has(seat)), queues: [...queues].map(([seat, q]) => [seat, q.held, q.claim, q.newest, q.ack]), inputs: [...queues] });
   }
   function checkpoint(force = false): void {
     if (persistent) {
@@ -1022,7 +1049,7 @@ export function createHost(o: HostOptions): Host {
       held.character = core.character(held.seat) ?? held.character; held.returning = true;
       present.delete(held.seat); queues.delete(held.seat); names.delete(held.seat);
       if (held.seat >= 0) core.seatLeave(held.seat); tick(o.clock.now());
-      if (running && people() === 0) pause();
+      if ((running || roundIdleUntil !== null) && people() === 0) pause();
     },
     characterReturned(account, lease) { if (characters.get(account)?.returning && characters.get(account)?.lease === lease) characters.delete(account); },
     get viewSettings() { return c.settings.view; },
@@ -1032,6 +1059,8 @@ export function createHost(o: HostOptions): Host {
     get epoch() { return epoch; },
     get running() { return running; },
     get paused() { return paused; },
+    get roundIdleUntil() { return roundIdleUntil; },
+    wakeRound,
     get people() { return people(); },
     frame, start, pause, resume, announce,
     // An orderly stop of a lasting world folds what moved since the last checkpoint. One that follows a failed write, or arrives during one, writes nothing.

package/rules/view.ts

@@ -941,6 +941,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   net.on('snapshot', onSnapshot);
   net.on('role', (e) => { if (e.snap) onSnapshot(e.snap); if (net.offline && !net.rulesHosting) setStatus(net.closedWhy ? 'closed' : 'offline'); });
   net.on('link', (e) => {
+    if (e.why === 'subscribe') return;
     if (e.state === 'online') { returningUntil = clock() + 3000; base = null; if (status !== 'playing') setStatus('connecting'); } else if (e.state === 'closed') setStatus('closed'); else if (e.state === 'alone' || e.state === 'offline') setStatus('offline');
   });
   net.on('round', (r) => { if (r.results) { results = r.results; if (round) { round = { ...round, results }; emit('round', roundNow()); } } });

package/tools/TOOLS.md

@@ -53,7 +53,12 @@ Workers AI requires the studio's own binding and owner authority, or an explicit
 never exposes the environment or raw credentials. A named secret capability in
 `studio.json` (`mcp.secrets.NAME: { origin, header, prefix, tools }`) lets an owner tool
 make an HTTPS request to one declared origin; `tools` can explicitly delegate this capability to named staff tools; redirects and credential echoes are
-refused. The studio’s AI can generate an integration secret and place it in Cloudflare and the sender through their authorized APIs. Never ask the person to find or paste a key, and never put a secret in source files.
+refused. Use `origin: 'self'` for the studio's own API: the capability resolves to
+ the current Worker request origin (or the configured studio origin for scheduled
+ functions), so a workers.dev address need not be known at build time. Calls may
+ use a relative URL such as `ctx.fetchWithSecret('API_TOKEN', '/api/sync')`.
+ HTTPS is still required; credentials in URLs and cross-origin targets are refused.
+ The studio’s AI can generate an integration secret and place it in Cloudflare and the sender through their authorized APIs. Never ask the person to find or paste a key, and never put a secret in source files.
 
 Studio handlers and imported parts are trusted Worker code, not sandboxed plugins.
 Review shared code before adding it: JavaScript wrappers cannot confine malicious

package/worker/analytics.mjs

@@ -0,0 +1,84 @@
+/** Page counters are sampled analytics, never billing or gameplay state.
+ * D1 retains historical totals. Each rollup adds only the delta from the last
+ * observed total, in the same transaction as its watermark, so retries are safe.
+ */
+export const PAGE_METRICS = new Set(['visit', 'play', 'screen', 'watch']);
+export function writePageMetric(env, row) {
+  if (!env.STUDIO_ANALYTICS || !env.STUDIO_ANALYTICS_DATASET || !PAGE_METRICS.has(row.metric)) return false;
+  const day = row.day ?? new Date().toISOString().slice(0, 10);
+  try { env.STUDIO_ANALYTICS.writeDataPoint({
+    indexes: [String(row.subject ?? '').slice(0, 80) || 'studio'],
+    blobs: [day, row.metric, String(row.subject ?? '').slice(0, 80), String(row.source ?? '').slice(0, 80)],
+    doubles: [Math.max(0, Math.floor(Number(row.n ?? 1) || 0))],
+  }); } catch (error) {
+    // Analytics is sampled telemetry. A binding failure must not fail a page or
+    // amplify the outage into a D1 write on every visit.
+    console.warn('Studio analytics point dropped:', error.message);
+  }
+  return true;
+}
+async function* analyticsPages(env,{now=Date.now(),pageSize=1000}={}) {
+  if (!env.ANALYTICS_SQL || !env.STUDIO_ANALYTICS_DATASET) return;
+  const dataset=String(env.STUDIO_ANALYTICS_DATASET);
+  if(!/^[a-z0-9_-]+$/.test(dataset))throw new Error('Invalid studio analytics dataset');
+  // Revisit each UTC day for late ingestion and sample corrections. Ordered
+  // pages avoid the aggregate 50k result ceiling, including a busy single day.
+  for(let ago=7;ago>=0;ago--) {
+    const day=new Date(now-ago*86400000).toISOString().slice(0,10);
+    for(let offset=0;;offset+=pageSize) {
+      const result=await env.ANALYTICS_SQL.query({
+        query:`SELECT blob1 AS day, blob2 AS metric, blob3 AS subject, blob4 AS source, SUM(_sample_interval * double1) AS n
+          FROM events.analyticsEngine."${dataset}" WHERE timestamp >= $start AND blob1 = $day
+          GROUP BY blob1, blob2, blob3, blob4 ORDER BY blob1, blob2, blob3, blob4 LIMIT ${pageSize} OFFSET $offset`,
+        params:{start:day+'T00:00:00Z',day,offset},
+      });
+      if(!Array.isArray(result.data))throw new Error('Incomplete studio analytics rollup');
+      yield result.data.filter(r=>/^\d{4}-\d{2}-\d{2}$/.test(r.day)&&PAGE_METRICS.has(r.metric)&&Number.isFinite(Number(r.n)));
+      if(result.data.length<pageSize)break;
+    }
+  }
+}
+export async function analyticsTotals(env,now=Date.now()) {
+  const rows=[];for await(const page of analyticsPages(env,{now}))rows.push(...page);return rows;
+}
+export async function analyticsStatus(env,now=Date.now()) {
+  const rows=(await env.DB.prepare("SELECT key,value FROM meta WHERE key IN ('analytics-rollup-error','analytics-rollup-success')").all()).results??[];
+  const values=Object.fromEntries(rows.map(r=>[r.key,r.value]));
+  const error=values['analytics-rollup-error'];
+  return {lastSuccess:Number(values['analytics-rollup-success'])||null,delayed:Boolean(error)||now-Number(values['analytics-rollup-success']??0)>7200000,error:error||null};
+}
+async function health(env,key,value) {
+  await env.DB.prepare('INSERT INTO meta(key,value) VALUES(?1,?2) ON CONFLICT(key) DO UPDATE SET value=excluded.value WHERE value!=excluded.value').bind(key,String(value)).run();
+}
+export async function rollupAnalytics(env,options={}) {
+  if(!env.DB||!env.ANALYTICS_SQL)return;
+  try {
+    for await(const rows of analyticsPages(env,options)) {
+      for(let offset=0;offset<rows.length;offset+=40) {
+        const statements=rows.slice(offset,offset+40).flatMap(r=>{
+          const args=[r.day,r.metric,r.subject,r.source,Math.round(Number(r.n))];
+          return [
+            env.DB.prepare(`INSERT INTO stats_daily(day,metric,subject,source,n)
+              SELECT ?1,?2,?3,?4,?5-COALESCE((SELECT n FROM stats_analytics_daily WHERE day=?1 AND metric=?2 AND subject=?3 AND source=?4),0)
+              WHERE NOT EXISTS(SELECT 1 FROM stats_analytics_daily WHERE day=?1 AND metric=?2 AND subject=?3 AND source=?4 AND n=?5)
+              ON CONFLICT(day,metric,subject,source) DO UPDATE SET n=stats_daily.n+excluded.n`).bind(...args),
+            env.DB.prepare(`INSERT INTO stats_analytics_daily(day,metric,subject,source,n) VALUES(?1,?2,?3,?4,?5)
+              ON CONFLICT(day,metric,subject,source) DO UPDATE SET n=excluded.n WHERE n!=excluded.n`).bind(...args),
+          ];
+        });
+        if(statements.length)await env.DB.batch(statements);
+      }
+    }
+    await health(env,'analytics-rollup-error','');
+    await health(env,'analytics-rollup-success',options.now??Date.now());
+    return {delayed:false};
+  } catch(error) {
+    console.error('Studio analytics counts delayed:',error.message);
+    await health(env,'analytics-rollup-error',String(error.message).slice(0,500));
+    return {delayed:true,error:error.message};
+  }
+}
+
+export const ANALYTICS_MIGRATION_FILE="0037_owner_analytics.sql";
+export const ANALYTICS_MIGRATION=`CREATE TABLE IF NOT EXISTS stats_analytics_daily(day TEXT NOT NULL,metric TEXT NOT NULL,subject TEXT NOT NULL,source TEXT NOT NULL,n INTEGER NOT NULL,PRIMARY KEY(day,metric,subject,source)) WITHOUT ROWID;
+`;

package/worker/app-frame.mjs

@@ -1,7 +1,7 @@
 /** Opaque frames retain their isolation. Unavailable Web Storage falls back to frame-local memory. */
 export const APP_STORAGE_JS=String.raw`(()=>{
  for(const name of ['localStorage','sessionStorage']) {
-  try {const storage=window[name];const probe='homie-storage-probe';storage.setItem(probe,'1');storage.removeItem(probe);continue;}catch{}
+  try {const storage=window[name];const probe='homie-storage-probe';storage.setItem(probe,'1');storage.removeItem(probe);continue;}catch{/* A blocked storage probe falls through to the in-memory shim. */}
   const data=new Map();const methods={getItem:k=>data.get(String(k))??null,setItem:(k,v)=>{data.set(String(k),String(v));},removeItem:k=>{data.delete(String(k));},clear:()=>data.clear(),key:i=>[...data.keys()][Number(i)]??null};
   const storage=new Proxy(methods,{get:(target,key)=>key==='length'?data.size:key in target?target[key]:data.get(String(key)),set:(_,key,value)=>{data.set(String(key),String(value));return true;},deleteProperty:(_,key)=>data.delete(String(key)),ownKeys:()=>[...data.keys()],getOwnPropertyDescriptor:()=>({enumerable:true,configurable:true})});
   Object.defineProperty(window,name,{value:storage,configurable:true});

package/worker/app-graphics.mjs

@@ -1,6 +1,6 @@
 export function appGraphicsFallback(text='This device cannot display the 3D scene. Use the text controls to continue.') {
  if(!document.querySelector('canvas')||document.querySelector('[data-webgl-fallback]'))return;
- try{const c=document.createElement('canvas');if(c.getContext('webgl2'))return;}catch{}
+ try{const c=document.createElement('canvas');if(c.getContext('webgl2'))return;}catch{/* Context creation can throw when graphics are unavailable; show the fallback. */}
  const p=document.createElement('p');p.dataset.webglFallback='';p.setAttribute('role','status');p.textContent=text;
  p.style.cssText='position:static;pointer-events:none;padding:12px;background:#fff;color:#222;font:16px system-ui;border-radius:12px';
  const canvas=document.querySelector('canvas');

package/worker/app-streams.mjs

@@ -10,11 +10,11 @@ ${['INSERT','UPDATE','DELETE'].map(op=>{const row=op==='DELETE'?'OLD':'NEW';retu
 END;`;}).join('\n')}
 `;
 const frame=value=>new TextEncoder().encode('data: '+JSON.stringify(value)+'\n\n');
-export const appHub=(env,app)=>env.LOBBY.get(env.LOBBY.idFromName('@app-records/'+app));
+export const appHub=(env,app)=>{const ns=env.APP_RECORDS??env.LOBBY;return ns.get(ns.idFromName('@app-records/'+app));};
 const pushedRevisions=new WeakMap();
 export async function pushAppRecords(env,cat){
  const apps=(cat.games??[]).filter(g=>g.kind==='app');
- if(!env.LOBBY||!env.DB||!apps.length)return;
+ if(!(env.APP_RECORDS??env.LOBBY)||!env.DB||!apps.length)return;
  const rows=(await env.DB.prepare(`SELECT app,collection,revision FROM app_record_revisions
  UNION ALL SELECT a.app,'*',SUM(COALESCE(r.revision,0)) FROM app_tool_namespaces a LEFT JOIN tool_data_revisions r ON r.namespace=a.namespace GROUP BY a.app`).all()).results;
  const signatures=new Map();for(const row of rows){const app=row.app.split(':check:')[0];signatures.set(app,(signatures.get(app)??'')+JSON.stringify(row));}
@@ -32,7 +32,7 @@ export async function pushAppRecords(env,cat){
 export class AppRecordStreams {
  constructor(env,ctx){this.env=env;this.ctx=ctx;this.streams=new Set();}
  dispose(){for(const s of [...this.streams])this.close(s);}
- close(s){if(!this.streams.delete(s))return;clearInterval(s.timer);clearTimeout(s.reconnect);try{s.controller.close();}catch{}this.presence();}
+ close(s){if(!this.streams.delete(s))return;clearInterval(s.timer);clearTimeout(s.reconnect);try{s.controller.close();}catch{/* The reader already cancelled or the stream already closed. */}this.presence();}
  count(s){return [...this.streams].filter(x=>x.app===s.app&&x.room===s.room).length;}
  send(s,data){if(s.controller.desiredSize<=0){this.close(s);return;}try{s.controller.enqueue(frame(data));}catch{this.close(s);}}
  presence(){for(const s of this.streams)this.send(s,{presence:this.count(s)});}

package/worker/asset-paths.mjs

@@ -0,0 +1,2 @@
+export const GAME_FILES = /^\/[a-z0-9][a-z0-9-]{0,39}\/(?:__game|__assets)(?:\/|$)/;
+export const PART_FILES = /^\/parts\/[a-z0-9][a-z0-9-]{0,47}\/\d{1,6}\.\d{1,6}\.\d{1,6}[^/]*\//;

package/worker/background-queue.mjs

@@ -0,0 +1,31 @@
+import {catalogue} from './catalogue.mjs';
+/** Durable rows remain the source of truth. Messages carry wakeups, never records. */
+export async function enqueueChanges(env, origin) {
+  if(env.BACKGROUND) {
+    try {return await env.BACKGROUND.send({v:1,type:'studio.changed',origin});}
+    catch(error) {console.warn('Background queue unavailable; delivering inline:',error.message);}
+  }
+  // Older wrappers and local unit fixtures without the binding keep their behavior.
+  return (await import('./functions.mjs')).runFunctions(env,()=>catalogue(env,origin),origin);
+}
+export async function consumeBackground(batch, env) {
+  const changes=batch.messages.filter(m=>m.body?.v===1&&m.body.type==='studio.changed');
+  if(changes.length) {
+    try {
+      const origin=changes[0].body.origin;
+      await (await import('./functions.mjs')).runFunctions(env,()=>catalogue(env,origin),origin);
+      for(const message of changes)message.ack();
+    } catch(error) {
+      console.error('Background delivery failed',error);
+      for(const message of changes)message.retry({delaySeconds:30});
+    }
+  }
+  for(const message of batch.messages)if(!changes.includes(message)) {
+    try {
+      if(message.body?.v===1&&message.body.type==='lobby.snapshot'){await (await import('./lobby-summary.mjs')).storeLobbySummary(env,message.body);message.ack();continue;}
+      if(message.body?.v!==1||message.body.type!=='stripe.event')throw new Error('Unknown background message type');
+      await (await import('./stripe-intake.mjs')).reconcileStripeEvent(env,message.body.id,await catalogue(env));
+      message.ack();
+    } catch(error) {console.error('Background queue delivery failed',error);message.retry({delaySeconds:error.retryAfterSeconds??30});}
+  }
+}

package/worker/build-id.mjs

@@ -1,2 +1,2 @@
 // Generated by lib/build-identity.mjs; identifies the bundled runtime sources.
-export const STUDIO_BUILD = Object.freeze({"version":"0.54.0","sha256":"4f65918ccb0f52120d8d0fa6cf761f2243b4636fdf10ccef395479318d603370"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.56.0","sha256":"9b000afecb22ce5781d6499a02f44ffcc255c61907e9f7d469dd63d0bd9f35d1"});

package/worker/built-metadata.mjs

@@ -0,0 +1,2 @@
+// Replaced with this build’s immutable metadata by lib/worker-build.mjs.
+export default null;

package/worker/catalogue.mjs

@@ -0,0 +1,18 @@
+const cache = new WeakMap();
+/** Cache completed immutable data only. Never share pending I/O across requests. */
+export async function catalogue(env, origin = 'https://studio.invalid') {
+  const baked = (await import('./built-metadata.mjs')).default;
+  if (baked) return baked.catalogue;
+  const hit = cache.get(env.ASSETS);
+  if (hit?.origin === origin && env.HOMIE_PREVIEW !== '1' && env.HOMIE_DEV !== '1') return hit.value;
+  const response = await env.ASSETS.fetch(new Request(`${origin}/games.json`));
+  if (!response.ok) return {studio: {name: env.STUDIO_NAME || 'Studio'}, games: []};
+  const tag=response.headers.get('etag');
+  if(tag&&hit?.origin===origin&&hit.tag===tag){await response.body?.cancel();return hit.value;}
+  const value = await response.json();
+  cache.set(env.ASSETS, {origin, value, tag});
+  return value;
+}
+export async function builtPosts() {
+  return (await import('./built-metadata.mjs')).default?.posts;
+}

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/custom-routes.mjs

@@ -0,0 +1,16 @@
+/** Studio configuration only: register once at module evaluation, never per request. */
+let handler = null;
+export function useRoutes(routes) {
+  if (routes !== null && typeof routes !== 'function') throw new TypeError('useRoutes expects a function or null');
+  handler = routes;
+}
+export async function customRoute(request, env, ctx) {
+  const response = await handler?.(request, env, ctx);
+  if (response == null) return null;
+  if (!(response instanceof Response)) throw new TypeError('A custom route must return a Response, null, or undefined');
+  if (response.status === 101 || response.webSocket) return response;
+  const headers = new Headers(response.headers);
+  headers.set('x-content-type-options', 'nosniff');
+  if (!headers.has('referrer-policy')) headers.set('referrer-policy', 'strict-origin-when-cross-origin');
+  return new Response(response.body, {status:response.status,statusText:response.statusText,headers});
+}

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

@@ -50,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');
@@ -70,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();
@@ -82,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};
@@ -92,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);
@@ -100,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;
@@ -113,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;
@@ -155,9 +157,19 @@ export async function pushToolList(env,cat,tools,origin) {
   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`)); }