@homie-rocks/studio 0.54.0 → 0.56.0

package/worker/lazy-objects.mjs

@@ -0,0 +1,43 @@
+/** 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);}
+  async webSocketMessage(...args) {await this.ready;return this.gate.webSocketMessage(...args);}
+  async webSocketClose(...args) {await this.ready;return this.gate.webSocketClose(...args);}
+  async webSocketError(...args) {await this.ready;return this.gate.webSocketError(...args);}
+}
+export class Concentrator extends Gate {}
+
+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-peak.mjs

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

package/worker/lobby-shards.mjs

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

package/worker/lobby-store.mjs

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

package/worker/lobby-summary.mjs

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

package/worker/lobby.mjs

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

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

package/worker/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') {