@homie-rocks/studio 0.44.1 → 0.45.0

package/worker/gate.mjs

@@ -0,0 +1,151 @@
+/** Trusted, ordered multiplex links. Public authentication stays at the Worker;
+ * only bindings can open these endpoints. A lost link closes its downstream
+ * sockets: clients resume with their existing seat tokens and a fresh keyframe.
+ * Inputs and commands are batched together, never overwritten or reordered.
+ */
+export function roomLayout(seats) {
+  const gates = Math.ceil(seats / 64);
+  return { gates, concentrators: gates > 8 ? Math.ceil(gates / 8) : 0 };
+}
+export function gateFor(env, game, room, seats, key) {
+  const layout = roomLayout(seats);
+  // 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.
+  if (layout.gates === 1) return env.TABLE.get(env.TABLE.idFromName(`${game}/${room}`));
+  let hash = 2166136261;
+  for (const c of key || crypto.randomUUID()) hash = Math.imul(hash ^ c.charCodeAt(0), 16777619) >>> 0;
+  const index = hash % layout.gates;
+  return { fetch(request) {
+    const url = new URL(request.url);
+    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* expandBatch(rows) {
+  for (const row of rows) {
+    if (row[0] === 'fan') { for (const id of row[1]) yield ['data', id, row[2]]; }
+    else yield row;
+  }
+}
+export function batchLink(socket, { setTimer = setTimeout, clearTimer = clearTimeout, delay = 5 } = {}) {
+  let queue = [], timer = null, closed = false;
+  const flush = () => {
+    timer = null;
+    if (closed || !queue.length) return;
+    const rows = []; let last = null;
+    for (const row of queue) {
+      if (row[0] === 'data' && last && (last[0] === 'data' || last[0] === 'fan') && last[2] === row[2]) {
+        if (last[0] === 'data') { last[0] = 'fan'; last[1] = [last[1]]; }
+        last[1].push(row[1]);
+      } else { last = row.slice(); rows.push(last); }
+    }
+    queue = [];
+    try { socket.send(JSON.stringify(rows)); } catch { close(); try { socket.close(1011, 'room link send failed'); } catch {} }
+  };
+  const close = () => { closed = true; queue = []; if (timer !== null) clearTimer(timer); timer = null; };
+  return { send(row) { if (closed) return; queue.push(row); if (queue.length >= 128) { if (timer !== null) clearTimer(timer); flush(); } else if (timer === null) timer = setTimer(flush, delay); }, flush, close, disconnect() { close(); socket.close(1012, 'room link restarted'); } };
+}
+
+/** Adapt one upstream socket into the same transport the Table accepts locally. */
+export function multiplexSession(socket, connect) {
+  const out = batchLink(socket), clients = new Map();
+  let chain = Promise.resolve(), closed = false;
+  const shutdown = () => {
+    if (closed) return;
+    closed = true; out.close();
+    for (const client of clients.values()) client.emit('close', {});
+    clients.clear();
+  };
+  socket.addEventListener('message', event => {
+    chain = chain.then(async () => {
+      if (closed) return;
+      const rows = JSON.parse(event.data);
+      if (!Array.isArray(rows)) throw new Error('invalid multiplex batch');
+      for (const [op, id, value, ip, agent] of expandBatch(rows)) {
+        if (op === 'open') {
+          if (clients.has(id)) throw new Error('duplicate multiplex client');
+          const handlers = new Map();
+          const client = {
+            accept() {},
+            addEventListener(name, fn) { const list = handlers.get(name) ?? []; list.push(fn); handlers.set(name, list); },
+            emit(name, event) { for (const fn of handlers.get(name) ?? []) fn(event); },
+            send(text) { out.send(['data', id, text]); },
+            close(code, reason) { out.send(['close', id, code, reason]); clients.delete(id); client.emit('close', {}); },
+          };
+          clients.set(id, client);
+          await connect(new Request(value, { headers: { Upgrade: 'websocket', ...(ip ? { 'cf-connecting-ip': ip } : {}), ...(agent ? { 'user-agent': agent } : {}) } }), client);
+        } else if (op === 'data') clients.get(id)?.emit('message', { data: value });
+        else if (op === 'close') { clients.get(id)?.emit('close', {}); clients.delete(id); }
+      }
+    }).catch(() => { shutdown(); try { socket.close(1011, 'room link failed'); } catch {} });
+  });
+  socket.addEventListener('close', shutdown);
+  socket.addEventListener('error', shutdown);
+  return { shutdown, settled: () => chain };
+}
+export function acceptMultiplex(request, connect) {
+  const [client, server] = Object.values(new WebSocketPair());
+  server.accept(); multiplexSession(server, connect);
+  return new Response(null, { status: 101, webSocket: client });
+}
+
+export class Gate {
+  constructor(ctx, env) { this.ctx = ctx; this.env = env; this.clients = new Map(); this.sequence = 0; this.link = null; this.opening = null; }
+  async upstream(url) {
+    if (this.link) return this.link;
+    if (this.opening) return this.opening;
+    this.opening = (async () => {
+      const name = `${url.searchParams.get('game')}/${url.searchParams.get('room')}`;
+      const gates = Number(url.searchParams.get('gates'));
+      const useConcentrator = !(this instanceof Concentrator) && gates > 8;
+      const binding = useConcentrator ? this.env.CONCENTRATOR : this.env.TABLE;
+      const key = useConcentrator ? `${name}/${Math.floor(Number(url.searchParams.get('gate')) / 8)}` : name;
+      const target = new URL(url); target.pathname = '/__multiplex';
+      const response = await binding.get(binding.idFromName(key)).fetch(new Request(target, { headers: { Upgrade: 'websocket' } }));
+      if (!response.webSocket) throw new Error('room link refused');
+      const socket = response.webSocket; socket.accept();
+      const link = batchLink(socket);
+      const lost = () => {
+        if (this.link !== link) return;
+        this.link = null; link.close();
+        for (const client of this.clients.values()) { try { client.close(1012, 'room link restarted'); } catch {} }
+        this.clients.clear();
+      };
+      socket.addEventListener('message', event => {
+        try { for (const [op, id, value, reason] of expandBatch(JSON.parse(event.data))) {
+          const client = this.clients.get(id);
+          if (op === 'data') {
+            try { client?.send(value); } catch {
+              this.clients.delete(id); link.send(['close', id]);
+              try { client?.close(1011, 'client connection ended'); } catch {}
+            }
+          } else if (op === 'close') {
+            this.clients.delete(id); try { client?.close(value, reason); } catch {}
+          }
+        } } catch { lost(); try { socket.close(1011, 'room link failed'); } catch {} }
+      });
+      socket.addEventListener('close', lost); socket.addEventListener('error', lost);
+      this.link = link; return link;
+    })();
+    try { return await this.opening; } finally { this.opening = null; }
+  }
+  async connect(request, server) {
+    const link = await this.upstream(new URL(request.url));
+    const id = String(++this.sequence);
+    this.clients.set(id, server);
+    link.send(['open', id, request.url, request.headers.get('cf-connecting-ip'), request.headers.get('user-agent')]);
+    server.addEventListener('message', event => { if (typeof event.data === 'string') link.send(['data', id, event.data]); });
+    const left = () => { if (this.clients.delete(id)) link.send(['close', id]); };
+    server.addEventListener('close', left); server.addEventListener('error', left);
+  }
+  async fetch(request) {
+    if (new URL(request.url).pathname === '/__multiplex') return acceptMultiplex(request, (req, socket) => this.connect(req, socket));
+    const [client, server] = Object.values(new WebSocketPair());
+    server.accept();
+    await this.connect(request, server);
+    return new Response(null, { status: 101, webSocket: client });
+  }
+}
+export class Concentrator extends Gate {}

package/worker/index.mjs

@@ -104,7 +104,9 @@ import { forgetLines, historyOf, keepLines, keptLine } from './lounge-store.mjs'
 import { isLoungePath, loungeRoutes } from './lounge.mjs';
 import { doorPage, serverPage, serversPage } from './site.mjs';
 import { isLocalOrigin, qrSvg } from './qr.mjs';
-import { SEAT_MAX, paramsFrom, perAddress, seatsOf } from './seats.mjs';
+import { acceptMultiplex, gateFor } from './gate.mjs';
+export { Gate, Concentrator } from './gate.mjs';
+import { seatCount, paramsFrom, perAddress, seatsOf } from './seats.mjs';
 import {
   SITE_JS, atomFeed, creditsPage, customPage, gameCover, gameLanding, gamesPage, homeLd, homePage, jsonFeed, landingLd, mediaArt, mediaIndexPage,
   notFoundPage, postPage, postsPage, roomView, roomsPage, sectionsOf, songPage, videoPage, watchOf,
@@ -129,7 +131,7 @@ import { licenseOf } from './license.mjs';
 // GAME PARTS (parts/PARTS.md section 4): three call-outs below, everything else is worker/parts.mjs.
 import { PART_FILES, isPartsPath, partsRoutes, withPartsBand } from './parts.mjs';
 
-export { SEAT_MAX } from './seats.mjs';
+export { seatCount, SEAT_MAX } from './seats.mjs';
 // Server-hosted games (NETPLAY.md section 29): the studio's site/src/worker.mjs hands the build's rules over with this.
 export { hostRules } from './hosted.mjs';
 /** For a studio whose Worker has player accounts: hand their server API to the back office once (worker/office.mjs). */
@@ -480,7 +482,7 @@ async function gameDocument(request, env, url, game, meta, cat, { agent = null }
   const policy = watchOf(meta);
   const watching = !agent && url.searchParams.get('watch') === '1';
   if (watching && policy === 'off') return new Response(`${meta?.name ?? game} cannot be watched; play it instead.\n`, { status: 403, headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' } });
-  const follow = /^(?:auto|overview|\d{1,2})$/.test(url.searchParams.get('follow') ?? '') ? url.searchParams.get('follow') : 'auto';
+  const follow = /^(?:auto|overview|\d+)$/.test(url.searchParams.get('follow') ?? '') ? url.searchParams.get('follow') : 'auto';
   const want = !agent && (watching || url.searchParams.get('want') === 'screen') ? 'screen' : 'play';
   const device = ['phone', 'desk', 'tv'].includes(url.searchParams.get('device')) ? url.searchParams.get('device') : undefined;
   const wsBase = `${url.protocol === 'https:' ? 'wss' : 'ws'}://${url.host}`;
@@ -1184,7 +1186,7 @@ async function route(request, env, ctx) {
       // one; none on a kids server, none for an AI or a watcher.
       const pid = !ag && !w && sub === '__net' ? parts.find((x) => x.startsWith('p-'))?.slice(2) : null;
       const badge = pid ? await roomBadge(env, cat, pid, { kids: pol.kids }) : null;
-      const stub = env.TABLE.get(env.TABLE.idFromName(`${game}/${room}`));
+      const stub = sub === '__net' ? gateFor(env, game, room, max, b) : env.TABLE.get(env.TABLE.idFromName(`${game}/${room}`));
       // Revision 9 (NETPLAY.md sections 22 and 23): the build that is live now (`cur`, always said, empty when the game
       // names none), the build this socket's page was served with (`gv`, from the socket's own address), and the game's
       // own stall time.
@@ -1934,10 +1936,17 @@ export class Table {
   }
 
   async fetch(request) {
+    if (new URL(request.url).pathname === '/__multiplex') {
+      return acceptMultiplex(request, (req, socket) => this.connect(req, socket));
+    }
+    return this.connect(request);
+  }
+
+  async connect(request, transport = null) {
     const url = new URL(request.url);
     const game = url.searchParams.get('game');
     const code = url.searchParams.get('room');
-    const max = Math.max(1, Math.min(SEAT_MAX, Math.floor(Number(url.searchParams.get('max'))) || 8));
+    const max = seatCount(url.searchParams.get('max'));
     if (url.pathname === '/__restart') {
       if (this.env.HOMIE_PREVIEW !== '1' || request.method !== 'POST') return new Response('not found', { status: 404 });
       // No last-chance save: this measures exactly what a real abrupt restart can lose.
@@ -1986,11 +1995,12 @@ export class Table {
       return json(res);
     }
     room.rules = url.searchParams.get('rules') === '1';
+    room.perIp = perAddress(max, room.rules);
     // Any tick rate a game may declare (1 to 60): the relay's allowances are the page's, from the same table.
     const hz = Number(url.searchParams.get('hz'));
     room.tickHz = Number.isInteger(hz) && hz >= 1 && hz <= 60 ? hz : 20;
     // The owner's room size: a room already open takes it from the next visitor on.
-    if (room.seatCap !== max || room.rules && room.maxPlayers !== max) room.setSeats(max, perAddress(max));
+    if (room.seatCap !== max || room.rules && room.maxPlayers !== max) room.setSeats(max, perAddress(max, room.rules));
     // Revision 9: the game's own stall time and the build that is live now, the Worker's word with every socket.
     const said = url.searchParams.has('cur');
     if (said) { room.setStall(url.searchParams.get('stall')); room.setCurrent(url.searchParams.get('cur') || null); }
@@ -2006,7 +2016,7 @@ export class Table {
     const agent = decodeFacts(url.searchParams.get('ag'));
     // Kept chat (0.29.0): the room's history is back in its window before this page hears it.
     await this.hydrateHistory(room);
-    const [client, server] = Object.values(new WebSocketPair());
+    const [client, server] = transport ? [null, transport] : Object.values(new WebSocketPair());
     server.accept();
     const via = url.searchParams.get('via');
     const conn = {
@@ -2043,7 +2053,7 @@ export class Table {
       // Watching shells are cheap (outgoing is free) but not free: a room holds at most 256, and 24 from one address
       // (room chat, 0.23.0: another site's page can open one too).
       const same = conn.ip ? [...room.watchers].filter((x) => x.ip === conn.ip).length : 0;
-      if (room.watchers.size >= 256 || same >= 24) { try { server.close(1013, 'too many watching'); } catch { /* gone */ } return new Response(null, { status: 101, webSocket: client }); }
+      if (room.watchers.size >= 256 || same >= 24) { try { server.close(1013, 'too many watching'); } catch { /* gone */ } return transport ? null : new Response(null, { status: 101, webSocket: client }); }
       const w = room.watch(conn);
       // The play page's vote card speaks on this socket (section 17); nothing else it says is read.
       server.addEventListener('message', (e) => {
@@ -2088,7 +2098,7 @@ export class Table {
       });
     }
     this.start();
-    return new Response(null, { status: 101, webSocket: client });
+    return transport ? null : new Response(null, { status: 101, webSocket: client });
   }
 
   start() {
@@ -2173,7 +2183,7 @@ export class Table {
     if (!r || r.phase !== 'over' || !Number.isFinite(r.n) || r.n <= this.recorded || !this.env.DB) return;
     this.recorded = r.n;
     this.ctx.storage.put('recorded', r.n).catch(() => {});
-    const results = Array.isArray(r.results) ? r.results.slice(0, SEAT_MAX * 2) : [];
+    const results = Array.isArray(r.results) ? r.results : [];
     // An AI's row is never a person's (the relay labelled it `agent`): rounds count agents as AI.
     const humans = results.filter((row) => row && !row.bot && !row.agent).length;
     // A round played only by house QA (every seated socket is marked) is kept in `rounds`, not in the stats.
@@ -2273,7 +2283,7 @@ export class Lobby {
     // the build of a game that names none ('').
     const ver = versionOf(url.searchParams.get('ver')) ?? '';
     if (url.pathname === '/join') {
-      const max = Math.max(1, Math.min(SEAT_MAX, Math.floor(Number(url.searchParams.get('max'))) || 8));
+      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));

package/worker/mcp-room.mjs

@@ -39,7 +39,6 @@ export async function roomSeat(table,room,ctl) {
   if(a.operation==='stand'){seat?.handle.onClose();seats.delete(a.connection);return {ok:true};}
   if(a.operation==='sit'&&(!seat||seat.closed)){
     for(const [id,old] of seats)if(old.closed)seats.delete(id);
-    if(seats.size>=32)throw new Error('remote seat capacity reached');
     await table.readVocab(table.game);
     seat={closed:false,frames:[]};
     const conn={ip:null,player:a.person,via:'p-'+a.person,agent:{pass:a.connection.replaceAll('-','').slice(0,16),role:'guide',hands:'host',by:'studio',name:a.name},send:text=>{seat.frames.push(JSON.parse(text));if(seat.frames.length>20)seat.frames.shift();},close:()=>{seat.closed=true;},buffered:()=>0};

package/worker/office.mjs

@@ -61,7 +61,7 @@ import { toolIdentity } from './tool-identity.mjs';
  * links to the studio's own Stripe, a CSV, the referral books and signed statements). A refund is the owner's one tap;
  * from an office key it is ALWAYS an ask (the AI may only propose one), and so is marking a referrer paid.
  */
-import { SEAT_MAX, seatsOf } from './seats.mjs';
+import { seatsOf } from './seats.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';
@@ -472,7 +472,7 @@ async function roomRow(env, meta, room, max) {
     openedAt: office.openedAt ?? f.openedAt ?? null, closedUntil: office.closedUntil ?? null, snapHz: f.snapHz ?? 0,
     regate: office.regate ?? null,
     host: f.host ?? null, announce: f.announce ?? null,
-    slots: slots.slice(0, 64).map((s) => ({ slot: s.slot, seat: s.seat ?? null, name: oneLine(s.name, 40), bot: Boolean(s.bot), ...(s.agent ? { agent: { role: s.agent.role ?? 'party', seat: s.agent.seat ?? null } } : {}) })),
+    slots: slots.map((s) => ({ slot: s.slot, seat: s.seat ?? null, name: oneLine(s.name, 40), bot: Boolean(s.bot), ...(s.agent ? { agent: { role: s.agent.role ?? 'party', seat: s.agent.seat ?? null } } : {}) })),
     clients, bans: office.bans ?? [], mutes: office.mutes ?? [],
     // Room chat (0.23.0): the room's last minutes, with who sent each line (a client id and account; never an address).
     chat: office.chat ? { mode: office.chat.rules?.mode ?? null, pending: office.chat.pending ?? 0, lines: (office.chat.lines ?? []).slice(-50).map((l) => ({ id: l.id, at: l.at, t: l.t, kind: l.kind, name: oneLine(l.name, 40), seat: l.seat ?? null, by: l.by, text: l.text ?? null, glyph: l.glyph ?? null, react: l.react ?? null, say: l.say ?? null, acct: Boolean(l.acct), owner: Boolean(l.owner), client: l.client ?? null, player: l.player ?? null, browser: l.browser ?? null, ...(l.review ? { review: l.review } : {}) })) } : null,
@@ -670,7 +670,7 @@ function checkAction(cat, op, body) {
       if (!meta) return bad('game is one of this studio\'s game ids');
       if (!room) return bad('room is the room\'s code (pub-3, or a named room)');
       const id = typeof body.id === 'string' && /^[A-Za-z0-9_-]{1,16}$/.test(body.id) ? body.id : null;
-      const seat = Number.isInteger(body.seat) && body.seat >= 0 && body.seat < SEAT_MAX ? body.seat : null;
+      const seat = Number.isInteger(body.seat) && body.seat >= 0 && Number.isSafeInteger(body.seat) ? body.seat : null;
       // From a chat line (0.23.0): its sender, whoever they are now (a watcher too); `purge` takes their lines down.
       const line = typeof body.line === 'string' && /^[A-Za-z0-9_-]{1,16}$/.test(body.line) ? body.line : null;
       if (id === null && seat === null && line === null) return bad('name the player: id (from the office), seat, or line (a chat message of theirs)');

package/worker/room.mjs

@@ -1,4 +1,4 @@
-import { interestSnapshot, snapshotEncoder } from '../rules/interest.mjs';
+import { interestSnapshot, snapshotEncoder, scheduledView } from '../rules/interest.mjs';
 /*
  * room.mjs — the netplay v1 relay semantics, with no transport in it.
  * =============================================================================
@@ -58,7 +58,7 @@ import { CHAT_LIMITS, CHAT_RATES, HELD_WORDS, allows, cleanText, floor, normaliz
 
 export const NET_VERSION = 1;
 /** The contract revision this relay speaks (NETPLAY.md): optional fields, frames and refusals; the wire stays `v: 1`. */
-export const NET_REVISION = 11;
+export const NET_REVISION = 12;
 /**
  * Revision 9 (NETPLAY.md sections 22 and 23). STALL: how long a host may send no snapshot, while others are present,
  * before the room is handed on: 1.5 s unless the game names its own (game.json `netplay.stallMs`), never under
@@ -316,7 +316,7 @@ export class NetRoom {
     this.lastSnapText = null;
     this.lastCkpt = null;
     this.lastRound = null;
-    this.lastRoster = null;
+    this.lastRoster = null; this.rosterSent = null;
     /** key → { d, bytes } — slow world state, handed to every joiner and to a promoted host */
     this.state = new Map();
     this.stateBytes = 0;
@@ -461,7 +461,7 @@ export class NetRoom {
   hostSnap(c, m, now, text = null) {
     // The server's stamp is this relay's own clock; a browser's is its estimate of it, and is checked.
     const snap = { k: Number(m.k) || 0, st: c ? this.stamp(m.st) : Number(m.st) || now, d: m.d ?? null };
-    if (Array.isArray(m.c)) snap.c = m.c.slice(0, this.server ? this.seatCap : 64);
+    if (Array.isArray(m.c)) snap.c = m.c.slice(0, this.server || this.rules ? this.seatCap : 64);
     // Revision 10: a rules game's snapshot names the room's epoch.
     if ((!c || this.rules && c.rules) && Number.isFinite(m.e)) snap.e = m.e;
     this.lastSnap = snap;
@@ -478,17 +478,23 @@ export class NetRoom {
       if (this.lite(o)) continue; // an agent with no game client draws nothing
       // A congested socket skips a snapshot rather than queueing a stale one.
       if (o.conn.buffered && o.conn.buffered() > 256 * 1024) { this.stats.drops += 1; continue; }
-      this.sendText(o.conn, this.server?.viewRadiusM != null ? JSON.stringify({ t: 'snap', from: null, ...this.playerSnapshot(o, snap) }) : out);
+      this.sendText(o.conn, this.hasViewSchedule() ? JSON.stringify({ t: 'snap', from: null, ...this.playerSnapshot(o, snap) }) : out);
     }
   }
 
+  hasViewSchedule() {
+    const view = this.server?.viewSettings;
+    return this.server?.viewRadiusM != null || Boolean(view?.precisionM > 0 || view?.nearM != null && view?.farHz != null);
+  }
+
   /** The same per-player delivery role will run in Gates. Keyframes belong to sockets, not saved seats. */
   playerSnapshot(client, snap, welcome = false) {
-    if (!snap || this.server?.viewRadiusM == null) return snap;
-    const selected = interestSnapshot(snap, client.seat, this.server.viewRadiusM);
-    client.snapEncoder ??= snapshotEncoder(this.tickHz);
+    if (!snap || !this.hasViewSchedule()) return snap;
+    client.viewSchedule ??= scheduledView(this.server.viewSettings ?? { radiusM: this.server.viewRadiusM }, this.tickHz);
+    const selected = client.viewSchedule(snap, client.seat);
+    client.snapEncoder ??= snapshotEncoder(this.tickHz, true);
     if (welcome) client.snapEncoder.reset();
-    return client.snapEncoder.encode(selected);
+    return client.snapEncoder.encode(selected, client.seat);
   }
 
   /** One key of the slow state channel from the host. `bytes`: the frame's size, counted against the room's cap for a browser host. */
@@ -540,9 +546,16 @@ export class NetRoom {
   hostRoster(c, m) {
     if (!Array.isArray(m.slots)) return;
     // A host cannot hide an AI: a seat an agent holds is named and marked so, a slot with no seat is a bot.
-    this.lastRoster = this.labelRoster(m.slots.slice(0, this.server ? this.seatCap : 64));
+    const previous = this.rosterSent ?? new Map();
+    this.lastRoster = this.labelRoster(m.slots.slice(0, this.server || this.rules ? this.seatCap : 64));
     this.persistDirty = true;
-    for (const o of (c && this.rules && c.rules ? this.live() : this.others(c))) this.send(o, { t: 'roster', slots: this.lastRoster });
+    const present = new Set(this.lastRoster.map(row => row.slot));
+    const changed = this.lastRoster.filter(row => previous.get(row.slot) !== JSON.stringify(row));
+    this.rosterSent = new Map(this.lastRoster.map(row => [row.slot, JSON.stringify(row)]));
+    const removed = [...previous.keys()].filter(slot => !present.has(slot));
+    const frame = this.server && previous.size ? { t: 'roster', patch: true, slots: changed, removed } : { t: 'roster', slots: this.lastRoster };
+    const text = JSON.stringify(frame);
+    for (const o of (c && this.rules && c.rules ? this.live() : this.others(c))) this.sendText(o.conn, text);
     this.tellWatchers();
   }
 
@@ -1121,7 +1134,8 @@ export class NetRoom {
       ...(this.vote ? { vote: this.voteView() } : {}),
       ...(c.agent ? { agent: { ...c.agent, name: c.name } } : {}),
     });
-    for (const o of this.others(c)) this.send(o, { t: 'join', peer: this.peer(c) });
+    const joinedText = JSON.stringify({ t: 'join', peer: this.peer(c) });
+    for (const o of this.others(c)) this.sendText(o.conn, joinedText);
     // The server host hears of every seat taken (a reconnect is the same stay: its body is back, not new).
     if (c.seat !== null) { this.syncServerSeats(); this.joinServer(c); }
     // A seat taken by a browser that also watches this room: its watching tab sees the overview from now on.
@@ -1211,7 +1225,8 @@ export class NetRoom {
       if (!this.seatClient(c, '')) return;
       this.stats.seated += 1;
       this.send(c, { t: 'seat', seat: c.seat, token: c.token, name: c.name, colour: c.colour, role: this.roleOf(c) });
-      for (const o of this.others(c)) this.send(o, { t: 'join', peer: this.peer(c) });
+      const joinedText = JSON.stringify({ t: 'join', peer: this.peer(c) });
+    for (const o of this.others(c)) this.sendText(o.conn, joinedText);
       this.syncServerSeats(); this.joinServer(c);
       this.log({ ev: 'seated', room: this.code, id: c.id, seat: c.seat });
       this.persist();
@@ -1588,7 +1603,8 @@ export class NetRoom {
       const s = this.seats.get(c.seat);
       if (s && s.token === c.token) { s.present = false; s.since = now; }
     }
-    for (const o of this.others(c)) this.send(o, { t: 'leave', id: c.id, seat: c.seat, why });
+    const leftText = JSON.stringify({ t: 'leave', id: c.id, seat: c.seat, why });
+    for (const o of this.others(c)) this.sendText(o.conn, leftText);
     // One line per departure, with what the room looked like. A `leave` is a departure (a closed tab, a lost network
     // arriving as the socket's error, a host that was replaced); a `failed` line (guard) is a room operation that threw.
     this.log({ ev: 'leave', room: this.code, id: c.id, seat: c.seat, why, ...(via ? { via } : {}), role: wasHost ? 'host' : c.seat === null ? 'screen' : 'replica', left: this.live().length });
@@ -1720,7 +1736,7 @@ export class NetRoom {
   forget() {
     this.hostId = null;
     for (const c of this.live()) this.kick(c, 'agents-alone', 4001);
-    this.lastSnap = null; this.lastSnapText = null; this.lastCkpt = null; this.lastRound = null; this.lastRoster = null;
+    this.lastSnap = null; this.lastSnapText = null; this.lastCkpt = null; this.lastRound = null; this.lastRoster = null; this.rosterSent = null;
     this.state.clear(); this.stateBytes = 0; this.seats.clear(); this.preferHost = null;
     this.emptySince = 0; this.openedAt = 0; this.askedMax = null;
     // The room is nobody's build again (section 23): the next visitor's is its build.
@@ -1813,7 +1829,7 @@ export class NetRoom {
 
   /** A round's results, labelled the same way (`agent: true` on every AI's row). */
   labelResults(rows) {
-    return rows.slice(0, this.server ? this.seatCap : 64).map((raw) => this.labelOne(raw, true)).filter(Boolean);
+    return rows.slice(0, this.server || this.rules ? this.seatCap : 64).map((raw) => this.labelOne(raw, true)).filter(Boolean);
   }
 
   labelOne(raw, result) {
@@ -2197,7 +2213,7 @@ export class NetRoom {
         }
         // Everything the room held goes, as when an empty room forgets (section 4).
         this.hostId = null;
-        this.lastSnap = null; this.lastSnapText = null; this.lastCkpt = null; this.lastRound = null; this.lastRoster = null;
+        this.lastSnap = null; this.lastSnapText = null; this.lastCkpt = null; this.lastRound = null; this.lastRoster = null; this.rosterSent = null;
         this.state.clear(); this.stateBytes = 0; this.seats.clear(); this.preferHost = null; this.openedAt = 0; this.askedMax = null;
         this.emptySince = now; this.seatsDirty = false; this.persistDirty = false;
         try { this.store?.clear?.(); } catch { /* best effort */ }
@@ -2303,7 +2319,7 @@ export class NetRoom {
    */
   forgetWorld(next) {
     this.log({ ev: 'build-changed', room: this.code, from: this.gameVer ?? null, to: next ?? null });
-    this.lastSnap = null; this.lastSnapText = null; this.lastCkpt = null; this.lastRound = null; this.lastRoster = null;
+    this.lastSnap = null; this.lastSnapText = null; this.lastCkpt = null; this.lastRound = null; this.lastRoster = null; this.rosterSent = null;
     this.state.clear(); this.stateBytes = 0; this.preferHost = null;
     this.persistDirty = true;
   }
@@ -2311,7 +2327,7 @@ export class NetRoom {
   setSeats(n, perIp = null) {
     this.seatCap = Math.max(1, Math.floor(n));
     this.maxPlayers = Math.max(1, Math.min(this.seatCap, (this.server || this.rules) ? this.seatCap : this.askedMax ?? this.seatCap));
-    if (Number.isFinite(perIp) && perIp > 0) this.perIp = perIp;
+    if (Number.isFinite(perIp) && perIp >= 0) this.perIp = perIp;
   }
 
   /** The owner's holds, the banner and a closed door: kept apart from the room's play (they outlive an empty room). */

package/worker/seats.mjs

@@ -2,24 +2,20 @@
  * Room sizes, shared by the site Worker (worker/index.mjs) and `homie-studio build` (lib/build.mjs).
  *
  * A game names its seats in its netplay manifest (game.json `netplay.maxPlayers`, or `netplay.json` with
- * `maxPlayers` or `players.max`); every room of that game has that many, up to SEAT_MAX (32).
+ * `maxPlayers` or `players.max`); every room of that game has that many, as chosen by the studio.
  */
 
 import { stallOf, versionOf } from './room.mjs';
 
-/** The most seats one room holds (NETPLAY.md §3). */
+/** Room size is chosen by the studio, not capped by admission. */
+export const seatCount = (n, fallback = 8) => Number.isSafeInteger(Number(n)) && Number(n) > 0 ? Number(n) : fallback;
+/** Compatibility limit for existing browser-hosted netplay games only. */
 export const SEAT_MAX = 32;
-
-/** A game's seats from its catalogue row: 1 to SEAT_MAX, 8 when it names none. */
-export const seatsOf = (meta) => Math.max(1, Math.min(SEAT_MAX, Math.floor(Number(meta?.players?.max)) || 8));
-
-/**
- * Sockets one client address may hold in one room: 12, or every seat plus four (a big screen or two, and a
- * visitor waiting for a seat) when that is more. A party of thirty phones and a TV on one Wi-Fi (or strangers
- * behind one carrier's shared address) fills a 32-seat room from a single address, and must be let in; an 8-seat
- * game keeps the old 12.
- */
-export const perAddress = (seats) => Math.max(12, seats + 4);
+export const seatsOf = (meta) => meta?.room?.contract || meta?.kind === 'app'
+  ? seatCount(meta?.players?.max)
+  : Math.max(1, Math.min(SEAT_MAX, Math.floor(Number(meta?.players?.max)) || 8));
+/** Rules rooms have no carrier-address ceiling; legacy rooms retain their old allowance. */
+export const perAddress = (seats, rules = false) => rules ? 0 : Math.max(12, seats + 4);
 
 /**
  * `net.prefs` (NETPLAY.md section 24): what the play page keeps for one game on one browser, because the game's frame

package/worker/servers.mjs

@@ -141,8 +141,8 @@ export function serverOf(raw, { from = 'd1' } = {}) {
     name: oneLine(raw.name, SERVER_LIMITS.name) || (id === 'public' ? 'Quick play' : id),
     blurb: oneLine(raw.blurb, SERVER_LIMITS.blurb),
     policy,
-    aiSeats: human || policy === 'open' ? 0 : int(pick('ai_seats', 'aiSeats'), 0, 31, policy === 'hybrid' ? 2 : 0),
-    guides: policy === 'beginner' ? int(pick('guides', 'guides'), 0, 31, 2) : 0,
+    aiSeats: human || policy === 'open' ? 0 : int(pick('ai_seats', 'aiSeats'), 0, Number.MAX_SAFE_INTEGER, policy === 'hybrid' ? 2 : 0),
+    guides: policy === 'beginner' ? int(pick('guides', 'guides'), 0, Number.MAX_SAFE_INTEGER, 2) : 0,
     bots: (pick('bots', 'bots') ?? (human ? 'off' : 'fill')) === 'off' ? 'off' : 'fill',
     level: Math.min(levelMax, int(pick('level', 'level'), 1, 5, policy === 'beginner' ? 2 : 3)),
     levelMax,
@@ -152,7 +152,7 @@ export function serverOf(raw, { from = 'd1' } = {}) {
     beginnerDays: policy === 'beginner' ? int(pick('beginner_days', 'beginnerDays'), 1, 3650, SERVER_LIMITS.beginnerDays) : null,
     beginnerLevel: policy === 'beginner' && pick('beginner_level', 'beginnerLevel') !== undefined && pick('beginner_level', 'beginnerLevel') !== null ? int(pick('beginner_level', 'beginnerLevel'), 1, 1_000_000, null) : null,
     roomsMax: int(pick('rooms_max', 'roomsMax'), 1, SERVER_LIMITS.roomsMax, id === 'public' ? SERVER_LIMITS.roomsMax : 4),
-    seats: pick('seats', 'seats') === undefined || pick('seats', 'seats') === null ? null : int(pick('seats', 'seats'), 1, 32, null),
+    seats: pick('seats', 'seats') === undefined || pick('seats', 'seats') === null ? null : int(pick('seats', 'seats'), 1, Number.MAX_SAFE_INTEGER, null),
     brain: human ? 'off' : BRAINS.includes(pick('brain', 'brain')) ? pick('brain', 'brain') : 'script',
     listed: pick('listed', 'listed') === undefined || pick('listed', 'listed') === null ? true : pick('listed', 'listed') === true || Number(pick('listed', 'listed')) === 1,
     state: ['open', 'closed', 'archived'].includes(raw.state) ? raw.state : 'open',
@@ -376,14 +376,14 @@ export function checkServer(body, { create = false } = {}) {
   }
   if (body.blurb !== undefined) f.blurb = oneLine(body.blurb, SERVER_LIMITS.blurb);
   const num = (k, lo, hi) => { if (body[k] === undefined) return true; const n = Math.floor(Number(body[k])); if (!Number.isFinite(n) || n < lo || n > hi) return false; f[k] = n; return true; };
-  if (!num('aiSeats', 0, 31)) return bad('aiSeats is 0 to 31 (and at most the room\'s seats less one)');
-  if (!num('guides', 0, 31)) return bad('guides is 0 to 31');
+  if (!num('aiSeats', 0, Number.MAX_SAFE_INTEGER)) return bad('aiSeats is a non-negative safe integer (and at most the room\'s seats less one)');
+  if (!num('guides', 0, Number.MAX_SAFE_INTEGER)) return bad('guides is a non-negative safe integer');
   if (!num('level', 1, 5)) return bad('level is 1 to 5 (Rookie, Steady, Fair, Strong, Maxed)');
   if (!num('levelMax', 1, 5)) return bad('levelMax is 1 to 5');
   if (!num('rooms', 1, SERVER_LIMITS.roomsMax)) return bad(`rooms is 1 to ${SERVER_LIMITS.roomsMax}`);
   if (!num('beginnerDays', 1, 3650)) return bad('beginnerDays is 1 to 3650');
   if (body.beginnerLevel === null) f.beginnerLevel = null; else if (!num('beginnerLevel', 1, 1_000_000)) return bad('beginnerLevel is a number, or null for none');
-  if (body.seats === null) f.seats = null; else if (!num('seats', 1, 32)) return bad('seats is 1 to 32, or null for the game\'s own');
+  if (body.seats === null) f.seats = null; else if (!num('seats', 1, Number.MAX_SAFE_INTEGER)) return bad('seats is a positive safe integer, or null for the game\'s own');
   if (body.kids !== undefined) f.kids = body.kids === true || body.kids === 'on';
   if (body.listed !== undefined) f.listed = !(body.listed === false || body.listed === 'off');
   if (body.bots !== undefined) { if (!['fill', 'off'].includes(body.bots)) return bad('bots is fill or off'); f.bots = body.bots; }

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.44.1';
+export const STUDIO_VERSION_TAG = '0.45.0';