@homie-rocks/studio 0.48.0 → 0.48.3

package/CHANGELOG.md

@@ -17,6 +17,80 @@ 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.48.3] - 2026-10-13
+
+**Plugin 0.48.3** · Restore rewind-based hits with input history.
+
+Rules input history fits the wire without starving current aim and trigger controls.
+
+### Fixed
+
+- **0.48.1 misjudged rewind-based hits.** Repeated input history and sub-tick
+  metadata could exceed the relay's 2 KB input limit, even with no latency or
+  loss. The server then kept stale aim and trigger state while the player's
+  predictor showed hits against the current aim. Input frames now fit that
+  existing byte limit, prioritizing current controls and missing receipts.
+- Optional sub-tick metadata uses only the space left after complete input
+  values and their sequence numbers. Integrated held durations, reliable
+  pulses, measured round trips and the rewind cap keep their existing meaning.
+  Bounded history recovery, application receipts and correction blending remain.
+
+### Upgrade notes
+
+- Existing games need no code changes.
+
+## [0.48.1] - 2026-10-13
+
+**Plugin 0.48.1** · Input history under loss.
+
+Rules views recover missing input and acknowledge late movement scheduling.
+
+### Changed
+
+- Snapshots that precede a predicted input's application receipt retain the live
+  movement prediction within the replay window; explicit placements still apply.
+- Prediction clock steering is limited to 0.5% instead of 5%; it slews without
+  repeatedly rebasing stamped input when the jitter estimate changes.
+- Rules input frames repeat a bounded history sized from measured latency and
+  jitter and missing application receipts, with input sequence numbers and sub-tick control changes. Snapshot
+  control rows report application ticks, including pulses. Retransmissions no
+  longer distort latency steering. A newer tick acknowledgement cannot stop
+  retries for an earlier missing input; only its own receipt does.
+- Late movement replays up to one second of body history against historical
+  geometry, fenced by authoritative body writes and placements. Outside that
+  history an entry applies next tick. Entries with press handlers also apply
+  next tick, so historical replay cannot duplicate world actions. New views use application receipts instead
+  of negative held-input compensation; old wire entries retain their behaviour.
+- Small visual corrections use `room.predict.blendMs` and expire within one
+  second (or an explicitly longer blend), including while stationary; `idleHold` no longer holds them indefinitely. Placement counters
+  still distinguish respawns from prediction corrections. Vertical travel cannot
+  erase a horizontal correction fast enough to reverse the held direction.
+  Remaining offsets drain over the final 250 ms rather than snapping at expiry.
+
+### Added
+
+- `room.input(sample, {at})` timestamps a control inside the current predicted
+  tick. `player.pulses: 'hold'` queues actions while control is taken;
+  `'drop'` remains the default.
+- Seeded virtual-time coverage of 40/80/150/300 ms each way and 0.5/1/2/5% loss,
+  dropped inputs and ordered stall/burst delivery, in small rooms and through Gates.
+- A seeded baked-physics-world regression at 80 ms each way and 2% loss checks
+  zero drawn warps, application receipts, 300 Hz substeps, predictor room reads
+  and exact settling for two moving bodies.
+
+### Fixed
+
+- Multiple pulse calls within one predicted tick queue instead of overwriting
+  one another. Their application ticks are distinct from the movement entry.
+- Placements preserve the established prediction-clock phase, and the snapshot
+  body is advanced to its predicted tick instead of relabelling an old pose.
+  Projection is bounded to the server's one-second input window, and its controls
+  are stamped for that same path. Queued held state from an earlier placement
+  cannot later change the respawned body; discrete presses received before the
+  browser learns of the placement still belong to the player.
+- A fresh control after a browser stall is recorded after resetting the stale
+  prediction clock, preventing a short press from moving by the stalled backlog.
+
 ## [0.48.0] - 2026-10-13
 
 **Plugin 0.48.0** · Baked physics worlds for server rules and local prediction.

package/guides/game/RULES.md

@@ -1221,10 +1221,8 @@ occupied terrain nodes out of the graph, and choose reachable endpoints.
 `@homie-rocks/nav` is the richer mesh/crowd API for applications that own that
 runtime; rules graphs avoid importing mutable navigation state into handlers.
 
-`room.predict.idleHold: true` holds small visual reconciliation offsets while
-input and body are stationary. Movement resumes smoothing. Large invalid poses
-still snap to authority. Opt in only after measuring stop/reversal and delayed
-collision behavior for the game's mover.
+Small reconciliation offsets expire even while stationary; see “Input during loss
+and stalls” below for the visual correction settings.
 
 For multi-cast movement or scratch trajectory checks, `ctx.world.sweep(body, delta, {ground:false})` (also captured-scene `sweep`) moves and returns the same collision but leaves `body.grounded` unchanged. Use it only when your mover computes support explicitly. Omitting the option retains the existing support query and grounding behavior. This avoids paying for identical support checks after horizontal and upward probes.
 
@@ -1385,3 +1383,50 @@ creates the same baked world and replays pending guarded movement against it;
 substep drawing traces remain temporary. Physics worlds are disposed when their
 host or view closes. A full solver save can exceed browser-host checkpoint caps;
 the build measures this, and server-hosted rooms retain the full save.
+
+## Input during loss and stalls (0.48.1)
+
+Rules views resend recent input automatically: a 4–64 tick history follows the
+measured round trip, jitter and missing application receipts (loss or recovery
+delay). Each tick entry carries a sequence number; each
+control change carries a field index, sequence and fraction of the predicted tick.
+Duplicates neither execute again nor count as fresh latency measurements. Both
+missing application frames and ordered TCP stalls are covered.
+
+The server retains up to one second of movement history and replays late movement
+against the geometry of those ticks. It never repeats commands or effects. An
+external body/motion write or placement fences that history. Beyond a fence or
+the retained history, input applies on the next tick instead. Entries carrying
+press handlers also apply next tick: world actions are never rerun as movement. Snapshot control
+rows report the application tick and the view uses it for replay. Within the
+replay window a snapshot still missing a predicted input does not replace live
+movement; an explicit placement always does. Legacy wire
+entries retain their old compensation; current views do not receive negative
+held values to repay late releases.
+
+Held controls integrate their duration, sampled controls coalesce to the latest
+value per tick, presses coalesce per field per tick, and valued pulses execute
+in order, one per tick. More sampled input never buys extra simulation steps.
+The clock resets before a fresh control after a long browser stall, so the press
+cannot inherit ten seconds of elapsed time. The prediction clock slews by at
+most 0.5%, preserving the cadence for fixed-step renderers.
+
+`room.input(sample, {at: event.timeStamp})` accepts the event's monotonic time
+(same origin as `performance.now()`), clamped to this predicted tick and now.
+Omit it to use the call time. A player can declare
+`player: {control: 'canMove', pulses: 'hold'}` to keep pulses during a knock or
+stun and deliver them when control returns. The default `'drop'` preserves the
+previous behaviour. The game's action handler still decides its cooldown.
+
+Residual drawing corrections use `room.predict.blendMs` (100 ms by default),
+slowed on each moving axis to avoid reversing movement (jumping cannot spend
+horizontal correction faster), with a one-second maximum
+(or the explicitly longer blendMs). Any remainder drains over the final 250 ms
+rather than disappearing on the deadline. `snapM` selects the large-error threshold;
+placements still snap. A placement keeps the established clock phase and
+projects the new body from the snapshot tick to the own tick; it never labels an
+old pose as a future one. Projection is bounded to one second and sends the
+controls it used. Queued held state from an earlier placement cannot later
+change the new body. Newly received discrete presses still belong to the player
+when the browser has not yet learned of that placement. `idleHold` no longer keeps a stopped body displaced
+indefinitely. These drawing settings never alter server truth.

package/guides/game/SKILL.md

@@ -469,3 +469,12 @@ save contract are in that section. Prefer kernel collision for its primitive
 maps; use physics for arbitrary static triangle levels. Initialization is awaited
 before the first room tick, calls in handlers are synchronous, and the complete
 physics snapshot is saved with the room. No opt-in means no physics load or cost.
+
+### Input under loss
+
+Rules games inherit redundant sequenced input, late movement replay and applied-tick
+receipts. Do not add a game-side resend loop or interpret negative held values as
+late-release repayment. Use `f.held()` for duration, sampled fields for latest
+state and `f.pulse()` for ordered actions. Choose `player.pulses: 'hold'` when a
+knock should buffer an action; the default drops it. See RULES.md, “Input during
+loss and stalls”, for timestamps, replay boundaries and visual correction settings.

package/lib/rules-types.mjs

@@ -119,7 +119,7 @@ export type Room<R = never> = Omit<BaseRoom<R>, 'me' | 'each' | 'get' | 'on' | '
  each<K extends keyof Entities>(kind: K, fn: (entity: Entities[K]) => void): void;
  get(id: string): Entity | null;
  on<K extends keyof Effects>(name: K, fn: (event: Effects[K]) => void): () => void;
- input(sample: ${input}): void;
+ input(sample: ${input}, options?: {at?: number}): void;
  command<K extends keyof Commands>(name: K, ...data: {} extends Commands[K] ? [data?: Commands[K]] : [data: Commands[K]]): void;
 };
 export declare function openRoom<R = never>(options?: OpenRoomOptions): Room<R>;

package/lib/template-history.json

@@ -2985,6 +2985,90 @@
      }
     }
    }
+  },
+  "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"
+      }
+     }
+    }
+   }
+  },
+  "0.48.3": {
+   "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,28 @@ 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. Each frame also fits the
+existing 2 KB input cap: current controls first, then missing receipts, then
+acknowledged history. Optional sub-tick metadata uses the remaining bytes; the
+complete row retains its integrated held values and sequence even when the
+metadata is omitted. Retained entries not selected for this frame remain
+available for subsequent recovery frames. 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.48.0",
+  "version": "0.48.3",
   "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/core.ts

@@ -158,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;
@@ -177,7 +178,7 @@ 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;
@@ -1091,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.
@@ -1205,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');
@@ -1215,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.
@@ -1492,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); },
@@ -1568,7 +1615,7 @@ 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(),

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;
     }

package/rules/rules.ts

@@ -144,7 +144,7 @@ export interface BodyDef { shape: 'circle' | 'sphere' | 'capsule' | 'box'; radiu
 export interface GuideDef { view: (world: RuntimeWorld, self: RuntimeSelf) => unknown; floor?: (world: RuntimeWorld, self: RuntimeSelf, view: any) => unknown }
 export interface RoundRecords {key:string; identity:string; eligible?:string; fields:Readonly<Record<string,string>>}
 export interface EntityDef {
-  player?: true | { away?: 'neutral' | 'think'; leave?: 'despawn' | 'bot'; control?: string; takeover?: string };
+  player?: true | { away?: 'neutral' | 'think'; leave?: 'despawn' | 'bot'; control?: string; pulses?: 'drop' | 'hold'; takeover?: string };
   fields?: Fields;
   motion?: Fields;
   input?: Fields;
@@ -388,7 +388,7 @@ export type FieldList = readonly (readonly [string, Field])[];
 export interface KindTable {
   name: string;
   index: number;
-  player: null | { away: 'neutral' | 'think'; leave: 'despawn' | 'bot'; control?: string; takeover?: string };
+  player: null | { away: 'neutral' | 'think'; leave: 'despawn' | 'bot'; control?: string; pulses?: 'drop' | 'hold'; takeover?: string };
   fields: FieldList;
   motion: FieldList;
   input: FieldList;
@@ -589,10 +589,11 @@ export function compileRules(def: RulesDef, env: CompileEnv = {}): Compiled {
       if (!p || typeof p !== 'object') throw new Error(`${at}.player is true, or { away, leave }`);
       if (p.away !== undefined && p.away !== 'neutral' && p.away !== 'think') throw new Error(`${at}.player.away is 'neutral' or 'think'`);
       if (p.leave !== undefined && p.leave !== 'despawn' && p.leave !== 'bot') throw new Error(`${at}.player.leave is 'despawn' or 'bot'`);
+      if (p.pulses !== undefined && !['drop','hold'].includes(p.pulses)) throw new Error(`${at}.player.pulses is 'drop' or 'hold'`);
       if (p.control !== undefined && !motion.some(([key, field]) => key === p.control && field.t === 'bit')) throw new Error(`${at}.player.control names a bit in motion`);
       if (p.takeover !== undefined && !fields.some(([key, field]) => key === p.takeover && ['fix','i8','i16','i32','u8','u16','u32'].includes(field.t))) throw new Error(`${at}.player.takeover names a numeric field`);
       if (p.control && typeof e.think !== 'function') throw new Error(`${at}.player.control needs think`);
-      player = { away: p.away ?? 'neutral', leave: p.leave ?? 'despawn', ...(p.control ? {control:p.control}:{}), ...(p.takeover ? {takeover:p.takeover}:{}) };
+      player = { ...(p.pulses ? {pulses:p.pulses}:{}), away: p.away ?? 'neutral', leave: p.leave ?? 'despawn', ...(p.control ? {control:p.control}:{}), ...(p.takeover ? {takeover:p.takeover}:{}) };
       if ((player.away === 'think' || player.leave === 'bot') && typeof e.think !== 'function') throw new Error(`${at}: away: 'think' and leave: 'bot' need a think(world, self) handler to steer the body`);
     }
     let body: KindTable['body'] = null;

package/rules/types.ts

@@ -67,7 +67,7 @@ export type RoomEvents<E = Record<string, never>> = RoundEvents & { seatJoined:
 export type RoundEvents = { roundStart: { n: number }; roundOver: { n: number; results: readonly { seat: number; id: string; driver: 'person' | 'bot' | 'ai'; score: number; place: number }[] } };
 type GuideWorld<W> = Pick<W, Extract<keyof W, 'tick' | 'dt' | 'ticks' | 'math' | 'map' | 'tune' | 'stage' | 'level' | 'levelMax' | 'guideLevel' | 'guideSeats' | 'kids' | 'levelSet' | 'round' | 'shared' | 'near' | 'inBox' | 'ray'>>;
 export type Entity<W, S, I, E, C, V, Answer = BuiltIns['answer'], G = Goal, A = GuideRequest, D = GuideDecision> = {
-  player?: true | { away?: 'neutral' | 'think'; leave?: 'despawn' | 'bot'; control?: string; takeover?: string }; fields?: Fields; motion?: Fields; input?: Fields; body?: BodyDef; collider?: ColliderDef; query?: QueryDef;
+  player?: true | { away?: 'neutral' | 'think'; leave?: 'despawn' | 'bot'; control?: string; pulses?: 'drop' | 'hold'; takeover?: string }; fields?: Fields; motion?: Fields; input?: Fields; body?: BodyDef; collider?: ColliderDef; query?: QueryDef;
   tick?: (world: W, self: S) => void;
   think?: (world: W, self: S) => Partial<I>;
   on?: { [K in keyof (Omit<E, keyof BuiltIns> & Omit<BuiltIns<E>, 'answer'> & { answer: Answer })]?: (world: W, self: S, event: EventData<(Omit<E, keyof BuiltIns> & Omit<BuiltIns<E>, 'answer'> & { answer: Answer })[K]>) => void };

package/rules/view.ts

@@ -6,7 +6,7 @@ import type { RayQueries, RayOptions } from './types.ts';
 import { snapshotDecoder } from './interest.mjs';
 import { collisionMap, collisionTargets, revisionAt, type CollisionRevision } from './live.ts';
 import { rulesOutput } from '../netplay/rules-output.mjs';
-import { rulesCaps, rulesRates } from '../worker/limits.mjs';
+import { LIMITS, rulesCaps, rulesRates } from '../worker/limits.mjs';
 /*
  * view.ts — what a rules game's view imports: the room, as a browser sees it.
  * =============================================================================
@@ -150,7 +150,7 @@ export interface Room<R = unknown> extends RayQueries {
   get(id: string): Entity | null;
   on(name: string, fn: (e: any) => void): () => void;
   readonly shared: Readonly<Record<string, unknown>>;
-  input(sample: Record<string, number | boolean>): void;
+  input(sample: Record<string, number | boolean>, options?: { at?: number }): void;
   command(name: string, data?: Record<string, unknown>): void;
   readonly round: RoomRound | null;
   readonly roster: RosterRow[];
@@ -256,22 +256,29 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   let lastSent = '';
   let lastSendAt = 0;
   let entries: { t: number; row: number[] }[] = [];
+  let inputSequence = 0;
+  let controlChanges: number[][] = [];
+  let sentHistory: { t: number; row: number[] }[] = [];
   let hiddenSent = false;
   const history = new Map<number, Mine>();
-  let pending: { t: number; input: Readonly<Record<string, unknown>>; pulses?: Record<string, number> }[] = [];
+  let pending: { seq?: number; applied?: number; t: number; input: Readonly<Record<string, unknown>>; pulses?: Record<string, number>; pulseTicks?: Record<string, number> }[] = [];
   /** Valued pulses sent, numbered: the server's control row names the newest it has acted on (0.46.3). */
   let pulseCount = 0;
+  const pulseQueue: {name:string; value:number; n:number; t:number}[] = [];
   let pulseNumber = new Map<string, number>();
   let replayHeld: Readonly<Record<string, unknown>> = Object.freeze({});
   /** `f.held()` values as the server last had them: those of the newest entry it has acknowledged. */
   let serverHeld: Record<string, number> = {};
   let speed = 1;
   let leadAfter = 0;
+  let calibratedRtt = 0;
+  let latencyCalibrated = false;
+  const applications = new Map<number, number>();
   let observedLeadAt = 0;
   let catchTick: number | null = null;
   let catchAt = 0;
   let headingBlend: { from: Vec3; at: number } | null = null;
-  let offsets: { delta: Vec3; at: number; path: Vec3; fade: number; last: number }[] = [];
+  let offsets: { delta: Vec3; at: number; path: Vec3; fade: number; last: number; end?: number }[] = [];
   const predict = schema.settings.predict;
   const quantile = (list: number[], q: number): number => [...list].sort((a, b) => a - b)[Math.floor((list.length - 1) * q)] ?? 0;
   const targetLead = (): number => 0.5 + Math.max(0, quantile(leads, 0.5) - quantile(leads, 0.05));
@@ -284,6 +291,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     const sum = { x: 0, y: 0, z: 0 };
     let waiting = false;
     for (const o of offsets) {
+      o.end ??= o.at + Math.max(1000, predict.blendMs);
+      const deadlineFade = Math.max(0, Math.min(1, (o.end - now) / 250));
       if (path) {
         // Loss can make even a small correction longer than the distance travelled in
         // 100 ms. Bound its fade by actual progress, or it pulls steady movement backwards.
@@ -297,13 +306,22 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
           // A knock may travel faster than normal movement, and catch-up already accelerates it.
           // Fading the offset must not add another fraction of that accelerated speed.
           const allowance = length ? (myKind()?.maxSpeed ?? 0) * elapsed / 1000 / length : 1;
-          const release = settled && !predict.idleHold && catchTick === null ? Math.min(allowance, elapsed / predict.blendMs) : 0;
-          const progress = length ? Math.min(allowance, distance(path, o.path) * 0.8 / length) : 1;
-          const nominal = Math.max(0, Math.min(1, 1 - (now - o.at) / predict.blendMs));
+          const release = settled && catchTick === null ? Math.min(allowance, elapsed / predict.blendMs) : 0;
+          let progress = length ? Math.min(allowance, distance(path, o.path) * 0.8 / length) : 1;
+          // Travel on one axis cannot pay for a correction on another. In particular,
+          // a jump must not erase a horizontal offset faster than running advances it.
+          for (const axis of ['x', 'y', 'z'] as const) {
+            const travelled = periodicDelta(o.path[axis], path[axis], map.wrap?.[axis]);
+            if (o.delta[axis] * travelled > 0) progress = Math.min(progress, .8 * Math.abs(travelled / o.delta[axis]));
+          }
+          const nominal = now >= o.end ? 0 : Math.max(0, Math.min(1, 1 - (now - o.at) / predict.blendMs));
           o.fade = Math.max(nominal, o.fade - Math.max(release, progress));
         }
         o.path = path; o.last = now;
       }
+      // Drain any remaining correction over the final quarter second, including
+      // queued offsets. Expiring it in one frame would itself create a warp.
+      o.fade = Math.min(o.fade, deadlineFade);
       waiting = true;
       sum.x += o.delta.x * o.fade; sum.y += o.delta.y * o.fade; sum.z += o.delta.z * o.fade;
     }
@@ -339,7 +357,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // The helper's ping ends at the relay. A browser host adds another network leg in both directions.
     // Snapshot stamps use the relay clock, so their observed age measures the complete downstream path.
     const relayRtt = net.stats().rtt ?? 100;
-    return net.offline ? 0 : schema.settings.host === 'browser' ? Math.max(relayRtt, 2 * quantile(hostAges, 0.5)) : relayRtt;
+    return net.offline ? 0 : Math.max(relayRtt, 2 * quantile(hostAges, 0.5));
   }
   function phaseAt(at: number): number {
     let p = phases[0];
@@ -350,7 +368,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   function steer(now: number): void {
     if (!base || !leads.length) return;
     base = { tick: tickAt(now), at: now };
-    speed = 1 + Math.max(-0.05, Math.min(0.05, (targetLead() - medianLead()) * 0.05));
+    // Input replay absorbs delivery jitter. Keep the physical tick cadence close to
+    // wall time: aggressive steering makes fixed-step custom renderers bunch ticks.
+    speed = 1 + Math.max(-0.005, Math.min(0.005, (targetLead() - medianLead()) * 0.005));
     if (phases[phases.length - 1]?.rate !== speed) phases.push({ ...base, rate: speed });
     while (phases.length > 2 && phases[1].at < now - Math.max(1000, 2 * authorityRtt() + period)) phases.shift();
   }
@@ -358,19 +378,41 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // Recalibrating an input clock is not a placement. Keep the drawn pose while
     // the new prediction catches up, just as for a snapshot reconciliation.
     const shown = reason === 'lead' ? meNow()?.pos : null;
+    const continuousTick = reason === 'placement' && base && tickAt(clock()) >= k && tickAt(clock()) - k <= tickHz ? tickAt(clock()) : null;
+    if(reason==='placement' || reason==='epoch')pulseQueue.length=0;
     correction.rebaseReason = reason; correction.rebaseError = medianLead() - targetLead();
-    const rtt = authorityRtt();
+    const rtt = authorityRtt(); calibratedRtt = rtt;
     // Lead samples refer to the clock which stamped them. Do not mix its offset with this clock's jitter.
     const target = targetLead();
     leads.length = 0;
     leadAfter = clock() + 2 * rtt + period;
-    base = { tick: k + Math.ceil(rtt / period + target) + sendEvery - 1, at: clock() };
-    stepped = Math.floor(base.tick) - 1;
-    entries = []; pending = []; history.clear(); replayHeld = {}; serverHeld = {}; held = {}; lastSent = ''; leads.length = 0; pressed = new Map(); pulseNumber = new Map(); heldTrack.clear(); if (reason !== 'lead') dropPredictions();
+    base = { tick: continuousTick ?? k + Math.min(tickHz, Math.ceil(rtt / period + target) + sendEvery - 1), at: clock() };
+    stepped = Math.max(k, Math.floor(base.tick) - (continuousTick === null ? 1 : 0));
+    entries = []; sentHistory = []; controlChanges = []; pending = []; history.clear(); replayHeld = {}; serverHeld = {}; held = {}; lastSent = ''; leads.length = 0; pressed = new Map(); pulseNumber = new Map(); heldTrack.clear(); if (reason !== 'lead') dropPredictions();
     speed = 1; phases.length = 0; phases.push({ ...base, rate: 1 }); catchTick = null; offsets = []; headingBlend = null; correction.rebases += 1;
     const u = mine && latest?.ents.get(mine.id); if (u) adopt(u);
     if (mine) {
+      // A snapshot is the body at k, not at the clock's future input tick.
+      // Project the intervening movement instead of relabelling that old pose;
+      // otherwise the next reconciliation suddenly adds a latency's worth of travel.
+      const kind = myKind()!;
+      const values: Record<string, unknown> = {};
+      for (const [name, fd] of kind.input) values[name] = fd.t === 'press' ? false : fd.t === 'pulse' ? 0 : coerce(fd, sample[name] ?? fd.init, dims);
+      held = replayHeld = Object.freeze(values);
+      history.set(k, copyMine(mine));
+      for (let t = k + 1; !kind.owner && t <= stepped; t++) {
+        Object.assign(mine, runMove(kind.name, mine, held, t));
+        runPredict(kind.name, mine, mine.fields, held, t, false, false);
+        history.set(t, copyMine(mine));
+      }
       history.set(stepped, copyMine(mine));
+      if (!kind.owner && stepped > k) {
+        // The projection used these controls from k+1. Stamp that first input too,
+        // so authority can recover the identical post-placement path.
+        const row = kind.input.map(([name]) => Number(held[name]));
+        entries.push({ t: k + 1, row: [...row, -471, ++inputSequence, 0] });
+        pending.push({ seq: inputSequence, t: k + 1, input: held });
+      }
       if (shown) offsets = [{ delta: { x: periodicDelta(mine.pos.x,shown.x,map.wrap?.x), y: periodicDelta(mine.pos.y,shown.y,map.wrap?.y), z: periodicDelta(mine.pos.z,shown.z,map.wrap?.z) }, at: clock(), path: mine.pos, fade: 1, last: clock() }];
     }
   }
@@ -519,6 +561,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   function step(t: number, fresh = true): void {
     const kind = myKind();
     if (!mine || !kind) return;
+    if(fresh && pulseQueue.length && pulseQueue[0].t<=t){const p=pulseQueue.shift()!;pressed.set(p.name,p.value);pulseNumber.set(p.name,p.n);}
     const values: number[] = [];
     const input: Record<string, unknown> = {};
     let press = false;
@@ -536,7 +579,8 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     }
     const claim = kind.owner ? [mine.pos.x, mine.pos.y, mine.pos.z, mine.vel.x, mine.vel.y, mine.vel.z, mine.heading.x, mine.heading.y, mine.heading.z] : [];
     const sig = JSON.stringify([values, claim]);
-    if (sig !== lastSent || press) { entries.push({ t, row: [...values, ...claim] }); pending.push({ t, input: held, ...(numbered ? { pulses: numbered } : {}) }); lastSent = sig; }
+    if (sig !== lastSent || press || controlChanges.length) { entries.push({ t, row: [...values, ...claim, -471, ++inputSequence, controlChanges.length, ...controlChanges.flat()] }); pending.push({ seq: inputSequence, t, input: held, ...(numbered ? { pulses: numbered } : {}) }); lastSent = sig; }
+    controlChanges = [];
     history.set(t, copyMine(mine));
     for (const k of history.keys()) if (k < t - tickHz && (catchTick === null || k < Math.floor(catchTick))) history.delete(k);
   }
@@ -548,11 +592,51 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   function flush(now: number, t: number): void {
     if (!mine) { entries = []; return; }
     if (!entries.length && now - lastSendAt >= 250) keepalive(t);
-    if (!entries.length) return;
-    const k = Math.min(entries[0].t, t - (t % sendEvery));
-    const rows: StepEntry[] = entries.map((e) => [e.t - k, ...e.row]);
+    const marker = myKind()!.input.length + (myKind()!.owner ? 9 : 0);
+    // A newer tick's acknowledgement cannot acknowledge a hole in the history.
+    if (!entries.length && !sentHistory.some(e => !applications.has(e.row[marker + 1]))) return;
+    const k = Math.min(entries[0]?.t ?? t, t - (t % sendEvery));
+    for (const entry of entries) {
+      const old = sentHistory.findIndex(e => e.t === entry.t);
+      if (old >= 0) sentHistory[old] = entry; else sentHistory.push(entry);
+    }
+    // Cover an authority round trip and jitter. Missing application receipts measure
+    // recovery delay (whether a dropped frame or a TCP stall): widen the history
+    // until they return, without allowing an unbounded packet or retained history.
+    const missing = sentHistory.find(e => e.t <= (latest?.k ?? 0) && !applications.has(e.row[marker + 1]));
+    const recoveryTicks = missing ? t - missing.t + 2 * sendEvery : 0;
+    const windowTicks = Math.min(64, Math.max(4, recoveryTicks, Math.ceil((2 * authorityRtt() + 250) / period + targetLead())));
+    sentHistory = sentHistory.filter(e => e.t >= t - windowTicks).slice(-64);
+    const first = Math.min(k, sentHistory[0]?.t ?? k);
+    // Repeated history must fit the relay's existing byte cap, including its
+    // envelope and snapshot acknowledgement. Always carry the newest controls;
+    // spend the remaining space on missing receipts before acknowledged history.
+    // Sub-tick samples are optional metadata: the row already contains the held
+    // duration integrated by heldMean. Never truncate its values or sequence.
+    const budget = LIMITS.in - 128;
+    const selected = new Map<number, StepEntry>();
+    let bytes = 2;
+    const newest = sentHistory.at(-1);
+    const candidates = [...(newest ? [newest] : []),
+      ...sentHistory.filter(e => e !== newest && !applications.has(e.row[marker + 1])),
+      ...sentHistory.filter(e => e !== newest && applications.has(e.row[marker + 1])).reverse()];
+    for (const e of candidates) {
+      const row = [e.t - first, ...e.row.slice(0, marker + 2), 0];
+      const size = JSON.stringify(row).length + (selected.size ? 1 : 0);
+      if (bytes + size > budget) continue;
+      selected.set(e.t, row); bytes += size;
+    }
+    // Use spare bytes for sample metadata only after reserving control history.
+    for (const e of candidates) {
+      const compact = selected.get(e.t);
+      if (!compact) continue;
+      const row = [e.t - first, ...e.row];
+      const extra = JSON.stringify(row).length - JSON.stringify(compact).length;
+      if (bytes + extra <= budget) { selected.set(e.t, row); bytes += extra; }
+    }
+    const rows = [...selected].sort((a, b) => a[0] - b[0]).map(([, row]) => row);
     entries = [];
-    if (net.steps(epoch, k, rows, mine.r)) lastSendAt = now;
+    if (net.steps(epoch, first, rows, mine.r)) lastSendAt = now;
   }
   /** The held values as an entry on tick `t`, without stepping the body again. */
   function keepalive(t: number): void {
@@ -560,7 +644,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     if (!mine || !kind) return;
     const values = kind.input.map(([name, fd]) => ((fd.t === 'press' || fd.t === 'pulse') ? 0 : fd.t === 'held' ? Number(coerce(fd, heldNumber(sample[name], fd.init), dims)) : Number(coerce(fd, sample[name] ?? fd.init, dims))));
     const claim = kind.owner ? [mine.pos.x, mine.pos.y, mine.pos.z, mine.vel.x, mine.vel.y, mine.vel.z, mine.heading.x, mine.heading.y, mine.heading.z] : [];
-    entries = [{ t, row: [...values, ...claim] }]; pending.push({ t, input: Object.fromEntries(kind.input.map(([name, fd], i) => [name, fd.t === 'press' ? false : values[i]])) }); lastSent = JSON.stringify([values, claim]);
+    entries = [{ t, row: [...values, ...claim, -471, ++inputSequence, controlChanges.length, ...controlChanges.flat()] }]; pending.push({ seq: inputSequence, t, input: Object.fromEntries(kind.input.map(([name, fd], i) => [name, fd.t === 'press' ? false : values[i]])) }); lastSent = JSON.stringify([values, claim]);
   }
   let pumping = false;
   function pump(): void {
@@ -628,13 +712,18 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     if (me) {
       const placed = !mine || mine.id !== me.id || mine.r !== me.r || changedEpoch;
       const row = f.rows.find((x) => x[0] === seat);
+      if(changedEpoch)applications.clear();
+      if(row?.[6]===471){for(let i=7;i+1<row.length;i+=2)applications.set(row[i],row[i+1]);while(applications.size>128)applications.delete(applications.keys().next().value!);}
       if (placed || !base) {
-        adopt(me); rebase(f.k);
+        adopt(me); rebase(f.k, changedEpoch ? 'epoch' : 'placement');
         if (placed) emit('placed', entityOf(me, true));
       } else if (kindOf.get(me.kind)?.owner) {
         mine!.motion = motionOf(me.kind, me.motion);
         if (predictors[me.kind]) mine!.fields = thawFields(kindOf.get(me.kind)?.fields ?? [], me.fields);
-      } else {
+      } else if (!pending.some(entry => entry.seq !== undefined && entry.t <= f.k && f.k - entry.t < tickHz && (applications.get(entry.seq) ?? Infinity) > f.k)) {
+        // This snapshot predates an input we already predicted. Within the rewind
+        // window it is provisional movement truth: wait for its application receipt
+        // rather than briefly adopting the path made with the missing control.
         const previous = mine!.pos;
         const shownBody = meNow();
         const shown = shownBody?.pos ?? previous;
@@ -643,8 +732,15 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         adopt(me);
         history.set(f.k, copyMine(mine!));
         const ack = row?.[2] ?? 0;
+        const scheduled = row?.[6] === 471;
+        if (scheduled) for(let i=7;i+1<row.length;i+=2){
+          if(row[i]>0){const entry=pending.find(e=>e.seq===row[i]);if(entry)entry.applied=row[i+1];}
+          else for(const entry of pending)for(const [name,n] of Object.entries(entry.pulses??{}))if(n===-row[i]){entry.pulseTicks??={};entry.pulseTicks[name]=row[i+1];}
+        }
+        const appliedAt = (entry: (typeof pending)[number]): number => entry.applied ?? entry.t;
         // A numbered pulse is still to come while the server's row has not reached its number (0.46.3): its own message
         // can be later than the input frame of its tick, so the input's acknowledgement says nothing about it.
+        while(pulseQueue.length && pulseQueue[0].n <= (row?.[4] ?? 0))pulseQueue.shift();
         const taken = typeof row?.[4] === 'number' ? row[4] : null;
         const owed = (entry: (typeof pending)[number], name: string): boolean => { const n = entry.pulses?.[name]; return taken !== null && n !== undefined ? n > taken : entry.t > ack; };
         const fresh = (entry: (typeof pending)[number]): boolean => f.k + 1 - entry.t <= Math.ceil(tickHz / 4);
@@ -654,7 +750,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         // predicted where the server will bring it and not where a late frame left it for a moment.
         const heldFields = myKind()!.input.filter(([, fd]) => fd.t === 'held').map(([name]) => name);
         const debt: Record<string, number> = {};
-        if (heldFields.length) {
+        if (heldFields.length && !scheduled) {
           for (const entry of pending) if (entry.t <= ack) for (const name of heldFields) serverHeld[name] = Number(entry.input[name]) || 0;
           const waiting = pending.filter((entry) => entry.t > ack && entry.t <= f.k && fresh(entry));
           if (waiting.length) for (let i = waiting[0].t; i <= f.k; i++) {
@@ -663,9 +759,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
             if (meant) for (const name of heldFields) debt[name] = (debt[name] ?? 0) + (Number(meant[name]) || 0) - (serverHeld[name] ?? 0);
           }
         }
-        for (const entry of pending) if (entry.t <= f.k) {
+        for (const entry of pending) if (appliedAt(entry) <= f.k) {
           replayHeld = entry.input;
-          if (fresh(entry))
+          if ((!scheduled || entry.applied === undefined) && fresh(entry))
             for (const [name, fd] of myKind()!.input) if ((fd.t === 'press' || fd.t === 'pulse') && entry.input[name] && (fd.t === 'pulse' ? owed(entry, name) : entry.t > ack)) late.set(name, entry.input[name]);
         }
         // After a reset nothing is held yet: the replay runs on every field's own zero, never on an input with no fields
@@ -674,9 +770,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         if (!Object.keys(input).length) { const zero: Record<string, unknown> = {}; for (const [name, fd] of myKind()!.input) zero[name] = fd.t === 'press' ? false : fd.t === 'pulse' ? 0 : coerce(fd, fd.init, dims); input = Object.freeze(zero); }
         for (let t = f.k + 1; t <= stepped; t++) {
           const presses = new Map(t === f.k + 1 ? late : []);
-          for (const entry of pending) if (entry.t === t) {
-            input = entry.input;
-            for (const [name, fd] of myKind()!.input) if ((fd.t === 'press' || fd.t === 'pulse') && entry.input[name]) presses.set(name, entry.input[name]);
+          for (const entry of pending) {
+            if(appliedAt(entry)===t)input = entry.input;
+            for (const [name, fd] of myKind()!.input) if ((fd.t === 'press' || fd.t === 'pulse') && entry.input[name] && (fd.t==='pulse' ? (entry.pulseTicks?.[name]??entry.t)===t : appliedAt(entry)===t)) presses.set(name, entry.input[name]);
           }
           const stepInput = { ...input };
           for (const [name, fd] of myKind()!.input) if (fd.t === 'press' || fd.t === 'pulse') stepInput[name] = presses.get(name) ?? (fd.t === 'press' ? false : 0);
@@ -685,7 +781,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
           runPredict(me.kind, mine!, mine!.fields, stepInput, t, false, false);
           history.set(t, copyMine(mine!));
         }
-        pending = pending.filter(e => e.t > f.k || fresh(e) && (e.t > ack || Object.keys(e.pulses ?? {}).some((name) => owed(e, name))));
+        pending = pending.filter(e => appliedAt(e) > f.k || (scheduled && ((e.applied === undefined && f.k-e.t<tickHz) || Object.keys(e.pulses??{}).some(name=>owed(e,name)))) || !scheduled && fresh(e) && (e.t > ack || Object.keys(e.pulses ?? {}).some((name) => owed(e, name))));
         if (shownBody && distance(oldHeading, mine!.heading) > 0.0001) headingBlend = { from: shownBody.heading, at: clock() };
         const error = distance(previous, mine!.pos);
         correction.last = error;
@@ -724,6 +820,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
           }
         }
       }
+      if (!latencyCalibrated && authorityRtt() > calibratedRtt + period && !Object.values(sample).some(Boolean) && !pending.some(e=>Object.values(e.input).some(Boolean))) { rebase(f.k, 'lead'); latencyCalibrated = true; }
       if (row && row[3] !== -128 && base && clock() >= leadAfter) {
         const now = clock(), rtt = authorityRtt();
         // A reported lead describes an input sent roughly one authority round trip ago. Remove that
@@ -732,10 +829,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
         observedLeadAt = now;
         leads.push(row[3] / 16 - phaseAt(now - rtt)); if (leads.length > 40) leads.shift();
         const med = medianLead(), target = targetLead();
-        if (leads.length >= 8 && Math.abs(med - target) > 4) rebase(f.k, 'lead');
-        else {
-          steer(now);
-        }
+        // A changing jitter estimate must not discard already stamped input. Slew the
+        // clock; late movement is settled by the server's retained history.
+        steer(now);
       }
       previewKey = '';
       settlePredictions(f, before && before.e === f.e ? before : null, row?.[2] ?? 0);
@@ -844,7 +940,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       // A held field previews as its mean over the part of the tick that has passed. The body is drawn that fraction of
       // the way to the preview, so it stands exactly where the control has carried it: it starts from rest at a press
       // 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);
+      for (const [name, fd] of kind.input) now[name] = (fd.t === 'press' || fd.t === 'pulse') ? (pressed.get(name) ?? (fd.t === 'pulse' && pulseQueue[0]?.name===name ? pulseQueue[0].value : 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);
       // 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
@@ -971,7 +1067,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     self: () => { const m = meNow(); return m ? { x: m.pos.x, y: m.pos.y, z: m.pos.z } : null; },
     peer: (seat: number) => { if (!latest) return null; for (const u of latest.ents.values()) if (u.seat === seat) return { x: u.pos.x, y: u.pos.y, z: u.pos.z }; return null; },
     movement: () => { const kinds = schema.kinds.filter(k => k.player); return kinds.length && kinds.every(k => k.maxSpeed === 0) ? 'stationary' : 'spatial'; },
-    prediction: () => ({ ...correction, observedLeadAt, lastSendAt, now: clock(), serverTick: latest?.k, tick: stepped, catchTick, lead: targetLead(), medianLead: medianLead(), rate: speed, rtt: authorityRtt(), hostAge: quantile(hostAges, 0.5), pending: pending.length }),
+    prediction: () => ({ ...correction, observedLeadAt, lastSendAt, now: clock(), serverTick: latest?.k, tick: stepped, catchTick, lead: targetLead(), medianLead: medianLead(), rate: speed, rtt: authorityRtt(), hostAge: quantile(hostAges, 0.5), pending: pending.length, applications: [...applications] }),
     scores: () => roster().map((r) => ({ seat: r.seat, score: r.score })),
     score: myScore, tick: () => latest?.k ?? 0, epoch: () => epoch, hosted: () => net.rulesHosting ? 'browser' : schema.settings.host, status: () => solo ? 'offline' : status,
   });
@@ -1038,8 +1134,9 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     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)); },
-    input(s) {
-      if (solo) { solo.input(s); return; }
+    input(s, options) {
+      pump();
+      if (solo) { solo.input(s, options); return; }
       const kind = myKind() ?? schema.kinds.find((k) => k.player) ?? null;
       const next: Record<string, unknown> = {};
       let changed = false;
@@ -1051,7 +1148,13 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       // a jump). Keep the pose at the instant of the press; only subsequent time
       // may advance the new path, rather than drawing elapsed time with new input.
       // A held control changed NOW, before anything else here takes time: the steps this call runs must already know it.
-      const at = clock();
+      const now = clock();
+      const at = typeof options?.at === 'number' && Number.isFinite(options.at) ? Math.max(edgeOf(stepped), Math.min(now, options.at)) : now;
+      for (const [index, [name, fd]] of (kind?.input ?? []).entries()) {
+        const value = Number(coerce(fd, s[name] ?? fd.init, dims));
+        if(value !== Number(coerce(fd, sample[name] ?? fd.init, dims)))controlChanges.push([index, ++inputSequence, Math.max(0,Math.min(1,tickAt(at)-stepped)), value]);
+      }
+      controlChanges=controlChanges.slice(-256);
       for (const [name, fd] of kind?.input ?? []) if (fd.t === 'held') {
         const v = heldNumber(next[name], fd.init), tr = heldTrack.get(name);
         if (!tr) heldTrack.set(name, { from: at, changes: [[at, v]] });
@@ -1059,15 +1162,19 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       }
       if (changed) pump();
       const shown = changed ? meNow()?.pos : null;
-      for (const [name, fd] of kind?.input ?? []) if ((fd.t === 'press' || fd.t === 'pulse') && coerce(fd,s[name],dims)) { const value=coerce(fd,s[name],dims) as number | boolean; if(fd.t==='pulse'&&!pressed.has(name)){pulseCount+=1;pulseNumber.set(name,pulseCount);net.send('pulse',[epoch,name,value,stepped+1,pulseCount]);} pressed.set(name,value); }
+      for (const [name, fd] of kind?.input ?? []) if ((fd.t === 'press' || fd.t === 'pulse') && coerce(fd,s[name],dims)) { const value=coerce(fd,s[name],dims) as number | boolean; if(fd.t==='pulse'){pulseCount+=1;const target=Math.max(stepped+1,(pulseQueue.at(-1)?.t??stepped)+1);pulseQueue.push({name,value:Number(value),n:pulseCount,t:target});net.send('pulse',[epoch,name,value,target,pulseCount]);} else pressed.set(name,value); }
       sample = next;
       if (shown) {
         const now = clock(), nextShown = meNow()?.pos;
         if (nextShown && distance(shown, nextShown) > 0.00001) {
           const carried = visualOffset(now);
-          // Coalesce the carried blend: analogue controls may change every frame.
-          offsets = [{ delta: { x: carried.x + periodicDelta(nextShown.x,shown.x,map.wrap?.x), y: carried.y + periodicDelta(nextShown.y,shown.y,map.wrap?.y), z: carried.z + periodicDelta(nextShown.z,shown.z,map.wrap?.z) },
-            at: now, last: now, fade: 1, path: { x: nextShown.x - carried.x, y: nextShown.y - carried.y, z: nextShown.z - carried.z } }];
+          // A new control must not restart the lifetime of an older correction.
+          const path = { x: nextShown.x-carried.x, y: nextShown.y-carried.y, z: nextShown.z-carried.z };
+          for(const offset of offsets){offset.path=path;offset.last=now;}
+          const delta={x:periodicDelta(nextShown.x,shown.x,map.wrap?.x),y:periodicDelta(nextShown.y,shown.y,map.wrap?.y),z:periodicDelta(nextShown.z,shown.z,map.wrap?.z)};
+          const last=offsets.at(-1);
+          if(last?.at===now && last.fade===1){last.delta={x:last.delta.x+delta.x,y:last.delta.y+delta.y,z:last.delta.z+delta.z};}
+          else offsets.push({delta,at:now,last:now,fade:1,path});
         }
       }
     },

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.48.0","sha256":"3c0bdb436a2a600fc529827f340b470cdce1cfa40f7d692ff0b9963b5b07c622"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.48.3","sha256":"52a096d783a92de61024123ffd3ce7e3e73c2c805d2a7238d342d2fc77d3830d"});

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