@homie-rocks/studio 0.37.2 → 0.38.0

package/CHANGELOG.md

@@ -17,6 +17,38 @@ 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.38.0] - 2026-10-09
+
+**Plugin 0.39.0**
+
+Your own character answers as soon as you press, even when the room runs on the server.
+
+### Added
+
+- Rules games predict your own movement with the same movement code the host runs. They ease corrections from the host and smoothly draw everyone else. Authors get this through the view library.
+- The build checks that browser movement agrees with the server and stays within its budget.
+
+### Changed
+
+- New Gem Rush games use rules plus view, with the server keeping movement, pickups and scores. The canvas, controls, waves and knockback keep their familiar look and play. Coin Dash also uses server movement with prediction.
+
+### Fixed
+
+- Rules prediction keeps movement continuous when snapshots replace its catch-up path or its input clock recalibrates, fixing backward steps on delayed, lossy connections.
+- A rules correction that catches up to the current fractional tick uses the next movement preview instead of holding still and jumping when the next whole tick arrives. Snapshots also preserve the drawn catch-up pose when they replace its history. Offset fading is bounded by normal movement speed, so it does not compound a fast knock's catch-up speed.
+- Gem Rush reports its downward Y axis to the rules probe, so control checks judge its actual on-screen direction. Rules views can supply their camera axes through `screenBasis`.
+- Playtest no longer attributes its default timeout duration to a rules game that declares no round duration in `game.json`.
+- Perf checks body presence in the last drawn frame without imposing a hidden 400 ms frame-rate requirement on software rendering.
+- Studio checks accept two replicas when the server hosts the rules. Perf reports and regression guards include both replicas, and choose a replica as the default goal for server rooms.
+- Shoot sends held keys to the game frame and reports a server-only preview without a running room as not playing. Its saved receipt now includes the final verdict.
+- The Game Lab exits after writing its completed report, even when Chrome leaves a pipe open. Coin Dash includes a reproducible Lab take.
+- Control timing starts at the game frame's receipt of a key or completed thumb gesture, judges the first changed frame, collects enough frames on a slow renderer, and measures the round clock between matching observations (including slow screenshots). The response and steering limits are unchanged.
+- The controls check exercises a browser disconnect and late joining in server rooms as well as host takeover in browser rooms. A hold with too little runway is repeated after moving away from the wall, with the same steering requirements.
+
+### Upgrade notes
+
+- Existing games keep their own source when you upgrade. Games written the old way keep working.
+
 ## [0.37.2] - 2026-10-09
 
 **Plugin 0.38.2** · [#70](https://github.com/homie-rocks/homie/pull/70)

package/bin/homie-studio.mjs

@@ -336,7 +336,7 @@ import { publish, publishBefore } from '../lib/directory.mjs';
 import { look } from '../lib/look.mjs';
 import { importPort, planPort } from '../lib/port.mjs';
 import { portCheck } from '../lib/port-check.mjs';
-import { DEFAULT_GOAL, perfCompare, perfRun, perfSizes } from '../lib/perf.mjs';
+import { perfCompare, perfRun, perfSizes } from '../lib/perf.mjs';
 import { LAB_PORT, labServe, labSet, labStop } from '../lib/lab.mjs';
 import { R2_COST, lineOf, mediaPlan, r2OverOf, recordUpload, resolveMedia, sizeOf, typeOf } from '../lib/media.mjs';
 import { newStudio } from '../lib/scaffold.mjs';
@@ -878,7 +878,7 @@ async function main() {
   }
   if (cmd === 'perf' && sub === 'compare') {
     if (!positional[2] || !positional[3]) return { ok: false, command: 'perf compare', why: 'usage: homie-studio perf compare <before dir> <after dir> [--goal <metric>] [--min 3]' };
-    return perfCompare(positional[2], positional[3], { goal: String(flags.get('goal') ?? DEFAULT_GOAL), min: flags.has('min') ? Number(flags.get('min')) / 100 : 0.03, guards: flags.get('guards') ? String(flags.get('guards')).split(',').map((x) => x.trim()).filter(Boolean) : null, also: flags.get('also') ? String(flags.get('also')).split(',').map((x) => x.trim()).filter(Boolean) : [] });
+    return perfCompare(positional[2], positional[3], { goal: flags.has('goal') ? String(flags.get('goal')) : null, min: flags.has('min') ? Number(flags.get('min')) / 100 : 0.03, guards: flags.get('guards') ? String(flags.get('guards')).split(',').map((x) => x.trim()).filter(Boolean) : null, also: flags.get('also') ? String(flags.get('also')).split(',').map((x) => x.trim()).filter(Boolean) : [] });
   }
   // The starter library and the optimiser work anywhere; the rest of style and assets inside a studio (lib/art-cli.mjs).
   if (cmd === 'assets' && ['find', 'optimise', 'optimize'].includes(sub)) return assetsCommand(null, sub, positional, flags, { log });
@@ -1327,7 +1327,7 @@ try {
   if (result && result.command !== 'help') print(result);
   if (result?.ok === false) process.exitCode = 1;
   // Chrome's pipes can outlive browser.close(); a finished check must not hang its caller.
-  if (['check', 'port check', 'look', 'perf', 'shoot'].includes(result?.command)) process.exit(process.exitCode ?? 0);
+  if (['check', 'port check', 'look', 'perf', 'shoot', 'lab check'].includes(result?.command)) process.exit(process.exitCode ?? 0);
 } catch (error) {
   await flushProgress().catch(() => {});
   print({ ok: false, why: error instanceof Error ? error.message : String(error) });

package/lib/perf.mjs

@@ -194,6 +194,17 @@ export function renderCostOf(samples) {
   return { samples: Math.max(calls.length, tris.length), drawCalls: sum(calls), triangles: sum(tris) };
 }
 
+/** Presence in the last drawn frame is independent of its frame rate. Runs measure frame timing separately. */
+export function gameReadiness() {
+  const p = window.__homiePort;
+  let self = null;
+  if (p && p.view !== 'board') {
+    const rows = p.rows(); const last = rows[rows.length - 1];
+    self = Boolean(last && Number.isFinite(last[1]) && Number.isFinite(last[2]));
+  }
+  return { first: window.__perf?.first?.() ?? null, port: Boolean(p), view: p?.view ?? null, self };
+}
+
 /** Open one browser of a run on the play page, instrumented, and wait until it is playable. */
 async function openPlayer(puppeteer, chrome, device, playUrl, label, log, cpu) {
   const dev = PERF_DEVICES[device];
@@ -243,12 +254,7 @@ async function openPlayer(puppeteer, chrome, device, playUrl, label, log, cpu) {
       shell = await T(page.evaluate(() => { const s = window.__shell; const a = s?.arrival; return s ? { room: s.room, seat: s.seat, role: s.stats?.role ?? null, arrival: a ? { phase: a.phase, lookMs: a.lookMs, liftedMs: a.liftedMs, by: a.by, mode: a.mode, explicitMs: a.explicitMs, lateMs: a.lateMs } : null } : null; }), 5000);
       const now = Date.now();
       if (seatedAt === null && shell?.room && Number.isInteger(shell.seat) && shell.role) seatedAt = now;
-      const g = await inGame(h, () => {
-        const p = window.__homiePort;
-        let self = null;
-        if (p && p.view !== 'board') { const r = p.rows(p.now() - 400); const last = r[r.length - 1]; self = last ? Number.isFinite(last[1]) : false; }
-        return { first: window.__perf?.first?.() ?? null, port: Boolean(p), view: p?.view ?? null, self };
-      });
+      const g = await inGame(h, gameReadiness);
       // The play page's arrival card (0.26.0) covers the game until the game says it is playable: not playable before.
       const lifted = !shell?.arrival || shell.arrival.phase === 'done';
       if (seatedAt !== null && g?.first !== null && g?.first !== undefined && lifted) {
@@ -651,7 +657,7 @@ function arrivalWords(summary, device, role, readyMs) {
 function headlineOf(summary) {
   const out = [];
   for (const device of summary.devices) {
-    for (const role of ['host', 'replica']) {
+    for (const role of ['host', 'replica', 'replica-2']) {
       const m = (k) => summary.metrics[`${device}.${role}.${k}`]?.median;
       if (m('frame.p50') === undefined) continue;
       out.push(`${device} ${role}: frames ${m('frame.p50')} ms median, ${m('frame.p95')} ms p95, ${m('frame.over50') ?? 0}% over 50 ms; game JS ${m('work.p50')} ms a frame (p95 ${m('work.p95')}); main thread ${m('busy')} ms a frame; first look at ${m('load.look') ?? '?'} ms, playable (control-ready) at ${m('load.playable') ?? '?'} ms${arrivalWords(summary, device, role, m('load.ready'))}; netplay ${m('net.msgsOut')} out / ${m('net.msgsIn')} in a second; heap ${m('heap')} MB; fetched before playable (measured) ${m('load.prePlayKb') ?? '?'} KB; renderer ${m('render.calls') !== undefined ? `${m('render.calls')} draw calls, ${m('render.triangles') ?? '?'} triangles (measured while playing)` : 'cost not exposed by the game (not measured)'}`);
@@ -749,8 +755,8 @@ export function readRuns(dir) {
 /** The metrics guarded by default: frame time and main-thread work of each role, time to playable and heap. */
 export function defaultGuards(devices, goal) {
   const g = [];
-  for (const d of devices) for (const role of ['host', 'replica']) g.push(`${d}.${role}.frame.p95`, `${d}.${role}.busy`, `${d}.${role}.load.playable`);
-  for (const d of devices) g.push(`${d}.host.heap`, `${d}.host.net.kbOut`);
+  for (const d of devices) for (const role of ['host', 'replica', 'replica-2']) g.push(`${d}.${role}.frame.p95`, `${d}.${role}.busy`, `${d}.${role}.load.playable`);
+  for (const d of devices) for (const role of ['host', 'replica', 'replica-2']) g.push(`${d}.${role}.heap`, `${d}.${role}.net.kbOut`);
   return g.filter((k) => k !== goal);
 }
 
@@ -758,10 +764,11 @@ export function defaultGuards(devices, goal) {
  * `homie-studio perf compare <before> <after>`: the goal metric and the guards, before against after, from the runs
  * in two folders. A run that was blocked, taken on a busy computer or profiled is left out (and counted).
  */
-export function perfCompare(beforeDir, afterDir, { goal = DEFAULT_GOAL, guards = null, also = [], min = 0.03, write = true } = {}) {
+export function perfCompare(beforeDir, afterDir, { goal = null, guards = null, also = [], min = 0.03, write = true } = {}) {
   const A = readRuns(beforeDir);
   const B = readRuns(afterDir);
   if (!A.runs.length || !B.runs.length) return { ok: false, command: 'perf compare', why: `no runs in ${!A.runs.length ? beforeDir : afterDir} (folders that homie-studio perf wrote)` };
+  goal ??= A.runs.every((r) => r.room?.hosted === 'server') ? DEFAULT_GOAL.replace('.host.', '.replica.') : DEFAULT_GOAL;
   const usable = (r) => !r.blocked && !r.loaded;
   const left = { before: A.runs.filter((r) => !usable(r)).length, after: B.runs.filter((r) => !usable(r)).length };
   const flat = (runs, sizes) => {

package/lib/port-check.mjs

@@ -60,6 +60,25 @@ function yawDeg(a, b) {
   const d = a[5] * b[5] + a[6] * b[6]; const la = Math.hypot(a[5], a[6]) || 1; const lb = Math.hypot(b[5], b[6]) || 1;
   return (Math.acos(Math.max(-1, Math.min(1, d / (la * lb)))) * 180) / Math.PI;
 }
+/** A server room keeps its authority and advances; a browser room must promote a host. */
+export function roomContinued(before, after, serverHosted) {
+  return serverHosted
+    ? after?.hosted === 'server' && after?.role === 'replica' && Number.isFinite(before?.tick) && after?.tick > before.tick && after?.frames > before.frames
+    : after?.role === 'host';
+}
+
+/** Compare two observations on the same browser clock, including time spent taking screenshots. */
+export function roundClockContinued(before, after) {
+  return !before?.round || !after?.round || before.round.n !== after.round.n
+    || Math.abs((before.round.leftMs - after.round.leftMs) - (after.observedAt - before.observedAt)) < 6000;
+}
+
+/** A wall can leave too little runway; retry the same hold after moving away, never excuse steering faults. */
+export function needsRunway(res) {
+  return !res.ok && (res.why === 'barely moved' || res.why?.startsWith('blocked at once'))
+    && res.yawChangeDeg < 10 && (res.dirErrDeg === null || res.dirErrDeg < 15);
+}
+
 const finite = (r) => r && Number.isFinite(r[1]) && Number.isFinite(r[2]);
 /** A frame the player steers (the probe's `busy` says when a knockback, a stun or a respawn has the body). */
 const steerable = (r) => finite(r) && !r[8];
@@ -134,6 +153,9 @@ export function judgePresses(rows, presses, size, view) {
   const out = presses.map((p) => {
     const seg = rows.filter((r) => r[0] >= p.a && r[0] <= p.b + 60 && steerable(r));
     if (seg.length < 4) return rows.some((r) => r[0] >= p.a && r[0] <= p.b && finite(r) && r[8]) ? { dir: p.dir, ok: false, blocked: true, busy: true } : { dir: p.dir, ok: false, why: 'no samples' };
+    // The first post-input frame can already show the response. Keep its preceding drawn pose.
+    const before = rows.filter((r) => r[0] < p.a).at(-1);
+    if (before && steerable(before)) seg.unshift(before);
     const u = DIRV[p.dir]; const r0 = seg[0];
     let matchAt = null, after = 0, afterOk = 0, maxYaw = 0, peakAlong = 0, contact = false;
     for (let i = 1; i < seg.length; i++) {
@@ -258,7 +280,7 @@ async function webkit(pw) {
 const frameOf = (h) => h.page.frames().find((f) => f.url().includes('/__game/')) ?? null;
 async function inFrame(h, src, v = null) { const f = frameOf(h); return f ? T(f.evaluate(src), 10_000, v) : v; }
 const shell = (h) => T(h.page.evaluate(() => { const s = window.__shell; return s ? { room: s.room, seat: s.seat, role: s.stats?.role ?? null, results: s.results ?? [], facts: s.facts ? { counts: s.facts.counts } : null } : null; }), 8000, null);
-const info = (h) => inFrame(h, '(() => { const p = window.__homiePort; if (!p) return null; const i = p.info(); const n = window.__homieNet; i.net = n ? { snapHzIn: n.stats().snapHzIn, snapHzOut: n.stats().snapHzOut, rtt: n.stats().rtt, promotions: n.stats().promotions } : null; i.v = p.view; i.size = p.size; i.keys = p.keys; i.thumb = p.thumb; return i; })()');
+const info = (h) => inFrame(h, '(() => { const p = window.__homiePort; if (!p) return null; const i = p.info(); i.observedAt = performance.now(); const n = window.__homieNet; i.net = n ? { snapHzIn: n.stats().snapHzIn, snapHzOut: n.stats().snapHzOut, rtt: n.stats().rtt, promotions: n.stats().promotions } : null; i.hosted = n?.probe?.hosted?.() ?? null; i.tick = n?.probe?.tick?.() ?? null; i.v = p.view; i.size = p.size; i.keys = p.keys; i.thumb = p.thumb; return i; })()');
 const rowsSince = (h, t) => inFrame(h, `(window.__homiePort ? window.__homiePort.rows(${Number(t) || 0}) : [])`, []);
 const frameNow = (h) => inFrame(h, '(window.__homiePort ? window.__homiePort.now() : performance.now())', 0);
 
@@ -285,13 +307,14 @@ async function focusGame(h) {
 
 /* ------------------------------------------------------------------ input */
 
-async function holdKey(h, code, ms) { await h.page.keyboard.down(code); await sleep(ms); await h.page.keyboard.up(code); }
+async function holdKey(h, code, ms, ready) { await h.page.keyboard.down(code); if (ready) await ready(); await sleep(ms); await h.page.keyboard.up(code); }
 
 function thumbAt(h, i) { const t = i?.thumb ?? [0.24, 0.74]; return [Math.round(h.vp.width * t[0]), Math.round(h.vp.height * t[1])]; }
-async function touchDrag(h, from, dir, reach, holdMs) {
+async function touchDrag(h, from, dir, reach, holdMs, ready) {
   const [x0, y0] = from; const u = DIRV[dir];
   await h.touch('touchStart', [{ id: 1, x: x0, y: y0 }]);
   for (let k = 1; k <= 8; k++) { await h.touch('touchMove', [{ id: 1, x: Math.round(x0 + (u[0] * reach * k) / 8), y: Math.round(y0 + (u[1] * reach * k) / 8) }]); await sleep(12); }
+  if (ready) await ready();
   const end = Date.now() + holdMs;
   let w = 0;
   while (Date.now() < end) {
@@ -302,6 +325,31 @@ async function touchDrag(h, from, dir, reach, holdMs) {
   }
   await h.touch('touchEnd', h.touchAll ? [] : [{ id: 1, x: Math.round(x0 + u[0] * reach), y: Math.round(y0 + u[1] * reach) }]);
 }
+/** Timestamp real input delivery, then keep it held until four frames can judge its direction.
+ * The response limit stays 600 ms; slow automation delivery and the thumb's ramp are not game latency. */
+export async function measuredPress(h, how, code, from, dir) {
+  await inFrame(h, `(() => {
+    if (!window.__homieCheckInput) {
+      const state = window.__homieCheckInput = {};
+      addEventListener('keydown', e => { if (state.code === e.code && state.key === null) state.key = performance.now(); }, true);
+      addEventListener('touchmove', () => { state.touch = performance.now(); }, { capture: true, passive: true });
+    }
+    Object.assign(window.__homieCheckInput, { code: ${JSON.stringify(code)}, key: null, touch: null });
+  })()`);
+  let a = null, b = null;
+  const ready = async () => {
+    a = await inFrame(h, `window.__homieCheckInput.${how === 'keys' ? 'key' : 'touch'}`);
+    if (!Number.isFinite(a)) throw new Error('the game frame did not receive the measured input');
+    await sleep(420);
+    const until = Date.now() + 3000;
+    while (Date.now() < until && (await rowsSince(h, a)).length < 4) await sleep(50);
+    b = await frameNow(h);
+  };
+  if (how === 'keys') await holdKey(h, code, 0, ready);
+  else await touchDrag(h, from, dir, 70, 0, ready);
+  return { dir, a, b };
+}
+
 async function swipe(h, dir) {
   const x0 = Math.round(h.vp.width * 0.5); const y0 = Math.round(h.vp.height * 0.55); const u = DIRV[dir]; const reach = Math.round(Math.min(h.vp.width, h.vp.height) * 0.3);
   await h.touch('touchStart', [{ id: 2, x: x0, y: y0 }]);
@@ -365,11 +413,22 @@ async function ownerTests(h, how, log) {
   const holds = view === 'side' ? ['right', 'left'] : ['down', 'left'];
   out.holds = [];
   for (const dir of holds) {
-    const a = await frameNow(h);
-    if (how === 'keys') await holdKey(h, keys[dir], 5000); else await touchDrag(h, thumbAt(h, i), dir, 70, 5000);
-    const b = await frameNow(h);
-    await sleep(250);
-    const res = judgeHold(await rowsSince(h, a - 50), dir, a, b, size, view);
+    const hold = async () => {
+      const a = await frameNow(h);
+      if (how === 'keys') await holdKey(h, keys[dir], 5000); else await touchDrag(h, thumbAt(h, i), dir, 70, 5000);
+      const b = await frameNow(h);
+      await sleep(250);
+      return judgeHold(await rowsSince(h, a - 50), dir, a, b, size, view);
+    };
+    let res = await hold();
+    if (needsRunway(res)) {
+      const first = res;
+      const away = { up: 'down', down: 'up', left: 'right', right: 'left' }[dir];
+      log(`  ${h.engine}-${h.kind} ${how} hold ${dir}: ${first.why}; move ${away} and retry the same hold`);
+      if (how === 'keys') await holdKey(h, keys[away], 1100); else await touchDrag(h, thumbAt(h, i), away, 70, 1100);
+      await sleep(400);
+      res = { ...await hold(), runwayRetry: first };
+    }
     out.holds.push(res);
     log(`  ${h.engine}-${h.kind} ${how} hold ${dir}: ${res.ok ? 'ok' : `FAIL (${res.why})`} travel ${res.travelBodies} bodies, yaw ${res.yawChangeDeg}°`);
     await sleep(400);
@@ -383,12 +442,9 @@ async function ownerTests(h, how, log) {
   const presses = [];
   const a0 = await frameNow(h);
   const until = Date.now() + 10_000;
-  for (let k = 0; Date.now() < until; k++) {
+  for (let k = 0; k < alt.length || Date.now() < until; k++) {
     const dir = alt[k % alt.length];
-    const a = await frameNow(h);
-    if (how === 'keys') await holdKey(h, keys[dir], 420); else await touchDrag(h, thumbAt(h, i), dir, 70, 380);
-    const b = await frameNow(h);
-    presses.push({ dir, a, b });
+    presses.push(await measuredPress(h, how, keys[dir], thumbAt(h, i), dir));
     await sleep(170);
   }
   await sleep(200);
@@ -595,10 +651,13 @@ export async function portCheck({ url, game, root, only = null, shots = null, lo
         if (!oa.ok || !ob.ok) { row('host-kill', false, { why: 'a browser was never seated' }); row('late-join', null, { why: 'skipped: no room' }); collect(A); collect(B); await close(A); await close(B); }
         else {
           await sleep(3000);
-          const ia = await info(A); const ib = await info(B);
-          if (ia?.role !== 'host') row('host-kill', null, { why: `the first browser was not the host (it was ${ia?.role}); skipped`, ia: ia?.role, ib: ib?.role });
+          const ia = await info(A); let ib = await info(B);
+          const serverHosted = ia?.hosted === 'server' && ib?.hosted === 'server';
+          if (ia?.role !== 'host' && !serverHosted) row('host-kill', null, { why: `the first browser was not the host (it was ${ia?.role}); skipped`, ia: ia?.role, ib: ib?.role });
           else {
             await shot(B, 'life-before');
+            // Screenshot encoding may span a round on a software renderer. Observe the room we actually leave.
+            ib = await info(B);
             const pids = A.pid ? [A.pid, ...descendants(A.pid)] : [];
             const killAt = Date.now();
             for (const p of pids) { try { process.kill(p, 'SIGKILL'); } catch { /* gone */ } }
@@ -606,14 +665,14 @@ export async function portCheck({ url, game, root, only = null, shots = null, lo
             collect(A);
             void A.close();
             let promoted = null; let ibAfter = null;
-            while (Date.now() - killAt < 15_000) { ibAfter = await info(B); if (ibAfter?.role === 'host') { promoted = Date.now() - killAt; break; } await sleep(100); }
+            while (Date.now() - killAt < 15_000) { ibAfter = await info(B); if (roomContinued(ib, ibAfter, serverHosted)) { promoted = Date.now() - killAt; break; } await sleep(100); }
             await sleep(1500);
             const ib2 = await info(B);
             const sameRound = ib?.round && ib2?.round && (ib2.round.n === ib.round.n || (ib.round.phase === 'over' || ib.round.leftMs < 3000));
-            const clockOk = ib?.round && ib2?.round && ib2.round.n === ib.round.n ? Math.abs((ib.round.leftMs - ib2.round.leftMs) - (Date.now() - killAt + 0)) < 6000 : true;
+            const clockOk = roundClockContinued(ib, ib2);
             const running = (ib2?.frames ?? 0) > (ibAfter?.frames ?? 0) && (ib2?.net?.snapHzOut ?? 0) >= 0;
             await shot(B, 'life-after-kill');
-            row('host-kill', Boolean(promoted !== null && promoted <= 5000 && sameRound && clockOk && running), { promotedMs: promoted, roundBefore: ib?.round ?? null, roundAfter: ib2?.round ?? null, why: promoted === null ? 'nobody took over as host within 15 s' : promoted > 5000 ? `the phone took over after ${promoted} ms (over 5 s)` : !sameRound ? 'the round did not continue (a new round started)' : !clockOk ? 'the round clock jumped at the takeover' : undefined });
+            row('host-kill', Boolean(promoted !== null && promoted <= 5000 && sameRound && clockOk && running), { hosted: serverHosted ? 'server' : 'browser', promotedMs: serverHosted ? null : promoted, continuedMs: serverHosted ? promoted : null, roundBefore: ib?.round ?? null, roundAfter: ib2?.round ?? null, why: promoted === null ? (serverHosted ? 'the server room stopped after a browser left' : 'nobody took over as host within 15 s') : promoted > 5000 ? `the phone took over after ${promoted} ms (over 5 s)` : !sameRound ? 'the round did not continue (a new round started)' : !clockOk ? 'the round clock jumped at the takeover' : undefined });
             // Late joiner into the same, running room.
             const C = await launch('desk');
             const joinAt = Date.now();

package/lib/rules-check-worker.mjs

@@ -183,12 +183,14 @@ function play(c, companions, allow) {
   const free = (seat) => { if (!seated.has(seat)) return; seated.delete(seat); did.push(`seat ${seat} left`); frames.push({ t: 'free', seat }); };
   const bots = (mode) => { policy = { ...(policy ?? {}), bots: mode }; frames.push({ t: 'policy', policy }); };
 
-  let A = open({ observe, noted, send });
+  const movesToCheck = [];
+  const moved = (...args) => movesToCheck.push(args);
+  let A = open({ observe, noted, moved, send });
   for (const m of told()) A.frame(m);
   /** The room stops and starts again as a deploy restarts it: a new epoch, everybody away until they are back. */
   const restart = () => {
     const bytes = A.save(); const epoch = A.epoch + 1; A.stop();
-    A = open({ observe, noted, send, restore: bytes, restoreEpoch: epoch });
+    A = open({ observe, noted, moved, send, restore: bytes, restoreEpoch: epoch });
     for (const m of told()) A.frame(m);
     // Everybody is back at once, but for the highest seat, which is a second late.
     const top = Math.max(...seated.keys());
@@ -342,6 +344,17 @@ function play(c, companions, allow) {
     const stats = A.core.stats; const cut = stats.ticksCut; const held = stats.held;
     A.tickNow();
     units += A.core.stats.tickUnits;
+    for (const [name, tick, input, before, after] of movesToCheck.splice(0)) {
+      const kind = c.kinds.find(k => k.name === name);
+      moveTick = tick;
+      const result = L.P.stepMove(kind.move, before, input, moveCtx.get(name), Math.max(1, Math.floor(budget / 4)), kind.motion, c.dims,
+        error => { fault ??= `${siteOf(name, 'move')} ${name}.move: prediction failed: ${error.message}.${when()}`; });
+      units += result.used;
+      const r = kind.body.radius, bounds = c.map.bounds;
+      result.pos = L.P.vec3({ x: Math.max(bounds.min.x + r, Math.min(bounds.max.x - r, result.pos.x)), y: Math.max(bounds.min.y + r, Math.min(bounds.max.y - r, result.pos.y)), z: result.pos.z }, c.dims);
+      delete result.used;
+      if (JSON.stringify(result) !== JSON.stringify(after)) fault ??= `${siteOf(name, 'move')} ${name}.move: prediction and the server produced different bodies from the same input.${when()}`;
+    }
     if (A.core.stats.tickUnits > peak) peak = A.core.stats.tickUnits;
     if (A.core.stats.maxUnits > most) { most = A.core.stats.maxUnits; worst = A.core.stats.worst; }
     const facts = A.facts();

package/lib/shoot.mjs

@@ -27,7 +27,7 @@
  *
  * `--preview` (no --url): THE FRAMES HALF WITHOUT THE WHOLE SITE. It starts the light preview server itself
  * (lib/preview.mjs: the one built game's files on 127.0.0.1, no Wrangler, no rooms), opens the game's own page there
- * and shoots it. The game plays alone, offline, with its bots, which is what pictures of the game itself want. The
+ * and shoots it. A game with offline play enabled plays alone, with its bots, which is what pictures of the game itself want. The
  * smoke is NOT RUN (there is no room to meet in: that half needs `dev`), and there is no loading cover to wait for.
  * The result says which build the frames are of (`build`: its hash, the one `build` printed) and that the page
  * really loaded that build's hashed bundle (`bundle`: lib/build.mjs bundleOf, never a guess at assets/main.js).
@@ -274,7 +274,11 @@ export async function shoot({ url, game, frames = 60, fps = 30, device = 'comput
     const inAll = (fn, arg) => Promise.all(all().map((f) => T(f.evaluate(fn, arg), 20_000)));
     const frozen = await inAll(() => (window.__homieClock ? (window.__homieClock.freeze(), true) : false));
     if (!frozen.some(Boolean)) { result.why = 'the virtual clock is not in the page (it was opened before the script could be injected)'; return result; }
-    if (hold) await first.page.keyboard.down(hold).catch(() => {});
+    if (hold) {
+      // The play page owns the top-level focus; the game's key listener lives in its iframe.
+      if (gf) await T(gf.evaluate(() => window.focus()), 5000);
+      await first.page.keyboard.down(hold).catch(() => {});
+    }
     const rows = [];
     for (let n = 1; n <= frames; n++) {
       if (left() < 3000) { result.partial = `stopped at frame ${n - 1} of ${frames}: the ${Math.round(timeoutMs / 1000)} s bound was reached (a slow renderer; ask for fewer frames or a longer --timeout)`; break; }
@@ -287,6 +291,7 @@ export async function shoot({ url, game, frames = 60, fps = 30, device = 'comput
       rows.push({ n, file, virtualMs: +(n * (1000 / fps)).toFixed(3), clockMs: nows.find((v) => Number.isFinite(v)) ?? null, realMs: Date.now() - t, ...(await frameFacts(first) ?? {}) });
     }
     if (hold) await first.page.keyboard.up(hold).catch(() => {});
+    result.rules = gf ? await T(gf.evaluate(() => { const p = window.__homieNet?.probe; return typeof p?.hosted === 'function' ? { hosted: p.hosted(), status: p.status?.(), tick: p.tick?.() } : null; }), 5000) : null;
     result.frames = rows.length;
     result.realSeconds = +((Date.now() - started) / 1000).toFixed(1);
     result.virtualSeconds = +((rows.length * 1000) / fps / 1000).toFixed(3);
@@ -294,10 +299,11 @@ export async function shoot({ url, game, frames = 60, fps = 30, device = 'comput
     result.limits = 'Stepped: requestAnimationFrame, performance.now, Date, setTimeout, setInterval, CSS and Web animations, in the page and the game\'s frame. NOT stepped: the room\'s socket and its server clock (other players and the round arrive in real time), Web Audio\'s clock, <video>, workers. These frames show what was drawn; they are not a frame rate.';
     const probed = rows.some((r) => r.phase !== undefined);
     if (!probed) result.note = [result.note, 'the game exposes no port probe (exposePort): the frames carry no round phase or position'].filter(Boolean).join('; ');
-    writeFileSync(join(out, 'shoot.json'), `${JSON.stringify({ v: 1, kind: 'homie-shoot', ...result, rows }, null, 1)}\n`);
     const smokeOk = result.smoke.ok !== false;
-    result.ok = rows.length === frames && smokeOk;
-    if (!result.ok) result.why = !smokeOk ? `smoke: ${result.smoke.why}` : result.partial;
+    const rulesOk = !result.rules || (result.rules.status === 'playing' && result.rules.tick > 0);
+    result.ok = rows.length === frames && smokeOk && rulesOk && !result.errors.length;
+    if (!result.ok) result.why = !smokeOk ? `smoke: ${result.smoke.why}` : !rulesOk ? 'The rules game is not playing. A server-only build needs its room: run homie-studio dev and shoot with --url (or explicitly enable room.offline for offline play).' : result.errors.length ? `game errors: ${result.errors.join('; ')}` : result.partial;
+    writeFileSync(join(out, 'shoot.json'), `${JSON.stringify({ v: 1, kind: 'homie-shoot', ...result, rows }, null, 1)}\n`);
     return result;
   } finally {
     if (served?.server) { served.server.closeAllConnections?.(); served.server.close(); }

package/lib/template-history.json

@@ -2112,6 +2112,50 @@
      }
     }
    }
+  },
+  "0.38.0": {
+   "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": "fc90f3609cad18ba"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": [
+      "8baf49e4291e7e88",
+      "c18362ed28975d81"
+     ],
+     "## Apps: one screen, roles and parts": "4db0abe4cdfac09f",
+     "## Commands (all through the pinned CLI in node_modules)": "a7f290579585368c",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "2da7fa74c8884834",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "98d08705087a33ec",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "2e6b29afb85dcf7e",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "7cad8fd10f62fef1"
+      }
+     }
+    }
+   }
   }
  }
 }

package/netplay/NETPLAY.md

@@ -2151,12 +2151,26 @@ and holds that lead from `lead`. A step whose sample (or claim) changed, or that
 makes an entry. A period with no entry sends nothing; after 250 ms without a frame the held values
 are sent again as an ordinary entry. A hidden tab sends one neutral entry and stops stepping.
 
-**In this release a person's body is owner-moved** (`body: { move: 'owner' }` in the rules): its
-browser runs the game's `move` code and claims a position, as `netplay.movement: 'owner'` does
-today, and the server holds each claim to the body's `maxSpeed` (a tick of it every tick, a quarter
-of a second banked at most). It does not stop a changed browser walking through a wall. Bots, and a
-body whose player is away, are moved by the server with the same `move` code. Scores, pickups,
-rounds and placements are the server's in either case.
+**Server movement with immediate local prediction.** The host runs `move` for every body.
+The view library runs the same guarded module for its own player, one step per tick and one
+throwaway preview between ticks. A snapshot replaces that body's position, velocity, heading,
+grounded flag and motion; the view replays pending inputs from there. Late presses are mirrored
+onto the next replay tick while they remain inside the quarter-second window. Scores, pickups,
+collisions between entities and effects are always the host's decisions. Bot and AI bodies
+are interpolated, never predicted by a player's view.
+
+Small errors fade as a visual offset with a nominal 100 ms blend. Overlapping small corrections
+queue their individual fades, so their accumulated offset is not erased all at once. A disagreement
+beyond three ticks of travel plays the corrected path from the snapshot at 1.25 times speed,
+showing the hold and slide of a knock. Offset fades are limited by progress along the drawn
+path and the body's declared maximum movement speed, so a late-input correction cannot erase more travel than the player makes or compound a fast knock's catch-up speed. Catch-up preserves the drawn pose when a snapshot replaces its history, and uses the next movement preview when its next whole-tick history entry is not yet available. When movement
+stops after catch-up, the remaining fade follows the configured blend time, still bounded by that speed. An effect on the body waits for its drawn tick. Placements, epoch changes and clock rebases
+jump deliberately. Other bodies keep the helper's adaptive interpolation, with one send period
+as the default minimum delay. The `room.predict` settings customize these defaults.
+
+`body: { move: 'owner' }` remains available for existing rules games: the browser supplies its
+position and the host limits each claim to `maxSpeed`. It cannot prevent a modified owner walking
+through a wall. New Coin Dash and Gem Rush use authoritative server movement instead.
 
 ### 29.3 The life of a server-hosted room
 

package/netplay/netplay.ts

@@ -631,6 +631,8 @@ export interface NetplayOptions<C = unknown> {
   checkpointMs?: number;
   /** Fixed interpolation delay in ms. Default: adaptive (arrival age p90 + 1.2 intervals). */
   interpDelayMs?: number;
+  /** Floor under the adaptive interpolation buffer (rules views). */
+  interpFloorMs?: number;
   /** Host: return the full rules state. Called every `checkpointMs`, before yielding, and on pagehide. */
   checkpoint?: () => C;
   /** ms to wait for a welcome before falling back to offline host, when the socket could not even open. Default 4000. */
@@ -2947,7 +2949,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
 
   function interpDelay(): number {
     if (opts.interpDelayMs !== undefined) return opts.interpDelayMs;
-    return delaySmooth || Math.max(50, iv * 1.6 + 8);
+    return Math.max(opts.interpFloorMs ?? 0, delaySmooth || Math.max(50, iv * 1.6 + 8));
   }
 
   // ---------------------------------------------------------------- connect

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.37.2",
+  "version": "0.38.0",
   "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/port/probe.ts

@@ -123,7 +123,8 @@ export function exposePort(net: Netplay<unknown, unknown, unknown> | null, opts:
     rows.push([t, me ? me.x : NaN, me ? me.y : NaN, b.right[0], b.right[1], b.up[0], b.up[1], m, busy]);
     if (rows.length > RING) rows.splice(0, rows.length - RING);
   };
-  const loop = (t: number): void => { sample(t); requestAnimationFrame(loop); };
+  // The position is sampled now; rAF may carry an earlier timestamp on a busy renderer.
+  const loop = (): void => { sample(performance.now()); requestAnimationFrame(loop); };
   if (typeof requestAnimationFrame === 'function') requestAnimationFrame(loop);
   const probe: PortProbe = {
     v: 1,

package/rules/core.ts

@@ -177,7 +177,7 @@ export interface Core {
  * `noted`: told, as it happens, of a value the rules wrote that the runtime changed to make it fit, or dropped (pack.ts
  * `Adjusted`; also `effect`, `think` and `decision`): the handler, what was done, the field's name and what was written.
  */
-export function createCore(c: Compiled, opts: { observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
+export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: number, input: Readonly<Record<string, unknown>>, before: import('./pack.ts').MoveBody, after: import('./pack.ts').MoveBody) => void; observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
   if (c.dims !== 2) throw new Error('this release runs rules with space.dims: 2; bodies with height (dims: 3) arrive in a later one');
   const dims = c.dims;
   const tickHz = c.settings.tickHz;
@@ -1002,6 +1002,7 @@ export function createCore(c: Compiled, opts: { observe?: (kind: string, handler
         }
         if (!k.move) continue;
         const b = { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: e.mself };
+        const beforeMove = opts.moved ? { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } } : null;
         moveRadius = body.radius;
         run(k.name, 'move', e, 'move', () => (k.move as NonNullable<KindTable['move']>)(b, e.input, moveCtx), 'body');
         // The runtime rounds to 32-bit floats, here and in the browser, so both step from exactly the same numbers.
@@ -1011,6 +1012,7 @@ export function createCore(c: Compiled, opts: { observe?: (kind: string, handler
         naming('body', 'pos'); e.pos = clampIn(V(own(b, 'pos')), body.radius); naming('body', 'vel'); e.vel = V(own(b, 'vel')); naming('body', 'heading'); e.heading = dir(own(b, 'heading'), dims); naming();
         G.note = null;
         e.grounded = own(b, 'grounded') === true;
+        if (beforeMove) opts.moved!(k.name, tick, e.input, beforeMove, { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } });
       }
       // Phase 2: for every entity, its commands and then its tick, starting from a different entity each tick.
       const list = [...ents.values()];

package/rules/host.ts

@@ -58,6 +58,8 @@ export interface HostClock {
 }
 export interface HostOptions {
   game: string;
+  /** The build check compares a movement step before any tick handler can change it. */
+  moved?: NonNullable<Parameters<typeof createCore>[1]>['moved'];
   /** Told of every handler as it ends, and what it threw if it threw (core.ts `observe`): the build check listens. */
   observe?(kind: string, handler: string, error?: string): void;
   /** Told of a written value the runtime changed to make it fit (core.ts `noted`): the build check listens. */
@@ -226,7 +228,7 @@ export function createHost(o: HostOptions): Host {
     }
   }
   if (saved && saved.v !== 1) throw new Error('this save was written by another version of the runtime');
-  const core = createCore(c, { observe: o.observe, noted: o.noted, seed: Math.floor(random() * 4294967296) >>> 0, epoch: saved ? undefined : (Math.floor(random() * 4294967295) >>> 0) + 1, restore: saved?.core ?? null, restoreEpoch: o.restoreEpoch, stage: o.stage, decisions: !o.check });
+  const core = createCore(c, { moved: o.moved, observe: o.observe, noted: o.noted, seed: Math.floor(random() * 4294967296) >>> 0, epoch: saved ? undefined : (Math.floor(random() * 4294967295) >>> 0) + 1, restore: saved?.core ?? null, restoreEpoch: o.restoreEpoch, stage: o.stage, decisions: !o.check });
   let epoch = core.epoch;
   if (saved && (o.startPaused ?? o.restoreEpoch !== undefined)) for (const body of core.bodies()) if (body.driver !== 'bot' && body.owner !== 'reserved') core.seatAway(body.seat, true);
   let lastSaveAt = o.clock.now();

package/rules/pack.ts

@@ -263,12 +263,39 @@ export interface MoveBody { pos: Vec3; vel: Vec3; heading: Vec3; grounded: boole
  */
 export function stepMove(fn: (body: MoveBody, input: unknown, ctx: unknown) => void, body: MoveBody, input: Readonly<Record<string, unknown>>, ctx: unknown, quota: number, motion: FieldList, dims: number, failed: (error: unknown) => void): MoveBody & { used: number } {
   G.left = quota;
+  const bag = coerceFields(motion, body.motion, dims);
+  const target: Record<string, unknown> = {};
+  const work: Record<string, unknown> = {};
+  // Match core.typed: scalar writes round immediately; collections copy on first read and settle at the end.
+  for (const [name, fd] of motion) {
+    const held = (v: unknown): unknown => { naming('body.motion', name); const out = coerce(fd, v, dims); naming(); return out; };
+    Object.defineProperty(target, name, { enumerable: true,
+      get: () => {
+        if (!mutable(fd)) return bag[name];
+        if (work[name] === undefined) {
+          const size = fd.t === 'list' ? 1 + (bag[name] as unknown[]).length * cellsOf(fd.of as Field)
+            : fd.t === 'map' ? 1 + Object.keys(bag[name] as object).length * (1 + cellsOf(fd.of as Field)) : cellsOf(fd);
+          charge(6 * size); work[name] = thaw(fd, bag[name]);
+        }
+        return work[name];
+      },
+      set: (v: unknown) => {
+        charge(mutable(fd) ? 6 * est(fd, v) : cellsOf(fd) === 1 ? 3 : 6 * cellsOf(fd));
+        bag[name] = held(v); work[name] = undefined;
+      },
+    });
+  }
+  body.motion = Object.preventExtensions(target);
   try { fn(body, input, ctx); } catch (error) { failed(error); }
+  try {
+    for (const [name, fd] of motion) if (work[name] !== undefined) {
+      charge(6 * est(fd, work[name])); naming('body.motion', name); bag[name] = coerce(fd, work[name], dims); naming();
+    }
+  } catch (error) { failed(error); }
   const used = quota - (G.left > 0 ? G.left : 0);
   G.left = Infinity;
-  naming('body', 'pos'); const pos = vec3(body.pos, dims); naming('body', 'vel'); const vel = vec3(body.vel, dims); naming('body', 'heading'); const heading = dir(body.heading, dims);
-  naming('body', 'motion'); const held = thawFields(motion, coerceFields(motion, body.motion, dims)); naming();
-  return { pos, vel, heading, grounded: body.grounded === true, motion: held, used };
+  naming('body', 'pos'); const pos = vec3(body.pos, dims); naming('body', 'vel'); const vel = vec3(body.vel, dims); naming('body', 'heading'); const heading = dir(body.heading, dims); naming();
+  return { pos, vel, heading, grounded: body.grounded === true, motion: thawFields(motion, bag), used };
 }
 
 /** How many values `pack` has packed since this was last set to 0: the core reads it to charge a tick for the state it sends. */