@homie-rocks/studio 0.46.3 → 0.46.5

package/CHANGELOG.md

@@ -17,6 +17,51 @@ To bring a studio up to date, tell Claude: "Upgrade my studio to the newest Homi
 `npx -y @homie-rocks/studio@latest upgrade`, which shows what's new since the version your studio pins (from this
 file) and what the upgrade would change, and changes nothing until you agree.
 
+## [0.46.5] - 2026-10-11
+
+**Plugin 0.46.5**
+
+A page left open across a deploy is brought up to date with its game, and a check never opens the live site
+unless it is asked to.
+
+### Added
+
+- `room.bots: { keep, names: [...] }`: a rules game names its own bots, by seat. The roster, the results and
+  `world.label` all use it. Opt-in: without `names` the toolkit's own list is used, as before.
+
+- A predictor can judge its own shot as the server will: `ctx.judgedTick(aimTick)` (the tick the server will
+  pose the others at for this seat; the snapshot's control row now carries the seat's own rewind allowance in a
+  game that declares `room.historySeconds`), `ctx.ray/rays(..., { atTick })` and `room.poseAt(id, tick)` (the pose
+  at a tick from the snapshots the browser holds), and `ctx.math` (the rules' own `math`).
+
+### Fixed
+
+Each of these changes what happened before; none needs a change to a game.
+
+- A play page open during a deploy kept hosting the newer game inside the older page: only the frame was loaded
+  again. When the newer game needed something the old page did not have (a player ticket, for a game that had
+  just started keeping results with `room.records`), the player saw an empty history and finished rounds were not
+  recorded until they reloaded the page themselves. The page now says what it was made for, the Worker answers
+  the frame with a stand-in when a page made now would differ, and the page does one full reload to the same room
+  and seat. A page from before this handshake is sent to a fresh page, by the one way it has, only when the game
+  cannot keep its results inside it. A deploy that changes only a game's code or art still reloads the frame alone.
+- A finished round that had no player to be written for was dropped without a word. The log now says
+  `record-unsaved`, and the player is told on their screen that the round was not saved and to reload.
+- The player's own body was drawn sinking for the whole tick it landed in, and standing only at the tick's end
+  (up to 33 ms late at 20 ticks a second). It is drawn down to the ground by the moment it met it.
+- `homie-studio check` with no `--url` opened the studio's **live** site, and with no game the first game by name:
+  `npm run check` could seat two check browsers in a live public room of a game nobody was working on. With no
+  `--url` a check now runs against this studio's own build: its running dev server, or one it starts on a free
+  port and stops afterwards. With no game it covers the games this checkout changed (against the default branch,
+  committed or not), else every game. The live site is checked only when asked: `--live`, or its address in
+  `--url`. `port check` and `perf` follow the same rule (the running dev server, `--url`, or `--live`).
+
+### Upgrade notes
+
+- Nothing to do. A script that relied on `homie-studio check` reaching the live site says `--live` now.
+- The first deploy of this version reloads open play pages whole, once (their pages are older than it).
+- Version 0.46.5 is provisional. No deploy or merge is part of this PR.
+
 ## [0.46.3] - 2026-10-11
 
 **Plugin 0.46.3**

package/bin/homie-studio.mjs

@@ -785,6 +785,8 @@ function print(result) {
         `Written: ${result.file}`);
       break;
     case 'check':
+      if (result.results) { for (const r of result.results) lines.push(`${r.game}: PASS at ${r.site}: room ${r.room}, round ${r.round?.n} (${r.round?.humans} humans, ${r.round?.bots} bots), connection ${r.uninterrupted === true ? 'uninterrupted' : r.uninterrupted === false ? 'INTERRUPTED' : 'unknown'}`); break; }
+      if (result.site) lines.push(`Checked ${result.local ? 'this studio\'s own build' : 'the site'} at ${result.site}.`);
       lines.push(`PASS: two fresh browsers in room ${result.room} finished round ${result.round.n} (${result.round.humans} humans, ${result.round.bots} bots) in ${Math.round(result.totalMs / 1000)} s.`,
         ...result.seats.map((s) => `  ${s.browser}: seat ${s.seat} (${s.role}), seated in ${(s.seatedMs / 1000).toFixed(1)} s`),
         ...(result.frames ?? []).map((f) => `  ${f.browser} drew ${f.fps ?? '?'} fps${f.renderer ? ` on ${f.renderer}` : ''}`),
@@ -933,8 +935,9 @@ async function main() {
   if (cmd === 'port' && sub === 'import') return importPort(root, positional[2], flags.get('id'), { name: flags.get('name'), mode: flags.get('mode') });
   if (cmd === 'port' && sub === 'check') {
     const game = positional[2] ?? listGames(root)[0]?.id;
-    const url = flags.get('url') ?? siteUrl(root);
-    if (!url) return { ok: false, command: 'port check', why: 'give --url (the local dev address or the live site)' };
+    // Never the live site unless asked (--live, or its address): this studio's running dev server, else say so.
+    const url = flags.get('url') ?? (flags.has('live') ? siteUrl(root) : (await import('../lib/dev.mjs')).runningDev(root)?.url);
+    if (!url) return { ok: false, command: 'port check', why: 'give --url (the local dev address), start npm run dev, or say --live for the live site' };
     return tracked(root, 'checks', (report) => portCheck({ url, game, root, only: flags.get('only') ?? null, shots: flags.get('shots') ? resolve(flags.get('shots')) : null, log, report }), 'port check');
   }
   if (cmd === 'app' && sub === 'role') {
@@ -955,8 +958,8 @@ async function main() {
   if (cmd === 'lab') return labCommand(root, sub);
   if (cmd === 'perf') {
     const game = sub ?? listGames(root)[0]?.id;
-    const url = flags.get('url') ?? siteUrl(root);
-    if (!url) return { ok: false, command: 'perf', why: 'give --url (the local dev address or the live site)' };
+    const url = flags.get('url') ?? (flags.has('live') ? siteUrl(root) : (await import('../lib/dev.mjs')).runningDev(root)?.url);
+    if (!url) return { ok: false, command: 'perf', why: 'give --url (the local dev address), start npm run dev, or say --live for the live site' };
     const devices = String(flags.get('device') ?? 'computer,phone').split(',').map((d) => d.trim()).filter(Boolean);
     const num = (k, d, lo, hi) => Math.max(lo, Math.min(hi, Number(flags.get(k) ?? d) || d));
     return perfRun({ root, url, game, devices, runs: num('runs', 1, 1, 50), seconds: num('seconds', 15, 3, 300), warm: num('warm', 3, 0, 60), profile: flags.has('profile'), out: flags.get('out') ? resolve(String(flags.get('out'))) : null, maxLoad: num('max-load', 0.8, 0.05, 50), cpu: num('cpu', 4, 1, 20), pair: flags.get('pair') ? String(flags.get('pair')) : null, log });
@@ -973,14 +976,30 @@ async function main() {
   if (cmd === 'dev' && flags.has('stop')) return stopDev(root);
   if (cmd === 'dev') return dev(root, { lan: flags.has('lan'), port: flags.get('port') ?? 8787, remoteAi: flags.has('remote-ai'), localAi: !flags.has('no-local-ai'), timestamps: flags.has('timestamps'), log });
   if (cmd === 'check') {
-    const game = positional[1] ?? listGames(root)[0]?.id;
-    const url = flags.get('url') ?? siteUrl(root);
-    if (!url) return { ok: false, command: 'check', why: 'give --url (the local dev address or the live site)' };
+    // lib/check-site.mjs: with no --url a check runs against this studio's own build, never the live site (--live asks
+    // for that); with no game it covers the games this checkout changed.
+    const { checkSite, gamesToCheck } = await import('../lib/check-site.mjs');
+    const { games, why } = gamesToCheck(root, positional[1]);
+    if (!games.length) return { ok: false, command: 'check', why: 'this studio has no game to check' };
     // A big binary committed under games/ fails the check before any browser starts: it belongs in R2, never in git.
     const { bigCommittedFiles } = await import('../lib/asset-check.mjs');
-    const big = bigCommittedFiles(root).filter((f) => f.path.startsWith(`games/${game}/`));
-    if (big.length) return { ok: false, command: 'check', why: `committed files over 5 MB under games/${game}: ${big.map((f) => `${f.path} (${(f.bytes / 1024 / 1024).toFixed(1)} MB)`).join(', ')}. Big media goes to the studio's R2 (homie-studio storage add, then media move); raw models stay in art/<slug>/raw/ (git-ignored); a shipped model is made phone-sized with homie-studio assets optimise. Take it out of git (git rm --cached), then check again.` };
-    return tracked(root, 'checks', (report) => check({ url, game, shots: flags.get('shots') ? resolve(flags.get('shots')) : null, log, report }), 'check');
+    for (const game of games) {
+      const big = bigCommittedFiles(root).filter((f) => f.path.startsWith(`games/${game}/`));
+      if (big.length) return { ok: false, command: 'check', why: `committed files over 5 MB under games/${game}: ${big.map((f) => `${f.path} (${(f.bytes / 1024 / 1024).toFixed(1)} MB)`).join(', ')}. Big media goes to the studio's R2 (homie-studio storage add, then media move); raw models stay in art/<slug>/raw/ (git-ignored); a shipped model is made phone-sized with homie-studio assets optimise. Take it out of git (git rm --cached <file>) and check again.` };
+    }
+    const site = await checkSite(root, { url: flags.get('url') ?? null, live: flags.has('live'), log });
+    if (!site.ok) return { ok: false, command: 'check', why: site.why };
+    try {
+      if (!positional[1]) log(`check: ${games.join(', ')} (${why}) at ${site.url}`);
+      const results = [];
+      for (const game of games) {
+        const shots = flags.get('shots') ? resolve(flags.get('shots'), ...(games.length > 1 ? [game] : [])) : null;
+        const r = await tracked(root, 'checks', (report) => check({ url: site.url, game, shots, log, report }), 'check');
+        results.push({ ...r, game, site: site.url, local: site.local });
+        if (!r.ok) break;
+      }
+      return results.length === 1 ? results[0] : { ok: results.every((r) => r.ok), command: 'check', site: site.url, local: site.local, why: results.find((r) => !r.ok)?.why, results };
+    } finally { await site.stop(); }
   }
   if (cmd === 'shoot') {
     const game = positional[1] ?? listGames(root)[0]?.id;

package/guides/game/RULES.md

@@ -1078,6 +1078,23 @@ leaves: take the marker down quietly. `ctx.ray/rays/rayAll` query what the
 player sees (`ctx.viewTick`); `ctx.preview` says the run is between ticks. A
 predictor runs often: keep it cheap, and keep per-entity state in `me`.
 
+To guess a shot the server will judge with rewind, ask for what the server
+will use (0.46.5). `ctx.judgedTick(aimTick)` is the tick it will pose the others
+at: the `aimTick` the input carries, held to how far back this seat may look
+right now (the server says so in every snapshot) and to this tick. Pass it on:
+`ctx.ray(from, dir, max, { atTick: ctx.judgedTick(input.aimTick), ...filters })`
+poses the other bodies as the server will, from the snapshots this browser
+holds (between two of them, or carried on from the newest along its velocity).
+Inside the allowance that is the drawn target; past the game's cap it is a newer
+pose, and the predictor then shows no hit where the server will see none.
+`room.poseAt(id, tick)` gives `{pos, vel, known}` for the game's own tests
+(`known: false` is a guess past the newest snapshot). `ctx.math` is the rules'
+own `math`, and the context is accepted by guarded rules code as a world is for
+what the two share (`tick`, `dt`, `math`, `ray`, `rays`, `rayAll`, and a scene's
+`ray`, `rayAll`, `sweep`, `support`), so an aiming helper written for the rules
+can be called with `ctx` instead of being restated in the view. It has no
+`near`, `inBox`, `send` or `emit`: a helper that needs those is the server's.
+
 A tick's prediction runs more than once (between ticks, again when the input
 changes, then the tick itself) and shows each thing once. Things are told apart
 by their name and `key`: give two effects of one name that mean different things
@@ -1087,6 +1104,12 @@ before using it in a `match` closure: `me` is reused. A valued pulse
 (`f.pulse()`) carries the tick it was predicted on, and the server acts on it in
 that tick, so a predicted swap is in the snapshot of the tick it was drawn for.
 
+### Naming the bots (0.46.5)
+
+`room.bots: { keep: 4, names: ['Vex', 'Moth', 'Kilo'] }` gives the game's bots its own names, by seat (the list
+wraps). The roster, the round's results and `world.label(id)` all say the same name, and a restore keeps it.
+Without `names` the toolkit's own list is used. A name is 1 to 24 characters on one line.
+
 ### Discrete actions with a value
 
 Use `select: f.pulse()` for a weapon slot or other byte-valued action. Call

package/guides/game/SKILL.md

@@ -304,6 +304,8 @@ npm run build                                          # fix every error it name
 npx --no-install homie-studio build --types            # the same, with the TypeScript checked first: run it before a deploy
 npm run dev                                            # in the background: http://127.0.0.1:8787/<id>/play
 npx --no-install homie-studio check <id> --url http://127.0.0.1:8787 --shots ./.checks
+# With no --url the check runs against this studio's own build (its running dev server, or one it starts and
+# stops); with no <id>, on the games this checkout changed. The live site only with --live or its address.
 npx --no-install homie-studio shoot <id> --preview     # pictures of the built game on a stepped clock, no site needed (a 3D game where there is no GPU)
 npx --no-install homie-studio preview <id>             # only that game's built files at an address (alone, offline): for a capture script
 ```

package/lib/check-site.mjs

@@ -0,0 +1,85 @@
+/**
+ * WHERE A CHECK RUNS, AND ON WHICH GAMES, WHEN NOBODY SAYS (0.46.5).
+ *
+ * A check puts real browsers in a real room. With no `--url` it used to open the studio's LIVE site, and with no game
+ * the first game by name: `npm run check` in a studio working on one game sat two check browsers in a live public
+ * room of another. A check is a gate on what is in this folder, so:
+ *
+ *   where   `--url <site>` as given; else this studio's own dev server: the one already running (lib/dev.mjs keeps
+ *           its record), or one started for the check on a free port and stopped when the check ends. The live site
+ *           only when asked by name: `--live`, or its address in `--url`.
+ *   which   the game named; else every game this checkout changed (files under games/<id>/ that differ from the
+ *           default branch, committed or not); else, when nothing changed or this is not a git checkout, every game.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { once } from 'node:events';
+import { createServer } from 'node:net';
+import { fileURLToPath } from 'node:url';
+import { runningDev } from './dev.mjs';
+import { listGames, siteUrl } from './studio.mjs';
+
+const CLI = fileURLToPath(new URL('../bin/homie-studio.mjs', import.meta.url));
+
+async function freePort() {
+  const s = createServer(); s.listen(0, '127.0.0.1'); await once(s, 'listening');
+  const port = s.address().port; await new Promise((r) => s.close(r)); return port;
+}
+
+/**
+ * The site a check opens: { ok, url, local, live, started, stop() }. `stop` ends only a server this call started.
+ * `spawnFn` and `fetchFn` are for tests.
+ */
+export async function checkSite(root, { url = null, live = false, log = () => {}, spawnFn = spawn, fetchFn = globalThis.fetch, waitMs = 240_000 } = {}) {
+  const none = async () => {};
+  if (url) return { ok: true, url: String(url), local: /^https?:\/\/(?:127\.0\.0\.1|localhost|\[::1\])(?::|\/|$)/.test(String(url)), live: false, started: false, stop: none };
+  if (live) {
+    const site = siteUrl(root);
+    return site ? { ok: true, url: site, local: false, live: true, started: false, stop: none } : { ok: false, why: 'this studio has no live site yet (deploy it first), so there is nothing for --live to check' };
+  }
+  const running = runningDev(root);
+  if (running) return { ok: true, url: running.url, local: true, live: false, started: false, stop: none };
+  const port = await freePort(), origin = `http://127.0.0.1:${port}`;
+  log(`check: no --url, so this studio's own build is checked: starting its dev server on ${origin} (stopped when the check ends; --live checks the live site)`);
+  const child = spawnFn(process.execPath, [CLI, 'dev', '--port', String(port), '--no-local-ai'], { cwd: root, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+  let tail = '';
+  for (const stream of [child.stdout, child.stderr]) stream?.on('data', (chunk) => { tail = (tail + chunk).slice(-4000); });
+  const stop = async () => {
+    if (child.exitCode !== null || child.signalCode !== null) return;
+    const ended = once(child, 'exit');
+    try { process.kill(-child.pid, 'SIGTERM'); } catch { try { child.kill('SIGTERM'); } catch { /* gone */ } }
+    const force = setTimeout(() => { try { process.kill(-child.pid, 'SIGKILL'); } catch { /* gone */ } }, 8000);
+    try { await ended; } finally { clearTimeout(force); }
+  };
+  const deadline = Date.now() + waitMs;
+  while (Date.now() < deadline && child.exitCode === null && child.signalCode === null) {
+    const up = await fetchFn(`${origin}/games.json`, { signal: AbortSignal.timeout(1500) }).then((r) => r.ok).catch(() => false);
+    if (up) return { ok: true, url: origin, local: true, live: false, started: true, stop };
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  await stop();
+  return { ok: false, why: `this studio's dev server did not start for the check${tail ? `:\n${tail.trim().split('\n').slice(-12).join('\n')}` : ''}\nStart it yourself (npm run dev) and give its address with --url, or fix the build.` };
+}
+
+/** The ids of the games this checkout changed against its default branch (committed or not), in the studio's order; [] when it cannot be told. */
+export function changedGames(root, { run = spawnSync } = {}) {
+  const git = (...args) => { const r = run('git', args, { cwd: root, encoding: 'utf8' }); return r.status === 0 ? String(r.stdout) : null; };
+  if (git('rev-parse', '--is-inside-work-tree') === null) return [];
+  const files = new Set((git('status', '--porcelain', '--', 'games') ?? '').split('\n').map((l) => l.slice(3).replace(/^"|"$/g, '').split(' -> ').pop()).filter(Boolean));
+  const head = (git('symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD') ?? '').trim();
+  for (const base of [head, 'origin/main', 'main', 'origin/master', 'master'].filter(Boolean)) {
+    const fork = (git('merge-base', 'HEAD', base) ?? '').trim();
+    if (!fork) continue;
+    for (const f of (git('diff', '--name-only', `${fork}..HEAD`, '--', 'games') ?? '').split('\n')) if (f) files.add(f);
+    break;
+  }
+  const touched = new Set([...files].map((f) => /^games\/([^/]+)\//.exec(f)?.[1]).filter(Boolean));
+  return listGames(root).map((g) => g.id).filter((id) => touched.has(id));
+}
+
+/** The games a check covers: the one named, else what changed, else all of them. */
+export function gamesToCheck(root, named, options) {
+  if (named) return { games: [named], why: 'named' };
+  const changed = changedGames(root, options);
+  if (changed.length) return { games: changed, why: 'changed in this checkout' };
+  return { games: listGames(root).map((g) => g.id), why: 'nothing changed against the default branch: every game' };
+}

package/lib/check.mjs

@@ -1,5 +1,6 @@
 /**
- * `homie-studio check <game> --url <site>` — the promise, measured: two fresh
+ * `homie-studio check [<game>] [--url <site> | --live]` — the promise, measured (where it runs and on which games
+ * when nobody says: lib/check-site.mjs; never the live site unless asked): two fresh
  * browsers (separate Chrome processes and profiles, one a computer and one a
  * phone) press Play, land in the SAME public room, play, and both see the round
  * finish. Exit 0 only when all of that happened. Uses this Mac's Chrome through

package/lib/rules-check.mjs

@@ -28,10 +28,10 @@ export const LONG_ALLOWANCE = Object.freeze({ ...ALLOWANCE, ticks: 8 * ALLOWANCE
 
 /** The ordered declarations a save depends on. Functions contribute their presence, never their implementation. */
 export function stateHash(c) {
-  const { kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map: geometry, dims, contract, seats, save, historySeconds, rewindSeconds } = c;
+  const { kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map: geometry, dims, contract, seats, save, historySeconds, rewindSeconds, botNames } = c;
   // Keep existing 2D save compatibility hashes when the 3D map vocabulary grows.
   const map = dims === 2 ? { name: geometry.name, bounds: geometry.bounds, boxes: geometry.boxes, circles: geometry.circles, spots: geometry.spots } : geometry;
-  return createHash('sha256').update(JSON.stringify({ kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map, dims, contract, seats, ...(historySeconds?{historySeconds}:{}), ...(rewindSeconds!==undefined?{rewindSeconds}:{}), tickHz: c.settings.tickHz, save }, (k, v) => typeof v === 'function' ? true : v)).digest('hex').slice(0, 32);
+  return createHash('sha256').update(JSON.stringify({ kinds, events, commands, effects, shared, rounds, bots, roomOn, asks, map, dims, contract, seats, ...(historySeconds?{historySeconds}:{}), ...(rewindSeconds!==undefined?{rewindSeconds}:{}), ...(botNames?{botNames}:{}), tickHz: c.settings.tickHz, save }, (k, v) => typeof v === 'function' ? true : v)).digest('hex').slice(0, 32);
 }
 
 /**

package/lib/rules-types.mjs

@@ -78,7 +78,7 @@ type W = World<${parameters}>;
 type RW = World<${parameters}, true>;
 type Definition = Omit<RulesDef, 'entities' | 'room' | 'move' | 'asks'> & {
   entities: ${entities}; move?: Moves;
-  room?: { records?: {key:string;identity:string;eligible?:string;fields:Readonly<Record<string,string>>}; rounds?: { seconds: number; breakSeconds: number }; bots?: { keep: number }; historySeconds?: number; rewindSeconds?: number;
+  room?: { records?: {key:string;identity:string;eligible?:string;fields:Readonly<Record<string,string>>}; rounds?: { seconds: number; breakSeconds: number }; bots?: { keep: number; names?: readonly string[] }; historySeconds?: number; rewindSeconds?: number;
     start?: (world: RW) => void;
     join?: (ctx: Pick<W, 'map' | 'shared' | 'tune' | 'math' | 'round'>, player: { seat: number; driver: 'person' | 'bot' | 'ai'; owner: string; character?: (${joins}) | null }) => ${joins};
     on?: { [K in keyof (Omit<Events, keyof GameRoomEvents> & GameRoomEvents)]?: (world: RW, event: EventData<(Omit<Events, keyof GameRoomEvents> & GameRoomEvents)[K]>) => void };

package/lib/template-history.json

@@ -2817,6 +2817,48 @@
      }
     }
    }
+  },
+  "0.46.5": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "394cbbe934e80722",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "8596f2b25edda3e2",
+     "## Commands (all through the pinned CLI in node_modules)": "5222e08ca55e326e",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "27881d11d3ff3803",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "611b437f5b3303f0"
+      }
+     }
+    }
+   }
   }
  }
 }

package/netplay/NETPLAY.md

@@ -1699,6 +1699,18 @@ reads the other's snapshot with the wrong code.
 - **An old tab that knocks at the live build's room is refused**: `error stale` (final; the helper
   shows "This game was updated. Tap to reload." and the play page reloads the frame, at most twice
   a minute).
+- **A page older than the game it would host is brought up to date too (0.46.5).** The frame alone
+  is reloaded only while the play page around it is still the page the Worker would write now. The
+  page says what it was made for (`sh` on the frame's address: the toolkit's version and the parts
+  of the manifest a page is built around, `shellKey` in worker/pages.mjs; not the game's code or
+  words). When that differs, the Worker answers the frame with a stand-in that says so, and the
+  page does **one full reload**, to the same room (it is in the address) and the same seat (its
+  token is in the tab). A page from before this handshake has only one way to load a whole new
+  page, the one for leaving a finished room; it is used only when the game cannot work inside the
+  old page at all: the game keeps results for a player (`room.records`) and the old page holds no
+  player ticket. Such a player lands in a fresh page and a room the lobby gives them. A result
+  that still has no player to be written for is never dropped in silence: the log says
+  `record-unsaved`, and the player's screen says the round was not saved and to reload.
 - **A tab of the live build that knocks at a room still on the old build waits**: `error
   room-stale` (not final). The room's players are told to reload; when the last of them has left,
   the next knock is let in, and the room **starts fresh**: its checkpoint, snapshot, round, roster

package/netplay/netplay.ts

@@ -2547,6 +2547,8 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
         // An AI alone in a room (nobody seated): it knocks again only after a while (section 17).
         if (code === 'agents-alone') aloneUntil = wall() + AGENTS_ALONE_WAIT_MS;
         if (code === 'host-fault') { rulesNotice(String(m.message)); return; }
+        // A result the server could not keep for this player (0.46.5): said on their screen, not dropped in silence.
+        if (code === 'unsaved') { rulesNotice(String(m.message)); return; }
         if (code === 'vote') { warnOnce('vote', m['message']); return; }
         if (code === 'rate' || code === 'state-full') { warnOnce(`${code}:${String(m['of'] ?? '')}`, m['message']); return; }
         // The room still runs another build of the game (section 23): not final. Its players were told to reload; this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.46.3",
+  "version": "0.46.5",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/rules/host.ts

@@ -289,6 +289,7 @@ export function createHost(o: HostOptions): Host {
    *
    * `room.rewindSeconds` is the game's hard cap on the sum. Without it the cap is `room.historySeconds`, as before.
    */
+  const historyTicks = Math.ceil((c.historySeconds ?? 0) * tickHz);
   const rewindCap = c.rewindSeconds !== undefined ? Math.ceil(c.rewindSeconds * tickHz) : null;
   const rewindTicks = (seat: number): number => {
     const waited = Math.max(1, Math.min(lateTicks, queues.get(seat)?.early ?? 1));
@@ -628,7 +629,9 @@ export function createHost(o: HostOptions): Host {
   /* ---------------------------------------------------------------- frames out */
 
   const hasHands = (seat: number, driver: Driver): boolean => driver === 'person' || (driver === 'ai' && [...peers.values()].some((p) => p.seat === seat && p.agent?.hands === 'self'));
-  const nameOf = (seat: number, driver: Driver): string => (driver === 'bot' || (driver === 'ai' && (core.bodies().find((b) => b.seat === seat)?.owner === 'reserved' || !names.has(seat))) ? BOT_NAMES[seat % BOT_NAMES.length] : names.get(seat) || `Player ${seat + 1}`);
+  // The game's own names for its bots (room.bots.names, 0.46.5), else the toolkit's.
+  const botNames = c.botNames?.length ? c.botNames : BOT_NAMES;
+  const nameOf = (seat: number, driver: Driver): string => (driver === 'bot' || (driver === 'ai' && (core.bodies().find((b) => b.seat === seat)?.owner === 'reserved' || !names.has(seat))) ? botNames[seat % botNames.length] : names.get(seat) || `Player ${seat + 1}`);
   function sendRoster(): void {
     const guides = new Map(agentSlots().map((s) => [s.slot, s.agent]));
     const slots = core.bodies().sort((a, b) => a.seat - b.seat).map((b) => ({ slot: b.seat, seat: b.driver === 'bot' ? null : b.seat, name: nameOf(b.seat, b.driver), bot: b.driver === 'bot', ...(guides.has(b.seat) ? { agent: guides.get(b.seat) } : {}) }));
@@ -749,7 +752,12 @@ export function createHost(o: HostOptions): Host {
       const q = queues.get(b.seat);
       // A fifth number only for a seat that has sent a numbered pulse: the newest one acted on.
       const taken = pulsesTaken.get(b.seat);
-      rows.push(taken === undefined ? [b.seat, b.r, q ? q.ack : 0, q && q.lead !== 127 ? q.lead : -128] : [b.seat, b.r, q ? q.ack : 0, q && q.lead !== 127 ? q.lead : -128, taken]);
+      const row = [b.seat, b.r, q ? q.ack : 0, q && q.lead !== 127 ? q.lead : -128];
+      // A sixth number only in a game that rewinds (room.historySeconds, 0.46.5): how many ticks back this seat's own
+      // ray may look right now, so its browser can predict against the pose the server will judge, not a guess at it.
+      if (historyTicks) row.push(taken ?? 0, Math.min(historyTicks, rewindTicks(b.seat)));
+      else if (taken !== undefined) row.push(taken);
+      rows.push(row);
       if (q) q.lead = 127;
     }
     // A snapshot is stamped with the moment its tick was due, so ticks run in a burst to catch up are still a tick

package/rules/rules.ts

@@ -167,7 +167,8 @@ export interface RulesDef {
   shared?: Fields;
   room?: {
     rounds?: { seconds: number; breakSeconds: number };
-    bots?: { keep: number };
+    /** `names` (0.46.5): what the game's bots are called, by seat; the toolkit's own list without it. */
+    bots?: { keep: number; names?: readonly string[] };
     records?: RoundRecords;
     historySeconds?: number;
   /** The furthest a person's ray may be rewound, in seconds (0.46.3): a hard cap under `historySeconds`, whatever their connection measures. */
@@ -396,6 +397,7 @@ export interface Compiled {
   rewindSeconds?: number;
   rounds: { seconds: number; breakSeconds: number } | null;
   bots: number;
+  botNames?: readonly string[];
   start: RoomHandler | null;
   join: NonNullable<RulesDef['room']>['join'] | null;
   roomOn: Record<string, RoomHandler>;
@@ -636,6 +638,8 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
   }
   const keep = room.bots === undefined ? 0 : typeof room.bots?.keep === 'number' ? Math.floor(room.bots.keep) : NaN;
   if (!(keep >= 0 && keep <= SEATS_MAX)) throw new Error(`room.bots is { keep: n }, 0 to ${SEATS_MAX}`);
+  const botNames = (room.bots as { names?: unknown } | undefined)?.names;
+  if (botNames !== undefined && !(Array.isArray(botNames) && botNames.length >= 1 && botNames.length <= 64 && botNames.every((n) => typeof n === 'string' && n.trim().length >= 1 && n.length <= 24 && !/[\u0000-\u001f\u007f\u200b-\u200f\u202a-\u202e\u2066-\u2069]/.test(n)))) throw new Error('room.bots.names is a list of 1 to 64 names, each 1 to 24 characters on one line');
   if (room.start !== undefined && typeof room.start !== 'function') throw new Error('room.start is a function');
   if (room.join !== undefined && typeof room.join !== 'function') throw new Error('room.join is a function');
   const players = kinds.filter((k) => k.player);
@@ -661,7 +665,7 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
   Object.freeze(navigation);
   return {
     navigation, contract: RULES_CONTRACT, save: SAVE_REVISION, dims, kinds, kindOf, events, commands, effects, effectNames: Object.keys(effects),
-    shared: fieldList(d.shared, 'shared'), view, ...(room.records?{records:room.records}:{}), ...(room.historySeconds ? {historySeconds:room.historySeconds}:{}), ...(room.rewindSeconds !== undefined ? {rewindSeconds:room.rewindSeconds}:{}), rounds, bots: Math.min(keep, seats), start: room.start ?? null, join: room.join ?? null, roomOn, asks,
+    shared: fieldList(d.shared, 'shared'), view, ...(room.records?{records:room.records}:{}), ...(room.historySeconds ? {historySeconds:room.historySeconds}:{}), ...(room.rewindSeconds !== undefined ? {rewindSeconds:room.rewindSeconds}:{}), rounds, ...(botNames ? { botNames: Object.freeze([...(botNames as string[])]) } : {}), bots: Math.min(keep, seats), start: room.start ?? null, join: room.join ?? null, roomOn, asks,
     tune, publicTune, map, settings, seats,
   };
 }
@@ -674,6 +678,8 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
  */
 export interface Schema {
   records?: true;
+  /** A game that rewinds (0.46.5): its window and its cap, for a browser predicting its own shots. */
+  rewind?: { historySeconds: number; capSeconds?: number };
   contract: 2;
   dims: 2 | 3;
   seats: number;
@@ -698,7 +704,7 @@ function publicField(field: Field, hidden=false): Field {
 }
 export function schemaOf(c: Compiled): Schema {
   return {
-    contract: RULES_CONTRACT, dims: c.dims, seats: c.seats, ...(c.records?{records:true as const}:{}),
+    contract: RULES_CONTRACT, dims: c.dims, seats: c.seats, ...(c.records?{records:true as const}:{}), ...(c.historySeconds ? { rewind: { historySeconds: c.historySeconds, ...(c.rewindSeconds !== undefined ? { capSeconds: c.rewindSeconds } : {}) } } : {}),
     kinds: c.kinds.map((k) => ({ ...(k.query?{query:k.query}:{}), ...(k.collider?{collider:k.collider}:{}), ...(k.body?.terrain ? {terrain:k.body.terrain} : {}), name: k.name, player: Boolean(k.player), ...(k.player?.control ? {control:k.player.control}:{}), owner: Boolean(k.body?.owner), radius: k.body?.radius ?? 0, ...(c.dims === 3 && k.body ? { shape: k.body.shape, height: k.body.height || 2 * k.body.radius } : {}), maxSpeed: k.body?.maxSpeed ?? 0, score: k.score, fields: k.fields.map(([name,field])=>[name,publicField(field)]), motion: k.motion, input: k.input })),
     effects: c.effects, effectNames: c.effectNames, commands: c.commands, shared: c.shared, rounds: c.rounds, settings: c.settings,
   };

package/rules/view.ts

@@ -47,8 +47,8 @@ import { createNetplay } from '../netplay/netplay.ts';
 import type { Netplay, NetplayOptions, RulesHostFactory, RoundInfo, Snapshot, StepEntry } from '../netplay/netplay.ts';
 import { lab } from '../lab/lab.ts';
 import { exposePort, type PortProbeOptions } from '../port/probe.ts';
-import { BudgetError } from './guard.ts';
-import { moveContext } from './math.ts';
+import { BudgetError, brand } from './guard.ts';
+import { math, moveContext } from './math.ts';
 import { coerce, coerceFields, dir, initFields, stepMove, thawFields, unpackEntity, unpackFields, unpackVec, vec3 } from './pack.ts';
 import type { Unpacked } from './pack.ts';
 import { compileMap } from './rules.ts';
@@ -113,6 +113,15 @@ export interface OpenRoomOptions {
 /** What a predictor (`openRoom({ predict })`) is handed beside the body and the tick's input. */
 export interface PredictContext extends RayQueries {
   readonly tick: number; readonly dt: number;
+  /** The same deterministic `math` a `move` is handed (0.46.5): a helper shared with the rules can be called with `ctx`. */
+  readonly math: typeof math;
+  /**
+   * The tick the server will judge this player's ray against when the browser says it aimed at `aimTick` (0.46.5):
+   * `aimTick`, held to how far back this seat may look right now (the server says so in every snapshot) and to this
+   * tick. Pass it to `ctx.ray(..., { atTick })`: the other bodies are then posed as the server will pose them, from
+   * the snapshots this browser holds (between two of them, or carried on from the newest along its velocity).
+   */
+  judgedTick(aimTick: number): number;
   /** The tick the other bodies are drawn at: what the player is looking at. */
   readonly viewTick: number;
   /** This run draws ahead of the tick; the tick's own run follows. What it shows is shown once. */
@@ -128,6 +137,8 @@ export interface PredictContext extends RayQueries {
 export type Predictor = (me: any, input: any, ctx: PredictContext) => void;
 export interface Room<R = unknown> extends RayQueries {
   readonly viewTick: number;
+  /** Where a body was at a tick, from the snapshots this browser holds (0.46.5); `known: false` past the newest one. */
+  poseAt(id: string, tick: number): { pos: Vec3; vel: Vec3; known: boolean } | null;
   readonly status: RoomStatus;
   readonly seat: number | null;
   readonly me: Entity | null;
@@ -184,6 +195,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
 
   let status: RoomStatus = 'connecting';
   let latest: Frame | null = null;
+  /** The snapshots this browser holds, oldest first: two seconds of them (see poseAt). */
+  const held2: Frame[] = [];
   let epoch = 0;
   let round: RoomRound | null = null;
   let results: RoundInfo['results'] | undefined;
@@ -380,11 +393,14 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // run has asked for: never by the order of everything asked, which changes when another action joins the tick.
     const asked = new Map<string, number>();
     const once = (what: string): boolean => { if (!live) return false; let set = shown.get(t); if (!set) { set = new Set(); shown.set(t, set); } const n = asked.get(what) ?? 0; asked.set(what, n + 1); const key = what + '#' + n; if (set.has(key)) return false; set.add(key); return true; };
-    const ctx: PredictContext = {
-      tick: t, dt: 1 / tickHz, preview,
+    // Branded as a world is (0.46.5): a guarded helper of the rules may call its queries, so the server's own aiming
+    // code can be run on it instead of being restated in the view.
+    const ctx: PredictContext = brand({
+      tick: t, dt: 1 / tickHz, preview, math,
+      judgedTick: (aimTick) => Math.max(t - rewindAllowance(), Math.min(t, Number(aimTick) || 0)),
       get viewTick() { return viewTickNow(); },
       ray: (from, direction, max, options) => viewRay(from, direction, max, options)[0],
-      rays: (options) => raySnapshot(map, viewTargets(), dims, options, id),
+      rays: (options) => raySnapshot(map, viewTargets(atTickOf(options)), dims, options, id),
       rayAll: (from, direction, max, options) => viewRay(from, direction, max, options, true),
       ghost(kindOfGhost, at, data = {}, options = {}) {
         const k = kindOf.get(kindOfGhost);
@@ -406,7 +422,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         if (waiting) waiting.confirms = true; else provisional.push({ name, tick: t, payload, match: options.match });
         emit(name, Object.freeze({ ...payload, predicted: true }));
       },
-    };
+    });
     const me = Object.assign(fields, { id, kind: kindName }) as Record<string, unknown>;
     for (const [key, value] of Object.entries({ pos: body.pos, vel: body.vel, heading: body.heading, grounded: body.grounded, motion: body.motion })) Object.defineProperty(me, key, { value, enumerable: false, configurable: true, writable: true });
     try { fn(me, input, ctx); } catch (err) { console.warn('[room] predict', err); }
@@ -551,6 +567,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     const before = latest;
     if (before && before.e === f.e && f.k <= before.k) return;
     latest = f;
+    if (before && before.e !== f.e) held2.length = 0;
+    held2.push(f); if (held2.length > 2 * tickHz) held2.shift();
     if (!before || before.e !== f.e) collisionHistory = [];
     const collision = f.collision;
     if (collision) {
@@ -785,11 +803,19 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       // and stops dead at a release, with nothing to blend away afterwards.
       for (const [name, fd] of kind.input) now[name] = (fd.t === 'press' || fd.t === 'pulse') ? (pressed.get(name) ?? (fd.t === 'press' ? false : 0)) : fd.t === 'held' ? coerce(fd, heldMean(name, fd.init, Math.min(clock(), edgeOf(stepped + 1)), false), dims) : coerce(fd, sample[name] ?? fd.init, dims);
       const next = runMove(kind.name, { pos: mine.pos, vel: mine.vel, heading: mine.heading, grounded: mine.grounded, motion: motionOf(mine.kind, mine.motion) }, Object.freeze(now), stepped + 1);
-      pos = vec3({ x: lerp(mine.pos.x, next.pos.x, a), y: lerp(mine.pos.y, next.pos.y, a), z: lerp(mine.pos.z, next.pos.z, a) }, dims);
+      // A landing does not take the whole tick (0.46.5): the body met the ground part way through it. How far through is
+      // read from the fall it would have made at the speed it entered the tick with; it is drawn down to the ground by
+      // then and standing from then, not sinking until the tick's end.
+      let av = a, landed = false;
+      if (dims === 3 && !mine.grounded && next.grounded && mine.vel.z < 0) {
+        const free = -mine.vel.z / tickHz, contact = free > 1e-6 ? Math.max(0.05, Math.min(1, (mine.pos.z - next.pos.z) / free)) : 1;
+        av = Math.min(1, a / contact); landed = a >= contact;
+      }
+      pos = vec3({ x: lerp(mine.pos.x, next.pos.x, a), y: lerp(mine.pos.y, next.pos.y, a), z: lerp(mine.pos.z, next.pos.z, av) }, dims);
       heading = blendHeading(mine.heading, next.heading, a, dims);
       velocity = vec3({ x: lerp(mine.vel.x, next.vel.x, a), y: lerp(mine.vel.y, next.vel.y, a), z: lerp(mine.vel.z, next.vel.z, a) }, dims);
       // A takeoff is airborne as soon as it rises; a landing waits for its contact.
-      grounded = mine.grounded && (a === 0 || next.grounded);
+      grounded = landed || mine.grounded && (a === 0 || next.grounded);
       preview = next;
       if (predictors[kind.name]) {
         // The own actions between ticks: the predictor on a copy of the fields, for the tick about to be stepped.
@@ -912,16 +938,43 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   if (typeof document !== 'undefined') document.addEventListener('visibilitychange', onShow);
 
   function viewTickNow(): number { const s=net.sample();const a=s?frameOf(s.a):latest,b=s?frameOf(s.b):latest;return a&&b?a.k+(b.k-a.k)*(s?.alpha??0):latest?.k??0; }
-  const viewTargets = () => {
+  /*
+   * WHERE A BODY WAS, OR WILL BE JUDGED TO BE (0.46.5). The server judges a rewound ray against poses it kept by
+   * tick. A browser holds the snapshots it has received: a pose at a tick between two of them is the point between;
+   * past the newest it is that snapshot's pose carried on along its velocity (`known: false`: a guess); before the
+   * oldest it is the oldest. A placement between the two is not glided across.
+   */
+  function poseAt(id: string, at: number): { pos: Vec3; vel: Vec3; known: boolean } | null {
+    let before: Frame | null = null, after: Frame | null = null;
+    for (const f of held2) { if (!f.ents.has(id)) continue; if (f.k <= at) before = f; if (f.k >= at && !after) after = f; }
+    const a = before?.ents.get(id), b = after?.ents.get(id);
+    if (a && b) { if (before === after || a.r !== b.r) return { pos: b.pos, vel: b.vel, known: true }; const m = (at - before!.k) / (after!.k - before!.k); return { pos: vec3({ x: lerp(a.pos.x, b.pos.x, m), y: lerp(a.pos.y, b.pos.y, m), z: lerp(a.pos.z, b.pos.z, m) }, dims), vel: b.vel, known: true }; }
+    if (a) { const s = Math.min(tickHz, at - before!.k) / tickHz; return { pos: vec3({ x: a.pos.x + a.vel.x * s, y: a.pos.y + a.vel.y * s, z: a.pos.z + a.vel.z * s }, dims), vel: a.vel, known: false }; }
+    return b ? { pos: b.pos, vel: b.vel, known: false } : null;
+  }
+  const atTickOf = (options: unknown): number | undefined => { const v = options !== null && typeof options === 'object' ? (options as { atTick?: unknown }).atTick : undefined; return typeof v === 'number' && Number.isFinite(v) ? v : undefined; };
+  /** How many ticks back this seat's ray may look: the server's own figure from the newest snapshot, else the rule it follows with this browser's round trip. */
+  function rewindAllowance(): number {
+    const seat = net.seat, row = seat === null ? undefined : latest?.rows.find((x) => x[0] === seat);
+    const history = Math.ceil((schema.rewind?.historySeconds ?? 0) * tickHz);
+    if (typeof row?.[5] === 'number') return row[5];
+    const cap = schema.rewind?.capSeconds !== undefined ? Math.ceil(schema.rewind.capSeconds * tickHz) : history;
+    return Math.min(history, cap, Math.ceil((authorityRtt() + 150) / period) + 1);
+  }
+  const viewTargets = (atTick?: number) => {
     pump();
     const targets: QueryTarget[] = collisionTargets(collisionMap(map, collisionHistory.at(-1)?.[2] ?? []));
     for(const k of schema.kinds) {
       if(k.collider || !k.radius)continue;
-      each(k.name,e=>targets.push({id:e.id,kind:k.name,query:k.query,fields:e as Record<string,unknown>,geometry:false,solid:solidAt(e.pos,{shape:k.shape??'circle',radius:k.radius,height:k.height??0}),at:e.pos}));
+      each(k.name,e=>{
+        // At a tick: where the server will have the body, with the fields as they are now (the server filters on current fields too).
+        const at = atTick !== undefined && e.id !== mine?.id && !e.provisional ? poseAt(e.id, atTick)?.pos ?? e.pos : e.pos;
+        targets.push({id:e.id,kind:k.name,query:k.query,fields:e as Record<string,unknown>,geometry:false,solid:solidAt(at,{shape:k.shape??'circle',radius:k.radius,height:k.height??0}),at});
+      });
     }
     return targets;
   };
-  const viewRay = (from: unknown, direction: unknown, max: number, options?: RayOptions, all=false) => rayQuery(map,viewTargets(),dims,from,direction,max,options,mine?.id,all);
+  const viewRay = (from: unknown, direction: unknown, max: number, options?: RayOptions, all=false) => rayQuery(map,viewTargets(atTickOf(options)),dims,from,direction,max,options,mine?.id,all);
   return {
     get viewTick() { return solo ? solo.viewTick : viewTickNow(); },
     get status() { return solo ? 'offline' : status; },
@@ -929,7 +982,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     get me() { pump(); return meNow(); },
     each, get,
     ray: (from,direction,max,options) => solo ? solo.ray(from,direction,max,options) : viewRay(from,direction,max,options)[0],
-    rays: options => solo ? solo.rays(options) : raySnapshot(map,viewTargets(),dims,options,mine?.id),
+    rays: options => solo ? solo.rays(options) : raySnapshot(map,viewTargets(atTickOf(options)),dims,options,mine?.id),
+    poseAt: (id, tick) => solo ? solo.poseAt(id, tick) : poseAt(id, tick),
     rayAll: (from,direction,max,options) => solo ? solo.rayAll(from,direction,max,options) : viewRay(from,direction,max,options,true),
     on(name, fn) { let set = listeners.get(name); if (!set) { set = new Set(); listeners.set(name, set); } set.add(fn); forwardSolo(name); return () => { set?.delete(fn); }; },
     get shared() { if (solo) return solo.shared; return Object.freeze(unpackFields(schema.shared, net.stateOf('shared'), dims)); },

package/worker/build-id.mjs

@@ -1,2 +1,2 @@
 // Generated by lib/build-identity.mjs; identifies the bundled runtime sources.
-export const STUDIO_BUILD = Object.freeze({"version":"0.46.3","sha256":"b36c0a219e734a32d419796f59d6965723849e1f462c75211468524c7b165266"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.46.5","sha256":"6e01cf0c45cbe8649134cb3332feed0ba34c9ac39f3431d4c8374e0237345c0b"});

package/worker/index.mjs

@@ -92,7 +92,7 @@ import { NetRoom, WATCH_POLICIES, departure, errorLine, versionOf } from './room
 import { hostedGame, hostedBuild, compiledFor, startHost } from './hosted.mjs';
 import { roomStore, restoreDelay } 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,
@@ -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-'));
@@ -1778,7 +1789,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());

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/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.5';