@homie-rocks/studio 0.46.3 → 0.46.6

package/worker/index.mjs

@@ -90,9 +90,9 @@ import { appRole, openPath } from './app-format.mjs';
 import { playerEnabled, EMBED_GAME_JS } from './embed.mjs';
 import { NetRoom, WATCH_POLICIES, departure, errorLine, versionOf } from './room.mjs';
 import { hostedGame, hostedBuild, compiledFor, startHost } from './hosted.mjs';
-import { roomStore, restoreDelay } from './room-store.mjs';
+import { roomStore, restoreDelay, LOOSE_SAVE } from './room-store.mjs';
 import { appCors, isAppOrigin } from './standalone.mjs';
-import { ROOM_ID, badRoomPage, embedAncestors, embedPreview, frameAncestors, noWatchPage, playPage, watchPage } from './pages.mjs';
+import { ROOM_ID, badRoomPage, embedAncestors, embedPreview, frameAncestors, noWatchPage, playPage, shellKey, shellStandIn, watchPage } from './pages.mjs';
 import {
   PUBLIC_SERVER, SERVER_ID, homeOf, memberCounts, memberOf, noteMember, policyOf, pooledRoom, roomCode, roomServer, serverAccess, serverPassOf, serverView, serversOf,
   setMembership,
@@ -105,7 +105,7 @@ 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 { acceptMultiplex, diagnosticsOf, gateFor, nextGate } from './gate.mjs';
+import { acceptMultiplex, diagnosticsOf, gateFor, gatePlayers, nextGate } from './gate.mjs';
 import { worldSource } from './world-wire.mjs';
 export { Gate, Concentrator } from './gate.mjs';
 import { seatCount, paramsFrom, perAddress, seatsOf } from './seats.mjs';
@@ -1226,6 +1226,17 @@ async function route(request, env, ctx) {
     if (sub === '__game' || sub === '__game/' || sub === '__game/index.html') {
       if (url.searchParams.get('embed') === '1' && (!playerEnabled(cat, meta) || launch !== 'public')) return notFoundPage('Embedding is off for this game.', cat);
       const who = await ticketSub(env, game, url.searchParams.get('t'));
+      // A play page left open across a deploy (0.46.5). One that names what it was made for (`sh`) and is behind is
+      // told so, and reloads itself whole, once, to the same room and seat. One from before that handshake is sent
+      // to a fresh page only when this game cannot work inside it: the game keeps verified results for a player, and
+      // the old page has no player ticket to give its frame (a result would have nobody to be written for).
+      if (url.searchParams.get('pf') === '1' && url.searchParams.get('embed') !== '1' && url.searchParams.get('want') !== 'screen' && !url.searchParams.has('watch')) {
+        const said = url.searchParams.get('sh'), now = shellKey(meta);
+        const ticketless = Boolean(meta.room?.records && env.DB) && !holders(who).some((x) => x.startsWith('p-'));
+        if (said !== null ? said !== now : ticketless) {
+          return new Response(shellStandIn(url.searchParams.get('room') ?? '', said !== null ? now : null), { headers: { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' } });
+        }
+      }
       if (launch !== 'public' && !(await ticketAllows(env, who, launch))) return new Response('This game is not open to you.\n', { status: 403, headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' } });
       // An agent's frame (hands `self`): the game plays as that AI.
       const agentPart = holders(who).find((x) => x.startsWith('a-'));
@@ -1350,6 +1361,9 @@ export class Table {
       if (this.saved?.retired === true) this.cleanupPending = true;
       this.recorded = (await ctx.storage.get('recorded')) ?? 0;
       this.officeSaved = (await ctx.storage.get('office')) ?? null;
+      // A big match room's last unconfirmed checkpoint (worker/room-store.mjs), read once as the object wakes.
+      try { this.looseSave = (await ctx.storage.list?.({ prefix: LOOSE_SAVE })) ?? null; }
+      catch (error) { this.looseSave = null; this.storageProblem(error); }
     });
   }
 
@@ -1423,7 +1437,7 @@ export class Table {
     try {
       const build = hostedBuild(this.game);
       const persistent = this.isPersistent();
-      try { this.durable ??= roomStore(this.ctx.storage, { persistent: this.isPersistent() }); } catch (error) { if (persistent) throw error; this.storageProblem(error); }
+      try { this.durable ??= this.openStore(); } catch (error) { if (persistent) throw error; this.storageProblem(error); }
       let saved = this.cleanupPending ? null : this.readRoom();
       restoring = Boolean(saved);
       if (this.persistentStored && build.settings.lifetime !== 'persistent') throw new Error('This room holds a lasting world. Keep room.lifetime persistent; its save is retained.');
@@ -1469,7 +1483,9 @@ export class Table {
       this.hostRt = startHost(this.game, {
         ...(saved ? { restore: new TextEncoder().encode((saved.hostText ?? JSON.stringify(saved.host))), restoreEpoch: epoch, startDelayMs: boot.count === 1 ? restoreDelay(`${this.game}/${this.code}`) : 0 } : {}),
         record: (owner,key,value) => this.queueRoundRecord(owner,key,value),
-        store: { save: (bytes, commitment) => this.saveRoom(bytes, commitment) },
+        store: { save: (bytes, commitment) => this.saveRoom(bytes, commitment, true) },
+        // A room behind Gates needs no snapshot as text: nothing is encoded that nobody is sent (room.mjs, hostSnap).
+        snapshotText: () => !this.relayed,
         ...(build.settings.characters ? { characterFor: (peer) => {
           const account = room.clients.get(peer.id)?.player;
           return account ? this.characterGrants.get(account) ?? null : null;
@@ -1509,12 +1525,19 @@ export class Table {
     }
   }
 
-  saveRoom(bytes, commitment) {
+  /** This object's room store, with the unconfirmed checkpoint it woke to (if any). */
+  openStore(persistent = this.isPersistent()) {
+    const loose = this.looseSave; this.looseSave = null;
+    return roomStore(this.ctx.storage, { persistent, loose, onProblem: (error) => this.storageProblem(error) });
+  }
+
+  /** `periodic`: the rules host's own checkpoint of a tick, as against a save an admission or a pause asked for. */
+  saveRoom(bytes, commitment, periodic = false) {
     if (this.persistentFailed) throw new Error('Lasting world stopped; restart from its committed save');
     const now = Date.now();
     if (now < (this.saveRetryAt ?? 0)) throw this.saveError ?? new Error('room save retry is waiting');
     try {
-      this.durable ??= roomStore(this.ctx.storage, { persistent: this.isPersistent() });
+      this.durable ??= this.openStore();
       const build = hostedBuild(this.game);
       const host = new TextDecoder().decode(bytes);
       const net = this.room.saved();
@@ -1533,6 +1556,10 @@ export class Table {
         commitment ??= { force: false, seconds: c.settings.durability.movementSeconds, tickHz: c.settings.tickHz,
           fields: { kinds: c.kinds.map(k => k.fields.flatMap(([,f],i) => f.durable ? [i] : [])), shared: c.shared.flatMap(([,f],i) => f.durable ? [i] : []) } };
         this.durable.commit(saved, commitment);
+      } else if (this.relayed && periodic && !clearing) {
+        // A room behind Gates: its once-a-second checkpoint holds none of its frames (worker/room-store.mjs). A save
+        // an admission asks for is still confirmed before the welcome that names the seat can leave.
+        this.durable.write(saved, { unconfirmed: true });
       } else this.durable.write(saved);
       if (clearing) { this.cleanupGeneration = (this.cleanupGeneration ?? 0) + 1; this.queueNetCleanup(false); }
       this.roomSave = saved;
@@ -1731,7 +1758,7 @@ export class Table {
     const room = this.room;
     if (!room || !this.hostRt) {
       if (this.ctx.storage.sql?.exec("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'save'").toArray().length) {
-        this.durable ??= roomStore(this.ctx.storage);
+        this.durable ??= this.openStore(false);
         const saved = this.cleanupPending ? null : this.readRoom(true);
         if (saved) {
           this.game = saved.game; this.code = saved.room;
@@ -1778,7 +1805,12 @@ export class Table {
     sql.exec('CREATE TABLE IF NOT EXISTS round_players(owner TEXT PRIMARY KEY,player TEXT)');
     const client=[...this.room.clients.values()].find(c=>c.seat!==null&&'p'+this.room.seats.get(c.seat)?.occ===owner);
     const player=client?.player??sql.exec('SELECT player FROM round_players WHERE owner=?',owner).toArray()[0]?.player;
-    if(!player)return;
+    if(!player){
+      // Never dropped in silence (0.46.5): the log says so, and the person is told on their own screen.
+      try{console.error(JSON.stringify({at:new Date().toISOString(),ev:'record-unsaved',why:'no-player',game:this.game??null,room:this.code??null,key,id:value?.id??null}));}catch{}
+      if(client)this.room.error(client,'unsaved','This round was not saved to your history. Reload the page to keep the next one.');
+      return;
+    }
     sql.exec('CREATE TABLE IF NOT EXISTS round_outbox(id TEXT PRIMARY KEY,player TEXT,key TEXT,value TEXT)');
     sql.exec('INSERT OR IGNORE INTO round_outbox VALUES(?,?,?,?)',player+':'+key+':'+value.id,player,key,JSON.stringify(value));
     this.ctx.waitUntil(this.flushRoundRecords());
@@ -2102,7 +2134,7 @@ export class Table {
       // players sent to a Gate in the last ten seconds who have not reached it yet.
       const gates = Number(new URL(request.url).searchParams.get('gates')) || 1, now = Date.now(), promised = new Map();
       for (const [index, due] of this.gatePromised) { const live = due.filter((at) => at > now); if (live.length) { this.gatePromised.set(index, live); promised.set(index, live.length); } else this.gatePromised.delete(index); }
-      const gate = nextGate(gates, this.gateHeld, promised);
+      const gate = nextGate(gates, this.gateHeld, promised, gatePlayers(this.env));
       if (!this.gatePromised.has(gate)) this.gatePromised.set(gate, []);
       this.gatePromised.get(gate).push(now + 10_000);
       return json({ gate });
@@ -2382,6 +2414,8 @@ export class Table {
       // A Gate's stamp on a player's message to this object handling it, ms.
       inputTransitMs: { n: transit.length, p50: at(0.5), p95: at(0.95), max: transit.at(-1) ?? null },
       durability: this.storageHealth ?? { ok: true },
+      // Checkpoints written without holding the room's frames for them (worker/room-store.mjs), so far.
+      save: { unconfirmed: this.durable?.unconfirmedWrites ?? 0 },
     });
     const work = diagnosticsOf(this.env, this.game, this.code).fetch('https://diagnostics/__diagnostics', { method: 'POST', body })
       .then((r) => r.body?.cancel?.())

package/worker/office.mjs

@@ -62,7 +62,7 @@ import { toolIdentity } from './tool-identity.mjs';
  * from an office key it is ALWAYS an ask (the AI may only propose one), and so is marking a referrer paid.
  */
 import { seatsOf } from './seats.mjs';
-import { diagnosticsOf, roomLayout } from './gate.mjs';
+import { diagnosticsOf, gatePlayers, roomLayout } from './gate.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';
@@ -432,7 +432,7 @@ async function roomFacts(env, game, room, max) {
  * small room answers for itself, as it always has.
  */
 export async function roomDiagnostics(env, game, room, max) {
-  if (!env.GATE || roomLayout(max).gates === 1) return roomFacts(env, game, room, max);
+  if (!env.GATE || roomLayout(max, gatePlayers(env)).gates === 1) return roomFacts(env, game, room, max);
   let kept = null;
   try {
     const res = await diagnosticsOf(env, game, room).fetch(`https://diagnostics/__diagnostics?room=${enc(room)}`);

package/worker/pages.mjs

@@ -8,6 +8,36 @@ import { playerAncestors, PLAYER_SANDBOX, PLAYER_SIZE } from './embed.mjs';
 import { esc, layout, gameSocialTags } from './site.mjs';
 import { NET_PALETTE } from './room.mjs';
 import { PARAM_VALUE, PREFS_LIMITS, playParams } from './seats.mjs';
+import { STUDIO_VERSION_TAG } from './version.mjs';
+
+/**
+ * What a play page was made for (0.46.5): the toolkit that wrote it and the parts of the game's manifest it is built
+ * around (who may sit, what the room keeps, whether the player has saves and a ticket). The page hands it to the
+ * game's frame (`sh`), and the Worker that serves the frame knows what a page made now would say. A page left open
+ * across a deploy says something older: it is brought up to date with one full reload, to the same room and seat,
+ * instead of hosting a newer game inside a page that lacks what that game needs (a player ticket, for one).
+ * It does not change when only the game's code or art does: that is still a reload of the frame alone.
+ */
+export function shellKey(g) {
+  // Never what names a build (the rules' build and state hashes, the bundle's version): those change with every
+  // edit, and a newer build of the same game inside the same page is exactly what the frame's own reload is for.
+  const { build: _build, stateHash: _state, ...room } = g?.room ?? {};
+  const { version: _version, ...netplay } = g?.netplay ?? {};
+  const text = JSON.stringify([g?.kind ?? null, g?.players ?? null, room, g?.saves ?? null, g?.agents ?? null, g?.screen ?? null, netplay, g?.launch ?? null]);
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i += 1) { h ^= text.charCodeAt(i); h = Math.imul(h, 16777619); }
+  return `${STUDIO_VERSION_TAG}-${(h >>> 0).toString(36)}`;
+}
+/**
+ * The frame's stand-in when its page is older than the game it would host. It tells the page, and loads no game.
+ * `key`: the page understands the handshake and reloads itself once. No key: a page from before the handshake, whose
+ * only way to load a whole new page is the one it has for leaving a finished room; it is used only when the game cannot
+ * work inside that page at all.
+ */
+export function shellStandIn(room, key) {
+  const message = key ? { t: 'homie-net', what: 'shell', key } : { t: 'homie-net', what: 'rematch', room };
+  return `<!doctype html><meta charset="utf-8"><title>Updating</title><body style="margin:0;background:#0b0d14;color:#cfd6e6;font:15px system-ui;display:grid;place-items:center;height:100vh"><p>This game was updated. Loading it again…</p><script>try{parent.postMessage(${JSON.stringify(message).replace(/</g, '\\u003c')},'*');}catch(e){}</script>`;
+}
 import { SKILLS } from './agents.mjs';
 import { KIDS_LINE, POLICY_WORDS } from './servers.mjs';
 import { SAVES_SHELL_CSS, SAVES_SHELL_JS } from './saves-shell.mjs';
@@ -180,7 +210,7 @@ ${SERVER_CSS}${CHAT_CSS}${g.saves && !screen ? SAVES_SHELL_CSS : ''}${shop ? SHO
   // game.json "agents": { "vote": "game" } draws its own vote card; false turns the vote off (section 17).
   const vote = g.agents?.vote === 'game' || g.agents?.vote === false ? g.agents.vote : 'shell';
   // The address's switches the game's frame is handed (NETPLAY.md section 24): the defaults and the game's own names.
-  const boot = { ...(g.kind === 'app' ? { kind: 'app', appWords: appWords(g) } : {}), embed, game: g.id, name: g.name, screen: Boolean(screen), share: places, params: playParams(g), paramValue: PARAM_VALUE, prefs: PREFS_LIMITS, ...(room ? { room } : {}), ...(ticket ? { t: ticket } : {}), ...(owner ? { owner: true, launch } : {}), ...(srv ? { server: srv } : {}), vote, skills: SKILLS.map((k) => ({ level: k.level, name: k.name, card: k.card })), words: POLICY_WORDS, kidsLine: KIDS_LINE, ...(shop ? { shop } : {}) };
+  const boot = { ...(g.kind === 'app' ? { kind: 'app', appWords: appWords(g) } : {}), embed, game: g.id, name: g.name, screen: Boolean(screen), share: places, params: playParams(g), paramValue: PARAM_VALUE, prefs: PREFS_LIMITS, ...(room ? { room } : {}), ...(ticket ? { t: ticket } : {}), sh: shellKey(g), ...(owner ? { owner: true, launch } : {}), ...(srv ? { server: srv } : {}), vote, skills: SKILLS.map((k) => ({ level: k.level, name: k.name, card: k.card })), words: POLICY_WORDS, kidsLine: KIDS_LINE, ...(shop ? { shop } : {}) };
   // game.json "screen": { "join": "top-left" | "top-right" | "bottom-left" | "bottom-right" } keeps the card off the game's own HUD.
   const joinCorner = corner('join', 'bottom-right');
   const first = places.desk;
@@ -497,6 +527,8 @@ const SHELL_JS = String.raw`${BUILD_RETRY_JS}(function () {
       q.set('b', roomKey);
       if (boot.embed) q.set('name', guestName);
       if (boot.t) q.set('t', boot.t);
+      // What this page was made for (0.46.5): the Worker answers with a stand-in when a page made now would differ.
+      if (boot.sh) q.set('sh', shellSaid || boot.sh);
       if (!boot.embed && params.get('name')) q.set('name', params.get('name'));
       else if (!boot.embed) {
         // A player with an account (or a named guest) on this studio plays under their own name in every room.
@@ -517,6 +549,18 @@ const SHELL_JS = String.raw`${BUILD_RETRY_JS}(function () {
     }
     state.params = {};
     (boot.params || []).forEach(function (k) { var v = params.get(k); if (v !== null && new RegExp(boot.paramValue || '^$').test(v)) state.params[k] = v; });
+    // The Worker says this page is older than the game (a deploy while it was open): one full reload, which keeps the
+    // room (it is in the address) and the seat (its token is in this tab's storage). Once for each newer page: if the
+    // reload came back the same, the frame is asked for as the Worker described it and play goes on.
+    var shellSaid = '';
+    function shellBehind(key) {
+      var tried = '';
+      try { tried = sessionStorage.getItem('homie-shell') || ''; } catch (e) {}
+      if (tried === key) { shellSaid = key; frame.src = frameUrl(); return; }
+      try { sessionStorage.setItem('homie-shell', key); } catch (e) { shellSaid = key; frame.src = frameUrl(); return; }
+      state.shellReload = key;
+      location.reload();
+    }
     var updating = buildRetry(function () {
       state.stale = null; state.closed = null; state.reloaded = (state.reloaded || 0) + 1;
       frame.src = frameUrl();
@@ -532,6 +576,7 @@ const SHELL_JS = String.raw`${BUILD_RETRY_JS}(function () {
       var m = ev.data;
       if (!m || typeof m !== 'object' || m.t !== 'homie-net') return;
       A.message(m);
+      if (m.what === 'shell' && typeof m.key === 'string' && /^[A-Za-z0-9._-]{1,64}$/.test(m.key)) { shellBehind(m.key); return; }
       if (m.what === 'wait') updating.stop();
       if (m.what === 'build' && updating.acknowledge(m.ver) && toast) toast.hidden = true;
       if (m.what === 'attached' || m.what === 'ready') updating.reported();

package/worker/room-store.mjs

@@ -12,8 +12,42 @@ import { normalizeWorld, denormalizeWorld, durableWorld, ownDurable, checkpointW
  * Only integer primary keys: no secondary-index write amplification.
  * The boot row outlives a save being replayed, so two restores of that save can never reuse an epoch.
  */
-export function roomStore(storage, { persistent = false } = {}) {
+export function roomStore(storage, { persistent = false, loose = null, onProblem = () => {} } = {}) {
   const sql = storage.sql;
+  /*
+   * THE CHECKPOINT THAT DOES NOT HOLD THE ROOM'S FRAMES. Cloudflare holds everything an object sends after a write
+   * until that write is confirmed. A match room behind Gates writes its whole self once a second, and every world
+   * and every receipt of the ticks that followed waited on it: one or two worlds a second reached every Gate a
+   * tick or more late, at every size. Such a checkpoint is a second old by design, and the worlds between two of
+   * them were never durable, so nothing a player sees is being promised. `write(value, { unconfirmed: true })`
+   * puts it in the object's key-value storage with `allowUnconfirmed`, which is Cloudflare's own way to say so.
+   *
+   * Every confirmed write removes it, so one found on disk was written after the last confirmed save, unless the
+   * object stopped between a confirmed write and that removal: each save says when it was made (`at`), and a read
+   * takes the later of the two. `loose` is what the object read of it when it woke (a Map from
+   * `storage.list({ prefix: LOOSE_SAVE })`); reads after that are answered from memory.
+   */
+  let looseText = null, looseOnDisk = false, looseWrites = 0;
+  if (loose && typeof loose.get === 'function' && loose.get(LOOSE_SAVE)) {
+    looseOnDisk = true;
+    try {
+      const meta = loose.get(LOOSE_SAVE), pieces = [];
+      for (let i = 0; i < meta.pieces; i += 1) { const piece = loose.get(`${LOOSE_SAVE}/${i}`); if (!(piece instanceof Uint8Array)) throw new Error('unconfirmed save pieces missing'); pieces.push(piece); }
+      const bytes = new Uint8Array(pieces.reduce((n, p) => n + p.length, 0));
+      let at = 0;
+      for (const piece of pieces) { bytes.set(piece, at); at += piece.length; }
+      if (!Number.isInteger(meta.pieces) || meta.pieces < 1 || bytes.length !== meta.bytes || bytes.length > 16_000_000) throw new Error('unconfirmed save does not fit its record');
+      looseText = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+      JSON.parse(looseText);
+    } catch (error) { looseText = null; onProblem(error); }
+  }
+  /** Removed with whatever confirmed write is being made: no await between them, so they are one transaction. */
+  function dropLoose() {
+    looseText = null;
+    if (!looseOnDisk || typeof storage.delete !== 'function') return;
+    looseOnDisk = false;
+    Promise.resolve(storage.delete([LOOSE_SAVE, ...Array.from({ length: LOOSE_PIECES }, (_, i) => `${LOOSE_SAVE}/${i}`)])).catch(onProblem);
+  }
   sql.exec('CREATE TABLE IF NOT EXISTS save (id INTEGER PRIMARY KEY, data BLOB NOT NULL)');
   sql.exec('CREATE TABLE IF NOT EXISTS boots (id INTEGER PRIMARY KEY, data TEXT NOT NULL)');
   let journalReady = false;
@@ -47,13 +81,22 @@ export function roomStore(storage, { persistent = false } = {}) {
       const total = sql.exec('SELECT SUM(length(data)) AS bytes FROM save').toArray()[0]?.bytes ?? 0;
       if (total > maxBytes) throw new Error('save exceeds 16 MB');
       const rows = sql.exec('SELECT id, data FROM save ORDER BY id').toArray();
-      if (!rows.length) return null;
-      if (rows.some((r, i) => r.id !== i) || rows.reduce((n, r) => n + r.data.byteLength, 0) > maxBytes) throw new Error('save pieces missing or save exceeds 16 MB');
-      const pieces = rows.map((r) => new Uint8Array(r.data));
-      const bytes = new Uint8Array(pieces.reduce((n, p) => n + p.length, 0));
-      let at = 0;
-      for (const p of pieces) { bytes.set(p, at); at += p.length; }
-      let value = JSON.parse(decoder.decode(bytes));
+      if (!rows.length && looseText === null) return null;
+      let value = null;
+      if (rows.length) {
+        if (rows.some((r, i) => r.id !== i) || rows.reduce((n, r) => n + r.data.byteLength, 0) > maxBytes) throw new Error('save pieces missing or save exceeds 16 MB');
+        const pieces = rows.map((r) => new Uint8Array(r.data));
+        const bytes = new Uint8Array(pieces.reduce((n, p) => n + p.length, 0));
+        let at = 0;
+        for (const p of pieces) { bytes.set(p, at); at += p.length; }
+        value = JSON.parse(decoder.decode(bytes));
+      }
+      // An unconfirmed checkpoint is the room when it is the later of the two (above).
+      if (looseText !== null && !boot?.persistent) {
+        const unconfirmed = JSON.parse(looseText);
+        if (!value || !(Number(value.at) >= Number(unconfirmed.at))) value = unconfirmed;
+      }
+      if (!value) return null;
       if (lasting) journal();
       sequence = floor;
       const journals = lasting ? sql.exec('SELECT id, seq, data FROM world_journal WHERE id > 0 AND seq > ? ORDER BY seq', floor).toArray() : [];
@@ -127,10 +170,20 @@ export function roomStore(storage, { persistent = false } = {}) {
       // Brought up to this tick by what changed in it (each value copied), never by copying the room.
       durable = applyChanges(durable, moved);
     },
-    write(value) {
+    /** `unconfirmed`: a match room's periodic checkpoint, which no frame waits on (above). Never a lasting world's. */
+    write(value, { unconfirmed = false } = {}) {
       if (lasting) journal();
-      const bytes = encoder.encode(JSON.stringify(value));
+      const text = JSON.stringify(value);
+      const bytes = encoder.encode(text);
       if (bytes.length > 16_000_000 && !lasting) throw new Error('save exceeds 16 MB');
+      if (unconfirmed && !lasting && typeof storage.put === 'function' && bytes.length <= LOOSE_PIECES * pieceBytes) {
+        const entries = { [LOOSE_SAVE]: { pieces: Math.max(1, Math.ceil(bytes.length / pieceBytes)), bytes: bytes.length, at: value.at ?? null } };
+        for (let i = 0; i < entries[LOOSE_SAVE].pieces; i += 1) entries[`${LOOSE_SAVE}/${i}`] = bytes.slice(i * pieceBytes, (i + 1) * pieceBytes);
+        // One put is one transaction: a reader never finds the record of one checkpoint with the pieces of another.
+        Promise.resolve(storage.put(entries, { allowUnconfirmed: true })).catch(onProblem);
+        looseText = text; looseOnDisk = true; looseWrites += 1;
+        return;
+      }
       storage.transactionSync(() => {
         let id = 0;
         for (let at = 0; at < bytes.length; at += pieceBytes) sql.exec('INSERT INTO save (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data', id++, bytes.slice(at, at + pieceBytes));
@@ -138,16 +191,23 @@ export function roomStore(storage, { persistent = false } = {}) {
         // The checkpoint holds every record so far: raising the floor retires them without touching their rows.
         if (lasting && sequence !== floor) sql.exec("INSERT INTO world_journal (id, seq, data) VALUES (0, ?, x'') ON CONFLICT(id) DO UPDATE SET seq = excluded.seq", sequence);
       });
+      dropLoose();
       floor = sequence;
       if (lasting) settle(value);
     },
+    /** Checkpoints written without holding the room's frames, so far. */
+    get unconfirmedWrites() { return looseWrites; },
     boots() { const value = JSON.parse(sql.exec('SELECT data FROM boots WHERE id = 1').toArray()[0]?.data ?? 'null'); lasting ||= value?.persistent === true; return value; },
     boot(value) { sql.exec('INSERT INTO boots (id, data) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data', JSON.stringify({ ...value, ...(lasting ? { persistent: true } : {}) })); },
     retire() { this.boot({ retired: true }); },
-    clear() { if (lasting) journal(); storage.transactionSync(() => { sql.exec('DELETE FROM save'); sql.exec('DELETE FROM boots'); if (lasting) sql.exec('DELETE FROM world_journal'); }); journalReady = false; base = null; durable = null; checkpoint = null; committedInputs = null; sequence = 0; floor = 0; },
+    clear() { dropLoose(); if (lasting) journal(); storage.transactionSync(() => { sql.exec('DELETE FROM save'); sql.exec('DELETE FROM boots'); if (lasting) sql.exec('DELETE FROM world_journal'); }); journalReady = false; base = null; durable = null; checkpoint = null; committedInputs = null; sequence = 0; floor = 0; },
   };
 }
 
+/** Where a match room's unconfirmed checkpoint is kept in the object's key-value storage: a record, and its pieces under it. */
+export const LOOSE_SAVE = 'room-save';
+const LOOSE_PIECES = 16;
+
 /** A repeatable delay spreads rooms that shared a failing isolate over thirty seconds. */
 export function restoreDelay(id) {
   let h = 2166136261;

package/worker/room.mjs

@@ -148,7 +148,10 @@ export function medianVote(list) {
   return v.length ? v[Math.floor((v.length - 1) / 2)] : null;
 }
 const utf8 = new TextEncoder();
-const byteLength = text => utf8.encode(text).length;
+// 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 };
 
@@ -473,6 +476,12 @@ export class NetRoom {
     const w = (c.rttWindow ??= []);
     w.push([now, ms]);
     while (w.length > 256 || (w.length > 1 && w[0][0] < now - 10000)) w.shift();
+    // A low percentile of ten seconds does not move in one. For a player behind a Gate (a big room) a full window
+    // is read once a second, not once an input: at ten inputs a second from a thousand players, sorting it each time
+    // was a tenth of the room's second when its clock moved between frames (0.46.3 against the build before it,
+    // test/crowd-room-cost.mjs). A room its players reach directly reads it as before.
+    if (c.conn.snapshotGroup && w.length >= 32 && now - (c.rttReadAt ?? 0) < 1000) return;
+    c.rttReadAt = now;
     const sorted = w.map((x) => x[1]).sort((a, b) => a - b);
     const low = sorted[Math.floor((sorted.length - 1) * 0.1)];
     if (c.measuredRtt !== undefined && Math.abs(low - c.measuredRtt) < 2 && now - (c.rttToldAt ?? 0) < 1000) return;
@@ -495,7 +504,10 @@ export class NetRoom {
     while (this.snapTimes.length && this.snapTimes[0] < now - 1000) this.snapTimes.shift();
     // A heartbeat (revision 9): the host's last state again while its frames hitch. It counts as a snapshot here
     // (the host is alive), and replicas are told which it is.
-    const out = text ?? JSON.stringify({ t: 'snap', from: c ? c.seat : null, ...snap, ...(m.hb === 1 ? { hb: 1 } : {}) });
+    // The whole snapshot as text: what a player with no view of their own is sent. The server's host hands it over
+    // unless this room sends it to nobody (a room behind Gates); then it is made only if somebody turns out to need it.
+    let out = text ?? (c ? JSON.stringify({ t: 'snap', from: c.seat, ...snap, ...(m.hb === 1 ? { hb: 1 } : {}) }) : null);
+    const whole = () => (out ??= JSON.stringify({ t: 'snap', from: null, ...snap, ...(m.hb === 1 ? { hb: 1 } : {}) }));
     if (m.hb === 1) this.stats.heartbeats = (this.stats.heartbeats ?? 0) + 1;
     this.lastSnapText = out;
     // A server-hosted room behind Gates hands each Gate ONE world a tick; the Gate selects, encodes and paces
@@ -513,9 +525,10 @@ export class NetRoom {
       }
       // 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.hasViewSchedule() ? 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) }) : whole());
     }
     if (groups) for (const group of groups) group.snapshot(snap, this.server.viewSettings ?? {}, this.tickHz);
+    if (out !== null) this.lastSnapText = out;
   }
 
   hasViewSchedule() {

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.46.3';
+export const STUDIO_VERSION_TAG = '0.46.6';