@irtio/client 0.2.0 → 0.4.0

package/dist/{chunk-AJHN3YF6.js → chunk-7UTJ7RSF.js}

@@ -2,6 +2,8 @@
 var E_CONNECT_FAILED = "E_CONNECT_FAILED";
 var MAX_PREDICTED_BODIES = 64;
 var PREDICTION_EPSILON = 0.05;
+var SMOOTHING_HALF_LIFE_MS = 70;
+var SMOOTHING_SNAP_UNITS = 4;
 function emptyPredictionStats() {
   return {
     freeSteps: 0,
@@ -10,7 +12,9 @@ function emptyPredictionStats() {
     snaps: 0,
     suppressed: 0,
     overCap: 0,
-    lastResimMicros: 0
+    lastResimMicros: 0,
+    smoothing: 0,
+    stampGap: 0
   };
 }
 
@@ -556,6 +560,8 @@ export {
   E_CONNECT_FAILED,
   MAX_PREDICTED_BODIES,
   PREDICTION_EPSILON,
+  SMOOTHING_HALF_LIFE_MS,
+  SMOOTHING_SNAP_UNITS,
   emptyPredictionStats,
   RESIM_DEPTH,
   ClientStore

package/dist/index.d.ts

@@ -195,6 +195,17 @@ declare class ClientStore {
  * shared resimulation depth (20, D19): beyond it the body snaps to authority and the snap is
  * counted.
  *
+ * ## What the renderer sees
+ *
+ * Not the head. The head moves once per server tick — and only when an arrival rebases the world
+ * onto it — while a display asks two to four times as often, so handing back the head draws a
+ * character running at a steady nine units a second as standing still for half the frames and
+ * moving at twenty for the rest. `read()` therefore keeps a short ring of recent poses per body
+ * and draws between the two either side of a render clock that runs on wall time, steered to sit
+ * about a tick behind the head. Correctness is unaffected: `room.state`, the per-tick history a
+ * correction is judged against, and `predictedValues` all still see the head. See bug 7 in
+ * `docs/bugs.md` for the measurement.
+ *
  * ## What is deliberately absent
  *
  * Non-predicted dynamic bodies do not exist in the local world, and neither do `predicted: true`
@@ -266,6 +277,32 @@ interface ClientPhysicsOptions {
      * an input frame landing one tick late on the server is invisible, not a storm). Default 0.05.
      */
     readonly epsilon?: number;
+    /**
+     * How fast the drawn position eases back onto the simulation after a re-simulation moved it,
+     * as a half-life in milliseconds. `0` turns the smoothing off. Default 70.
+     *
+     * A rebase can move a body that has already been drawn — because the server disagreed, or
+     * because a newly-flushed intent changed what the last few ticks should have been. Handing
+     * that straight to the renderer is a step, and a step in the middle of steady motion is what
+     * a player calls a yank. Instead the jump is taken out of the drawn pose and put into a
+     * per-body offset that decays: the character keeps moving smoothly and arrives at the truth a
+     * moment later.
+     *
+     * This smooths the **error**, not the motion. A rate limiter on the drawn position — the
+     * obvious version, and the one a game writes for itself — cannot tell a correction from the
+     * character running, so it lags real movement too. Nothing here touches motion the simulation
+     * actually produced.
+     */
+    readonly smoothingHalfLifeMs?: number;
+    /**
+     * How far the drawn position may be held from the simulation while an offset eases away, in
+     * world units. Past it the offset is dropped and the body appears where it is. Default 4.
+     *
+     * This is the teleport case: a respawn, an area change, a resync. Easing across one of those
+     * draws the body sliding through the level, which is worse than the step it avoids. It is the
+     * one number here that depends on how big a world unit is in your game.
+     */
+    readonly smoothingSnapUnits?: number;
 }
 /** Counters for the report and `room.prediction.stats`. */
 interface PredictionStats {
@@ -287,6 +324,21 @@ interface PredictionStats {
     overCap: number;
     /** Microseconds spent in the last rebase's re-steps. */
     lastResimMicros: number;
+    /**
+     * The largest render-error offset currently being eased away, in world units — how far the
+     * furthest-off predicted body is being drawn from where the simulation puts it, so that a
+     * re-simulation did not arrive as a step (`smoothingHalfLifeMs`). It rises on a correction and
+     * falls back towards zero; what is unhealthy is a value that *stays* up, which means the
+     * client is being corrected as fast as it can absorb it.
+     */
+    smoothing: number;
+    /**
+     * Ticks between the stamp a `WRITE` carries and the server tick it was applied at, smoothed
+     * (bug 1). The client stamps on its predicted clock, which leads authority, so this is how far
+     * *early* a naive replay would put every pending intent. 0 until a server that reports the
+     * applied tick judges a stamped write.
+     */
+    stampGap: number;
 }
 declare class PhysicsPredictor {
     private readonly store;
@@ -310,6 +362,27 @@ declare class PhysicsPredictor {
     private lastNow;
     private lastFrameNow;
     private failed;
+    /**
+     * The local world's head, on the server's tick timeline: the authoritative tick the last
+     * rebase started from plus the lead it re-stepped, then one per free-run step.
+     */
+    private headTick;
+    /** The newest server tick any authority has been seen for. `headTick`'s base. */
+    private authorityTick;
+    /** The newest tick a pose has been stored for. `-1` until the first capture. */
+    private curTick;
+    /**
+     * Where the renderer is, as a fractional tick. Advanced by wall time every frame and steered
+     * to sit about a tick behind `curTick`; `read()` draws between the stored poses either side
+     * of it.
+     */
+    private renderTick;
+    /** Scratch for one interpolated pose. `read()` is synchronous, so one is enough. */
+    private readonly scratch;
+    /** Scratch quaternions, so the per-body per-frame offset maths allocates nothing. */
+    private readonly qa;
+    private readonly qb;
+    private readonly qc;
     /**
      * Per owned body: the server tick its authoritative record is *from* (the tick of the last
      * `CORRECT` that touched it), and the per-tick prediction history — after every local step,
@@ -319,6 +392,11 @@ declare class PhysicsPredictor {
      * against it would report the lead as misprediction).
      */
     private readonly authorityTicks;
+    /** Smoothed stamp-minus-applied gap; see `noteWriteApplied`. */
+    private stampGap;
+    private gapMeasured;
+    /** The newest stamp already folded into `stampGap`, so a repeated echo is not re-weighted. */
+    private gapSampledThrough;
     private readonly predictedTicks;
     private readonly history;
     /** History kept per body — comfortably past the resim depth. */
@@ -335,10 +413,32 @@ declare class PhysicsPredictor {
     free(): void;
     /** A resync (`WELCOME`) replaced the authority wholesale: rebase everything, drop banked time. */
     reset(): void;
-    /** Authoritative body state arrived (`DELTA` on a non-owned body, `CORRECT` on an owned one). */
-    noteAuthority(): void;
+    /**
+     * Authoritative body state arrived (`DELTA` on a non-owned body, `CORRECT` on an owned one).
+     *
+     * `tick` is the server tick it carried, and it is the base of the predictor's own head clock —
+     * which the renderer's interpolation is paced against. It has to be the *world's* clock rather
+     * than any one body's: a client with nothing of its own to own still draws a world full of
+     * predicted bodies.
+     */
+    noteAuthority(tick?: number): void;
     /** The session tells us which server tick one body's authoritative record is from. */
     noteAuthorityTick(collection: string, id: string, tick: number): void;
+    /**
+     * A `CORRECT` reported both halves of a judged write: the stamp the client put on it and the
+     * server tick it was actually applied at (bug 1). The gap between them is the systematic error
+     * in the rebase's replay, and it is not zero even on a loopback: the stamp is the predictor's
+     * *head* (authority + lead), while the server applies on arrival, at a tick barely past the
+     * authority the client is replaying from. Replaying at the stamp therefore held the previous
+     * intent for `gap` ticks the server had already simulated under the new one — the overshoot on
+     * every key release, sized `gap x speed`.
+     *
+     * Smoothed, because it rides on delivery jitter and the measurement is one sample per judged
+     * write. Clamped into `[0, RESIM_DEPTH]`: a stamp taken before this client had any physics
+     * authority is on the session's bare write counter rather than the server's tick stream, and
+     * differencing the two clocks is meaningless — 0 is the old behaviour and the honest default.
+     */
+    noteWriteApplied(stampTick: number, appliedTick: number): void;
     /** Does the local world currently simulate `collection[id]`? */
     has(collection: string, id: string): boolean;
     /**
@@ -355,11 +455,88 @@ declare class PhysicsPredictor {
      * draw loop — or a bot's render sampling — is the clock; there is no timer.
      */
     frame(now: number): void;
+    /**
+     * The head moved: store every predicted body's pose under the tick it now holds.
+     *
+     * A tick can be simulated more than once — a `DELTA` and a `CORRECT` both arrive for the same
+     * tick and each rebases — so the slot is simply rewritten with the better answer. It can also
+     * move backwards, when a free-run step is discarded by the rebase behind it; `curTick` does
+     * not follow it down, because moving the newest label backwards would drag the segment the
+     * renderer is crossing backwards with it.
+     */
+    private capturePoses;
+    /**
+     * Advance the render clock by one frame of wall time, steering it towards a target distance
+     * behind the head rather than clamping it there.
+     *
+     * `renderTick` and `curTick` agree on rate — one tick per tick period — but not on phase, and
+     * the phase error is delivery jitter: authority arrives when the network hands it over, not
+     * every 33 ms however steady the server is. Left alone the two would wander apart, so the
+     * clock is steered, by rate rather than by position. What the network did to a packet is not
+     * something the player's character should be seen doing.
+     */
+    private advanceRenderClock;
+    /**
+     * Keep the render clock inside the span there are poses for.
+     *
+     * Both ends are real. At `curTick` there is nothing further to draw towards, so a late arrival
+     * holds the pose rather than extrapolating motion the next tick would have to take back — the
+     * same trade that sized the prediction lead (bug 1). At the far end the ring has recycled the
+     * slot and the pose is genuinely gone. Between them the clock floats, and the rate trim above
+     * is what keeps it from spending its time against either stop.
+     */
+    private holdRenderTick;
+    /** `smoothingHalfLifeMs`, or 0 when the game turned the smoothing off. */
+    private halfLifeMs;
+    /** Remember where every body is being drawn, before this frame re-simulates anything. */
+    private snapshotDrawn;
+    /**
+     * Take whatever the re-simulation moved the drawn pose by and put it in the offset instead.
+     *
+     * This is the whole of correction smoothing, and it is smoothing the *error*: the difference
+     * measured here is between two answers to the same question — where is this body at the render
+     * clock — asked either side of a rebase. Motion the simulation produced is not in it, because
+     * the render clock advanced before the snapshot. So real movement is never slowed, which is
+     * the thing a rate limiter on the drawn position cannot promise: it sees a position that moved
+     * and has no way to know whether the body ran or was corrected.
+     *
+     * It absorbs more than server disagreement. A newly flushed intent changes what the last few
+     * ticks should have been, and the replay hands that over as a jump the same way; so does the
+     * render clock being pulled back inside the poses it has. All of it is the same defect from
+     * the player's side — the character was drawn somewhere it now turns out it was not — and all
+     * of it eases away here.
+     */
+    private absorbJump;
+    /**
+     * Ease every offset towards zero. Exponential, so the rate is proportional to the error and
+     * there is no world-scale speed to pick: a correction worth a tenth of a unit is worked off
+     * gently and one worth a whole unit is not left hanging around for a second.
+     */
+    private decayOffsets;
+    private clearOffset;
+    /**
+     * The pose to draw one body at: the stored poses either side of the render clock, blended.
+     * Falls back to the body's live transform when the ring cannot bracket it — before the first
+     * capture, and for a body that appeared this frame.
+     */
+    private rawPose;
+    /** `rawPose` with the render-error offset applied — what the draw loop actually gets. */
+    private renderPose;
     /**
      * The predicted record for `collection[id]`: the authoritative record (which already carries
      * local intent writes — `track()` writes through to plain state) with the body-mapped channels
      * replaced by the local world's values, `Math.fround`ed for f32 fields so what the draw loop
      * reads is what the wire would carry.
+     *
+     * Drawn *between* two simulated ticks, not at the head. The local world steps at the room's
+     * tick rate, and only when authority arrives to rebase it; a display runs at two to four times
+     * that and asks on every frame. Handing back the head means the answer changes on some frames
+     * and not others, so a character running at a steady nine units a second is drawn standing
+     * still for half of them and moving at twenty for the rest. It is the player's own character
+     * answering their own key, and it reads as the game hitching.
+     *
+     * This is a *render* read. `room.state` and every correctness path — `predictedValues`, the
+     * per-tick history a correction is judged against — still see the head exactly as before.
      */
     read(desc: CollectionDesc, id: string, base: AnyRecord$2): AnyRecord$2;
     /**
@@ -388,11 +565,43 @@ declare class PhysicsPredictor {
     private warnOverCap;
     private warnOnce;
     /**
-     * The client's lead over authority, in ticks: one-way latency plus one tick of margin.
-     * Measured (dive e2e, 2026-08-27): a full-round-trip lead was tried for the tick-aligned
-     * replay and made release transitions *worse* (-1.4 to -1.8 u worst backwards step vs -0.6 at
-     * half), because the extra lead grows the standing overshoot a rest-settling body has to give
-     * back. Half the trip plus margin is where the stamp clock and the correction stream meet.
+     * The client's lead over authority, in ticks: the one-way transit the authority in hand has
+     * already spent in flight, rounded to the nearest tick. Nothing more.
+     *
+     * Every tick of lead beyond that transit is a tick of motion the client draws on the
+     * assumption that the input it is holding will still be held when the server gets there. On a
+     * release that assumption is wrong by construction, and the invented travel is handed back as
+     * a backwards yank — bug 1's "keeps moving after key up and then snaps back". It was
+     * `ceil(owd) + 1`, which on a fast link is two whole ticks of margin over a transit of nearly
+     * zero. Measured on the arena fixture at no injected latency (release overshoot of a 6 u/s
+     * held-input character, `physics-predict.test.ts`):
+     *
+     * | lead | drawn overshoot past the server's stop | worst backwards step |
+     * | --- | --- | --- |
+     * | `ceil(owd) + 1` (was) | 0.585 u | -0.585 u |
+     * | `max(1, round(owd))` (is) | 0.293 u | -0.292 u |
+     * | `round(owd)`, floor 0 | 0.0008 u | -0.0008 u |
+     *
+     * One tick of running is 0.3 u there: the overshoot is the lead, in ticks, and nothing else.
+     * On a link with no transit to cover, every tick of lead is a tick of guessing that the key is
+     * still held.
+     *
+     * The floor of 1 is not margin, it is the smallest lead that is still prediction. At 0 the
+     * rebase takes no steps: the local world is pinned to the authority it just received, which is
+     * already a tick old, so the client responds to its own input only when the next `CORRECT`
+     * arrives and every moving body reads as mispredicted by one tick of motion. Measured: the
+     * bot suites' correction-storm invariant fires immediately (21 corrections/s per bot against a
+     * threshold of 5 in `packages/cli/test/simulate-physics.test.ts`). One tick of speculation is
+     * the price of predicting at all; two was the bug.
+     *
+     * Erring low is also the cheap direction — a lead shorter than the transit means authority
+     * arrives slightly *ahead* of the prediction, and a correction that pulls the character the way
+     * it is already going is the one nobody can see.
+     *
+     * Measured earlier the same day (dive e2e): a *full*-round-trip lead was worse again
+     * (-1.4 to -1.8 u worst backwards step vs -0.6 at half), which is the same finding from the
+     * other end. `stats.stampGap` is the running check on all of this — it reports how far ahead
+     * of the server's application the stamps still land, and it should sit at 0.
      */
     private leadTicks;
     private timestepMs;
@@ -416,6 +625,7 @@ declare class PhysicsPredictor {
     stampTick(): number | undefined;
     /** After every step: advance each owned body's prediction clock and remember its channels. */
     private recordStep;
+    /** Returns the number of steps taken, so the caller knows whether the head moved. */
     private freeRun;
     /**
      * Applies intents for every owned predicted body before one step: the intent in force at the
@@ -634,6 +844,20 @@ type MessageTarget = 'all' | string | {
 declare const MAX_PREDICTED_BODIES = 64;
 /** Default correction-suppression epsilon, world units (see `ClientPhysicsOptions.epsilon`). */
 declare const PREDICTION_EPSILON = 0.05;
+/**
+ * Default half-life for render-error smoothing, milliseconds (see
+ * `ClientPhysicsOptions.smoothingHalfLifeMs`). About two ticks at 30Hz: long enough that a
+ * correction is a settle rather than a step, short enough that the drawn position is back on the
+ * simulation within a fifth of a second.
+ */
+declare const SMOOTHING_HALF_LIFE_MS = 70;
+/**
+ * Default distance past which a render-error offset is dropped rather than eased away, world
+ * units (see `ClientPhysicsOptions.smoothingSnapUnits`). A respawn, an area change or a session
+ * resync moves a body somewhere else entirely, and sliding into it is worse than arriving.
+ * Four units is a guess at world scale and the one number here a game may need to change.
+ */
+declare const SMOOTHING_SNAP_UNITS = 4;
 /** `room.prediction` (D22 part 2). */
 interface PredictionStatus {
     /** The engine is loaded and the local world exists. */
@@ -655,7 +879,10 @@ interface Room<S, Role extends string = RoleOf<S> & string> {
     readonly me: string;
     /** The room code (from `WELCOME`). */
     readonly id: string;
-    /** Shareable URL carrying `?room=<id>`. */
+    /**
+     * Shareable URL carrying `?room=<id>`, with per-client params (`role`) stripped so it is safe
+     * to hand to somebody else. The address bar keeps them.
+     */
     readonly link: string;
     /** The last server tick this client saw. */
     readonly tick: number;
@@ -666,7 +893,9 @@ interface Room<S, Role extends string = RoleOf<S> & string> {
     /**
      * The render read path (D20): same shapes as `room.state`, but non-owned entities are
      * interpolated at `now − interpDelayMs` (numeric fields lerp, everything else steps) while
-     * owned entities return the predicted local values. A draw loop opts in by one substitution —
+     * predicted bodies are drawn between the two most recent ticks of the local physics world.
+     * Either way the value advances with the frame clock rather than with arrivals or with the
+     * tick rate. A draw loop opts in by one substitution —
      * `room.state.players` → `room.render.players`. Tests and game logic keep reading
      * `room.state`, which stays authoritative.
      */
@@ -757,8 +986,10 @@ declare const webSocketTransport: Transport;
  * The interpolated render read path (D20, week 8): `room.render.<collection>` mirrors
  * `room.state`'s shapes, but non-owned entities are rendered at `now − interpDelayMs`, lerping
  * numeric fields between the two bracketing DELTAs and stepping everything else (strings, bools,
- * enums, refs, lists). Owned entities return the predicted (local) values — the same object
- * `room.state` hands out — so one read path serves the whole draw loop.
+ * enums, refs, lists). Predicted bodies — owned or `predicted: true` — come from the local
+ * physics world instead, drawn between the two most recent simulated ticks rather than at the
+ * simulation head, so they too advance with the frame clock and not with whatever rate their
+ * source happens to update at (`physics.ts`, `read`). One read path serves the whole draw loop.
  *
  * `room.state` stays authoritative and untouched: tests, bots and existing code see exactly what
  * they saw before. Entities appear and disappear at the buffered time; past the newest delta the
@@ -820,8 +1051,13 @@ type AnyRecord = Record<string, unknown>;
 type ClientImpl = (params: AnyRecord) => unknown;
 /** Default hard cap on the owned-write flush window. */
 declare const DEFAULT_WRITE_INTERVAL_MS = 50;
-/** How often the client pings for `room.rtt`. */
-declare const PING_INTERVAL_MS = 10000;
+/**
+ * How often the client pings for `room.rtt`. Two seconds rather than ten (bug 4): the prediction
+ * lead is re-derived from `rtt` on every rebase, so the interval is not just how fresh a
+ * diagnostic number is — it is how long one measurement gets to size the client's simulation.
+ * A PING is a 4-byte payload; five of them a minute is not the reason a room costs anything.
+ */
+declare const PING_INTERVAL_MS = 2000;
 /** How long an outbound RPC waits for its `REPLY` before rejecting. */
 declare const CALL_TIMEOUT_MS = 10000;
 interface SessionOptions {
@@ -1008,4 +1244,4 @@ declare function joinRoom<S extends AnySchema, Role extends string = RoleOf<S> &
  */
 declare function joinRelay(options?: JoinRelayOptions): Promise<RelayRoom>;
 
-export { CALL_TIMEOUT_MS, type ClientBodySpec, type ClientCollection, type ClientPhysicsOptions, type ClientRapierBody, type ClientRapierModule, type ClientRapierWorld, type ClientState, ClientStore, type ClientVector3, type Correction, DEFAULT_REGION, DEFAULT_WRITE_INTERVAL_MS, DEV_PORT, E_CONNECT_FAILED, type FrameHook, type JoinOptions, type JoinRelayOptions, MAX_PREDICTED_BODIES, type MessageTarget, PING_INTERVAL_MS, PREDICTION_EPSILON, type PredictionStats, type PredictionStatus, RESIM_DEPTH, type RelayRoom, type Room, type RoomCallProxy, type RoomError, type RoomEvents, type Scheduler, Session, type Status, type Transport, type TransportSocket, type Unsubscribe, defaultScheduler, joinRelay, joinRoom, linkForUrl, resolveUrl, roomIdFrom, webSocketTransport };
+export { CALL_TIMEOUT_MS, type ClientBodySpec, type ClientCollection, type ClientPhysicsOptions, type ClientRapierBody, type ClientRapierModule, type ClientRapierWorld, type ClientState, ClientStore, type ClientVector3, type Correction, DEFAULT_REGION, DEFAULT_WRITE_INTERVAL_MS, DEV_PORT, E_CONNECT_FAILED, type FrameHook, type JoinOptions, type JoinRelayOptions, MAX_PREDICTED_BODIES, type MessageTarget, PING_INTERVAL_MS, PREDICTION_EPSILON, type PredictionStats, type PredictionStatus, RESIM_DEPTH, type RelayRoom, type Room, type RoomCallProxy, type RoomError, type RoomEvents, SMOOTHING_HALF_LIFE_MS, SMOOTHING_SNAP_UNITS, type Scheduler, Session, type Status, type Transport, type TransportSocket, type Unsubscribe, defaultScheduler, joinRelay, joinRoom, linkForUrl, resolveUrl, roomIdFrom, webSocketTransport };

package/dist/index.js

@@ -4,8 +4,10 @@ import {
   MAX_PREDICTED_BODIES,
   PREDICTION_EPSILON,
   RESIM_DEPTH,
+  SMOOTHING_HALF_LIFE_MS,
+  SMOOTHING_SNAP_UNITS,
   emptyPredictionStats
-} from "./chunk-AJHN3YF6.js";
+} from "./chunk-7UTJ7RSF.js";
 
 // src/endpoint.ts
 var DEFAULT_REGION = "eu";
@@ -61,15 +63,19 @@ function roomIdFromLocation() {
     return "";
   }
 }
+var PER_CLIENT_PARAMS = ["role"];
 function publishRoomToLocation(roomId) {
   const loc = currentLocation();
   const history = globalThis.history;
   if (!loc) return void 0;
   let href;
+  let share;
   try {
     const url = new URL(loc.href);
     url.searchParams.set("room", roomId);
     href = url.href;
+    for (const param of PER_CLIENT_PARAMS) url.searchParams.delete(param);
+    share = url.href;
   } catch {
     return void 0;
   }
@@ -79,7 +85,7 @@ function publishRoomToLocation(roomId) {
     } catch {
     }
   }
-  return href;
+  return share;
 }
 function linkForUrl(wsUrl, roomId) {
   try {
@@ -114,6 +120,7 @@ import {
   encodeReply,
   errorByCode,
   formatError,
+  readCorrectAppliedTick,
   readCorrectClientTick,
   relaySchema,
   rpcTable,
@@ -479,7 +486,8 @@ var webSocketTransport = {
 
 // src/session.ts
 var DEFAULT_WRITE_INTERVAL_MS = 50;
-var PING_INTERVAL_MS = 1e4;
+var PING_INTERVAL_MS = 2e3;
+var RTT_ALPHA = 0.3;
 var CALL_TIMEOUT_MS = 1e4;
 var BACKOFF_START_MS = 250;
 var BACKOFF_MAX_MS = 5e3;
@@ -518,7 +526,7 @@ var Session = class {
     if (options.physics && hasPhysics) {
       const physics = options.physics;
       this.predictionRequested = true;
-      void import("./physics-BBFSQEYL.js").then(({ PhysicsPredictor }) => {
+      void import("./physics-H2VDQLAU.js").then(({ PhysicsPredictor }) => {
         if (this.left) return;
         const predictor = new PhysicsPredictor(
           this.ext,
@@ -836,7 +844,7 @@ var Session = class {
     this.store.applyServerDelta(delta);
     this.render.recordDelta(delta);
     if (this.predictor && delta.collections.some((dc) => this.predictor?.predictsCollection(dc.name))) {
-      this.predictor.noteAuthority();
+      this.predictor.noteAuthority(delta.tick);
       this.predictor.frame(this.scheduler.now());
     }
   }
@@ -844,6 +852,10 @@ var Session = class {
     const r = new ByteReader(payload);
     const delta = decodeDeltaFrom(this.ext, r);
     const clientTick = readCorrectClientTick(r);
+    const appliedTick = readCorrectAppliedTick(r);
+    if (clientTick !== void 0 && appliedTick !== void 0) {
+      this.predictor?.noteWriteApplied(clientTick, appliedTick);
+    }
     this.tick = delta.tick;
     const predicted = this.capturePredicted(delta);
     let sawBodyFields = false;
@@ -870,7 +882,7 @@ var Session = class {
       });
     }
     if (sawBodyFields && this.predictor) {
-      this.predictor.noteAuthority();
+      this.predictor.noteAuthority(delta.tick);
       this.predictor.frame(this.scheduler.now());
     }
   }
@@ -916,7 +928,8 @@ var Session = class {
   }
   onPong(payload) {
     const pong = decodePong(payload);
-    this.rtt = Math.max(1, (this.scheduler.now() >>> 0) - pong.t >>> 0);
+    const sample = Math.max(1, (this.scheduler.now() >>> 0) - pong.t >>> 0);
+    this.rtt = this.rtt === 0 ? sample : Math.max(1, Math.round(this.rtt + (sample - this.rtt) * RTT_ALPHA));
     if (pong.serverTick > this.tick) this.tick = pong.serverTick;
   }
   onMsg(payload) {
@@ -1310,6 +1323,8 @@ export {
   PING_INTERVAL_MS,
   PREDICTION_EPSILON,
   RESIM_DEPTH,
+  SMOOTHING_HALF_LIFE_MS,
+  SMOOTHING_SNAP_UNITS,
   Session,
   defaultScheduler,
   joinRelay,