@homie-rocks/studio 0.47.0 → 0.48.1

package/lib/template-history.json

@@ -2943,6 +2943,90 @@
      }
     }
    }
+  },
+  "0.48.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": "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"
+      }
+     }
+    }
+   }
+  },
+  "0.48.1": {
+   "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

@@ -2329,3 +2329,23 @@ private round imports no room save, match score or simulation state into the onl
 room. When a body is assigned, the private round closes and the view joins the
 online match. Ember Vale retains its separate cloud hero: experience earned in
 solo play still belongs to that hero, whose level is sent through the usual command.
+
+### Rules input history trailer (studio 0.47.1)
+
+A rules step keeps its `[tickOffset, ...fields, ...ownerClaim]` prefix. Current
+views append `[-471, sequence, changeCount, ...changes]`, where each change is
+`[fieldIndex, changeSequence, fractionOfTick, value]`. All components are numbers.
+Input frames repeat recent entries, sorted by tick; the retained window is
+4–64 ticks based on measured authority RTT and jitter. The host deduplicates
+entry sequences, including history received after a missing frame. Duplicate
+history is not a fresh lead observation. Frames without the trailer keep the
+legacy input semantics.
+
+Control rows keep their first six columns and append
+`[471, sequence, appliedTick, ...]`. Positive sequences identify input entries;
+negative sequences identify the independently numbered reliable pulse stream.
+The last 64 receipts repeat in snapshots, including projected Gate snapshots.
+An on-time entry names its predicted tick; a safely rewound movement entry names
+that historical tick; an entry beyond retained movement history or an authority
+boundary names the next tick. Entry receipts describe coalesced per-tick input;
+command/effect handlers are not rerun in the past.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.47.0",
+  "version": "0.48.1",
   "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",
@@ -92,7 +92,8 @@
     "./functions": {
       "types": "./functions/functions.ts",
       "default": "./functions/functions.ts"
-    }
+    },
+    "./rules/physics-engine": "./rules/physics-engine.ts"
   },
   "files": [
     "docs/",
@@ -165,5 +166,13 @@
   "scripts": {
     "test": "node --test --test-concurrency=2 --test-timeout=1800000 test/*.test.mjs",
     "prepack": "node lib/build-identity.mjs --check && node ../../scripts/authoring-guides.mjs --check"
+  },
+  "peerDependencies": {
+    "@homie-rocks/physics": "0.1.2"
+  },
+  "peerDependenciesMeta": {
+    "@homie-rocks/physics": {
+      "optional": true
+    }
   }
 }

package/rules/core.ts

@@ -1,3 +1,5 @@
+import { physicsWorld } from './physics.ts';
+import { substeps } from './substeps.ts';
 import { prepareMapReplacement, type MapRevision } from './map-state.ts';
 import { tileApi } from './tiles.ts';
 import { boundPosition, periodicDelta, relativePoint, blendPosition, wrapPoint } from './topology.mjs';
@@ -143,6 +145,7 @@ export interface SavedCore {
   v: number; tick: number; epoch: number; rng: number; nextId: number; seq: number;
   round: [number, number, number, number]; overAt: number; match: [number, number]; trips: number;
   shared: unknown[]; policy: CorePolicy; intent?: [number, number, number?];
+  physics?: number[];
   collision?: [number,number];
   maps?: {current:MapRevision|null;pending:MapRevision|null};
   history?: [number, [string, number, number, number, number][]][];
@@ -155,6 +158,7 @@ export interface Core {
   readonly tick: number;
   readonly epoch: number;
   step(inputs?: ReadonlyMap<number, StepInput>, guides?: () => void): void;
+  reviseMovement(seat: number, at: number, values: Record<string, unknown>): boolean;
   guide(seat: number, floor?: unknown): Record<string, unknown> | null;
   vocabulary(value: Vocabulary | null): void;
   goal(seat: number, value?: unknown): unknown;
@@ -174,10 +178,11 @@ export interface Core {
   listeners(): { seat: number; id: string; pos: Vec3 }[];
   /** The body in a seat, as the host runtime needs it for the input protocol. */
   character(seat: number): import('./rules.ts').Character | null;
-  bodyOf(seat: number): { id: string; kind: KindTable; r: number; away: boolean; driver: Driver } | null;
+  bodyOf(seat: number): { id: string; kind: KindTable; r: number; away: boolean; controlled: boolean; driver: Driver } | null;
   /** What happened since the last call: rounds, effects, a changed roster, changed shared state, a new epoch, a failure. */
   drain(): CoreOut[];
   save(): SavedCore;
+  dispose(): void;
   /** The `world` object rules are handed (a test walks it to prove nothing else is reachable). */
   readonly world: object;
   /**
@@ -195,6 +200,8 @@ export interface Core {
  * `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: { characterForSeat?: (seat: number) => import('./rules.ts').Character | null | undefined; characterSaved?: (seat: number, character: import('./rules.ts').Character) => void; rewindTicks?: (seat: number)=>number; label?: (seat:number,driver:Driver)=>string; moved?: (kind: string, tick: number, input: Readonly<Record<string, unknown>>, before: import('./pack.ts').MoveBody, after: import('./pack.ts').MoveBody, geometry: import('./math.ts').MapShapes, id: string) => 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 (opts.restore && (c.map.physics !== undefined) !== (opts.restore.physics !== undefined)) throw new Error('physics: save and game differ');
+  const physics = physicsWorld(c.map.physics, opts.restore?.physics);
   let currentMap=c.map;
   let mapRevision:MapRevision|null=null,pendingMap:MapRevision|null=null;
   let pendingGeometry:typeof currentMap|null=null,mapCells=0,currentMapCells=0,pendingMapCells=0;
@@ -553,6 +560,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
     tick: () => tick, dt: () => dt, round: () => roundApi, shared: sharedView, level: () => policy.level, levelMax: () => policy.levelMax, guideLevel: () => policy.guideLevel ?? policy.level, guideSeats: () => policy.guideSeats ?? EMPTY_GUIDE_SEATS, kids: () => Boolean(policy.kids), levelSet: () => Boolean(policy.levelSet),
     // What the running handler may still spend (0.46.3): a handler that plans can stop short of its share instead of being stopped.
     unitsLeft: () => Math.max(0, Math.min(2147483647, Math.floor(G.left))),
+    ...(physics ? {physics: () => physics.api} : {}),
     stage: () => stage, tune: () => c.tune, math: () => math, map: () => mapApi,
   };
   for (const [name, get] of Object.entries(getters)) Object.defineProperty(world, name, { get, enumerable: true });
@@ -824,7 +832,8 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
   let moveShape = { shape: 'sphere', radius: 0, height: 0 };
   const moveCtx = brand({} as Record<string, unknown>);
   for (const [name, get] of Object.entries({ tick: () => tick, dt: () => dt, tune: () => c.publicTune, math: () => math, map: () => moveMap, world: () => moveWorld })) Object.defineProperty(moveCtx, name, { get, enumerable: true });
-  Object.assign(moveCtx, { ticks: (seconds: unknown): number => { charge(1); return ticks(seconds); } });
+  Object.assign(moveCtx, { substeps: substeps(c.settings.tickHz), ticks: (seconds: unknown): number => { charge(1); return ticks(seconds); } });
+  if (physics) Object.assign(moveCtx, {physics: physics.movement});
   Object.freeze(moveCtx);
   const joinCtx = brand({} as Record<string, unknown>);
   for (const [name, get] of Object.entries({ map: () => mapApi, shared: sharedView, tune: () => c.tune, math: () => math, round: () => roundApi })) Object.defineProperty(joinCtx, name, { get, enumerable: true });
@@ -1083,7 +1092,46 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
     // Inside the cone: the angle to its axis is at most half its opening, compared by cosine.
     return (dx * a.dir.x + dy * a.dir.y + dz * a.dir.z) / l >= exact.cos(a.half);
   }
+  // Movement-only rewind never repeats effects or commands. External body writes fence history.
+  type MovementState = {pos: Vec3; vel: Vec3; heading: Vec3; grounded: boolean; motion: Record<string, unknown>};
+  type MovementFrame = {tick: number; r: number; before: MovementState; after: MovementState; input: Readonly<Record<string, unknown>>; geometry: typeof moveGeometry; map: typeof currentMap};
+  const movementHistory = new Map<string, MovementFrame[]>();
+  const movementState = (e: Ent): MovementState => ({pos:e.pos,vel:e.vel,heading:e.heading,grounded:e.grounded,motion:{...e.m}});
+  const sameMovement = (a: MovementState,b: MovementState): boolean => JSON.stringify(a) === JSON.stringify(b);
+  function putMovement(e: Ent, b: MovementState): void {
+    e.pos=b.pos;e.vel=b.vel;e.heading=b.heading;e.grounded=b.grounded;
+    Object.assign(e.m,b.motion);
+  }
+  function reviseMovement(seat: number, at: number, values: Record<string, unknown>): boolean {
+    const id=seats.get(seat)?.id, e=id?ents.get(id):null;
+    if(!e || !e.kind.move || e.kind.body?.owner || e.away || e.driver!=='person') return false;
+    const frames=movementHistory.get(e.id), start=frames?.findIndex(f=>f.tick===at)??-1;
+    if(!frames || start<0 || frames.at(-1)!.tick!==tick || frames[start].r!==e.r || !sameMovement(frames.at(-1)!.after,movementState(e)))return false;
+    const control=e.kind.player?.control;
+    if(control && frames.slice(start).some(f=>!f.before.motion[control] || !f.after.motion[control]))return false;
+    for(let i=start+1;i<frames.length;i++)if(frames[i].r!==e.r || !sameMovement(frames[i-1].after,frames[i].before))return false;
+    const saved=movementState(e), savedTick=tick, geometry=moveGeometry, map=currentMap;
+    const old=frames.map(f=>({...f}));
+    try {
+      putMovement(e,frames[start].before);
+      for(let i=start;i<frames.length;i++){
+        const f=frames[i];tick=f.tick;moveGeometry=f.geometry;currentMap=f.map;moveShape=e.kind.body!;
+        f.before=movementState(e);
+        // An entry holds until the next explicitly different input.
+        if(i===start || JSON.stringify(old[i].input)===JSON.stringify(old[i-1].input))f.input=Object.freeze(coerceFields(e.kind.input,values,dims));else values={...f.input};
+        const b={pos:e.pos,vel:e.vel,heading:e.heading,grounded:e.grounded,motion:e.mself};
+        const errors=stats.errors, stops=stats.budgetStops;
+        if(!run(e.kind.name,'move',e,'move',()=>e.kind.move!(b,f.input,moveCtx),'body'))throw new Error('rewind budget');
+        if(stats.errors!==errors || stats.budgetStops!==stops)throw new Error('rewind failed');
+        e.pos=clampIn(V(own(b,'pos')),e.kind.body!.radius,e.kind.body!.height||2*e.kind.body!.radius);e.vel=V(own(b,'vel'));e.heading=dir(own(b,'heading'),dims);e.grounded=own(b,'grounded')===true;
+        f.after=movementState(e);
+      }
+      return true;
+    } catch {putMovement(e,saved);movementHistory.set(e.id,old);return false;}
+    finally {tick=savedTick;moveGeometry=geometry;currentMap=map;}
+  }
   function step(inputs: ReadonlyMap<number, StepInput> = new Map(), guides?: () => void): void {
+    for(const id of movementHistory.keys())if(!ents.has(id))movementHistory.delete(id);
     tick = (tick + 1) >>> 0;
     if(pendingMap&&pendingMap[0]<=tick){currentMap=pendingGeometry!;mapRevision=pendingMap;currentMapCells=pendingMapCells;mapCells=currentMapCells;pendingMapCells=0;pendingMap=null;pendingGeometry=null;moveGeometry=currentMap;}
     // The tick pays first for the state it sends: what the last snapshot packed. A room that holds more than a tick can send has nothing left for its handlers, and ends as any room does whose budget trips on every tick.
@@ -1197,6 +1245,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
         }
         if (!k.move) continue;
         const b = { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: e.mself };
+        const rewindBefore = k.player && e.driver === 'person' && !e.away ? movementState(e) : null;
         const beforeMove = opts.moved ? { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } } : null;
         moveShape = body;
         run(k.name, 'move', e, 'move', () => (k.move as NonNullable<KindTable['move']>)(b, e.input, moveCtx), 'body');
@@ -1207,6 +1256,11 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
         naming('body', 'pos'); e.pos = clampIn(V(own(b, 'pos')), body.radius, body.height || 2 * 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 (rewindBefore) {
+          let frames=movementHistory.get(e.id);if(!frames){frames=[];movementHistory.set(e.id,frames);}
+          frames.push({tick,r:e.r,before:rewindBefore,after:movementState(e),input:e.input,geometry:moveGeometry,map:currentMap});
+          while(frames.length>tickHz)frames.shift();
+        }
         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 } }, moveGeometry, e.id);
       }
       // Phase 2: for every entity, its commands and then its tick, starting from a different entity each tick.
@@ -1281,6 +1335,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
   }
   function save(): SavedCore {
     return {
+      ...(physics ? {physics: physics.save()} : {}),
       v: SAVE_REVISION, tick, epoch, rng, nextId, seq, round: [round.n, round.phase === 'live' ? 1 : 0, round.endsAt, round.startedAt], overAt, match: [playing, restartAt], trips,
       ...((hasColliders||mapRevision||pendingMap)?{collision:collisionState().slice(0,2) as [number,number]}:{}),
       ...((mapRevision||pendingMap)?{maps:{current:mapRevision,pending:pendingMap}}:{}),
@@ -1307,7 +1362,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
       for(const [name,value] of Object.entries(r.maps)){if(value===null)continue;check(Array.isArray(value)&&value.length===2&&uint(value[0])&&(name==='pending'?value[0]===r.tick+1:value[0]<=r.tick));prepareMapReplacement(value[1],c.map);}
     }
     if(r.collision!==undefined)check(Array.isArray(r.collision)&&r.collision.length===2&&uint(r.collision[0])&&uint(r.collision[1])&&r.collision[0]<=r.tick&&r.collision[1]===r.collision[0]+1);
-    check(Object.keys(r).every(k => ['v', 'tick', 'epoch', 'rng', 'nextId', 'seq', 'round', 'overAt', 'match', 'trips', 'shared', 'policy', 'intent', 'asks', 'guideViews', 'ents', 'spawns', 'seats', 'queue', 'areas', 'ops', 'history', 'collision', 'maps'].includes(k)));
+    check(Object.keys(r).every(k => ['v', 'tick', 'epoch', 'rng', 'nextId', 'seq', 'round', 'overAt', 'match', 'trips', 'shared', 'policy', 'intent', 'asks', 'guideViews', 'ents', 'spawns', 'seats', 'queue', 'areas', 'ops', 'history', 'collision', 'maps', 'physics'].includes(k)));
     const askNames = new Set();
     check(Array.isArray(r.asks));
     for (const a of r.asks) {
@@ -1429,6 +1484,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
     }
   }
   const r = opts.restore;
+  try {
   if (r) {
     if (r.v !== SAVE_REVISION) throw new Error('this save was written by another version of the runtime');
     validateSave(r);
@@ -1466,6 +1522,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
     ops = r.ops as typeof ops;
     if(hasColliders||mapRevision||pendingMap)collisionState();
   } else startMatch();
+  } catch (error) { physics?.dispose(); throw error; }
 
   function decisionResult(value: unknown): Record<string, unknown> {
     const v = plainData(value, { n: ANSWER_MAX });
@@ -1481,6 +1538,7 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
   return {
     round: () => ({ t: 'round', ...round, ...(round.phase === 'over' && !overAt ? { results: results() } : {}) }),
     get tick() { return tick; },
+    reviseMovement,
     get epoch() { return epoch; },
     step,
     answer: (n, result) => { const a = pendingAsks.find((x) => x.n === n); if (a && !a.result) a.result = decisionResult(result); },
@@ -1557,9 +1615,10 @@ export function createCore(c: Compiled, opts: { characterForSeat?: (seat: number
     character: (seat) => { const e = playerBodies().find(e => e.seat === seat); return e ? JSON.parse(JSON.stringify({ kind: e.kind.name, at: e.pos, heading: e.heading, fields: e.f, motion: e.m })) : null; },
     bodies: () => playerBodies().map((e) => ({ seat: e.seat, id: e.id, kind: e.kind.name, driver: e.driver, owner: e.owner, away: e.away, score: e.kind.score ? Number(e.f[e.kind.score]) || 0 : 0, r: e.r })),
     listeners: () => playerBodies().filter((e) => e.driver === 'person').map((e) => ({ seat: e.seat, id: e.id, pos: e.pos })),
-    bodyOf: (seat) => { const s = seats.get(seat); const e = s?.id ? ents.get(s.id) : null; return e ? { id: e.id, kind: e.kind, r: e.r, away: e.away, driver: e.driver } : null; },
+    bodyOf: (seat) => { const s = seats.get(seat); const e = s?.id ? ents.get(s.id) : null; return e ? { id: e.id, kind: e.kind, r: e.r, away: e.away, controlled: !e.kind.player?.control || Boolean(e.m[e.kind.player.control]), driver: e.driver } : null; },
     drain: () => { const o = out; out = []; return o; },
     save,
+    dispose: () => physics?.dispose(),
     world,
     stats,
   };

package/rules/host.ts

@@ -135,8 +135,11 @@ export interface Host {
   readonly core: Core;
 }
 
-interface Entry { at: number; values: Record<string, unknown>; presses: (string | [string, number])[]; claim: StepInput['claim']; /** How many ticks before its own tick it arrived (0.46.3): the time the input itself waited here. */ early?: number }
+interface Entry { placement?: number; source?: number; at: number; values: Record<string, unknown>; presses: (string | [string, number])[]; claim: StepInput['claim']; /** How many ticks before its own tick it arrived (0.46.3): the time the input itself waited here. */ early?: number }
 interface SeatIn {
+  heldAt?: number;
+  receipts?: [number, number][];
+  received?: number[];
   /** A valued pulse, and the tick its browser predicted it on (0: none given, act at once). */
   pulses?: [string,number,number?,number?][];
   /** The wait of the entry now held, in ticks (see Entry.early). */
@@ -259,9 +262,11 @@ export function createHost(o: HostOptions): Host {
       check(Array.isArray(saved.inputs) && saved.inputs.length <= c.seats);
       for (const [seat, q] of saved.inputs) {
         check(uint(seat) && seat < c.seats && q && valuesOk(seat, q.held) && claimOk(q.claim) && uint(q.newest) && uint(q.ack) && uint(q.lastFrameTick) && Number.isInteger(q.lead) && q.lead >= -127 && q.lead <= 127);
+        if(q.received!==undefined)check(Array.isArray(q.received)&&q.received.length<=256&&q.received.every(uint));
+        if(q.receipts!==undefined)check(Array.isArray(q.receipts)&&q.receipts.length<=64&&q.receipts.every(r=>Array.isArray(r)&&r.length===2&&Number.isSafeInteger(r[0])&&r[0]!==0&&uint(r[1])));
         check(Array.isArray(q.stamps) && q.stamps.length <= 256 && q.stamps.every(uint) && Array.isArray(q.entries) && q.entries.length <= c.settings.tickHz + 1);
         if(q.pulses!==undefined)check(Array.isArray(q.pulses)&&q.pulses.length<=16&&q.pulses.every(p=>Array.isArray(p)&&(p.length===2||p.length>=3&&p.length<=4&&uint(p[2])&&(p[3]===undefined||uint(p[3])))&&c.kinds.some(k=>k.input.some(([n,f])=>n===p[0]&&f.t==='pulse'))&&Number.isInteger(p[1])&&p[1]>0&&p[1]<=255));
-        for (const e of q.entries) check(uint(e.at) && valuesOk(seat, e.values) && claimOk(e.claim) && Array.isArray(e.presses) && e.presses.every((p) => c.kinds.some((k) => k.input.some(([name, fd]) => (typeof p === 'string' ? name === p && fd.t === 'press' : Array.isArray(p) && p.length === 2 && name === p[0] && fd.t === 'pulse' && Number.isInteger(p[1]) && p[1] > 0 && p[1] <= 255)))));
+        for (const e of q.entries) check((e.placement === undefined || uint(e.placement)) && uint(e.at) && valuesOk(seat, e.values) && claimOk(e.claim) && Array.isArray(e.presses) && e.presses.every((p) => c.kinds.some((k) => k.input.some(([name, fd]) => (typeof p === 'string' ? name === p && fd.t === 'press' : Array.isArray(p) && p.length === 2 && name === p[0] && fd.t === 'pulse' && Number.isInteger(p[1]) && p[1] > 0 && p[1] <= 255)))));
       }
     }
   }
@@ -474,8 +479,8 @@ export function createHost(o: HostOptions): Host {
     stats.ins += 1;
     q.lastFrameTick = K;
     // Lead: from this frame's arrival to the moment its first tick was due, in sixteenths of a tick. Negative is late.
-    const lead = Math.max(-127, Math.min(126, Math.round(((base.ms + (k - base.tick) * period - o.clock.now()) / period) * 16)));
-    if (lead < q.lead) q.lead = lead;
+    const lead = Math.max(-127, Math.min(126, Math.round(((base.ms + (k + num(m.s.at(-1)?.[0]) - base.tick) * period - o.clock.now()) / period) * 16)));
+
     const r = num(m.r) & 0xffff;
     let before = -1;
     for (const raw of (m.s as unknown[]).slice(0, 64)) {
@@ -485,10 +490,18 @@ export function createHost(o: HostOptions): Host {
       before = off;
       const j = (k + off) >>> 0;
       // A duplicate: not above the newest stamp this seat has sent. It still counted as the player being there.
-      if (j <= q.newest) continue;
+      const marker = 1 + kind.input.length + (kind.body?.owner ? 9 : 0);
+      const seq = raw[marker] === -471 && Number.isSafeInteger(raw[marker+1]) && raw[marker+1] > 0 ? raw[marker+1] as number : 0;
+      // A discrete action sent before the client learns of a placement still
+      // belongs to its player. Held state from that old placement does not.
+      const action = kind.input.some(([, fd], index) => fd.t === 'press' && raw[index + 1] === 1);
+      if (seq && r !== body.r && !action) continue;
+      if (seq ? q.received?.includes(seq) : j <= q.newest) continue;
       // Too early: more than a second ahead. This entry and the rest of the frame are dropped.
       if (j > K + tickHz) { stats.dropped += 1; break; }
-      q.newest = j;
+      if(j >= q.newest && lead < q.lead)q.lead=lead;
+      q.newest = Math.max(q.newest,j);
+      if(seq){q.received??=[];q.received.push(seq);if(q.received.length>256)q.received.shift();}
       const values: Record<string, unknown> = {};
       const presses: (string | [string, number])[] = [];
       let i = 1;
@@ -499,9 +512,22 @@ export function createHost(o: HostOptions): Host {
       }
       const claim = kind.body?.owner && raw.length >= i + 9 ? { pos: unpackVec([raw[i], raw[i + 1], raw[i + 2]], c.dims), vel: unpackVec([raw[i + 3], raw[i + 4], raw[i + 5]], c.dims), heading: unpackVec([raw[i + 6], raw[i + 7], raw[i + 8]], c.dims), r } : null;
       q.stamps.push(j);
-      if (j > K) { q.entries.push({ at: j, values, presses, claim, early: Math.min(lateTicks, j - K) }); continue; }
+      if(seq){q.receipts??=[];q.receipts.push([seq,j>K?j:K+1]);if(q.receipts.length>64)q.receipts.shift();}
+      if (j > K) { q.entries.push({ ...(seq ? { placement: body.r } : {}), source: j, at: j, values, presses, claim, early: Math.min(lateTicks, j - K) }); continue; }
       // Late: its values hold from the next tick, and its presses fire there if that is within a quarter of a second of its stamp.
       stats.lateEntries += 1;
+      if(seq){
+        if(!presses.length && K-j<tickHz && core.reviseMovement(seat as number,j,values))q.receipts![q.receipts!.length-1][1]=j;
+        const at=K+1;
+        const same=q.entries.find(e=>e.at===at);
+        if(j >= (q.heldAt??0) && (!same || j >= (same.source??0))){
+          if(same){same.placement=body.r;same.source=j;same.values=values;same.claim=claim;same.presses.push(...presses);}else q.entries.push({placement:body.r,source:j,at,values,claim,presses});
+        } else if(presses.length){
+          if(same)same.presses.push(...presses);else q.entries.push({placement:body.r,source:q.heldAt,at,values:{...q.held},claim:q.claim,presses});
+        }
+        q.entries.sort((a,b)=>a.at-b.at);
+        continue;
+      }
       const book = heldBook.get(seat as number);
       if (book) for (const row of book.ran) if (row[0] >= j) { for (const name of heldOf(kind)) { const meant = Number(values[name]) || 0; book.debt[name] = (book.debt[name] ?? 0) + meant - (row[1][name] ?? 0); row[1][name] = meant; } book.until = K + 1 + lateTicks; }
       const at = (K + 1) >>> 0;
@@ -704,7 +730,8 @@ export function createHost(o: HostOptions): Host {
       const presses: (string | [string, number])[] = [];
       while (q.entries.length && q.entries[0].at <= t) {
         const e = q.entries.shift() as Entry;
-        q.held = e.values; q.claim = e.claim; q.early = e.early ?? 1;
+        if (e.placement !== undefined && e.placement !== body.r) continue;
+        q.heldAt=e.source??e.at; q.held = e.values; q.claim = e.claim; q.early = e.early ?? 1;
         if (e.at === t) for (const p of e.presses) presses.push(p);
       }
       // Silence: no frame for a second. Its input is neutral until the next entry.
@@ -723,7 +750,7 @@ export function createHost(o: HostOptions): Host {
       }
       for (const p of presses) { if (typeof p === 'string') values[p] = true; else values[p[0]] = p[1]; }
       // One pulse a tick, in order: the head waits for its own tick when that is no more than a quarter of a second ahead.
-      const head=q.pulses?.[0];if(head&&!((head[2]??0)>t&&(head[2] as number)-t<=Math.ceil(tickHz/4))){q.pulses!.shift();values[head[0]]=head[1];if(head[3])pulsesTaken.set(seat,head[3]);}
+      const head=q.pulses?.[0];if(head&&(body.controlled||body.kind.player?.pulses!=='hold')&&(head[2]??0)<=t){q.pulses!.shift();values[head[0]]=head[1];if(head[3]){pulsesTaken.set(seat,head[3]);q.receipts??=[];q.receipts.push([-head[3],t]);if(q.receipts.length>64)q.receipts.shift();}}
       inputs.set(seat, { values, claim: q.claim });
     }
     if (roundRebasePending) publishRebase(now);
@@ -760,6 +787,7 @@ export function createHost(o: HostOptions): Host {
       // 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);
+      if(q?.receipts){while(row.length<6)row.push(0);row.push(471,...q.receipts.flat());}
       rows.push(row);
       if (q) q.lead = 127;
     }
@@ -932,6 +960,7 @@ export function createHost(o: HostOptions): Host {
   }
   function stop(): void {
     running = false; paused = false; ended = true;
+    core.dispose();
     disarm();
     agents?.stop();
     for (let i = recent.length - 1; i >= 0; i -= 1) if (recent[i].who === self) recent.splice(i, 1);

package/rules/math.ts

@@ -1,3 +1,5 @@
+import { physicsWorld } from './physics.ts';
+import { substeps } from './substeps.ts';
 import { wrapPoint } from './topology.mjs';
 import { tileApi } from './tiles.ts';
 import { nearbyMap } from './map-index.ts';
@@ -299,15 +301,22 @@ export function sweepMap(map: MapShapes, body: unknown, delta: unknown, radius:
  * map. One function, so that the browser (view.ts) and the person the build check plays hold the same one. The
  * server's own (core.ts `moveCtx`) is made beside the rest of its world, and charges as that does.
  */
+const physicsContexts = new WeakMap<object, () => void>();
+export function disposeMoveContext(context: object): void { physicsContexts.get(context)?.(); physicsContexts.delete(context); }
 export function moveContext(o: { tick: () => number; tickHz: number; tune: unknown; map: MapShapes; name: string; spots: Readonly<Record<string, readonly unknown[]>>; radius: () => number; shape?: () => BodyShape; dims: number; geometry?: () => MapShapes; self?: () => string | undefined }): unknown {
+  const physics = physicsWorld((o.map as import('./rules.ts').GameMap).physics);
   const none = Object.freeze([]);
   const currentMap = () => (o.geometry?.()?.staticMap ?? o.geometry?.() ?? o.map) as import('./rules.ts').GameMap;
   const queries = collisionQueries(() => o.geometry?.() ?? o.map, () => o.shape?.() ?? {shape: 'sphere', radius: o.radius(), height: 2 * o.radius()}, o.dims, o.self);
-  return brand(Object.freeze({
+  const context = brand(Object.freeze({
+    ...(physics ? {physics: physics.movement} : {}),
+    substeps: substeps(o.tickHz),
     get tick() { return o.tick(); }, dt: 1 / o.tickHz, tune: o.tune, math,
     // As the server's `ctx.ticks` reads it: a plain number, or nothing.
     ticks: (seconds: unknown): number => { const s = num(seconds); const n = Math.round(s * o.tickHz); return s > 0 && Number.isFinite(n) ? Math.max(1, n) : 0; },
     world: brand(Object.freeze(queries)),
     map: brand(Object.freeze({ ...tileApi(currentMap), name: o.name, spot: (name: string) => (own(currentMap().spots ?? o.spots, name) as readonly unknown[] | undefined)?.[0], spots: (name: string) => own(currentMap().spots ?? o.spots, name) ?? none, ...queries })),
   }));
+  if (physics) physicsContexts.set(context, physics.dispose);
+  return context;
 }

package/rules/pack.ts

@@ -1,3 +1,4 @@
+import { takeSubsteps, type StepPose } from './substeps.ts';
 /*
  * pack.ts — declared state in and out: holding a value to its declared type, and packing it for the wire and the save.
  * =============================================================================
@@ -262,7 +263,7 @@ export interface MoveBody { pos: Vec3; vel: Vec3; heading: Vec3; grounded: boole
  * left rounded to 32-bit floats and held to the declared shapes as the server does it, so both hold the same numbers.
  * `used` is the units it took. What it throws goes to `failed` (the budget's own stop too) and the body is still read.
  */
-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 } {
+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; steps?: readonly StepPose[] } {
   G.queryEpoch++; G.left = quota;
   const bag = coerceFields(motion, body.motion, dims);
   const target: Record<string, unknown> = {};
@@ -296,7 +297,8 @@ export function stepMove(fn: (body: MoveBody, input: unknown, ctx: unknown) => v
   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();
-  return { pos, vel, heading, grounded: body.grounded === true, motion: thawFields(motion, bag), used };
+  const steps = takeSubsteps(body);
+  return { pos, vel, heading, grounded: body.grounded === true, motion: thawFields(motion, bag), used, ...(steps ? {steps} : {}) };
 }
 
 /** 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. */

package/rules/physics-engine.ts

@@ -0,0 +1,73 @@
+/** Loaded only by games declaring a baked physics level. */
+import { createWorld } from '@homie-rocks/physics/World.js';
+import { initPhysics } from '@homie-rocks/physics/Worker.js';
+import { brand, charge } from './guard.ts';
+import { registerPhysics, type PhysicsMovement, type RulesPhysics } from './physics.ts';
+
+// CPU calibration is recorded in docs/physics-048-calibration.md. Charges precede work.
+export const PHYSICS_UNITS = Object.freeze({ cast: 768, ray: 640, overlap: 640, step: 2400 });
+export async function initializePhysics(source: WebAssembly.Module | BufferSource): Promise<void> {
+  await initPhysics(source);
+  registerPhysics((mesh, saved) => {
+    const world = createWorld({ up: 'z', fixedDt: 1 / 300, maxSubsteps: 128, bounds: null });
+    try {
+      if (saved) world.restore(Uint8Array.from(saved));
+      else world.createBody({ type: 'static', colliders: [{ shape: { kind: 'mesh', vertices: Float32Array.from(mesh.vertices), indices: Uint32Array.from(mesh.indices) } }] });
+      const count = Math.max(1, Math.ceil(mesh.indices.length / (1754 * 3)));
+      const convex = (shape: {kind:string}) => { if (!['box','sphere','capsule'].includes(shape.kind)) throw new Error('rules physics queries use a box, sphere or capsule'); };
+      const movement: PhysicsMovement = {
+        cast(...args) { charge(PHYSICS_UNITS.cast * count); convex(args[0]); return world.castShape(...args); },
+        ray(...args) { charge(PHYSICS_UNITS.ray * count); return world.raycast(...args); },
+        overlap(...args) { charge(PHYSICS_UNITS.overlap * count); convex(args[0]); return world.overlaps(...args); },
+        sweep(body, delta, radius, height) {
+          charge(64);
+          let left = { ...delta }, pos = { ...body.pos }, vel = { ...body.vel };
+          let grounded = false;
+          for (let n = 0; n < 4; n++) {
+            const length = Math.hypot(left.x, left.y, left.z);
+            if (length < 1e-9) break;
+            charge(PHYSICS_UNITS.cast * count);
+            const hit = world.castCapsule(pos, left, radius, height);
+            const fraction = hit ? Math.max(0, hit.fraction) : 1;
+            pos = { x: pos.x + left.x * fraction, y: pos.y + left.y * fraction, z: pos.z + left.z * fraction };
+            if (!hit) break;
+            if (hit.normal.z > .65 && delta.z <= 0) grounded = true;
+            const normal = hit.normal;
+            const dot = left.x * normal.x + left.y * normal.y + left.z * normal.z;
+            const speed = vel.x * normal.x + vel.y * normal.y + vel.z * normal.z;
+            if (normal.z > .65 && delta.z <= 0) {
+              // Lift the requested horizontal travel along a walkable slope.
+              // Projecting gravity onto its normal would make an idle capsule drift.
+              left = { x: left.x * (1-fraction), y: left.y * (1-fraction), z: 0 };
+              left.z = -(left.x * normal.x + left.y * normal.y) / normal.z;
+              vel = { x: vel.x, y: vel.y, z: Math.max(0, vel.z) };
+            } else {
+              left = { x: (left.x-normal.x*Math.min(0,dot))*(1-fraction), y: (left.y-normal.y*Math.min(0,dot))*(1-fraction), z: (left.z-normal.z*Math.min(0,dot))*(1-fraction) };
+              vel = { x:vel.x-normal.x*Math.min(0,speed), y:vel.y-normal.y*Math.min(0,speed), z:vel.z-normal.z*Math.min(0,speed) };
+            }
+          }
+          body.pos = pos; body.vel = vel; body.grounded = grounded;
+        },
+      };
+      const api: RulesPhysics = {
+        ...movement,
+        step(dt) {
+          charge(8);
+          if (!Number.isFinite(dt) || dt < 0) throw new Error('physics: dt must be finite and nonnegative');
+          charge(PHYSICS_UNITS.step * count * Math.max(1, Math.ceil(dt * 300)));
+          while (dt > .1) { world.step(.1); dt -= .1; }
+          world.step(dt);
+        },
+      };
+      let disposed = false, finalSave: number[] | undefined;
+      return { api: brand(Object.freeze(api)), movement: brand(Object.freeze(movement)),
+        save: () => finalSave ? [...finalSave] : Array.from(world.snapshot()),
+        dispose: () => {
+          if (disposed) return;
+          try { finalSave = Array.from(world.snapshot()); } catch { /* A failed engine has no final checkpoint. */ }
+          world.dispose(); disposed = true;
+        },
+      };
+    } catch (error) { world.dispose(); throw error; }
+  });
+}

package/rules/physics.ts

@@ -0,0 +1,26 @@
+/** Opt-in boundary. Importing the rules kernel never imports or initializes WASM. */
+import type { Vec3 } from './rules.ts';
+export interface PhysicsMesh { vertices: readonly number[]; indices: readonly number[] }
+// Structural query types keep the ordinary rules types independent of the optional package.
+export type PhysicsShape = {kind: 'box'; halfExtents: Vec3} | {kind: 'sphere'; radius: number} | {kind: 'capsule'; radius: number; halfHeight: number};
+export interface PhysicsRotation {x: number; y: number; z: number; w: number}
+export interface PhysicsFilter {layers?: {membership: number; filter: number}; excludeBody?: number; excludeCollider?: number; sensors?: boolean}
+export interface PhysicsHit {collider: number; body: number; point: Vec3; normal: Vec3}
+export interface PhysicsMovement {
+  sweep(body: {pos: Vec3; vel: Vec3; grounded: boolean}, delta: Vec3, radius: number, height: number): void;
+  ray(origin: Vec3, direction: Vec3, distance: number, filter?: PhysicsFilter): (PhysicsHit & {distance: number}) | null;
+  overlap(shape: PhysicsShape, position: Vec3, orientation?: PhysicsRotation, filter?: PhysicsFilter): number[];
+  cast(shape: PhysicsShape, position: Vec3, delta: Vec3, orientation?: PhysicsRotation, filter?: PhysicsFilter): (PhysicsHit & {fraction: number}) | null;
+}
+export interface RulesPhysics extends PhysicsMovement {
+  step(seconds: number): void;
+}
+export interface PhysicsBridge { api: RulesPhysics; movement: PhysicsMovement; save(): number[]; dispose(): void }
+let factory: ((mesh: PhysicsMesh, saved?: number[]) => PhysicsBridge) | undefined;
+export function registerPhysics(value: NonNullable<typeof factory>): void { factory = value; }
+export function physicsWorld(mesh?: PhysicsMesh, saved?: number[]): PhysicsBridge | undefined {
+  if (!mesh) { if (saved !== undefined) throw new Error('physics save requires a physics level'); return; }
+  if (saved !== undefined && (!Array.isArray(saved) || saved.some(n => !Number.isInteger(n) || n < 0 || n > 255))) throw new Error('physics: invalid saved bytes');
+  if (!factory) throw new Error('physics: initialize the game before starting its room');
+  return factory(mesh, saved);
+}