@homie-rocks/studio 0.53.0 → 0.55.0

package/worker/room-controls.mjs

@@ -0,0 +1,296 @@
+/** Owner controls, moderation and launch transitions for a room. The relay owns its shared state. */
+
+
+
+
+import { skillPreset } from './agents.mjs';
+
+import { CHAT_LIMITS, HELD_WORDS, floor } from './chat.mjs';
+import { STALL, stallOf, versionOf, CONTROL_LIMITS, oneLine, randomId, keptRef } from './room-protocol.mjs';
+export class RoomControls {
+ constructor(room) {this.room=room;}
+findClient({ id = null, seat = null } = {}) {
+    if (typeof id === 'string' && id) { const c = this.room.clients.get(id); if (c && c.helloed) return c; }
+    if (Number.isInteger(seat)) return this.room.live().find((c) => c.seat === seat) ?? null;
+    return null;
+  }
+banOf(c, token = c.token) {
+    const now = this.room.now();
+    const pass = c.agent?.pass ?? c.agentWord?.pass ?? null;
+    return this.room.bans.find((b) => b.until > now && ((b.token && b.token === token) || (b.browser && b.browser === c.browser) || (b.player && b.player === c.player) || (b.ip && b.ip === c.ip) || (b.pass && b.pass === pass))) ?? null;
+  }
+muteOf(c) {
+    const now = this.room.now();
+    return this.room.mutes.find((m) => m.until > now && ((m.token && m.token === c.token) || (m.browser && m.browser === c.browser) || (m.player && m.player === c.player))) ?? null;
+  }
+liveAnnouncement() {
+    const a = this.room.announcement;
+    return a && a.until > this.room.now() ? a : null;
+  }
+heldNotice(conn) {
+    const now = this.room.now();
+    if (this.room.closedUntil > now) return { t: 'closed', room: this.room.code, until: this.room.closedUntil, message: this.room.closedWhy || 'The studio closed this room.' };
+    const probe = { token: null, browser: conn.browser ?? null, player: conn.player ?? null, ip: null };
+    if (!probe.browser && !probe.player) return null;
+    const ban = this.room.banOf(probe, null);
+    if (ban) return { t: 'kicked', room: this.room.code, until: ban.until, message: ban.message };
+    const mute = this.room.muteOf(probe);
+    return mute ? { t: 'muted', room: this.room.code, until: mute.until } : null;
+  }
+tellBrowser(who, msg) {
+    const text = JSON.stringify(msg);
+    for (const w of this.room.watchers) if ((who.browser && w.browser === who.browser) || (who.player && w.player === who.player)) this.room.sendText(w, text);
+  }
+control(op, a = {}) {
+    const now = this.room.now();
+    const minutes = Math.max(1, Math.min(CONTROL_LIMITS.minutes, Math.floor(Number(a.minutes) || 10)));
+    this.room.bans = this.room.bans.filter((b) => b.until > now);
+    this.room.mutes = this.room.mutes.filter((m) => m.until > now);
+    switch (op) {
+      case 'kick': {
+        // From a chat line (section 19): its sender, in this room now or not (a watcher with no seat is held too). A line
+        // older than the window comes from the room's kept history (the Worker read it: its sender's account only).
+        const line = typeof a.line === 'string' ? this.room.chatLog.find((r) => r.id === a.line) ?? keptRef(a) : null;
+        const target = this.room.findClient(a) ?? (line?.from?.client ? this.room.clients.get(line.from.client) ?? null : null);
+        if (!target && line) return this.room.holdSender(line, minutes, now, { kick: true, message: oneLine(a.message, CONTROL_LIMITS.message) || 'The studio removed you from this room.', purge: a.purge === true });
+        if (!target) return { ok: false, error: 'no-player', message: 'nobody is in that seat now' };
+        const purged = a.purge === true ? this.room.unsay(this.room.linesOf({ client: target.id, token: target.token, browser: target.browser, player: target.player })) : 0;
+        const until = now + minutes * 60_000;
+        // The message is the studio's words; `until` says when (the shell says it in the player's own time).
+        const message = oneLine(a.message, CONTROL_LIMITS.message) || 'The studio removed you from this room.';
+        // An AI is held out by its pass (its seat becomes a brainless AI seat again); a person by token, browser, account.
+        const ban = { token: target.token, browser: target.browser, player: target.player, ip: a.address ? target.ip : null, pass: target.agent?.pass ?? null, name: line?.name ?? target.name, seat: target.seat, until, at: now, message };
+        this.room.bans = [...this.room.bans, ban].slice(-CONTROL_LIMITS.bans);
+        // Every socket of that player in this room: the seat itself, and its browser's or account's other tabs.
+        const out = this.room.live().filter((o) => o === target || (ban.browser && o.browser === ban.browser) || (ban.player && o.player === ban.player));
+        for (const o of out) {
+          const seat = o.seat;
+          const token = o.token;
+          this.room.error(o, 'kicked', message, { until });
+          this.room.onClose(o, 'kicked');
+          // The seat is free for somebody else at once, and its token resumes nothing.
+          const s = seat === null ? null : this.room.seats.get(seat);
+          if (s && s.token === token) { this.room.seats.delete(seat); this.room.seatsDirty = true; }
+          try { o.conn.close(1008, 'kicked'); } catch { /* gone */ }
+        }
+        this.room.stats.ownerKicks = (this.room.stats.ownerKicks ?? 0) + 1;
+        this.room.tellBrowser(ban, { t: 'kicked', room: this.room.code, until, message });
+        this.room.persist(now);
+        this.room.tellWatchers();
+        return { ok: true, op, name: ban.name, seat: ban.seat, sockets: out.length, until, ...(purged ? { removed: purged } : {}) };
+      }
+      case 'mute': {
+        const line = typeof a.line === 'string' ? this.room.chatLog.find((r) => r.id === a.line) ?? keptRef(a) : null;
+        const target = this.room.findClient(a) ?? (line?.from?.client ? this.room.clients.get(line.from.client) ?? null : null);
+        if (!target && line && a.off !== true) return this.room.holdSender(line, minutes, now, { kick: false, purge: a.purge === true });
+        if (!target) return { ok: false, error: 'no-player', message: 'nobody is in that seat now' };
+        const off = a.off === true;
+        const purged = !off && a.purge === true ? this.room.unsay(this.room.linesOf({ client: target.id, token: target.token, browser: target.browser, player: target.player })) : 0;
+        const same = (m) => (m.token && m.token === target.token) || (m.browser && m.browser === target.browser) || (m.player && m.player === target.player);
+        this.room.mutes = this.room.mutes.filter((m) => !same(m));
+        const until = off ? 0 : now + minutes * 60_000;
+        if (!off) this.room.mutes = [...this.room.mutes, { token: target.token, browser: target.browser, player: target.player, name: line?.name ?? target.name, seat: target.seat, until, at: now }].slice(-CONTROL_LIMITS.mutes);
+        const note = { t: 'mute', id: target.id, seat: target.seat, until };
+        for (const o of this.room.live()) this.room.send(o, note);
+        this.room.tellBrowser(target, { t: 'muted', room: this.room.code, until });
+        this.room.tellWatchers();
+        return { ok: true, op, name: line?.name ?? target.name, seat: target.seat, until, ...(purged ? { removed: purged } : {}) };
+      }
+      case 'card': {
+        // Show what you made (0.29.0): a link card to a studio's game, which the Worker read from that studio's own
+        // manifest and checked (its words passed the floor and the review there). Its sender's name and account are the
+        // Worker's word; a mute holds a card as it holds a line.
+        const c = a.card && typeof a.card === 'object' ? a.card : null;
+        if (!c || typeof c.url !== 'string' || !/^https?:\/\//.test(c.url)) return { ok: false, error: 'card', message: 'no card' };
+        const who = { token: null, browser: typeof a.browser === 'string' ? a.browser : null, player: typeof a.player === 'string' ? a.player : null, ip: null };
+        if (a.owner !== true && this.room.banOf(who, null)) return { ok: false, error: 'kicked', message: 'The studio has held you out of this room for now.' };
+        if (a.owner !== true && this.room.muteOf(who)) return { ok: false, error: 'muted', message: HELD_WORDS.muted };
+        const card = { url: c.url.slice(0, 300), title: oneLine(c.title, 80), studio: oneLine(c.studio, 60), pitch: oneLine(c.pitch, 160), image: typeof c.image === 'string' && /^https:\/\//.test(c.image) ? c.image.slice(0, 400) : null, ...(typeof c.game === 'string' ? { game: c.game.slice(0, 40) } : {}) };
+        const note = oneLine(a.note, CHAT_LIMITS.text);
+        const rules = this.room.chatRules();
+        if (rules.mode !== 'text' && a.owner !== true) return { ok: false, error: 'held', why: rules.mode === 'off' ? 'off' : 'lines', message: 'The Lounge isn\'t taking cards right now.' };
+        // The card's words (the person's note, the game's own title and pitch) pass the floor like any typed line.
+        const words = [note, card.title, card.pitch].filter(Boolean).join(' · ');
+        const f = floor(words, { ...rules, links: 'block' });
+        if (!f.ok && a.owner !== true) return { ok: false, error: 'held', why: f.why, message: HELD_WORDS[f.why] ?? HELD_WORDS.unknown };
+        const rec = {
+          kind: 'card', card, text: note || `Made: ${card.title}${card.studio ? ` by ${card.studio}` : ''}`,
+          name: oneLine(a.name, CHAT_LIMITS.name) || 'Someone', seat: null, colour: null, by: 'watcher', bubble: false,
+          acct: a.acct === true, owner: a.owner === true, ...(a.mod === true ? { mod: true } : {}),
+          from: { client: null, token: null, browser: who.browser, player: who.player },
+        };
+        // And the studio's review, as a typed line gets it (the owner's own card is never reviewed).
+        if (rules.ai && typeof this.room.review === 'function' && a.owner !== true) {
+          return Promise.resolve()
+            .then(() => this.room.review(words, { room: this.room.code, links: 'block' }))
+            .then((v) => v, () => ({ ok: true, by: 'error' }))
+            .then((v) => {
+              if (v && v.ok === false) { this.room.stats.chatAiHeld = (this.room.stats.chatAiHeld ?? 0) + 1; return { ok: false, error: 'held', why: 'ai', message: HELD_WORDS.ai }; }
+              rec.review = { by: v?.by ?? 'ai' };
+              if (this.room.muteOf(who)) return { ok: false, error: 'muted', message: HELD_WORDS.muted };
+              return { ...this.room.publishChat(rec), op };
+            });
+        }
+        return { ...this.room.publishChat(rec), op };
+      }
+      case 'unsay': {
+        // Room chat (section 19): the owner takes a message down (or every message: `all`), on every screen at once.
+        const ids = a.all === true ? this.room.chatLog.map((r) => r.id) : (Array.isArray(a.ids) ? a.ids : [a.id]).filter((x) => typeof x === 'string' && /^[A-Za-z0-9_-]{1,16}$/.test(x)).slice(0, 64);
+        if (!ids.length) return { ok: false, error: 'no-line', message: 'which message?' };
+        const removed = this.room.unsay(ids);
+        this.room.stats.chatRemoved = (this.room.stats.chatRemoved ?? 0) + removed;
+        return { ok: true, op, removed };
+      }
+      case 'announce': {
+        const text = oneLine(a.text, CONTROL_LIMITS.announce);
+        const prev = this.room.announcement;
+        if (!text) {
+          this.room.announcement = null;
+          if (prev) { const clear = JSON.stringify({ t: 'announce', id: prev.id, text: null }); for (const o of this.room.live()) this.room.sendText(o.conn, clear); for (const w of this.room.watchers) this.room.sendText(w, clear); }
+          this.room.tellWatchers();
+          return { ok: true, op, cleared: Boolean(prev) };
+        }
+        const seconds = Math.max(5, Math.min(CONTROL_LIMITS.announceSeconds, Math.floor(Number(a.seconds) || 30)));
+        this.room.announcement = { id: typeof a.id === 'string' && /^[A-Za-z0-9_-]{1,24}$/.test(a.id) ? a.id : randomId(6), text, at: now, until: now + seconds * 1000, from: 'studio' };
+        const msg = JSON.stringify({ t: 'announce', ...this.room.announcement });
+        for (const o of this.room.live()) this.room.sendText(o.conn, msg);
+        for (const w of this.room.watchers) this.room.sendText(w, msg);
+        // The room's chat shows it too, as the studio's own line (section 19).
+        this.room.publishChat({ kind: 'studio', text, name: 'Studio', seat: null, colour: null, by: 'studio', bubble: false, acct: false, owner: true, from: null });
+        this.room.tellWatchers();
+        return { ok: true, op, id: this.room.announcement.id, people: this.room.live().length, until: this.room.announcement.until };
+      }
+      case 'close': {
+        if (a.reopen === true) { this.room.closedUntil = 0; this.room.closedWhy = ''; this.room.tellWatchers(); return { ok: true, op, reopened: true }; }
+        // `seconds` (10 s to a day) is a short close: everyone comes back through the game's door (a launch state change).
+        const seconds = Math.floor(Number(a.seconds));
+        const until = now + (seconds >= 10 ? Math.min(seconds, CONTROL_LIMITS.minutes * 60) * 1000 : minutes * 60_000);
+        const message = oneLine(a.message, CONTROL_LIMITS.message) || 'The studio closed this room. Thanks for playing!';
+        this.room.closedUntil = until;
+        this.room.closedWhy = message;
+        const people = this.room.live().length;
+        for (const c of [...this.room.clients.values()]) {
+          if (c.helloed) this.room.error(c, 'room-closed', message, { until });
+          this.room.clients.delete(c.id);
+          try { c.conn.close(1000, 'room-closed'); } catch { /* gone */ }
+        }
+        // Everything the room held goes, as when an empty room forgets (section 4).
+        this.room.hostId = null;
+        this.room.lastSnap = null; this.room.lastSnapText = null; this.room.lastCkpt = null; this.room.lastRound = null; this.room.lastRoster = null; this.room.rosterSent = null;
+        this.room.state.clear(); this.room.stateBytes = 0; this.room.seats.clear(); this.room.preferHost = null; this.room.openedAt = 0; this.room.askedMax = null;
+        this.room.emptySince = now; this.room.seatsDirty = false; this.room.persistDirty = false;
+        try { this.room.store?.clear?.(); } catch { /* best effort */ }
+        this.room.hosted.clear();
+        try { this.room.onForget?.(); } catch { /* the room is closed either way */ }
+        const msg = JSON.stringify({ t: 'closed', room: this.room.code, until, message });
+        for (const w of this.room.watchers) this.room.sendText(w, msg);
+        this.room.tellWatchers();
+        return { ok: true, op, people, until };
+      }
+      case 'regate': {
+        // A game's launch state changed (NETPLAY.md section 15): who may play is now narrower (`allow`: ticket kinds o,
+        // i, p), or anyone again (`allow` absent: a pending change is cancelled). The current round finishes first.
+        if (!Array.isArray(a.allow)) { const had = Boolean(this.room.regate); this.room.regate = null; this.room.tellWatchers(); return { ok: true, op, cancelled: had }; }
+        const allow = a.allow.filter((k) => ['o', 'i', 'p'].includes(k));
+        const leaving = this.room.live().filter((c) => !this.room.allowedAfter(c, allow)).length;
+        if (!leaving) { this.room.regate = null; this.room.tellWatchers(); return { ok: true, op, leaving: 0 }; }
+        const r = this.room.lastRound;
+        const playing = Boolean(r && r.phase === 'live' && Number(r.endsAt) > now);
+        const until = Math.min(now + 15 * 60_000, playing ? Number(r.endsAt) + 20_000 : now + 30_000);
+        this.room.regate = { allow, roundN: playing ? Number(r.n) : null, until, at: now, message: oneLine(a.message, CONTROL_LIMITS.message) || 'Thanks for playing!' };
+        const notice = oneLine(a.notice, CONTROL_LIMITS.announce);
+        if (notice) this.room.control('announce', { text: notice, seconds: Math.ceil((until - now) / 1000) + 5 });
+        this.room.tellWatchers();
+        return { ok: true, op, leaving, until, afterRound: playing ? Number(r.n) : null };
+      }
+      case 'seats': {
+        const n = Math.floor(Number(a.max));
+        if (!(n >= 1)) return { ok: false, error: 'max', message: 'seats is a number of at least 1' };
+        this.room.setSeats(n);
+        this.room.tellWatchers();
+        return { ok: true, op, max: this.room.maxPlayers };
+      }
+      case 'policy': {
+        // The owner changed the server (section 17): its new policy now, and AI out after the round if it is humans-only.
+        const r = this.room.setPolicy(a.pol, { force: true });
+        return r.ok ? { ...r, op } : { ...r, op };
+      }
+      case 'level': {
+        // The owner sets this room's dial (room_level): it applies at once, as a vote's result does.
+        const n = Math.floor(Number(a.level));
+        if (!(n >= 1 && n <= 5)) return { ok: false, error: 'level', message: 'level is 1 to 5' };
+        this.room.level = Math.min(this.room.policy.levelMax, n);
+        this.room.levelBy = 'owner';
+        this.room.seatsDirty = true;
+        this.room.tellPolicy();
+        this.room.tellWatchers();
+        return { ok: true, op, level: this.room.level, name: skillPreset(this.room.level, { kids: this.room.policy.kids }).name };
+      }
+      default:
+        return { ok: false, error: 'op', message: `no control called ${String(op).slice(0, 24)}` };
+    }
+  }
+allowedAfter(c, allow) {
+    // The owner's own agent passes count as the owner's (only the owner can mint one).
+    return String(c.via ?? '').split('~').some((part) => (part === 'o' && allow.includes('o')) || (part.startsWith('i-') && allow.includes('i')) || (part.startsWith('p-') && allow.includes('p'))
+      || (part.startsWith('a-') && allow.includes('o') && c.agent?.by === 'studio'));
+  }
+applyRegate(now = this.room.now()) {
+    const g = this.room.regate;
+    if (!g) return 0;
+    this.room.regate = null;
+    // The holder of the room's storage keeps the owner's state (the Table writes it on its next tick).
+    this.room.officeDirty = true;
+    const out = this.room.live().filter((c) => !this.room.allowedAfter(c, g.allow));
+    for (const c of out) {
+      const seat = c.seat;
+      const token = c.token;
+      this.room.error(c, 'room-closed', g.message);
+      this.room.onClose(c, 'regated');
+      const s = seat === null ? null : this.room.seats.get(seat);
+      if (s && s.token === token) { this.room.seats.delete(seat); this.room.seatsDirty = true; }
+      try { c.conn.close(1000, 'room-closed'); } catch { /* gone */ }
+      this.room.tellBrowser(c, { t: 'closed', room: this.room.code, message: g.message });
+    }
+    this.room.persist(now);
+    this.room.tellWatchers();
+    return out.length;
+  }
+setStall(ms) {
+    this.room.stallMs = stallOf(ms) ?? STALL.ms;
+    return this.room.stallMs;
+  }
+setCurrent(ver) {
+    this.room.currentVer = ver === undefined ? undefined : versionOf(ver);
+  }
+forgetWorld(next) {
+    this.room.log({ ev: 'build-changed', room: this.room.code, from: this.room.gameVer ?? null, to: next ?? null });
+    this.room.lastSnap = null; this.room.lastSnapText = null; this.room.lastCkpt = null; this.room.lastRound = null; this.room.lastRoster = null; this.room.rosterSent = null;
+    this.room.state.clear(); this.room.stateBytes = 0; this.room.preferHost = null;
+    this.room.persistDirty = true;
+  }
+setSeats(n, perIp = null) {
+    this.room.seatCap = Math.max(1, Math.floor(n));
+    this.room.maxPlayers = Math.max(1, Math.min(this.room.seatCap, (this.room.server || this.room.rules) ? this.room.seatCap : this.room.askedMax ?? this.room.seatCap));
+    if (Number.isFinite(perIp) && perIp >= 0) this.room.perIp = perIp;
+  }
+officeSaved() {
+    const now = this.room.now();
+    return {
+      bans: this.room.bans.filter((b) => b.until > now), mutes: this.room.mutes.filter((m) => m.until > now),
+      announcement: this.room.liveAnnouncement(), closedUntil: this.room.closedUntil > now ? this.room.closedUntil : 0, closedWhy: this.room.closedWhy,
+      regate: this.room.regate, agentsOut: this.room.agentsOut,
+    };
+  }
+restoreOffice(o) {
+    if (!o || typeof o !== 'object') return;
+    const now = this.room.now();
+    this.room.bans = (Array.isArray(o.bans) ? o.bans : []).filter((b) => b && b.until > now).slice(-CONTROL_LIMITS.bans);
+    this.room.mutes = (Array.isArray(o.mutes) ? o.mutes : []).filter((m) => m && m.until > now).slice(-CONTROL_LIMITS.mutes);
+    this.room.announcement = o.announcement && o.announcement.until > now ? o.announcement : null;
+    this.room.closedUntil = Number(o.closedUntil) > now ? Number(o.closedUntil) : 0;
+    this.room.closedWhy = this.room.closedUntil ? String(o.closedWhy ?? '') : '';
+    // A launch change still waiting comes back; one long past is over (whoever it was for has gone).
+    this.room.regate = o.regate && Array.isArray(o.regate.allow) && Number(o.regate.until) > now - 120_000 ? o.regate : null;
+    this.room.agentsOut = o.agentsOut && Number(o.agentsOut.until) > now - 120_000 ? o.agentsOut : null;
+  }}

package/worker/room-lifecycle.mjs

@@ -0,0 +1,10 @@
+export const ROOM_ALARM_MS = 10 * 60_000;
+
+export const ROOM_PAUSE_MS = 60_000;
+
+export function roomEndAt({ people, pausedAt, createdAt, restoredAt = null, savedAt = null, alarmAt = null }) {
+  // Only people keep play alive. With no durable alarm, the last save bounds an unrecorded departure.
+  const absence = pausedAt ?? (restoredAt !== null && alarmAt === null ? savedAt : null) ?? restoredAt ?? createdAt;
+  return people > 0 ? Infinity : absence + ROOM_PAUSE_MS;
+}
+

package/worker/room-protocol.mjs

@@ -0,0 +1,197 @@
+
+
+/** Shared wire constants and validation; importing these never loads the relay engine. */
+
+export { LIMITS, GROWS, capOf } from './limits.mjs';
+
+
+import { CHAT_LIMITS, normalizeChat } from './chat.mjs';
+
+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 = 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
+ * 1.5 s (a shorter one swaps hosts on a single slow frame) and never over 10 s (a frozen host must still be replaced
+ * while its players are watching a still picture).
+ */
+export const STALL = Object.freeze({ ms: 1500, min: 1500, max: 10_000 });
+/** A game's own stall time, held to STALL's bounds; null when it names none (or not a number). */
+export function stallOf(v) {
+  const n = Math.floor(Number(v));
+  return Number.isFinite(n) && n > 0 ? Math.max(STALL.min, Math.min(STALL.max, n)) : null;
+}
+const VERSION_TEXT = /^[A-Za-z0-9._-]{1,32}$/;
+/** A game revision (game.json `netplay.version`): 1 to 32 of A-Z a-z 0-9 . _ -, a number as its digits; else null. */
+export function versionOf(v) {
+  const t = typeof v === 'number' && Number.isFinite(v) ? String(v) : typeof v === 'string' ? v.trim() : '';
+  return VERSION_TEXT.test(t) ? t : null;
+}
+const FEATURE_TEXT = /^[a-z0-9][a-z0-9-]{0,23}$/;
+/** What a build says it can do (`hello.feat`): up to 8 short lowercase words. */
+export function featuresOf(list) {
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const x of list) { const k = String(x ?? '').toLowerCase(); if (FEATURE_TEXT.test(k) && !out.includes(k)) out.push(k); if (out.length >= 8) break; }
+  return out;
+}
+/**
+ * A SOCKET THAT WENT AWAY IS NOT A FAILED ROOM. A browser that closes its tab, loses its network or is replaced by a
+ * new host ends its socket without a goodbye, and the runtime reports that as an error ("Network connection lost",
+ * "WebSocket peer disconnected"…). Those are departures: the room has already handled them (the seat is held, the
+ * host is replaced). Anything else thrown while the room was doing something IS a failure, and is logged with the
+ * room and what it was doing. `departure(error)` says which; the transport (the Table) asks it at its boundary.
+ */
+const DEPARTURE = /network connection lost|connection (?:was )?(?:closed|reset|aborted|lost)|peer disconnected|websocket (?:is )?(?:closed|closing|not open|already closed)|socket (?:is )?closed|client disconnected|disconnected|broken pipe|econnreset|epipe|aborted|cancell?ed|the script will never generate a response|durable object reset/i;
+export function departure(error) {
+  const text = typeof error === 'string' ? error : `${error?.name ?? ''} ${error?.message ?? ''} ${error?.code ?? ''}`;
+  return DEPARTURE.test(text);
+}
+/** An error as a log line carries it: its name and message, cut short. Never the frame it was thrown for. */
+export function errorLine(error) {
+  return String(error?.stack && typeof error.stack === 'string' ? error.stack.split('\n').slice(0, 4).join(' | ') : error?.message ?? error).slice(0, 400);
+}
+const POLICY_KINDS = ['open', 'humans-only', 'hybrid', 'beginner'];
+/**
+ * A room's policy before the Worker says anything (and the public server's with nothing set): today's behaviour.
+ * NETPLAY.md section 17: `server` null is a named room; `aiSeats + guides` seats are kept for AI (the top seats).
+ */
+export const DEFAULT_POLICY = Object.freeze({ v: 1, at: 0, server: null, kind: 'open', aiSeats: 0, guides: 0, bots: 'fill', level: 3, levelMax: 5, speech: 'game', kids: false, brain: 'script' });
+/** An agent's speech: at most one line every 4 s and 8 a minute (the relay drops the rest and counts them). */
+export const AGENT_SPEECH = Object.freeze({ gapMs: 4000, perMinute: 8 });
+/** The party's vote on the dial: open 15 s (or until every seated person voted); one opened by a player per 2 min. */
+export const VOTE = Object.freeze({ ms: 15_000, cooldownMs: 120_000, autoMs: 30 * 60_000 });
+/** Agents left with no person seated for this long are closed (`agents-alone`): an AI never keeps a room alive. */
+export const AGENTS_ALONE_MS = 60_000;
+const CAPS = ['skill', 'agents'];
+/** Revision 7: what a game's host shows an AI (`agent:view`) and how often an AI may act (`agent:do`). */
+export const AGENT_FRAMES = Object.freeze({ viewMs: 2000, viewBytes: 2048, doMs: 3000 });
+const SAY = /^say:([a-z][a-z0-9_]{0,31})$/;
+const d0 = (m) => (m.d && typeof m.d === 'object' && !Array.isArray(m.d) ? m.d : {});
+const ASK = /^ask:([a-z][a-z0-9_]{0,31})$/;
+
+/** A policy as the relay keeps it: every field checked (the Worker composed it, but a bad one must not break a room). */
+export function normalizePolicy(p) {
+  if (!p || typeof p !== 'object') return null;
+  const int = (v, lo, hi, d) => { const n = Math.floor(Number(v)); return Number.isFinite(n) ? Math.max(lo, Math.min(hi, n)) : d; };
+  const kind = POLICY_KINDS.includes(p.kind) ? p.kind : 'open';
+  const kids = p.kids === true;
+  const levelMax = int(p.levelMax, 1, kids ? 3 : 5, kids ? 3 : 5);
+  const server = p.server && typeof p.server === 'object' && /^[a-z0-9][a-z0-9-]{0,19}$/.test(String(p.server.id ?? ''))
+    ? { id: String(p.server.id), name: String(p.server.name ?? p.server.id).replace(/[\u0000-\u001f\u007f]+/g, ' ').slice(0, 40) } : null;
+  const reserveOk = kind === 'hybrid' || kind === 'beginner';
+  return {
+    v: 1, at: Math.max(0, Number(p.at) || 0), server, kind,
+    aiSeats: reserveOk ? int(p.aiSeats, 0, 31, 0) : 0, guides: kind === 'beginner' ? int(p.guides, 0, 31, 0) : 0,
+    bots: p.bots === 'off' ? 'off' : 'fill', level: Math.min(levelMax, int(p.level, 1, 5, 3)), levelMax,
+    speech: ['game', 'lines', 'off'].includes(p.speech) ? p.speech : 'game', kids,
+    brain: kind === 'humans-only' ? 'off' : ['off', 'script', 'workers-ai', 'owner-key'].includes(p.brain) ? p.brain : 'script',
+    // Revision 8: the room's chat rules (section 19), capped by the server's speech and kids.
+    ...(p.chat !== undefined ? { chat: normalizeChat(p.chat === false ? { mode: 'off' } : p.chat, { kids, speech: ['game', 'lines', 'off'].includes(p.speech) ? p.speech : 'game' }) } : {}),
+  };
+}
+const policySig = (p) => JSON.stringify({ ...p, at: 0 });
+/** The lower middle of the votes (DESIGN D8: a tie is settled kindly), or null with none. */
+export function medianVote(list) {
+  const v = [...list].filter(Number.isFinite).sort((a, b) => a - b);
+  return v.length ? v[Math.floor((v.length - 1) / 2)] : null;
+}
+const utf8 = new TextEncoder();
+// A message's size in bytes. Text that is all ASCII (nearly every frame a game sends) is as long as it is wide: it is
+// not encoded to be measured, which at ten inputs a second from a thousand players was a twentieth of a room's second.
+const ASCII = /^[\x00-\x7f]*$/;
+const byteLength = text => ASCII.test(text) ? text.length : utf8.encode(text).length;
+const PALETTE_SIZE = 12;
+const DEVICE_RANK = { desk: 0, tv: 1, phone: 2 };
+
+/** Rate caps (messages per rolling second, per client). Over the cap a message is dropped, counted and reported. */
+export { RATES, EV_RATES, STATE_CAPS } from './limits.mjs';
+
+/**
+ * THE OWNER'S CONTROLS (revision 4, NETPLAY.md section 15). The studio's Worker, acting for the signed-in owner,
+ * hands the room a control: kick a player out (and hold the door for some minutes), mute one, announce a line to
+ * everyone, close the room, or change its seats. The Table verifies the owner's signature before it calls
+ * `control()`; this file only applies one. What a player sees of them is new optional frames and two new refusals,
+ * so a v1 game that knows none of it keeps playing (its shell shows the notice and the banner).
+ */
+export const CONTROL_LIMITS = Object.freeze({ minutes: 24 * 60, announce: 280, announceSeconds: 3600, bans: 200, mutes: 200, message: 200 });
+/** What a muted player cannot say: an `ev` whose kind starts with one of these (a game's chat, quick lines, emotes). */
+export const SPEECH = /^(?:say|chat|emote)/i;
+/**
+ * The contract's 12 player colours: a peer's `colour` (its seat % 12) is an index into this list. The watch page's
+ * player strip draws them; a game that colours its players the same way matches it (Gem Rush does).
+ */
+export const NET_PALETTE = Object.freeze(['#8fe36a', '#ffd166', '#ef6f6c', '#6cb4ee', '#c792ea', '#f4a261', '#2ec4b6', '#ff8fab', '#a7c957', '#e9c46a', '#90e0ef', '#f28482']);
+/**
+ * What a game lets its watchers see (game.json "watch", passed by the Worker as `conn.watchPolicy`): `follow` (any
+ * player's view, the default), `overview` (the whole room only: a game with hidden hands or hidden roles), `off`.
+ */
+export const WATCH_POLICIES = Object.freeze(['follow', 'overview', 'off']);
+const oneLine = (v, max) => String(v ?? '').replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+/** A short tag for a browser's room key: enough for the owner to see "the same browser", never the key itself. */
+export function browserTag(key) {
+  if (!key) return null;
+  let h = 2166136261;
+  for (const ch of String(key)) h = Math.imul(h ^ ch.charCodeAt(0), 16777619) >>> 0;
+  return h.toString(36).padStart(6, '0').slice(-6);
+}
+
+/**
+ * A seat's handle when its player typed no name: two words, varied per seat and per room ("Velvet Comet"), never
+ * "Player 1" (a game that falls back to a list by seat number made every room's first player the same name).
+ * At most 16 characters, so a game that trims names at 18 keeps all of it.
+ */
+export const HANDLE_WORDS = Object.freeze({
+  first: ['Neon', 'Velvet', 'Static', 'Amber', 'Cobalt', 'Lucky', 'Rapid', 'Silent', 'Solar', 'Lunar', 'Crimson', 'Golden',
+    'Frosty', 'Wild', 'Quiet', 'Swift', 'Brave', 'Clever', 'Cosmic', 'Mellow', 'Rusty', 'Shiny', 'Sunny', 'Stormy', 'Turbo',
+    'Pixel', 'Retro', 'Jolly', 'Nimble', 'Bold', 'Misty', 'Copper'],
+  second: ['Comet', 'Otter', 'Falcon', 'Fox', 'Panda', 'Rocket', 'Tiger', 'Raven', 'Pilot', 'Ranger', 'Rider', 'Moth', 'Koi',
+    'Lynx', 'Heron', 'Badger', 'Yeti', 'Wolf', 'Bison', 'Gecko', 'Orca', 'Puma', 'Sparrow', 'Beacon', 'Meteor', 'Nova',
+    'Ember', 'Drift', 'Spark', 'Echo', 'Kite', 'Mantis'],
+});
+/** The handle for a seat token (random per seat), skipping any handle another seat in the room already has. */
+export function handleFor(token, taken = new Set()) {
+  let h = 2166136261;
+  for (const ch of String(token ?? '')) h = Math.imul(h ^ ch.charCodeAt(0), 16777619) >>> 0;
+  const { first, second } = HANDLE_WORDS;
+  const all = first.length * second.length;
+  for (let i = 0; i < all; i += 1) {
+    const n = (h + i * 7919) % all;
+    const name = `${first[n % first.length]} ${second[Math.floor(n / first.length) % second.length]}`;
+    if (!taken.has(name)) return name;
+  }
+  return `${first[h % first.length]} ${second[h % second.length]}`;
+}
+
+/** Random bytes as base64url, with no Node Buffer (runs in workerd too). */
+function randomId(n) {
+  const raw = new Uint8Array(n);
+  crypto.getRandomValues(raw);
+  let s = '';
+  for (const b of raw) s += String.fromCharCode(b);
+  return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+/** Press counts are summed by the host: clamp them so `{fire: 1e9}` is 8, not a billion loop turns. */
+function clampPresses(p) {
+  if (!p || typeof p !== 'object' || Array.isArray(p)) return null;
+  const out = {};
+  let n = 0;
+  for (const [k, v] of Object.entries(p)) {
+    if (n >= 16) break;
+    const c = Math.max(0, Math.min(8, Math.floor(Number(v) || 0)));
+    if (c) { out[String(k).slice(0, 32)] = c; n += 1; }
+  }
+  return n ? out : null;
+}
+
+/** A kept line the Worker read from the room's history (its id, name and sender's account), for a mute or a kick. */
+function keptRef(a) {
+  const k = a.kept && typeof a.kept === 'object' ? a.kept : null;
+  if (!k || k.id !== a.line || !k.from || typeof k.from.player !== 'string') return null;
+  return { id: k.id, name: oneLine(k.name, CHAT_LIMITS.name) || 'Someone', seat: null, from: { client: null, token: null, browser: null, player: k.from.player } };
+}
+
+
+export {VERSION_TEXT,FEATURE_TEXT,DEPARTURE,POLICY_KINDS,CAPS,SAY,d0,ASK,policySig,utf8,ASCII,byteLength,PALETTE_SIZE,DEVICE_RANK,oneLine,randomId,clampPresses,keptRef};