@homie-rocks/studio 0.47.0 → 0.48.1

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;
@@ -291,7 +291,7 @@ export interface MapBox { readonly min: Vec3; readonly max: Vec3 }
 export interface MapCircle { readonly at: Vec3; readonly r: number }
 export interface MapHeightTile { readonly base?: number; readonly diagonal?: '00-11' | '10-01'; readonly at: Vec3; readonly size: Readonly<{ x: number; y: number }>; readonly heights: readonly [number, number, number, number] }
 export type MapWrap = Readonly<Partial<Record<'x' | 'y' | 'z', readonly [number, number]>>>;
-export interface GameMap { readonly tiles?: Tiles; readonly wrap?: MapWrap; readonly name: string; readonly heightTiles: readonly MapHeightTile[]; readonly bounds: MapBox; readonly boxes: readonly MapBox[]; readonly circles: readonly MapCircle[]; readonly spheres: readonly MapCircle[]; readonly capsules: readonly (MapCircle & { height: number })[]; readonly spots: Readonly<Record<string, readonly Vec3[]>> }
+export interface GameMap { readonly physics?: import('./physics.ts').PhysicsMesh; readonly tiles?: Tiles; readonly wrap?: MapWrap; readonly name: string; readonly heightTiles: readonly MapHeightTile[]; readonly bounds: MapBox; readonly boxes: readonly MapBox[]; readonly circles: readonly MapCircle[]; readonly spheres: readonly MapCircle[]; readonly capsules: readonly (MapCircle & { height: number })[]; readonly spots: Readonly<Record<string, readonly Vec3[]>> }
 
 const vecOf = (a: unknown, what: string): Vec3 => {
   const p = Array.isArray(a) ? { x: a[0], y: a[1], z: a[2] ?? 0 } : a as { x?: unknown; y?: unknown; z?: unknown } | null;
@@ -340,7 +340,16 @@ export function compileMap(raw: unknown, name = 'main'): GameMap {
   }
   const tiled=compileTiles(m.tiles,wrap);
   if(tiled) for(const k of ['x','y'] as const) if(wrap?.[k] && (tiled.tiles.at[k]!==bounds.min[k] || tiled.tiles.at[k]+tiled.tiles.size*(k==='x'?tiled.tiles.width:tiled.tiles.height)!==bounds.max[k])) throw new Error(`${where}: tiles must span each wrapped axis`);
+  let physics: import('./physics.ts').PhysicsMesh | undefined;
+  if (m.physics !== undefined) {
+    const {vertices, indices} = m.physics ?? {};
+    if (!Array.isArray(vertices) || !Array.isArray(indices) || !vertices.length || vertices.length % 3 || !indices.length || indices.length % 3 ||
+      vertices.some((n: unknown) => typeof n !== 'number' || !Number.isFinite(n) || !Number.isFinite(Math.fround(n))) ||
+      indices.some((n: unknown) => !Number.isSafeInteger(n) || (n as number) < 0 || (n as number) >= vertices.length / 3)) throw new Error(`${where}: physics needs a build-time baked triangle mesh`);
+    physics = Object.freeze({vertices:Object.freeze([...vertices]),indices:Object.freeze([...indices])});
+  }
   const result = Object.freeze({
+    ...(m.physics ? {physics: physics!} : {}),
     ...(tiled?{tiles:tiled.tiles}:{}),
     name, ...(wrap ? {wrap} : {}),
     heightTiles: Object.freeze((m.heightTiles ?? []).map((t: any, i: number) => {
@@ -379,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;
@@ -580,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/substeps.ts

@@ -0,0 +1,39 @@
+import { brand, charge, own } from './guard.ts';
+
+export interface Substep { readonly dt: number; readonly index: number; readonly count: number; readonly first: boolean; readonly fraction: number }
+export interface StepPose { pos: {x:number;y:number;z:number}; vel: {x:number;y:number;z:number}; heading: {x:number;y:number;z:number}; grounded: boolean }
+const traces = new WeakMap<object, readonly StepPose[]>();
+const running = new WeakSet<object>();
+const scalar = (value: unknown): number => typeof value === 'number' && Number.isFinite(value) ? value : 0;
+const vector = (value: unknown) => ({x:scalar(own(value,'x')),y:scalar(own(value,'y')),z:scalar(own(value,'z'))});
+const pose = (body: object): StepPose => ({pos:vector(own(body,'pos')),vel:vector(own(body,'vel')),heading:vector(own(body,'heading')),grounded:own(body,'grounded') === true});
+
+/** Same integration and trace accounting on authority and prediction; no independent quota. */
+export function substeps(tickHz: number) {
+  return (body: object, hz: number, step: (context: Substep) => void): void => {
+    charge(8);
+    const count = typeof hz === 'number' ? hz / tickHz : NaN;
+    if (typeof hz !== 'number' || !Number.isSafeInteger(count) || count < 1) throw new RangeError('substeps: hz must be a positive integer multiple of room.tickHz');
+    if (!body || typeof body !== 'object' || typeof step !== 'function') throw new TypeError('substeps: expected body, hz, callback');
+    if (running.has(body) || traces.has(body)) throw new Error('substeps: integrate a body only once per move');
+    // Pay before allocation and callbacks. Each pose copies ten scalars and three vectors.
+    charge(64 * (count + 1));
+    const samples: StepPose[] = [pose(body)];
+    running.add(body);
+    traces.delete(body);
+    try {
+      for (let index = 0; index < count; index++) {
+        step(brand(Object.freeze({dt:1/hz,index,count,first:index === 0,fraction:(index+1)/count})));
+        samples.push(pose(body));
+      }
+      traces.set(body, samples);
+    } finally { running.delete(body); }
+  };
+}
+
+/** Runtime-only drawing data, never an extra part of a room save or wire frame. */
+export function takeSubsteps(body: object): readonly StepPose[] | undefined {
+  const samples = traces.get(body);
+  traces.delete(body);
+  return samples;
+}

package/rules/types.ts

@@ -28,6 +28,7 @@ export interface MapView { tile(x:number,y:number):number; distance(flow:string,
 export interface Clock { readonly tick: number; readonly dt: number; ticks(seconds: number): number; readonly math: typeof math }
 export interface Round { readonly n: number; readonly phase: 'live' | 'over'; readonly endsAt: number }
 export type World<E, F, S, V, C, A, T, Room extends boolean = false> = Clock & {
+  readonly physics: import('./physics.ts').RulesPhysics;
   readonly tune: ReadonlyState<T>; readonly map: MapView & (Room extends true ? {replace(data:Record<string,unknown>):void} : {}); readonly stage: string; readonly level: number; readonly levelMax: number; readonly guideLevel: number; readonly guideSeats: readonly number[]; readonly kids: boolean; readonly levelSet: boolean;
   readonly shared: Room extends true ? S : ReadonlyState<S>;
   readonly round: Round & (Room extends true ? { end(): void; restart(): void } : {});
@@ -66,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 };
@@ -76,4 +77,4 @@ export type Entity<W, S, I, E, C, V, Answer = BuiltIns['answer'], G = Goal, A =
 };
 export interface MoveBody<M> { get pos(): Vec3; set pos(value: Point); get vel(): Vec3; set vel(value: Point); get heading(): Vec3; set heading(value: Point); grounded: boolean; readonly motion: M }
 export interface MoveCollision<M> extends RayQueries { sweep(body: MoveBody<M>, delta: Point, options?: {ground?: boolean}): Hit | undefined; support(body: MoveBody<M>, distance?: number): (Hit & {dist: number}) | undefined; overlaps(body: MoveBody<M>): boolean }
-export type MoveContext<T, M> = Clock & { readonly tune: ReadonlyState<T>; readonly map: MapView & MoveCollision<M>; readonly world: MoveCollision<M> };
+export type MoveContext<T, M> = Clock & { readonly physics: import('./physics.ts').PhysicsMovement; substeps(body: MoveBody<M>, hz: number, step: (context: import('./substeps.ts').Substep) => void): void; readonly tune: ReadonlyState<T>; readonly map: MapView & MoveCollision<M>; readonly world: MoveCollision<M> };

package/rules/view.ts

@@ -1,3 +1,4 @@
+import { disposeMoveContext } from './math.ts';
 import { boundPosition, periodicDelta, blendPosition, relativePoint, wrapPoint } from './topology.mjs';
 import { rayQuery, raySnapshot, type QueryTarget } from './query.ts';
 import { solidAt } from './collision.ts';
@@ -114,6 +115,8 @@ export interface OpenRoomOptions {
 /** What a predictor (`openRoom({ predict })`) is handed beside the body and the tick's input. */
 export interface PredictContext extends RayQueries {
   readonly tick: number; readonly dt: number;
+  /** Read the authoritative snapshot this prediction started from, without advancing time. */
+  each(kind: string, fn: (e: Entity) => void): void;
   /** The same deterministic `math` a `move` is handed (0.46.5): a helper shared with the rules can be called with `ctx`. */
   readonly math: typeof math;
   /**
@@ -147,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[];
@@ -253,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));
@@ -281,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.
@@ -294,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;
     }
@@ -336,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];
@@ -347,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();
   }
@@ -355,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() }];
     }
   }
@@ -377,7 +422,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     mine = { id: u.id, kind: u.kind, r: u.r, pos: u.pos, vel: u.vel, heading: u.heading, grounded: u.grounded, motion: motionOf(u.kind, u.motion), fields: predictors[u.kind] ? thawFields(kindOf.get(u.kind)?.fields ?? [], u.fields) : u.fields };
   }
   /** The game's guarded `move` for one tick, counted as the server counts it, with the result rounded as the server rounds it. */
-  function runMove(kindName: string, body: { pos: Vec3; vel: Vec3; heading: Vec3; grounded: boolean; motion: Record<string, unknown> }, input: Readonly<Record<string, unknown>>, t: number): typeof body {
+  function runMove(kindName: string, body: { pos: Vec3; vel: Vec3; heading: Vec3; grounded: boolean; motion: Record<string, unknown> }, input: Readonly<Record<string, unknown>>, t: number): typeof body & {steps?: readonly import('./substeps.ts').StepPose[]} {
     const fn = moves[kindName];
     if (!fn || (kindOf.get(kindName)?.control && !body.motion[kindOf.get(kindName)!.control!])) return body;
     moveTick = t;
@@ -393,6 +438,11 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   /* ---------------------------------------------------------------- the own actions, predicted (0.46.3) */
 
   const predictors = opts.predict ?? {};
+  let predicting = false;
+  let predictionFrame: Frame | null = null;
+  function predictionEach(kind: string, fn: (e: Entity) => void): void {
+    for (const u of (predictionFrame ?? latest)?.ents.values() ?? []) if (u.kind === kind) fn(entityOf(u, u.id === mine?.id));
+  }
   interface Ghost { id: string; kind: string; tick: number; pos: Vec3; fields: Record<string, unknown>; until: number; match?: (e: Entity) => boolean; /** The server's entity that confirmed it: the ghost is drawn until that one is. */ real?: string }
   const ghosts = new Map<string, Ghost>();
   let ghostSeq = 0;
@@ -422,7 +472,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     // Branded as a world is (0.46.5): a guarded helper of the rules may call its queries, so the server's own aiming
     // code can be run on it instead of being restated in the view.
     const ctx: PredictContext = brand({
-      tick: t, dt: 1 / tickHz, preview, math,
+      tick: t, dt: 1 / tickHz, preview, math, each: predictionEach,
       judgedTick: (aimTick) => Math.max(t - rewindAllowance(), Math.min(t, Number(aimTick) || 0)),
       get viewTick() { return viewTickNow(); },
       ray: (from, direction, max, options) => viewRay(from, direction, max, options)[0],
@@ -451,7 +501,10 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     });
     const me = Object.assign(fields, { id, kind: kindName }) as Record<string, unknown>;
     for (const [key, value] of Object.entries({ pos: body.pos, vel: body.vel, heading: body.heading, grounded: body.grounded, motion: body.motion })) Object.defineProperty(me, key, { value, enumerable: false, configurable: true, writable: true });
+    const wasPredicting = predicting, previousFrame = predictionFrame;
+    predicting = true; predictionFrame = latest;
     try { fn(me, input, ctx); } catch (err) { console.warn('[room] predict', err); }
+    finally { predicting = wasPredicting; predictionFrame = previousFrame; }
     // What it wrote is held to the declared types, as the server holds its own writes.
     for (const [name, fd] of kind.fields) fields[name] = coerce(fd, fields[name], dims);
     for (const key of Object.keys(fields)) if (!kind.fields.some(([name]) => name === key)) delete fields[key];
@@ -508,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;
@@ -525,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);
   }
@@ -537,11 +592,25 @@ 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);
+    const rows: StepEntry[] = sentHistory.map((e) => [e.t - first, ...e.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 {
@@ -549,12 +618,12 @@ 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 {
     // A predictor's own queries read the room, and reading the room pumps: a step is never begun inside a step.
-    if (closed || pumping) return;
+    if (closed || pumping || predicting) return;
     pumping = true;
     try { pumpOnce(); } finally { pumping = false; }
   }
@@ -588,6 +657,11 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
   }
 
   function onSnapshot(s: Snapshot<unknown>): void {
+    const wasPumping = pumping;
+    pumping = true;
+    try { applySnapshot(s); } finally { pumping = wasPumping; }
+  }
+  function applySnapshot(s: Snapshot<unknown>): void {
     const f = frameOf(s);
     if (!f) return;
     const before = latest;
@@ -612,13 +686,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;
@@ -627,8 +706,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);
@@ -638,7 +724,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++) {
@@ -647,9 +733,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
@@ -658,9 +744,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);
@@ -669,7 +755,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;
@@ -708,6 +794,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
@@ -716,10 +803,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);
@@ -810,6 +896,7 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
    * drawn frame, not on the next tick.
    */
   function meNow(): Entity | null {
+    if (predicting) { const u = mine && predictionFrame?.ents.get(mine.id); return u ? entityOf(u, true) : null; }
     if (solo) return solo.me;
     if (!mine || !latest) return null;
     const server = latest.ents.get(mine.id);
@@ -827,7 +914,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
@@ -842,6 +929,14 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
       velocity = vec3({ x: lerp(mine.vel.x, next.vel.x, a), y: lerp(mine.vel.y, next.vel.y, a), z: lerp(mine.vel.z, next.vel.z, a) }, dims);
       // A takeoff is airborne as soon as it rises; a landing waits for its contact.
       grounded = landed || mine.grounded && (a === 0 || next.grounded);
+      if (next.steps?.length) {
+        const n = next.steps.length - 1, at = a * n, index = Math.min(n - 1, Math.floor(at)), f = at - index;
+        const before = next.steps[index], after = next.steps[index + 1];
+        pos = vec3(blendPosition(before.pos, after.pos, f, map.wrap), dims);
+        heading = blendHeading(before.heading, after.heading, f, dims);
+        velocity = vec3({x:lerp(before.vel.x,after.vel.x,f),y:lerp(before.vel.y,after.vel.y,f),z:lerp(before.vel.z,after.vel.z,f)},dims);
+        grounded = f === 1 ? after.grounded : before.grounded && after.grounded;
+      }
       preview = next;
       if (predictors[kind.name]) {
         // The own actions between ticks: the predictor on a copy of the fields, for the tick about to be stepped.
@@ -946,7 +1041,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,
   });
@@ -1013,8 +1108,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;
@@ -1026,7 +1122,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]] });
@@ -1034,15 +1136,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});
         }
       }
     },
@@ -1055,6 +1161,6 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     askButtons(id, offer = {}) { if (solo) return []; const e = latest?.ents.get(id); return e && e.seat !== undefined ? agents?.askButtons(e.seat, offer) ?? [] : []; },
     tune, get map(){return solo ? solo.map : mapAt(latest?.k??0);}, net: net as Netplay,
     pump,
-    close() { stopSolo(); closed = true; if (timer) clearInterval(timer); if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', onShow); agents?.stop(); net.close(); setStatus('closed'); },
+    close() { stopSolo(); disposeMoveContext(moveCtx as object); closed = true; if (timer) clearInterval(timer); if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', onShow); agents?.stop(); net.close(); setStatus('closed'); },
   };
 }

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.47.0","sha256":"4e1a1a503557e68e60b55a05dc289e4e688831c429d18c8f13ad2a24c3e05315"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.48.1","sha256":"01670eff45e75c7fca0bee9df359442e097aa916cc837e2d8b772a452a105dea"});