@woosh/meep-engine 3.30.0 → 3.32.0

package/src/engine/network/NetworkSession.js

@@ -11,15 +11,21 @@ import { NetworkSystem } from "./ecs/NetworkSystem.js";
 import { NetworkIdentitySerializationAdapter, } from "./ecs/serialization/NetworkIdentitySerializationAdapter.js";
 import { NetworkPeer, ResumeRejectReason, } from "./orchestrator/NetworkPeer.js";
 import { ServerAuthoritativeClient } from "./orchestrator/ServerAuthoritativeClient.js";
-import { ServerAuthoritativeServer } from "./orchestrator/ServerAuthoritativeServer.js";
+import { LateInput, ServerAuthoritativeServer } from "./orchestrator/ServerAuthoritativeServer.js";
 import { OwnerAwareScope } from "./replication/ScopeFilter.js";
 import { BinaryInterpolationAdapter, InterpolationKind, } from "../interpolation/BinaryInterpolationAdapter.js";
+import { Interpoland } from "../interpolation/Interpoland.js";
+import { Interpolated, INTERPOLATION_SOURCE_LOCAL } from "../interpolation/Interpolated.js";
 import { InterpolationLog } from "../interpolation/InterpolationLog.js";
+import { InterpolationSystem } from "../interpolation/InterpolationSystem.js";
 import { SimAction } from "./sim/SimAction.js";
 import { snapshotter_emit } from "./sim/Snapshotter.js";
+import { PredictionHistory } from "./state/PredictionHistory.js";
 import { AdaptiveRenderDelay } from "./time/AdaptiveRenderDelay.js";
 import { RenderPlayout } from "./time/RenderPlayout.js";
 import { TimeDilation } from "./time/TimeDilation.js";
+import { DeferredTransport } from "./transport/DeferredTransport.js";
+import { CorrectionTarget, HOST_VALUE_CORRECTION } from "./correction/Correction.js";
 
 /**
  * Roles a session can occupy. The orchestrator it wires up underneath is
@@ -44,10 +50,38 @@ export const NetworkSessionRole = Object.freeze({
     Host: 'host',
 });
 
-const DEFAULT_TICK_RATE_HZ = 60;
+/**
+ * How a client brings the entities it predicts back in line with the host's authoritative state.
+ *
+ * @readonly @enum {string}
+ */
+export const NetworkSessionReconcile = Object.freeze({
+    /**
+     * Compare the host's state for frame S with what this client predicted for S. Equal: nothing
+     * to do. Different: carry the difference observed at S into the present, component by
+     * component, as each component's {@link Correction} says — a pose by its offset and turn, a
+     * velocity by its difference, a value with no notion of difference by the host's value. No
+     * rewind, no replay, so it holds for state produced by physics and any other fixed-step system,
+     * not only by actions.
+     */
+    Correct: 'correct',
+    /**
+     * Rewind the action log to S, apply the host's state, and re-execute this client's input for
+     * every frame since. Exact when everything predicted is produced by deterministic actions; a
+     * replay re-executes actions only, never the engine's systems.
+     */
+    Replay: 'replay',
+});
+
 const DEFAULT_SIMULATION_DELAY_TICKS = 4;
 const DEFAULT_INITIAL_RENDER_DELAY_FRAMES = 6;
 
+/**
+ * Frames of remote state the network timeline keeps at the least: the adaptive render delay's
+ * ceiling (30) plus room for the playhead to blend across a burst of late arrivals.
+ */
+const PLAYOUT_HISTORY_FRAMES = 64;
+
 /**
  * Default depth of the action-log ring (in frames). This single value bounds
  * THREE distinct horizons at once:
@@ -66,8 +100,6 @@ const DEFAULT_INITIAL_RENDER_DELAY_FRAMES = 6;
  * orchestrator, so it is cheap to grow).
  */
 const DEFAULT_ACTION_LOG_FRAME_CAPACITY = 32;
-const MAX_CLIENT_DILATED_TICKS_PER_STEP = 3;
-const MAX_FIXED_STEPS_PER_TICK = 8;
 
 const DEFAULT_SERVER_RESUME_GRACE_MS = 30_000;
 /**
@@ -108,6 +140,19 @@ const ReconnectState = Object.freeze({
     Lost: 'lost',
 });
 
+/**
+ * Client-side: how the host has answered the transport binding in use. A new binding does not know
+ * which world the client is in until the host says: the one it has been predicting on, which the
+ * host resumes (RESUME_ACCEPT), or the host's own, sent as a snapshot (INITIAL_SYNC). The first
+ * answer is the answer; the host's handshake arriving after it is stale.
+ * @readonly @enum {string}
+ */
+const BindingAnswer = Object.freeze({
+    Pending: 'pending',
+    Resumed: 'resumed',
+    Synced: 'synced',
+});
+
 /**
  * Scratch buffer size used for AUTH_STATE assembly and net_mutate_component
  * event payloads. Sized for the common cases (Transform ≈ 36 B); components
@@ -115,12 +160,92 @@ const ReconnectState = Object.freeze({
  */
 const SCRATCH_BUFFER_BYTES = 1024;
 
+
 /**
- * Shared zero-length payload for empty ack packets. Hoisted to module scope so
- * the per-peer, per-tick ack send doesn't allocate a fresh array each time.
- * @type {Uint8Array}
+ * {@link NetworkSession#tick} warns once per process.
+ * @type {boolean}
  */
-const EMPTY_PAYLOAD = new Uint8Array(0);
+let tick_deprecation_warned = false;
+
+/**
+ * The deprecated {@link NetworkSession#replicate} warns once per process.
+ * @type {boolean}
+ */
+let replicate_deprecation_warned = false;
+
+/**
+ * @param {string} method for the message
+ * @param {string} name the component's, for the message
+ * @param {*} adapter the blend
+ */
+function assert_linear_blend(method, name, adapter) {
+    if (!(adapter instanceof BinaryInterpolationAdapter)) {
+        throw new Error(`NetworkSession.${method}: the blend for ${name} must extend BinaryInterpolationAdapter`);
+    }
+    if (adapter.kind !== InterpolationKind.Linear) {
+        throw new Error(
+            `NetworkSession.${method}: only Linear interpolation is currently supported; got kind=${adapter.kind} for ${name}. ` +
+            `A component with no in-between is replicated with replicate_discrete(); Cubic is reserved.`,
+        );
+    }
+}
+
+/**
+ * @param {string} method for the message
+ * @param {string} name the component's, for the message
+ * @param {*} correction
+ */
+function assert_correction(method, name, correction) {
+    if (correction === null || correction === undefined || correction.isCorrection !== true) {
+        throw new Error(
+            `NetworkSession.${method}: ${name} needs a Correction — how a client that predicts it corrects it when the host disagrees ` +
+            `(HOST_VALUE_CORRECTION takes the host's value)`,
+        );
+    }
+}
+
+/**
+ * While a blend is drawn over a component, its simulated value is held aside and put back before the
+ * next step. Held through a wire layout it would come back rounded, every step, and small increments
+ * would drift or stall; held with the component's own `copy`, it comes back exactly.
+ *
+ * @param {string} method for the message
+ * @param {string} name the component's, for the message
+ * @param {Function} ComponentClass
+ */
+function assert_copies_itself(method, name, ComponentClass) {
+    if (typeof ComponentClass.prototype.copy !== 'function') {
+        throw new Error(
+            `NetworkSession.${method}: ${name} is blended between network ticks, and while a blend is drawn over it the engine holds ` +
+            `its simulated value with ${name}.prototype.copy(other), which it does not have. Give ${name} a copy(other) that copies every ` +
+            `field the simulation uses, or replicate it with replicate_discrete().`,
+        );
+    }
+}
+
+/**
+ * @param {Uint8Array} a
+ * @param {Uint8Array} b
+ * @param {number} length
+ * @returns {boolean}
+ */
+function bytes_equal(a, b, length) {
+    for (let i = 0; i < length; i++) {
+        if (a[i] !== b[i]) return false;
+    }
+    return true;
+}
+
+/**
+ * @param {Uint8Array} a
+ * @param {number} a_length
+ * @param {Uint8Array} b
+ * @param {number} b_length
+ * @returns {boolean}
+ */
+function bytes_equal_lengths(a, a_length, b, b_length) {
+    return a_length === b_length && bytes_equal(a, b, a_length);
+}
 
 /**
  * High-level networking facade. Wraps the orchestrator + state machinery
@@ -133,23 +258,45 @@ const EMPTY_PAYLOAD = new Uint8Array(0);
  * Mutation is event-driven: callers fire
  * `dataset.sendEvent(entity, "net_mutate_component", payload)`.
  *
- * Per-tick driving is a single `session.tick(dt_seconds)`. The session
- * runs fixed-timestep stepping, client time dilation, server-side input
- * buffer, AUTH_STATE dispatch, time-dilation feedback, and interpolated
- * rendering for remote-owned entities.
+ * **The session runs on the engine's clock.** The `EntityManager`'s fixed
+ * step is the network tick: each step opens a network frame before any
+ * system's `fixedUpdate` and closes it after the last, so everything the
+ * step simulates — physics, controllers, game code — happens inside the
+ * frame. There is nothing to call per frame; `entity_manager.update(dt)`
+ * (the engine loop) drives it. Client time dilation is applied as the
+ * `EntityManager`'s `fixedStepTimeScale`.
+ *
+ * What arrives from the network is applied as a step opens, never when the
+ * transport happens to deliver it: a browser delivers packets whenever its
+ * event loop gets to them, which is usually between a frame's render blend and
+ * its draw. And the session's timers — the render playout, idle reaping, the
+ * grace window — run on the frame time the engine passes to `update`, so they
+ * pause with the engine and follow any engine that is driven by hand.
+ *
+ * **Networked entities are smooth by default.** The session attaches an
+ * {@link Interpolated} to each one and keeps it in line with ownership: on
+ * the host, and for entities the client owns (and predicts), the local
+ * fixed-step timeline; for everything else on a client, the network's
+ * render-delayed playout. Both are blended by the engine's
+ * {@link InterpolationSystem}, which the session adds if the engine has
+ * none.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
 export class NetworkSession {
 
-    // ---- Pre-start registration (set via replicate / defineAction / defineInputSampler) ----
+    // ---- Pre-start registration (replicate_* / defineAction / defineInputSampler) ----
 
     /**
-     * User-registered replicated component classes, in `replicate()` call
-     * order. Finalized at `start()` into {@link #replicated} with
-     * `NetworkIdentity` prepended.
-     * @private @type {Array<{klass: Function, interp: BinaryInterpolationAdapter|null}>}
+     * User-registered replicated component classes, in the order they were
+     * registered. Finalized at `start()` into {@link #replicated} with
+     * `NetworkIdentity` prepended. `interpoland` is how the component is blended
+     * between network ticks, `null` when it is not; `interpolator` is the blend
+     * handed to the deprecated {@link replicate}, turned into an interpoland at
+     * `start()`, when the component's replication layout is known; `correction`
+     * is how a client corrects it.
+     * @private @type {Array<{klass: Function, interpoland: Interpoland|null, interpolator: BinaryInterpolationAdapter|null, correction: Correction}>}
      */
     #user_replicated = [];
 
@@ -157,8 +304,8 @@ export class NetworkSession {
      * Finalized at `start()`. Insertion order = wire-format order;
      * `NetworkIdentity` is the first entry (its slot allocation must
      * fire before subsequent components attach during initial-sync apply).
-     * Each value: `{ interp, interp_type_id }`.
-     * @private @type {Map<Function, {interp: BinaryInterpolationAdapter|null, interp_type_id: number}>}
+     * `interp_type_id` is the component's replication type id.
+     * @private @type {Map<Function, {interp_type_id: number, interpoland: Interpoland|null, interpolator: BinaryInterpolationAdapter|null, correction: Correction|null}>}
      */
     #replicated = new Map();
 
@@ -215,19 +362,145 @@ export class NetworkSession {
     #playout;
 
     /**
-     * Set after `#render_interpolated_entities` writes interp values into
-     * live components; cleared by `normalize_if_dirty`. Drives the
-     * canonical-form invariant: live is canonical when this is false,
-     * polluted (smooth) when true.
-     * @private @type {boolean}
+     * @deprecated Always false. Render blends are owned by the {@link InterpolationSystem}, which
+     * restores them itself; {@link normalize_if_dirty} restores unconditionally.
+     * @type {boolean}
      */
     render_dirty = false;
 
+    // ---- Interpolation wiring (set in start()) ----
+
+    /** @private @type {InterpolationSystem|null} */
+    #interpolation = null;
+
+    /** @private @type {number} source id of the network playout in {@link #interpolation} */
+    #interp_source_id = -1;
+
+    /**
+     * Interpolands for the replicated components that interpolate, in `#replicated` order. The
+     * same list serves both timelines: records on the local timeline are keyed by entity, records
+     * in the network log by `network_id`.
+     * @private @type {Interpoland[]}
+     */
+    #interpolands = [];
+
+    /**
+     * Networked entities whose {@link Interpolated} has to be brought in line with their role —
+     * newly networked, or ownership changed. Applied as the next step opens, not from inside the
+     * observer that noticed: on an initial sync the identity arrives before the components it
+     * would interpolate.
+     * @private @type {Set<number>}
+     */
+    #interpolation_pending = new Set();
+
+    /**
+     * The {@link Interpolated} components this session attached, by entity, so it can take them
+     * back.
+     * @private @type {Map<number, Interpolated>}
+     */
+    #attached_interpolated = new Map();
+
+    /** @private @type {{tick_a:number, tick_b:number, t:number}} */
+    #playout_window = { tick_a: 0, tick_b: 0, t: 0 };
+
     // ---- Per-tick driver state ----
 
     /** @private @type {number} */ #local_frame = 0;
-    /** @private @type {number} */ #local_frame_accum = 0;
-    /** @private @type {number} */ #sim_accum_ms = 0;
+
+    /** @private @type {boolean} a network frame is open: the fixed step that opened it has not closed */
+    #step_open = false;
+
+    /**
+     * Every connected peer's transport, holding what arrives until the next fixed step opens.
+     * @private @type {Map<number, DeferredTransport>}
+     */
+    #inbound = new Map();
+
+    // ---- Host: publishing what the simulation changed ----
+
+    /** @private @type {boolean} */
+    #publish_changes;
+
+    /** @private @type {string} */
+    #late_input;
+
+    /**
+     * What the peers hold for each networked entity, per replicated component type id, as the
+     * replication adapter's bytes — so "changed" means "changed on the wire". Updated by every
+     * record the host publishes and by every action it executes (the peers apply the action and
+     * arrive at the same value), and compared with the live state at the end of each step.
+     * @private @type {Map<number, Array<{bytes: Uint8Array, length: number}|null>>}
+     */
+    #published = new Map();
+
+    /** @private @type {BinaryBuffer} */
+    #scratch_publish_buf = new BinaryBuffer();
+
+    // ---- Client: reconciliation by comparison ----
+
+    /** @private @type {string} */
+    #reconcile;
+
+    /**
+     * What this client predicted for the entities it owns, per frame, as wire bytes.
+     * @private @type {PredictionHistory}
+     */
+    #prediction_history = new PredictionHistory(128);
+
+    /**
+     * Authoritative states waiting for the next step, newest per network id: the frame and each
+     * replicated component's bytes, in `#replicated` order (`null` where the entity lacks it).
+     * @private @type {Map<number, {frame: number, parts: Array<{type_id: number, bytes: Uint8Array}|null>}>}
+     */
+    #pending_auth = new Map();
+
+    /**
+     * The newest frame reconciled per network id. An authoritative state for that frame or an
+     * earlier one arriving afterwards — reordered, or retransmitted — is stale: the present was
+     * already moved by a newer one, and moving it again by an older difference would undo that.
+     * @private @type {Map<number, number>}
+     */
+    #reconciled_frame = new Map();
+
+    /**
+     * Scratch instances per replicated class, for decoding without touching the world: the host's
+     * state, the prediction, and a later prediction being corrected.
+     * @private @type {Map<Function, object[]>}
+     */
+    #decode_scratch = new Map();
+
+    /** @private @type {CorrectionTarget} */
+    #correction_target = new CorrectionTarget();
+
+    /**
+     * Per replicated component, in `#replicated` order: whether the one being reconciled differs.
+     * @private @type {boolean[]}
+     */
+    #differs = [];
+
+    /**
+     * Client: authoritative states that differed from the prediction and were corrected.
+     * @type {number}
+     */
+    correction_count = 0;
+
+    /**
+     * Client: authoritative states that could not be compared because the prediction for their
+     * frame is not held (before the first predicted frame, or older than the history).
+     * @type {number}
+     */
+    correction_skipped_count = 0;
+
+    /**
+     * Client, {@link NetworkSessionReconcile.Correct}: a component of an authoritative state
+     * differed from the prediction, and the present was corrected. Once per component corrected.
+     * Args: `(entity_id, server_frame, component_class, magnitude)` — the size of the correction as
+     * the component's {@link Correction} measures it (a pose: how far the position moved, in world
+     * units). Diagnostic: a steady stream of these on a quiet link means the client simulates
+     * something differently from the host.
+     * @type {Signal}
+     */
+    onCorrection = new Signal();
 
     /** @private @type {Set<number>} */
     #connected_peers = new Set();
@@ -235,12 +508,28 @@ export class NetworkSession {
     /**
      * Host-only: peer_id → remaining-resends. Drained in
      * `#on_host_tick_complete` once `current_sim_frame >= 0`. Sent twice
-     * for loss tolerance; production code should re-send on receiver
-     * RECOVERY request.
+     * for loss tolerance, and never queued again on the peer's say-so: each
+     * send serializes the whole world, and a sync the peer could ask for is one
+     * it could keep asking for. Filled only by {@link #queue_initial_sync}.
+     * (A fragment of one that goes missing is re-sent on the receiver's
+     * NACK_FRAGMENT. That repair is `NetworkPeer`'s: a NACK re-sends each
+     * chunk of the sync at most once, for at most
+     * `FRAGMENT_RETENTION_MAX_RETRIES` NACKs, so it adds at most that many
+     * copies of each sync, however the peer asks.)
      * @private @type {Map<number, number>}
      */
     #pending_initial_sync = new Map();
 
+    /**
+     * Host-only: peers whose current connection has been given its
+     * INITIAL_SYNC — queued, or queued and already sent. A connection is
+     * given the world once. Cleared when `connect()` binds the peer a new
+     * connection; until then it describes the last one, on which nothing can
+     * arrive any more.
+     * @private @type {Set<number>}
+     */
+    #initial_sync_given = new Set();
+
     /**
      * Sampled-action ledger for predict-reconcile replay. The sampler
      * reads live input, so re-calling it during reconcile would give
@@ -270,6 +559,15 @@ export class NetworkSession {
      */
     #peer_grace_state = new Map();
 
+    /**
+     * Peers whose current connection has had its RESUME_HELLO answered. A
+     * client sends at most one per connection, from `connect()`; the host
+     * answers the first and ignores the rest. Cleared when `connect()` binds
+     * the peer a new connection.
+     * @private @type {Set<number>}
+     */
+    #resume_hello_answered = new Set();
+
     /**
      * Per-peer transport onDisconnect listener bookkeeping so we can
      * unsubscribe when the peer is fully dropped.
@@ -312,6 +610,26 @@ export class NetworkSession {
      * @private @type {boolean}
      */
     #has_ever_connected = false;
+    /**
+     * Client-side: how the host has answered the binding the last `connect()`
+     * made. Once it has, what the binding carries about the handshake is news
+     * no longer: the host sends each sync more than once against loss, and a
+     * host that has finished with our old session takes the new transport for
+     * a fresh peer and sends its sync before reading the RESUME_HELLO the
+     * transport carried, so the RESUME_REJECT it answers that with arrives
+     * after the resync it asks for.
+     * @private @type {BindingAnswer|string}
+     */
+    #binding_answer = BindingAnswer.Pending;
+    /**
+     * Client-side: the first frame predicted on the world this client holds —
+     * where the last INITIAL_SYNC it applied set the frame counter, 0 before
+     * any. Input predicted before it was predicted on a world the sync
+     * replaced, and is never sent: not by the binding that brought the sync,
+     * and not by any later one that resumes the world the sync began.
+     * @private @type {number}
+     */
+    #world_start_frame = 0;
 
     // ---- Signals (initialized inline because they take no input) ----
 
@@ -376,7 +694,13 @@ export class NetworkSession {
     /** @private @type {(() => object) | null} */ #transport_factory;
 
     /** @private @type {number} ms of inbound silence before reaping; 0 = off */ #connection_timeout_ms;
-    /** @private @type {number} monotonic ms clock advanced by tick(dt) */ #liveness_clock_ms = 0;
+    /**
+     * The session's clock, in milliseconds: the engine's frame time, advanced by the delta of every
+     * rendered frame. Paces the render playout, idle reaping and the grace window, so all of them
+     * follow the engine — a paused engine pauses them, a test that drives the engine drives them.
+     * @private @type {number}
+     */
+    #clock_ms = 0;
     /**
      * Per-peer liveness mark: the inbound-packet count last seen and the clock
      * time it was last seen advancing. Drives idle reaping.
@@ -421,7 +745,10 @@ export class NetworkSession {
      *   unique across peers.
      * - `simulation_delay_ticks` is honored only under `role: 'host'`.
      *   Default 4. See {@link ServerAuthoritativeServer}.
-     * - `tick_rate_hz` defaults to 60.
+     * - `tick_rate_hz`: the network tick rate, which is the engine's fixed-step
+     *   rate — given, it sets `entity_manager.fixedUpdateStepSize`; omitted, the
+     *   session uses the step the engine already has (60 Hz by default). Every
+     *   peer must run the same rate.
      * - `frame_capacity` sizes the action-log ring (rollback depth + back-fill
      *   range + retransmit window — see {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}).
      *   Default 32. Raise it for high-RTT / lossy links.
@@ -435,6 +762,18 @@ export class NetworkSession {
      * - `reconnect` (client role): policy for the reconnect ladder. See
      *   {@link DEFAULT_RECONNECT_POLICY}. Set `enabled: false` to opt
      *   out entirely.
+     * - `publish_changes` (host role, default true): at the end of every
+     *   step, send each replicated component the simulation changed — physics,
+     *   controllers, anything that wrote it directly. Components an action
+     *   wrote are already on the wire and are not sent twice. Publishing never
+     *   writes back into the host's own state. Set false to publish by hand
+     *   (`net_mutate_component`).
+     * - `reconcile` (client role): see {@link NetworkSessionReconcile}. Default
+     *   `'correct'`.
+     * - `late_input` (host role): what to do with client input that arrives
+     *   for a frame already simulated — see {@link LateInput}. Default
+     *   `'apply'`: fold it into the current frame. `'rollback'` rewinds and
+     *   replays, which re-executes actions only, never the engine's systems.
      */
     constructor({
                     entity_manager,
@@ -443,7 +782,7 @@ export class NetworkSession {
                     role = NetworkSessionRole.Client,
                     local_peer_id = -1,
                     simulation_delay_ticks = DEFAULT_SIMULATION_DELAY_TICKS,
-                    tick_rate_hz = DEFAULT_TICK_RATE_HZ,
+                    tick_rate_hz = undefined,
                     frame_capacity = DEFAULT_ACTION_LOG_FRAME_CAPACITY,
                     binary_registry = null,
                     scope_filter = null,
@@ -452,14 +791,19 @@ export class NetworkSession {
                     server_resume_grace_ms = DEFAULT_SERVER_RESUME_GRACE_MS,
                     connection_timeout_ms = DEFAULT_CONNECTION_TIMEOUT_MS,
                     reconnect = null,
+                    publish_changes = true,
+                    late_input = LateInput.Apply,
+                    reconcile = NetworkSessionReconcile.Correct,
                 } = {}) {
         assert.ok(entity_manager !== undefined && entity_manager !== null,
             'NetworkSession: entity_manager is required');
         if (role !== NetworkSessionRole.Client && role !== NetworkSessionRole.Host) {
             throw new Error(`NetworkSession: invalid role '${role}'`);
         }
-        assert.isNumber(tick_rate_hz, 'tick_rate_hz');
-        assert.ok(tick_rate_hz > 0, 'tick_rate_hz must be positive');
+        if (tick_rate_hz !== undefined) {
+            assert.isNumber(tick_rate_hz, 'tick_rate_hz');
+            assert.ok(tick_rate_hz > 0, 'tick_rate_hz must be positive');
+        }
         assert.isNonNegativeInteger(simulation_delay_ticks, 'simulation_delay_ticks');
         assert.isPositiveInteger(frame_capacity, 'frame_capacity');
 
@@ -481,11 +825,18 @@ export class NetworkSession {
          */
         this.role = role;
 
+        // One clock: the network tick IS the engine's fixed step. A rate given here sets the step;
+        // otherwise the session adopts the one the engine already has.
+        if (tick_rate_hz !== undefined) {
+            entity_manager.fixedUpdateStepSize = 1 / tick_rate_hz;
+        }
+
         /**
+         * The network tick period, which is the `EntityManager`'s fixed step.
          * @readonly
          * @type {number}
          */
-        this.tick_period_ms = 1000 / tick_rate_hz;
+        this.tick_period_ms = entity_manager.fixedUpdateStepSize * 1000;
 
         /**
          * @readonly
@@ -553,6 +904,12 @@ export class NetworkSession {
         this.#connection_timeout_ms = connection_timeout_ms;
         this.#reconnect_policy = Object.freeze({ ...DEFAULT_RECONNECT_POLICY, ...(reconnect || {}) });
         this.#transport_factory = transport_factory;
+        this.#publish_changes = publish_changes;
+        this.#late_input = late_input;
+        if (reconcile !== NetworkSessionReconcile.Correct && reconcile !== NetworkSessionReconcile.Replay) {
+            throw new Error(`NetworkSession: reconcile must be one of ${Object.values(NetworkSessionReconcile).join(', ')}, got '${reconcile}'`);
+        }
+        this.#reconcile = reconcile;
     }
 
     // ----------------------------------------------------------------
@@ -560,52 +917,129 @@ export class NetworkSession {
     // ----------------------------------------------------------------
 
     /**
-     * Register a component class for network replication.
+     * Replicate `ComponentClass`, and draw it between network ticks by blending. A network tick is
+     * coarser than a rendered frame, and a component shown only as each state lands moves in steps;
+     * `interpoland` says how it is drawn instead — the layout each tick's state is recorded in, and
+     * the blend of two records for a rendered frame.
+     *
+     * - `interpoland.component_class` is `ComponentClass`, and its blend is of kind
+     *   {@link InterpolationKind.Linear}.
+     * - `interpoland.type_id` names its records. No two components one session replicates may share
+     *   one; {@link start} checks.
+     * - `ComponentClass` has `copy(other)`: while a blend is drawn over the component, its simulated
+     *   value is held with it, and put back exactly before the next step.
+     *
+     * `correction` is how a client that predicts the component corrects it when the host disagrees
+     * — see {@link Correction}.
+     *
+     * See {@link replicate_discrete} for a component with no in-between.
+     *
+     * Like every replicated component, `ComponentClass` needs a
+     * {@link BinaryClassSerializationAdapter} registered for its `typeName` in `binary_registry`
+     * before {@link start} — its wire format. Components are laid out on the wire in the order they
+     * are replicated, so every peer must replicate the same components in the same order.
+     *
+     * @param {Function} ComponentClass
+     * @param {Interpoland} interpoland
+     * @param {Correction} correction
+     */
+    replicate_interpolated(ComponentClass, interpoland, correction) {
+        const name = this.#assert_can_replicate('replicate_interpolated', ComponentClass);
+
+        if (interpoland === null || interpoland === undefined || interpoland.isInterpoland !== true) {
+            throw new Error(`NetworkSession.replicate_interpolated: ${name} needs an Interpoland — the layout its states are recorded in, and the blend between them`);
+        }
+        if (interpoland.component_class !== ComponentClass) {
+            throw new Error(`NetworkSession.replicate_interpolated: the interpoland given for ${name} interpolates ${interpoland.component_class?.typeName ?? interpoland.component_class?.name}`);
+        }
+
+        assert_linear_blend('replicate_interpolated', name, interpoland.interpolation_adapter);
+        assert_copies_itself('replicate_interpolated', name, ComponentClass);
+        assert_correction('replicate_interpolated', name, correction);
+
+        this.#user_replicated.push({ klass: ComponentClass, interpoland, interpolator: null, correction });
+    }
+
+    /**
+     * Replicate `ComponentClass`, and draw it as each state lands, with no blend between network
+     * ticks. For a value that has no in-between — a count, a name, a state machine's state.
      *
-     * The component must have a {@link BinaryClassSerializationAdapter}
-     * registered for its `typeName` in the session's `binary_registry`
-     * before {@link start} is called — that adapter handles the wire
-     * format and rewind capture.
+     * `correction` is how a client that predicts the component corrects it when the host disagrees
+     * — see {@link Correction}.
      *
-     * `interpolator` is optional. When omitted, the component's state
-     * snaps on each received update (no sub-tick smoothing). When
-     * provided, it must extend {@link BinaryInterpolationAdapter} with
-     * `kind = InterpolationKind.Linear` — Discrete and Cubic are
-     * reserved for future support and currently throw.
+     * Like every replicated component, `ComponentClass` needs a
+     * {@link BinaryClassSerializationAdapter} registered for its `typeName` in `binary_registry`
+     * before {@link start} — its wire format. Components are laid out on the wire in the order they
+     * are replicated, so every peer must replicate the same components in the same order.
      *
-     * The order of `replicate()` calls must match across all peers in
-     * the session: AUTH_STATE payload layout iterates components in
-     * insertion order.
+     * @param {Function} ComponentClass
+     * @param {Correction} correction
+     */
+    replicate_discrete(ComponentClass, correction) {
+        const name = this.#assert_can_replicate('replicate_discrete', ComponentClass);
+
+        assert_correction('replicate_discrete', name, correction);
+
+        this.#user_replicated.push({ klass: ComponentClass, interpoland: null, interpolator: null, correction });
+    }
+
+    /**
+     * **Deprecated.** Use {@link replicate_interpolated} or {@link replicate_discrete}, which say how
+     * the component is drawn. Warns once.
      *
+     * Keeps its meaning: `replicate(C)` replicates `C` discretely; `replicate(C, interpolator)` blends
+     * it with `interpolator`, recorded in its replication layout. A component blended this way needs
+     * `copy(other)`, as with {@link replicate_interpolated}. A client corrects what it registers by
+     * taking the host's value ({@link HOST_VALUE_CORRECTION}).
+     *
+     * @deprecated
      * @param {Function} ComponentClass
-     * @param {BinaryInterpolationAdapter} [interpolator]
+     * @param {BinaryInterpolationAdapter|null} [interpolator]
      */
     replicate(ComponentClass, interpolator = null) {
-        this.#assert_not_started('replicate');
+        if (!replicate_deprecation_warned) {
+            replicate_deprecation_warned = true;
+            console.warn(
+                'NetworkSession.replicate() is deprecated: use replicate_interpolated(C, interpoland, correction) for a component ' +
+                'blended between network ticks, or replicate_discrete(C, correction) for one that is not.',
+            );
+        }
+
+        if (interpolator === null) {
+            this.replicate_discrete(ComponentClass, HOST_VALUE_CORRECTION);
+            return;
+        }
+
+        const name = this.#assert_can_replicate('replicate', ComponentClass);
+
+        assert_linear_blend('replicate', name, interpolator);
+        assert_copies_itself('replicate', name, ComponentClass);
+
+        this.#user_replicated.push({ klass: ComponentClass, interpoland: null, interpolator, correction: HOST_VALUE_CORRECTION });
+    }
+
+    /**
+     * @param {string} method
+     * @param {Function} ComponentClass
+     * @returns {string} the component's name, for messages
+     */
+    #assert_can_replicate(method, ComponentClass) {
+        this.#assert_not_started(method);
         assert.isFunction(ComponentClass, 'ComponentClass');
 
+        const name = ComponentClass.typeName ?? ComponentClass.name;
+
         if (ComponentClass === NetworkIdentity) {
-            throw new Error("NetworkSession.replicate: NetworkIdentity is auto-replicated; do not call replicate() for it");
+            throw new Error(`NetworkSession.${method}: NetworkIdentity is replicated by the session itself`);
         }
 
         for (const entry of this.#user_replicated) {
             if (entry.klass === ComponentClass) {
-                throw new Error(`NetworkSession.replicate: ${ComponentClass.typeName ?? ComponentClass.name} already registered`);
+                throw new Error(`NetworkSession.${method}: ${name} is already replicated`);
             }
         }
-        if (interpolator !== null) {
-            if (!(interpolator instanceof BinaryInterpolationAdapter)) {
-                throw new Error("NetworkSession.replicate: interpolator must extend BinaryInterpolationAdapter");
-            }
-            if (interpolator.kind !== InterpolationKind.Linear) {
-                throw new Error(
-                    `NetworkSession.replicate: only Linear interpolation is currently supported; ` +
-                    `got kind=${interpolator.kind} for ${ComponentClass.typeName ?? ComponentClass.name}. ` +
-                    `Omit the interpolator argument for snap (Discrete) behavior; Cubic is reserved.`,
-                );
-            }
-        }
-        this.#user_replicated.push({ klass: ComponentClass, interp: interpolator });
+
+        return name;
     }
 
     /**
@@ -658,12 +1092,12 @@ export class NetworkSession {
     /**
      * Wire the session to the engine. After this, the EntityObserver
      * is active, the right orchestrator is constructed, and a
-     * {@link NetworkSystem} is attached. Subsequent {@link replicate}
+     * {@link NetworkSystem} is attached. Subsequent `replicate_*`
      * / {@link defineAction} / {@link defineInputSampler} calls throw.
      *
-     * Pre-condition: every component class passed to {@link replicate}
-     * must already have a `BinaryClassSerializationAdapter` registered
-     * in the session's binary_registry.
+     * Pre-condition: every replicated component class must already have a
+     * `BinaryClassSerializationAdapter` registered in the session's
+     * binary_registry.
      */
     async start() {
         if (this.#started) throw new Error("NetworkSession.start: already started");
@@ -684,13 +1118,15 @@ export class NetworkSession {
         const network_identity_scratch = new BinaryBuffer();
         network_identity_scratch.setCapacity(SCRATCH_BUFFER_BYTES);
         this.#replicated.set(NetworkIdentity, {
-            interp: null,
             interp_type_id: next_id++,
+            interpoland: null,
+            interpolator: null,
+            correction: null, // ownership is never predicted
         });
         this.#interp_type_id_to_class[0] = NetworkIdentity;
-        for (const { klass, interp } of this.#user_replicated) {
+        for (const { klass, interpoland, interpolator, correction } of this.#user_replicated) {
             const interp_type_id = next_id++;
-            this.#replicated.set(klass, { interp, interp_type_id });
+            this.#replicated.set(klass, { interp_type_id, interpoland, interpolator, correction });
             this.#interp_type_id_to_class[interp_type_id] = klass;
         }
 
@@ -705,6 +1141,8 @@ export class NetworkSession {
             }
         }
 
+        this.#interpolands = this.#build_interpolands();
+
         // Build the synthetic ReplaceComponentAction now so it's in the
         // action_classes list when the orchestrator is constructed.
         this.#ReplaceComponentAction = this.#make_replace_component_action_class();
@@ -724,6 +1162,7 @@ export class NetworkSession {
             this.#server = new ServerAuthoritativeServer({
                 ...orchestrator_opts,
                 simulation_delay_ticks: this.simulation_delay_ticks,
+                late_input: this.#late_input,
             });
             this.#peer = this.#server.peer;
             this.#peer.replicator.scope_filter = this.#scope_filter || new OwnerAwareScope({
@@ -732,6 +1171,9 @@ export class NetworkSession {
                 identity_class: NetworkIdentity,
             });
             this.#server.onTickComplete.add((sim_frame) => this.#on_host_tick_complete(sim_frame));
+            if (this.#publish_changes) {
+                this.#server.onBeforeTickClose.add(() => this.#publish_simulated_changes());
+            }
         } else {
             // Client role: covers both "playing" (input sampler registered)
             // and "spectator" (no sampler — sampler-driven onPredict
@@ -740,7 +1182,13 @@ export class NetworkSession {
             this.#client = new ServerAuthoritativeClient({
                 ...orchestrator_opts,
                 time_dilation: this.#time_dilation,
+                auto_reconcile: this.#reconcile === NetworkSessionReconcile.Replay,
             });
+            if (this.#reconcile === NetworkSessionReconcile.Correct) {
+                this.#client.peer.onAuthState.add((_peer_id, server_frame, network_id, buffer) => {
+                    this.#queue_auth_state(server_frame, network_id, buffer);
+                });
+            }
             this.#peer = this.#client.peer;
             if (this.#scope_filter) {
                 this.#peer.replicator.scope_filter = this.#scope_filter;
@@ -750,12 +1198,19 @@ export class NetworkSession {
 
         // Install the canonical-form normalize hook on the executor.
         // Anything that calls executor.execute — predict apply, action-
-        // stream apply, reconcile replay — first normalizes the world.
-        // Idempotent: cheap when `render_dirty` is false (one bool
-        // check), expensive (one adapter.deserialize per remote-owned
-        // component) only on the first execute after a render pass.
+        // stream apply, reconcile replay — first puts back any render
+        // blend, so the prior state it captures is the truth. Idempotent:
+        // cheap when nothing is blended, one compare + deserialize per
+        // blended component on the first execute after a render pass.
         this.#peer.executor.before_execute = this.#bound_normalize_if_dirty;
 
+        if (this.role === NetworkSessionRole.Host && this.#publish_changes) {
+            // an action carries its own change to the peers: what it wrote is what they will hold
+            this.#peer.executor.on_component_written = (entity_id, component_class) => {
+                this.#note_published(entity_id, component_class);
+            };
+        }
+
         // Secure-by-default inbound authorization on the host: a remote client
         // may only mutate entities it owns (NetworkIdentity.owner_peer_id ===
         // sender); the authoritative server (sender === local_peer_id) may
@@ -776,14 +1231,30 @@ export class NetworkSession {
         // startup completes (it auto-starts when added to an already-Running
         // EM). Await it so the session's identity observer below doesn't
         // race with the NetworkSystem's observer over slot_table allocation.
-        await this.entity_manager.addSystem(new NetworkSystem(this.#peer));
-
-        // Sub-tick interpolation log: records per-frame replicated component
-        // state, sampled at render time for remotely-owned entities.
+        //
+        // It is also the session's place in the engine loop: each fixed step opens a network frame
+        // and closes it, and every rendered frame runs the session's wall-paced work.
+        await this.entity_manager.addSystem(new NetworkSystem(this.#peer, {
+            open_step: () => this.#open_step(),
+            close_step: () => this.#close_step(),
+            frame: (dt) => this.#on_frame(dt),
+        }));
+
+        // The network timeline: per-frame state of every remote entity, blended at render time on
+        // the render-delayed playout by the engine's InterpolationSystem.
         this.#interp_log = new InterpolationLog({
-            buffer_capacity_bytes: 65536,
-            records_capacity: 4096,
-        });
+            buffer_capacity_bytes: 1 << 18,
+            records_capacity: 8192,
+        }); // grows with the entity count, see #on_frame_applied
+
+        let interpolation = this.entity_manager.getSystem(InterpolationSystem);
+        if (interpolation === null) {
+            interpolation = new InterpolationSystem();
+            await this.entity_manager.addSystem(interpolation);
+        }
+        this.#interpolation = interpolation;
+        this.#interp_source_id = interpolation.allocateSourceId();
+        interpolation.registerSource(this.#interp_source_id, this.#interp_log, () => this.#sample_playout());
 
         // Per-frame applied: snapshot all replicated components for each
         // remote-owned entity into the interpolation log.
@@ -796,7 +1267,15 @@ export class NetworkSession {
         // action-stream processing, and finalize any in-flight Tier-3
         // resync state.
         if (this.role === NetworkSessionRole.Client) {
-            this.#peer.onInitialSync.add((_peer_id, session_token, frame_number, buf, payload_end) => {
+            this.#peer.onInitialSync.add((peer_id, session_token, frame_number, buf, payload_end) => {
+                if (this.#binding_answer === BindingAnswer.Synced && this.#reconnect_state !== ReconnectState.Resyncing) {
+                    // A copy: the host sends every sync more than once, against loss, and this
+                    // binding already has its world. The client has been predicting on it since;
+                    // applied again, it would put what the client owns back behind input already
+                    // sent, and seek the frame counter over frames already predicted.
+                    return;
+                }
+
                 const token = new UUID();
                 token.data = session_token;
                 this.session_token = token;
@@ -816,7 +1295,22 @@ export class NetworkSession {
                 */
                 this.seek_to_frame(frame_number + 1 + this.#time_dilation.target_buffer_depth);
 
+                // The world is about to be the host's. What this client predicted, sampled or was
+                // told about the one it had is about a world, and a frame numbering, that is gone.
+                this.#prediction_history.clear();
+                this.#pending_auth.clear();
+                this.#reconciled_frame.clear();
+                this.#sampled_actions_per_frame.clear();
+
                 this.#apply_initial_sync(buf, payload_end);
+                this.#binding_answer = BindingAnswer.Synced;
+
+                // Input from here on is predicted on the host's world. What was predicted before —
+                // held since this binding was made, or still in the log from before it — was
+                // predicted on the world just replaced, and is never sent.
+                this.#world_start_frame = this.#local_frame;
+                this.#peer.release_outbound(peer_id, this.#world_start_frame);
+
                 // Reconnecting counts as well as Resyncing: a host that has
                 // finished with our old session readmits us as a fresh peer,
                 // so the snapshot arrives with no RESUME_ACCEPT ahead of it.
@@ -833,7 +1327,15 @@ export class NetworkSession {
                 }
             });
             // Host's response to our RESUME_HELLO during reconnect.
-            this.#peer.onResumeAccept.add(() => {
+            this.#peer.onResumeAccept.add((peer_id) => {
+                if (this.#binding_answer !== BindingAnswer.Pending) {
+                    // stale, as a reject would be: this binding has had its answer
+                    return;
+                }
+                this.#binding_answer = BindingAnswer.Resumed;
+                // The host kept the world this client holds, so what the client predicted on it —
+                // while cut off, and since — is owed to the host like any input, late as it is.
+                this.#peer.release_outbound(peer_id, this.#world_start_frame);
                 if (this.#reconnect_state === ReconnectState.Reconnecting
                     || this.#reconnect_state === ReconnectState.Resyncing) {
                     this.#enter_connected();
@@ -841,6 +1343,15 @@ export class NetworkSession {
                 }
             });
             this.#peer.onResumeReject.add((_peer_id, reason_code) => {
+                if (this.#binding_answer !== BindingAnswer.Pending) {
+                    // Stale: this binding has had its answer. A host that has finished with our
+                    // old session readmits the binding as a fresh peer before it reads our
+                    // RESUME_HELLO, and the sync it sends then is the resync this reject asks for,
+                    // already applied. Acted on, the reject would throw away the token that sync
+                    // issued and wait on a sync already here. A reject that ends the connection is
+                    // followed by a DISCONNECT, which still does.
+                    return;
+                }
                 if (this.#reconnect_policy.accept_state_resync) {
                     // Tier-3: drop unconfirmed predictions and wait for
                     // the host to deliver a fresh INITIAL_SYNC.
@@ -899,15 +1410,36 @@ export class NetworkSession {
      * a peer id is the matchmaking layer's decision, not a race between
      * whatever connections happen to arrive.
      *
+     * A client sends its input on the new connection only once the host has
+     * answered it. A RESUME_ACCEPT sends everything predicted meanwhile; an
+     * INITIAL_SYNC drops everything predicted before it, on the world it
+     * replaces. See the network README, "Connecting, and coming back".
+     *
      * @param {number} remote_peer_id
      * @param {object} transport
      */
     connect(remote_peer_id, transport) {
         if (!this.#started) throw new Error("NetworkSession.connect: call start() first");
 
+        // What the peer's previous transport delivered — and its end, if it has ended — is taken
+        // before the new transport is bound, in the order it arrived: a connection that dropped
+        // moments ago has not been noticed until its news is read, and a peer id is only free
+        // once it has been. That holds when this is called from inside that transport's own
+        // delivery — by an application handing on the id of a peer whose DISCONNECT is being
+        // read, say: the flush goes on from the packet after the one being read.
+        const previous = this.#inbound.get(remote_peer_id);
+        if (previous !== undefined) {
+            previous.flush();
+        }
+
         if (this.role === NetworkSessionRole.Host) {
             const in_grace = this.#peer_grace_state.has(remote_peer_id);
-            this.#server.connect_peer(remote_peer_id, transport);
+            const deferred = this.#bind_deferred(remote_peer_id, transport,
+                (t) => this.#server.connect_peer(remote_peer_id, t));
+            // A new connection: nothing it says has been answered yet, and it
+            // has not been given the world.
+            this.#resume_hello_answered.delete(remote_peer_id);
+            this.#initial_sync_given.delete(remote_peer_id);
             if (in_grace) {
                 // Resume candidate. Wait for RESUME_HELLO; restore
                 // baseline + add to connected_peers on validation.
@@ -915,10 +1447,10 @@ export class NetworkSession {
                 // RESUME_REJECT.
             } else {
                 // Fresh peer. Queue initial-sync for the next host tick.
-                this.#pending_initial_sync.set(remote_peer_id, 2);
+                this.#queue_initial_sync(remote_peer_id);
                 this.#connected_peers.add(remote_peer_id);
             }
-            this.#wire_peer_transport_disconnect(remote_peer_id, transport);
+            this.#wire_peer_transport_disconnect(remote_peer_id, deferred);
         } else {
             // Client. Release whatever binding this peer id already has: the
             // reconnect ladder fires on a back-off timer, not on the previous
@@ -934,11 +1466,19 @@ export class NetworkSession {
             this.#peer.disconnect_peer(remote_peer_id);
             this.#connected_peers.delete(remote_peer_id);
             this.#peer_inbound_mark.delete(remote_peer_id);
-            this.#client.connect_to_server(remote_peer_id, transport);
+            const deferred = this.#bind_deferred(remote_peer_id, transport,
+                (t) => this.#client.connect_to_server(remote_peer_id, t));
             this.#remote_peer_id = remote_peer_id;
-            this.#current_transport = transport;
-            this.#wire_client_transport_disconnect(transport);
+            this.#wire_client_transport_disconnect(deferred);
+            this.#current_transport = deferred;
             this.#connected_peers.add(remote_peer_id);
+            // A new binding, and until the host answers it the client does not know which world it
+            // is in: the one it has been predicting on, if the host resumes it (RESUME_ACCEPT), or
+            // the host's, if it sends a snapshot (INITIAL_SYNC) — and input predicted on a world the
+            // snapshot replaces must never reach the host. So what the client predicts meanwhile is
+            // held: sent on an accept, dropped on a sync.
+            this.#binding_answer = BindingAnswer.Pending;
+            this.#peer.hold_outbound(remote_peer_id);
 
             // Announce ourselves whenever this connect could be a claim on an
             // id the host still holds a record for: we have a token to prove
@@ -1057,116 +1597,322 @@ export class NetworkSession {
     }
 
     /**
-     * Tear down. Idempotent — safe to call from cleanup paths.
+     * Tear down. Idempotent — safe to call from cleanup paths.
+     */
+    stop() {
+        if (!this.#started) return;
+
+        this.entity_manager.fixedStepTimeScale = 1;
+
+        if (this.#step_open) {
+            // stopped from inside a fixed step: close the frame the step opened
+            this.#step_open = false;
+            if (this.#server !== null) this.#server.end_tick(); else this.#client.end_tick();
+        }
+
+        if (this.#interpolation !== null) {
+            this.#interpolation.restore();
+            this.#interpolation.unregisterSource(this.#interp_source_id);
+        }
+        for (const [entity_id, interpolated] of this.#attached_interpolated) {
+            if (this.world.getComponent(entity_id, Interpolated) === interpolated) {
+                this.world.removeComponentFromEntity(entity_id, Interpolated);
+            }
+        }
+        this.#attached_interpolated.clear();
+        this.#interpolation_pending.clear();
+        this.#pending_auth.clear();
+        this.#reconciled_frame.clear();
+        this.#prediction_history.clear();
+
+        if (this.#identity_observer !== null) {
+            this.#identity_observer.disconnect();
+            this.#identity_observer = null;
+        }
+        for (const [entity_id, listener] of this.#event_listeners) {
+            this.world.removeEntityEventListener(entity_id, "net_mutate_component", listener);
+        }
+        this.#event_listeners.clear();
+        this.#remote_entities.clear();
+        this.#sampled_actions_per_frame.clear();
+        this.#peer_inbound_mark.clear();
+        for (const transport of this.#inbound.values()) {
+            transport.release();
+        }
+        this.#inbound.clear();
+        this.#started = false;
+    }
+
+    // ----------------------------------------------------------------
+    //  Per-tick driver
+    // ----------------------------------------------------------------
+
+    /**
+     * **Deprecated; does nothing.** The session used to run its own fixed-step clock here, next to
+     * the engine's: two clocks, so network frame N and the engine's step N were unrelated, and
+     * nothing interpolated against one could be blended on the other. The session now runs on the
+     * `EntityManager`'s fixed step — `entity_manager.update(dt)`, which the engine loop already
+     * calls, drives it — and calling this as well would advance it twice.
+     *
+     * Warns once. Remove the call.
+     *
+     * @deprecated
+     * @param {number} [dt_seconds]
+     */
+    tick(dt_seconds) {
+        if (!tick_deprecation_warned) {
+            tick_deprecation_warned = true;
+            console.warn('NetworkSession.tick() is deprecated and does nothing: the session runs on the EntityManager fixed step, driven by entity_manager.update(dt). Remove the call.');
+        }
+    }
+
+    /**
+     * The fixed step about to run opens a network frame. Before it does: the live components are
+     * given back the simulation's truth (a render blend is not state), and everything that arrived
+     * from the network since the last step is applied to it — here, where simulation writes happen,
+     * and not whenever the browser delivers a packet, which is usually between a frame's blend and
+     * its draw.
+     */
+    #open_step() {
+        if (!this.#started) return;
+
+        this.#interpolation.settle();
+
+        this.#flush_inbound();
+
+        this.#apply_pending_interpolation();
+
+        if (this.#client !== null && this.#pending_auth.size > 0) {
+            this.#apply_pending_corrections();
+        }
+
+        try {
+            if (this.#server !== null) {
+                this.#server.begin_tick(this.#local_frame);
+            } else {
+                this.#client.begin_tick(this.#local_frame);
+            }
+        } catch (e) {
+            // the frame is spent: the next step moves on to the next one rather than repeat it
+            // over what this one already applied
+            this.#local_frame++;
+            throw e;
+        }
+
+        this.#step_open = true;
+    }
+
+    /**
+     * The fixed step has run: close its network frame.
+     */
+    #close_step() {
+        if (!this.#step_open) return;
+
+        try {
+            if (this.#server !== null) {
+                // runs the frame's local sim, then publishes (onBeforeTickClose), then closes it
+                this.#server.end_tick();
+            } else {
+                this.#client.end_tick();
+                this.#send_frame_marker(this.#local_frame);
+                if (this.#reconcile === NetworkSessionReconcile.Correct) {
+                    this.#record_prediction(this.#local_frame);
+                }
+            }
+        } finally {
+            this.#step_open = false;
+            this.#local_frame++;
+        }
+    }
+
+    /**
+     * Deliver what every peer's transport has held since the last step, and let go of the
+     * transports of peers no longer connected.
+     */
+    #flush_inbound() {
+        for (const [peer_id, transport] of this.#inbound) {
+            if (!this.#peer.is_connected(peer_id)) {
+                transport.release();
+                this.#inbound.delete(peer_id);
+                continue;
+            }
+            transport.flush();
+        }
+    }
+
+    /**
+     * Bind `peer_id` to `transport` through `bind`, with the transport's traffic held for
+     * {@link #open_step}. Whatever held the peer's traffic before is let go once the new binding
+     * stands; if binding throws, nothing changes.
+     *
+     * @param {number} peer_id
+     * @param {object} transport
+     * @param {(deferred: DeferredTransport) => void} bind
+     * @returns {DeferredTransport}
+     */
+    #bind_deferred(peer_id, transport, bind) {
+        const deferred = new DeferredTransport(transport);
+
+        try {
+            bind(deferred);
+        } catch (e) {
+            deferred.release();
+            throw e;
+        }
+
+        const previous = this.#inbound.get(peer_id);
+        if (previous !== undefined) {
+            previous.release();
+        }
+        this.#inbound.set(peer_id, deferred);
+
+        return deferred;
+    }
+
+    /**
+     * Host, end of step: record every replicated component whose wire image differs from what the
+     * peers hold, into the still-open frame, for the action stream to carry. Recorded, not
+     * executed — see {@link SimActionExecutor#record}. A component an action wrote this step and
+     * nothing changed since is not sent again: the peers apply the action.
+     */
+    #publish_simulated_changes() {
+        const world = this.world;
+        const executor = this.#peer.executor;
+        const scratch = this.#scratch_publish_buf;
+        const changed_entities = executor.changed_entities;
+
+        for (const entity_id of this.#event_listeners.keys()) {
+            const identity = world.getComponent(entity_id, NetworkIdentity);
+            if (identity === undefined || identity.network_id < 0) continue;
+
+            for (const [ComponentClass, desc] of this.#replicated) {
+                if (ComponentClass === NetworkIdentity) continue;
+
+                const live = world.getComponent(entity_id, ComponentClass);
+                if (live === undefined) continue;
+
+                const type_id = desc.interp_type_id;
+
+                scratch.position = 0;
+                this.binary_registry.getAdapter(ComponentClass.typeName).serialize(scratch, live);
+                const length = scratch.position;
+
+                if (!this.#remember_published(entity_id, type_id, scratch.raw_bytes, length)) continue;
+
+                const action = this.#peer.action_registry.acquire(this.#ReplaceComponentAction);
+                try {
+                    action.network_id = identity.network_id;
+                    action.component_type_id = type_id;
+                    action.payload_buf.position = 0;
+                    action.payload_buf.writeBytes(scratch.raw_bytes, 0, length);
+                    action.payload_length = length;
+                    executor.record(action);
+                } finally {
+                    this.#peer.action_registry.release(action);
+                }
+
+                if (changed_entities !== null) changed_entities.add(identity.network_id);
+            }
+        }
+    }
+
+    /**
+     * Host: an action wrote `ComponentClass` of `entity_id`; the peers will hold what it wrote.
+     * @param {number} entity_id
+     * @param {Function} ComponentClass
+     */
+    #note_published(entity_id, ComponentClass) {
+        const desc = this.#replicated.get(ComponentClass);
+        if (desc === undefined || ComponentClass === NetworkIdentity) return;
+
+        const live = this.world.getComponent(entity_id, ComponentClass);
+        if (live === undefined) return;
+
+        const scratch = this.#scratch_publish_buf;
+        scratch.position = 0;
+        this.binary_registry.getAdapter(ComponentClass.typeName).serialize(scratch, live);
+        this.#remember_published(entity_id, desc.interp_type_id, scratch.raw_bytes, scratch.position);
+    }
+
+    /**
+     * Set what the peers hold for `(entity_id, type_id)`.
+     * @param {number} entity_id
+     * @param {number} type_id
+     * @param {Uint8Array} bytes
+     * @param {number} length
+     * @returns {boolean} whether it differs from what was held before
      */
-    stop() {
-        if (!this.#started) return;
-        if (this.#identity_observer !== null) {
-            this.#identity_observer.disconnect();
-            this.#identity_observer = null;
+    #remember_published(entity_id, type_id, bytes, length) {
+        let published = this.#published.get(entity_id);
+        if (published === undefined) {
+            published = [];
+            this.#published.set(entity_id, published);
         }
-        for (const [entity_id, listener] of this.#event_listeners) {
-            this.world.removeEntityEventListener(entity_id, "net_mutate_component", listener);
+        while (published.length <= type_id) published.push(null);
+
+        let held = published[type_id];
+        if (held !== null && held.length === length && bytes_equal(bytes, held.bytes, length)) {
+            return false;
         }
-        this.#event_listeners.clear();
-        this.#remote_entities.clear();
-        this.#sampled_actions_per_frame.clear();
-        this.#peer_inbound_mark.clear();
-        this.#started = false;
-    }
 
-    // ----------------------------------------------------------------
-    //  Per-tick driver
-    // ----------------------------------------------------------------
+        if (held === null || held.bytes.length < length) {
+            held = { bytes: new Uint8Array(Math.max(length, 32)), length: 0 };
+            published[type_id] = held;
+        }
+        held.bytes.set(bytes.subarray(0, length), 0);
+        held.length = length;
+
+        return true;
+    }
 
     /**
-     * Fixed-timestep accumulator-driven step. Catch-up bounded by
-     * `MAX_FIXED_STEPS_PER_TICK`. Under `role: 'client'` the local frame
-     * advances at `1 / dilation_factor` per fixed step.
-     *
-     * @param {number} dt_seconds elapsed wall seconds since the previous call
+     * Once per rendered frame: the work paced by wall time rather than by the simulation.
+     * @param {number} dt_seconds
      */
-    tick(dt_seconds) {
+    #on_frame(dt_seconds) {
         if (!this.#started) return;
 
-        // Restore canonical form before sim work. The executor's
-        // `before_execute` hook also covers per-action paths (e.g.
-        // packets delivered between session.tick calls).
-        this.normalize_if_dirty();
-
         const dt_ms = dt_seconds * 1000;
 
-        // Host: expire grace-window peers whose deadline has passed.
+        this.#clock_ms += dt_ms;
+
+        // the playhead moves with the clock whether or not anything is drawn from it this frame
+        this.#playout.window(this.#clock_ms);
+
         if (this.role === NetworkSessionRole.Host) {
-            this.#expire_grace_peers(performance.now());
+            // Host: expire grace-window peers whose deadline has passed.
+            this.#expire_grace_peers(this.#clock_ms);
         } else {
             // Client: drive the reconnect timer.
             this.#tick_reconnect(dt_ms);
+
+            // Time dilation: run the whole local simulation a few percent fast or slow, as the
+            // host asks, by stretching the wall time each step consumes. The step itself — and so
+            // every system's dt — is unchanged, and the render alpha stays a true fraction of it.
+            this.entity_manager.fixedStepTimeScale = 1 / this.#client.dilation_factor;
         }
 
         // Idle reaping: a connected peer that has gone silent past the timeout
-        // is reaped (host → grace, client → reconnect ladder). The clock is the
-        // deterministic tick-dt accumulator (not wall-clock), so it's testable.
+        // is reaped (host → grace, client → reconnect ladder).
         if (this.#connection_timeout_ms > 0) {
-            this.#liveness_clock_ms += dt_ms;
             this.#reap_silent_peers();
         }
-
-        this.#sim_accum_ms += dt_ms;
-        let steps = 0;
-        while (this.#sim_accum_ms >= this.tick_period_ms && steps < MAX_FIXED_STEPS_PER_TICK) {
-            this.#sim_accum_ms -= this.tick_period_ms;
-            this.#simulate_one_step();
-            steps++;
-        }
-        if (steps === MAX_FIXED_STEPS_PER_TICK) this.#sim_accum_ms = 0;
-
-        // Per-render-frame: smooth interpolated rendering of remote
-        // entities. Marks the live ECD as polluted so the next sim-tick
-        // or reconcile starts with a normalize.
-        this.#render_interpolated_entities();
     }
 
     /**
-     * Undo render-time interpolation on remote-owned components by
-     * restoring each from its latest InterpolationLog entry. Idempotent
-     * via the `render_dirty` flag — cheap when false.
+     * Put the truth back wherever a render blend is in the live components — the
+     * {@link InterpolationSystem}'s restore. Anything written over a blend since goes with it; what
+     * is written after this call stays. Idempotent and cheap when nothing is blended.
      *
-     * Called from `tick()` (top), `executor.before_execute` (per-action
-     * applies, including transport-delivered action stream), and
-     * `client.onBeforeReconcile` (before the rewind walk).
-     *
-     * @private
+     * Runs before every action the executor applies (an action captures the prior value of what it
+     * overwrites, and that must not be a blend), before a reconciliation, and at the start of every
+     * fixed step. Game code that writes a networked entity's state between steps calls it first.
+     * The name is kept from when the session owned its own blend.
      */
     normalize_if_dirty() {
-        if (!this.render_dirty) return;
         this.render_dirty = false;
-
-        if (!this.#playout.has_frames) return;
-        if (this.#remote_entities.size === 0) return;
-
-        const scratch = this.#scratch_interp_buf;
-        const tick = this.#playout.latest_frame;
-
-        for (const entity_id of this.#remote_entities) {
-            const identity = this.world.getComponent(entity_id, NetworkIdentity);
-            if (identity === undefined || identity.network_id < 0) continue;
-            for (const [ComponentClass, desc] of this.#replicated) {
-                if (desc.interp === null) continue;
-                const live = this.world.getComponent(entity_id, ComponentClass);
-                if (live === undefined) continue;
-                scratch.position = 0;
-                // tick_a === tick_b, t = 0 — degenerate "snap to single
-                // snapshot" lerp. Output equals the stored snapshot.
-                const ok = this.#interp_log.interpolate(
-                    scratch, identity.network_id, desc.interp_type_id,
-                    tick, tick, 0, desc.interp,
-                );
-                if (!ok) continue;
-                scratch.position = 0;
-                const adapter = this.binary_registry.getAdapter(ComponentClass.typeName);
-                adapter.deserialize(scratch, live);
-            }
+        if (this.#interpolation !== null) {
+            this.#interpolation.restore();
         }
     }
 
@@ -1324,13 +2070,23 @@ export class NetworkSession {
      * A client now seeks automatically on INITIAL_SYNC. This is the manual door, for a caller that
      * computes its own lead.
      *
+     * A client sends the host nothing it predicted before its last sync, and knows it by frame: its
+     * input starts at the frame the sync sought to. A caller whose own lead is shorter moves that
+     * start back with it, so what it predicts on the synced world is sent however it counts it.
+     *
      * @param {number} frame
      */
     seek_to_frame(frame) {
         assert.isNonNegativeInteger(frame, 'frame');
 
         this.#local_frame = frame;
-        this.#local_frame_accum = 0;
+
+        if (frame < this.#world_start_frame) {
+            this.#world_start_frame = frame;
+            if (this.#binding_answer !== BindingAnswer.Pending && this.#peer.is_connected(this.#remote_peer_id)) {
+                this.#peer.release_outbound(this.#remote_peer_id, frame);
+            }
+        }
     }
 
     // ----------------------------------------------------------------
@@ -1353,6 +2109,7 @@ export class NetworkSession {
         if (identity.owner_peer_id !== this.local_peer_id) {
             this.#remote_entities.add(entity_id);
         }
+        this.#interpolation_pending.add(entity_id);
         // Per-entity event listener for net_mutate_component.
         const listener = (payload) => this.#on_net_mutate_component(entity_id, payload);
         this.world.addEntityEventListener(entity_id, "net_mutate_component", listener);
@@ -1366,6 +2123,10 @@ export class NetworkSession {
             this.#event_listeners.delete(entity_id);
         }
         this.#remote_entities.delete(entity_id);
+        this.#published.delete(entity_id);
+        this.#prediction_history.forget(entity_id);
+        // take back our Interpolated at the next step or frame, if the entity outlives its identity
+        this.#interpolation_pending.add(entity_id);
     }
 
     /**
@@ -1387,7 +2148,7 @@ export class NetworkSession {
         }
         const desc = this.#replicated.get(component_type);
         if (desc === undefined) {
-            throw new Error(`net_mutate_component: ${component_type.typeName ?? component_type.name} is not replicated; call session.replicate() for it before mutating`);
+            throw new Error(`net_mutate_component: ${component_type.typeName ?? component_type.name} is not replicated; replicate it (replicate_interpolated or replicate_discrete) before mutating`);
         }
 
         const network_id = this.#peer.slot_table.network_for(entity_id);
@@ -1497,32 +2258,16 @@ export class NetworkSession {
     //  Internal: per-step simulation
     // ----------------------------------------------------------------
 
-    #simulate_one_step() {
-        if (this.role === NetworkSessionRole.Host) {
-            this.#server.tick(this.#local_frame);
-            this.#local_frame++;
-            return;
-        }
-        // Client. Dilated tick rate: each fixed step advances by
-        // `1 / dilation_factor` (capped at MAX_CLIENT_DILATED_TICKS_PER_STEP).
-        this.#local_frame_accum += 1.0 / this.#client.dilation_factor;
-        let inner = 0;
-        while (this.#local_frame_accum >= 1.0 && inner < MAX_CLIENT_DILATED_TICKS_PER_STEP) {
-            this.#local_frame_accum -= 1.0;
-            this.#client.tick(this.#local_frame);
-            this.#send_empty_ack_packet();
-            this.#local_frame++;
-            inner++;
-        }
-    }
-
     /**
-     * Empty action-stream packet to advance the channel's seq/ack
-     * baseline on ticks with no outbound actions of our own.
+     * The tick's keep-alive to the host: a frame marker, which advances the channel's seq/ack
+     * baseline like any packet and tells the host how far this client's clock has run — the depth
+     * its time dilation steers by — on ticks that carry no input as well as on ones that do.
+     *
+     * @param {number} frame the frame just simulated
      */
-    #send_empty_ack_packet() {
+    #send_frame_marker(frame) {
         for (const peer_id of this.#connected_peers) {
-            this.#peer.channel_for(peer_id).send(EMPTY_PAYLOAD, 0);
+            this.#peer.send_frame_marker(peer_id, frame);
         }
     }
 
@@ -1577,6 +2322,21 @@ export class NetworkSession {
     }
 
 
+    /**
+     * Queue `peer_id`'s INITIAL_SYNC, unless its connection has been given
+     * one already — queued, or queued and sent. These are the host's only
+     * full-world sends, so how many a connection gets is the host's decision:
+     * one, when it takes the connection for a fresh peer — as `connect()`
+     * binds it, or after refusing its claim to resume. Nothing the peer sends
+     * afterwards earns it another.
+     * @param {number} peer_id
+     */
+    #queue_initial_sync(peer_id) {
+        if (this.#initial_sync_given.has(peer_id)) return;
+        this.#initial_sync_given.add(peer_id);
+        this.#pending_initial_sync.set(peer_id, 2);
+    }
+
     /**
      * Emit a Snapshotter-format payload to a freshly-connected peer.
      * Generates and stashes a UUID v1 session token on first send,
@@ -1619,6 +2379,9 @@ export class NetworkSession {
      *
      */
     #apply_initial_sync(buffer, payload_end) {
+        // written over the truth, not over a render blend that a restore would then put back
+        this.normalize_if_dirty();
+
         const entity_count = buffer.readUintVar();
         for (let i = 0; i < entity_count; i++) {
             const network_id = buffer.readUintVar();
@@ -1644,6 +2407,8 @@ export class NetworkSession {
                     this.world.addComponentToEntity(local_entity_id, component);
                 } else {
                     adapter.deserialize(buffer, existing);
+                    adapter.announce(this.world, local_entity_id);
+                    this.#note_moved(local_entity_id);
 
                     /*
                      Re-decide what this entity is to us.
@@ -1706,6 +2471,7 @@ export class NetworkSession {
         } else {
             this.#remote_entities.add(entity_id);
         }
+        this.#interpolation_pending.add(entity_id);
     }
 
     /**
@@ -1800,7 +2566,7 @@ export class NetworkSession {
         this.#pending_initial_sync.delete(peer_id);
         this.#unwire_peer_transport_disconnect(peer_id);
         this.#peer_grace_state.set(peer_id, {
-            deadline_ms: performance.now() + this.#server_resume_grace_ms,
+            deadline_ms: this.#clock_ms + this.#server_resume_grace_ms,
             last_acked,
         });
         this.onPeerLost.send2(peer_id, reason);
@@ -1808,11 +2574,24 @@ export class NetworkSession {
 
     /**
      * Validate a RESUME_HELLO and either welcome the peer back (restore
-     * baseline + send RESUME_ACCEPT) or reject with a reason code.
-     * Rejection schedules a fresh INITIAL_SYNC so the client falls
-     * through to Tier-3.
+     * baseline + send RESUME_ACCEPT) or reject with a reason code. A claim
+     * the host cannot honour is readmitted as a fresh peer, whose
+     * INITIAL_SYNC is the Tier-3 resync; one it must not honour is kicked.
+     *
+     * Answered once per connection; see the first branch.
      */
     #on_resume_hello(transport_peer_id, claimed_peer_id, last_acked_frame, has_token, claimed_token_bytes) {
+        // A client says RESUME_HELLO at most once per connection, from
+        // `connect()`, so a second one on the same connection is a duplicated
+        // datagram — the channel passes those on — or a peer asking the host to
+        // do its work again. Every answer below costs the host something: a
+        // packet at least, a serialization of its whole world at most. What a
+        // connection gets is settled the first time it asks, and the rest are
+        // ignored: unanswered rather than kicked, since a kick would also land
+        // on a client whose one hello the network happened to deliver twice.
+        if (this.#resume_hello_answered.has(transport_peer_id)) return;
+        this.#resume_hello_answered.add(transport_peer_id);
+
         // Engine convention: the matchmaking layer routes the reconnecting
         // transport to the same `peer_id` it had before. If `claimed_peer_id`
         // disagrees with `transport_peer_id`, the matchmaker mis-routed —
@@ -1866,12 +2645,17 @@ export class NetworkSession {
         }
         const grace = this.#peer_grace_state.get(claimed_peer_id);
         if (grace === undefined) {
-            // Either the peer is fully unknown OR they're already
-            // connected (their previous transport never dropped).
-            // Either way, no resume record to validate against.
+            // No resume record to validate against. There was none when
+            // `connect()` bound this connection either — a record outlives
+            // neither grace expiry nor `drop_peer`, and both release the
+            // channel of an attempt waiting on it — so the connection was
+            // taken for a fresh peer: it is in the live set, and its
+            // INITIAL_SYNC is queued or already sent. Refuse the claim, and
+            // treat the peer as the fresh one it is; the sync it has is the
+            // resync, and `#queue_initial_sync` does not give a connection
+            // the world twice.
             this.#peer.send_resume_reject(transport_peer_id, ResumeRejectReason.UnknownPeer);
-            // Treat as a fresh peer; schedule INITIAL_SYNC.
-            this.#pending_initial_sync.set(transport_peer_id, 2);
+            this.#queue_initial_sync(transport_peer_id);
             this.#connected_peers.add(transport_peer_id);
             return;
         }
@@ -1879,7 +2663,7 @@ export class NetworkSession {
         if (expected_token === undefined) {
             this.#peer.send_resume_reject(transport_peer_id, ResumeRejectReason.UnknownPeer);
             this.#peer_grace_state.delete(claimed_peer_id);
-            this.#pending_initial_sync.set(transport_peer_id, 2);
+            this.#queue_initial_sync(transport_peer_id);
             this.#connected_peers.add(transport_peer_id);
             return;
         }
@@ -1919,7 +2703,7 @@ export class NetworkSession {
         if (last_acked_frame + 1 < ring_floor) {
             this.#peer.send_resume_reject(transport_peer_id, ResumeRejectReason.StaleFrame);
             this.#peer_grace_state.delete(claimed_peer_id);
-            this.#pending_initial_sync.set(transport_peer_id, 2);
+            this.#queue_initial_sync(transport_peer_id);
             this.#connected_peers.add(transport_peer_id);
             return;
         }
@@ -1996,18 +2780,20 @@ export class NetworkSession {
      * @private
      */
     #peer_is_silent(peer_id) {
-        const count = this.#peer.inbound_count(peer_id);
+        // what the peer has sent, whether or not the next step has applied it yet
+        const inbound = this.#inbound.get(peer_id);
+        const count = inbound !== undefined ? inbound.received_count : this.#peer.inbound_count(peer_id);
         const mark = this.#peer_inbound_mark.get(peer_id);
         if (mark === undefined) {
-            this.#peer_inbound_mark.set(peer_id, { count, since_ms: this.#liveness_clock_ms });
+            this.#peer_inbound_mark.set(peer_id, { count, since_ms: this.#clock_ms });
             return false;
         }
         if (count !== mark.count) {
             mark.count = count;
-            mark.since_ms = this.#liveness_clock_ms;
+            mark.since_ms = this.#clock_ms;
             return false;
         }
-        return this.#liveness_clock_ms - mark.since_ms >= this.#connection_timeout_ms;
+        return this.#clock_ms - mark.since_ms >= this.#connection_timeout_ms;
     }
 
     // ----------------------------------------------------------------
@@ -2041,7 +2827,7 @@ export class NetworkSession {
             // Stop treating this peer as a live send target. The channel is
             // gone, but `#remote_peer_id` is deliberately kept so the reconnect
             // ladder can re-`connect()` to the same id. Without this delete,
-            // `#send_empty_ack_packet` (driven every tick) dereferences the
+            // `#send_frame_marker` (driven every tick) dereferences the
             // now-undefined channel and throws — which would crash the very
             // tick loop that drives the reconnect ladder.
             this.#connected_peers.delete(this.#remote_peer_id);
@@ -2151,13 +2937,232 @@ export class NetworkSession {
     //  Internal: client predict-reconcile wiring
     // ----------------------------------------------------------------
 
+    /**
+     * A scratch instance of `ComponentClass`, for decoding wire bytes without touching the world.
+     * @param {Function} ComponentClass
+     * @param {number} slot 0: the host's state, 1: the prediction, 2: a later prediction
+     * @returns {object}
+     */
+    #scratch_of(ComponentClass, slot) {
+        let instances = this.#decode_scratch.get(ComponentClass);
+        if (instances === undefined) {
+            instances = [new ComponentClass(), new ComponentClass(), new ComponentClass()];
+            this.#decode_scratch.set(ComponentClass, instances);
+        }
+        return instances[slot];
+    }
+
+    /**
+     * Decode `length` bytes of `bytes` into `target` with `ComponentClass`'s replication adapter.
+     */
+    #decode_into(ComponentClass, bytes, length, target) {
+        const buffer = this.#scratch_interp_buf;
+        buffer.position = 0;
+        buffer.writeBytes(bytes, 0, length);
+        buffer.position = 0;
+        this.binary_registry.getAdapter(ComponentClass.typeName).deserialize(buffer, target);
+    }
+
+    /**
+     * AUTH_STATE, {@link NetworkSessionReconcile.Correct}: split the payload into its components'
+     * wire bytes now — the receive buffer is the peer's and is reused — and keep the newest per
+     * entity for the next step. Parsing mirrors the host's writer: every replicated component the
+     * entity carries, in `#replicated` order.
+     */
+    #queue_auth_state(server_frame, network_id, buffer) {
+        const pending = this.#pending_auth.get(network_id);
+        if (pending !== undefined && pending.frame >= server_frame) return;
+
+        const reconciled = this.#reconciled_frame.get(network_id);
+        if (reconciled !== undefined && reconciled >= server_frame) return;
+
+        const entity_id = this.#peer.slot_table.entity_for(network_id);
+        if (entity_id < 0) return;
+
+        const parts = [];
+        for (const [ComponentClass, desc] of this.#replicated) {
+            if (this.world.getComponent(entity_id, ComponentClass) === undefined) {
+                parts.push(null);
+                continue;
+            }
+            const start = buffer.position;
+            this.binary_registry.getAdapter(ComponentClass.typeName).deserialize(buffer, this.#scratch_of(ComponentClass, 0));
+            parts.push({ type_id: desc.interp_type_id, bytes: buffer.raw_bytes.slice(start, buffer.position) });
+        }
+
+        this.#pending_auth.set(network_id, { frame: server_frame, parts });
+    }
+
+    /**
+     * Client, end of step: remember what was predicted for every entity this client owns.
+     * @param {number} frame
+     */
+    #record_prediction(frame) {
+        const scratch = this.#scratch_send_buf;
+        const world = this.world;
+
+        for (const entity_id of this.#event_listeners.keys()) {
+            if (this.#remote_entities.has(entity_id)) continue;
+
+            const identity = world.getComponent(entity_id, NetworkIdentity);
+            if (identity === undefined || identity.network_id < 0) continue;
+
+            for (const [ComponentClass, desc] of this.#replicated) {
+                if (ComponentClass === NetworkIdentity) continue;
+                const live = world.getComponent(entity_id, ComponentClass);
+                if (live === undefined) continue;
+
+                scratch.position = 0;
+                this.binary_registry.getAdapter(ComponentClass.typeName).serialize(scratch, live);
+                this.#prediction_history.record(entity_id, frame, desc.interp_type_id, scratch.raw_bytes, scratch.position);
+            }
+        }
+    }
+
+    /**
+     * Client, start of step: reconcile every queued authoritative state.
+     */
+    #apply_pending_corrections() {
+        const pending_auth = this.#pending_auth;
+
+        for (const [network_id, pending] of pending_auth) {
+            const entity_id = this.#peer.slot_table.entity_for(network_id);
+            if (entity_id < 0 || this.#remote_entities.has(entity_id)) continue;
+            this.#reconciled_frame.set(network_id, pending.frame);
+            try {
+                this.#reconcile_entity(entity_id, pending.frame, pending.parts);
+            } catch (e) {
+                // one entity's failure is its own: the others are corrected, and the step opens
+                console.error(`NetworkSession: reconciling entity ${entity_id} to frame ${pending.frame} failed:`, e);
+            }
+        }
+
+        pending_auth.clear();
+    }
+
+    /**
+     * Compare the host's state of `entity_id` at `frame` with the prediction for `frame`, and where
+     * a component differs, carry the difference into the present through its {@link Correction}.
+     * See {@link NetworkSessionReconcile.Correct}.
+     *
+     * @param {number} entity_id
+     * @param {number} frame
+     * @param {Array<{type_id: number, bytes: Uint8Array}|null>} parts
+     */
+    #reconcile_entity(entity_id, frame, parts) {
+        const history = this.#prediction_history;
+        const differs = this.#differs;
+
+        // Compare first: every part must have a prediction to compare against.
+        let any = false;
+        let index = 0;
+        for (const [ComponentClass, desc] of this.#replicated) {
+            const i = index++;
+            differs[i] = false;
+
+            const part = parts[i];
+            if (part === null || desc.correction === null) continue;
+
+            const type_id = desc.interp_type_id;
+            const predicted_length = history.length(entity_id, frame, type_id);
+            if (predicted_length < 0) {
+                this.correction_skipped_count++;
+                return;
+            }
+
+            const predicted_bytes = history.bytes(entity_id, frame, type_id);
+            if (bytes_equal_lengths(part.bytes, part.bytes.length, predicted_bytes, predicted_length)) continue;
+
+            const server = this.#scratch_of(ComponentClass, 0);
+            const predicted = this.#scratch_of(ComponentClass, 1);
+            this.#decode_into(ComponentClass, part.bytes, part.bytes.length, server);
+            this.#decode_into(ComponentClass, predicted_bytes, predicted_length, predicted);
+
+            if (!desc.correction.same(server, predicted)) {
+                differs[i] = true;
+                any = true;
+            }
+        }
+
+        if (!any) return;
+
+        index = 0;
+        for (const [ComponentClass, desc] of this.#replicated) {
+            const i = index++;
+            if (!differs[i]) continue;
+
+            const live = this.world.getComponent(entity_id, ComponentClass);
+            if (live === undefined) continue;
+
+            const magnitude = this.#correct_component(entity_id, live, ComponentClass, desc, frame, parts[i].bytes);
+            this.onCorrection.send4(entity_id, frame, ComponentClass, magnitude);
+        }
+
+        this.correction_count++;
+    }
+
+    /**
+     * Carry the difference between the host's state and the prediction at `frame` into the live
+     * component and into every prediction since, through the component's correction.
+     *
+     * @returns {number} the correction's size, as the strategy measures it
+     */
+    #correct_component(entity_id, live, ComponentClass, desc, frame, server_bytes) {
+        const history = this.#prediction_history;
+        const type_id = desc.interp_type_id;
+        const correction = desc.correction;
+        const adapter = this.binary_registry.getAdapter(ComponentClass.typeName);
+
+        const server = this.#scratch_of(ComponentClass, 0);
+        const predicted = this.#scratch_of(ComponentClass, 1);
+        this.#decode_into(ComponentClass, server_bytes, server_bytes.length, server);
+        this.#decode_into(ComponentClass, history.bytes(entity_id, frame, type_id), history.length(entity_id, frame, type_id), predicted);
+
+        // the present
+        const target = this.#correction_target;
+        target.entity_manager = this.entity_manager;
+        target.entity = entity_id;
+        target.component = live;
+        target.interpolation = this.#interpolation;
+        target.adapter = adapter;
+
+        let magnitude;
+        try {
+            magnitude = correction.apply(target, server, predicted);
+        } finally {
+            target.component = null;
+            target.adapter = null;
+        }
+        adapter.announce(this.world, entity_id);
+
+        // the predictions: the host's at `frame`, and the difference carried into each since
+        history.record(entity_id, frame, type_id, server_bytes, server_bytes.length);
+
+        const state = this.#scratch_of(ComponentClass, 2);
+        const buffer = this.#scratch_send_buf;
+        const latest = this.#local_frame - 1;
+        for (let f = frame + 1; f <= latest; f++) {
+            const held_length = history.length(entity_id, f, type_id);
+            if (held_length < 0) continue;
+            this.#decode_into(ComponentClass, history.bytes(entity_id, f, type_id), held_length, state);
+            correction.carry(state, server, predicted);
+            buffer.position = 0;
+            adapter.serialize(buffer, state);
+            history.record(entity_id, f, type_id, buffer.raw_bytes, buffer.position);
+        }
+
+        return magnitude;
+    }
+
     #wire_client_predict_reconcile() {
         // Rewind doesn't go through executor.execute, so the
         // before_execute normalize hook misses it. Catch it here.
         this.#client.onBeforeReconcile.add(() => this.normalize_if_dirty());
 
-        // Predict: run the sampler, execute each action, record its
-        // bytes so the replay path can re-execute without re-sampling.
+        // Predict: run the sampler, record each action's bytes so the replay path can re-execute
+        // without re-sampling, and execute the action as those bytes say — as the host will apply
+        // it, rounding included. Executed as sampled, a field the wire rounds (a Float32 speed)
+        // would predict a little differently from the host every frame.
         this.#client.onPredict.add((frame, _input_writer) => {
             if (this.#input_sampler === null) return;
             const actions = this.#input_sampler(frame);
@@ -2171,7 +3176,10 @@ export class NetworkSession {
                 action.serialize(scratch);
                 const bytes = scratch.raw_bytes.slice(0, scratch.position);
                 recorded.push({ type_id, bytes });
-                this.#client.executor.execute(action, this.local_peer_id);
+                if (!this.#execute_recorded(type_id, bytes)) {
+                    // not a registered action: executed as it is, for the executor to say so
+                    this.#client.executor.execute(action, this.local_peer_id);
+                }
             }
             this.#sampled_actions_per_frame.set(frame, recorded);
             this.#trim_sampled_action_ledger();
@@ -2183,19 +3191,7 @@ export class NetworkSession {
             const recorded = this.#sampled_actions_per_frame.get(frame);
             if (!recorded) return;
             for (const { type_id, bytes } of recorded) {
-                const klass = this.#peer.action_registry.klass_for(type_id);
-                if (klass === undefined) continue;
-                const action = this.#peer.action_registry.acquire(klass);
-                const scratch = this.#scratch_interp_buf;
-                scratch.position = 0;
-                scratch.writeBytes(bytes, 0, bytes.length);
-                scratch.position = 0;
-                action.deserialize(scratch);
-                try {
-                    this.#client.executor.execute(action, this.local_peer_id);
-                } finally {
-                    this.#peer.action_registry.release(action);
-                }
+                this.#execute_recorded(type_id, bytes);
             }
         });
 
@@ -2209,10 +3205,36 @@ export class NetworkSession {
                 if (live === undefined) continue;
                 const adapter = this.binary_registry.getAdapter(ComponentClass.typeName);
                 adapter.deserialize(buffer, live);
+                adapter.announce(this.world, local);
             }
         });
     }
 
+    /**
+     * Execute the action `bytes` encode, as this client's own.
+     * @param {number} type_id
+     * @param {Uint8Array} bytes
+     * @returns {boolean} false when no action is registered under `type_id`
+     */
+    #execute_recorded(type_id, bytes) {
+        const klass = this.#peer.action_registry.klass_for(type_id);
+        if (klass === undefined) return false;
+
+        const action = this.#peer.action_registry.acquire(klass);
+        try {
+            const scratch = this.#scratch_interp_buf;
+            scratch.position = 0;
+            scratch.writeBytes(bytes, 0, bytes.length);
+            scratch.position = 0;
+            action.deserialize(scratch);
+            this.#client.executor.execute(action, this.local_peer_id);
+        } finally {
+            this.#peer.action_registry.release(action);
+        }
+
+        return true;
+    }
+
     #trim_sampled_action_ledger() {
         const action_log = this.#peer.action_log;
         if (action_log === undefined) return;
@@ -2223,73 +3245,241 @@ export class NetworkSession {
     }
 
     // ----------------------------------------------------------------
-    //  Internal: interpolation log + render-time sampling
+    //  Internal: interpolation — the network timeline, and each entity's role on it
     // ----------------------------------------------------------------
 
+    /**
+     * The interpolands of the replicated components that are blended, in `#replicated` order. One
+     * given to the deprecated {@link replicate} as a bare blend is built here, recorded in the
+     * component's replication layout under its replication type id.
+     *
+     * @returns {Interpoland[]}
+     */
+    #build_interpolands() {
+        const out = [];
+        const taken = new Map();
+
+        for (const [ComponentClass, desc] of this.#replicated) {
+            if (desc.interpoland === null && desc.interpolator !== null) {
+                desc.interpoland = new Interpoland(
+                    desc.interp_type_id,
+                    ComponentClass,
+                    this.binary_registry.getAdapter(ComponentClass.typeName),
+                    desc.interpolator,
+                );
+            }
+
+            const interpoland = desc.interpoland;
+            if (interpoland === null) continue;
+
+            const other = taken.get(interpoland.type_id);
+            if (other !== undefined) {
+                throw new Error(
+                    `NetworkSession.start: ${ComponentClass.typeName ?? ComponentClass.name} and ${other.typeName ?? other.name} are interpolated ` +
+                    `under the same interpoland type_id ${interpoland.type_id}; their records would be read for each other. Give each its own.`,
+                );
+            }
+            taken.set(interpoland.type_id, ComponentClass);
+
+            out.push(interpoland);
+        }
+
+        return out;
+    }
+
+    /**
+     * The network moved `entity_id` somewhere its own simulation did not take it — a resync. On
+     * the local timeline, show it there at once rather than blend across the gap. (An entity on
+     * the network playout is drawn from the playout's own history, which the move does not touch.)
+     * @param {number} entity_id
+     */
+    #note_moved(entity_id) {
+        const interpolated = this.world.getComponent(entity_id, Interpolated);
+        if (interpolated !== undefined && interpolated.sourceId === INTERPOLATION_SOURCE_LOCAL) {
+            interpolated.snap = true;
+        }
+    }
+
+    /**
+     * Bring every queued entity's {@link Interpolated} in line with what the entity is to this
+     * session. Entities that cannot be decided yet (no network id, or not yet carrying what they
+     * interpolate) stay queued.
+     */
+    #apply_pending_interpolation() {
+        const pending = this.#interpolation_pending;
+
+        if (pending.size === 0 || this.#interpolation === null) {
+            return;
+        }
+
+        for (const entity_id of pending) {
+            if (this.#assign_interpolation(entity_id)) {
+                pending.delete(entity_id);
+            }
+        }
+    }
+
+    /**
+     * The role decides the timeline. The host simulates every entity, and a client simulates the
+     * ones it owns (it predicts them): those are blended on the local fixed-step timeline, keyed by
+     * entity. Everything else on a client is written by the network and blended on the network
+     * playout, keyed by `network_id`.
+     *
+     * An `Interpolated` the game attached itself is adapted rather than replaced: it keeps any
+     * interpoland of its own for a component the session does not interpolate, and hands the ones
+     * the session does over to the session's (two interpolands on one component would each take
+     * the other's blend for the truth).
+     *
+     * @param {number} entity_id
+     * @returns {boolean} true when the entity is settled and can leave the queue
+     */
+    #assign_interpolation(entity_id) {
+        const world = this.world;
+
+        if (!world.entityExists(entity_id)) {
+            this.#attached_interpolated.delete(entity_id);
+            return true;
+        }
+
+        const identity = world.getComponent(entity_id, NetworkIdentity);
+
+        if (identity === undefined || identity === null) {
+            // no longer networked: take back what we attached
+            const ours = this.#attached_interpolated.get(entity_id);
+            if (ours !== undefined) {
+                this.#attached_interpolated.delete(entity_id);
+                if (world.getComponent(entity_id, Interpolated) === ours) {
+                    world.removeComponentFromEntity(entity_id, Interpolated);
+                }
+            }
+            return true;
+        }
+
+        if (identity.network_id < 0) {
+            return false; // not allocated yet
+        }
+
+        // `#remote_entities` means "not owned here" on either role, but only a client plays anything
+        // out from the network: the host simulates every entity, the ones its clients own included.
+        const remote = this.role === NetworkSessionRole.Client && this.#remote_entities.has(entity_id);
+
+        const session_interpolands = this.#interpolands;
+
+        if (session_interpolands.length === 0) {
+            return true;
+        }
+
+        let carries_any = false;
+        for (let i = 0; i < session_interpolands.length; i++) {
+            if (world.getComponent(entity_id, session_interpolands[i].component_class) !== undefined) {
+                carries_any = true;
+                break;
+            }
+        }
+        if (!carries_any) {
+            return false; // e.g. an initial sync that has attached the identity but not the transform yet
+        }
+
+        const source_id = remote ? this.#interp_source_id : INTERPOLATION_SOURCE_LOCAL;
+
+        const key = remote ? identity.network_id : entity_id;
+
+        let interpolated = world.getComponent(entity_id, Interpolated);
+
+        if (interpolated === undefined) {
+            interpolated = new Interpolated();
+            interpolated.interpolands = session_interpolands.slice();
+            interpolated.sourceId = source_id;
+            interpolated.key = key;
+            world.addComponentToEntity(entity_id, interpolated);
+            this.#attached_interpolated.set(entity_id, interpolated);
+            return true;
+        }
+
+        if (interpolated.sourceId === source_id && interpolated.key === key
+            && session_interpolands.every(ip => interpolated.interpolands.includes(ip))) {
+            return true; // already in line
+        }
+
+        // Only ever called as a step opens, when no render blend is in the live components, so the
+        // interpolands can be swapped without one being left behind as the truth.
+        const kept = interpolated.interpolands.filter(
+            ip => !session_interpolands.some(own => own.component_class === ip.component_class)
+        );
+        interpolated.interpolands = kept.concat(session_interpolands);
+        interpolated.sourceId = source_id;
+        interpolated.key = key;
+
+        return true;
+    }
+
     /**
      * Record post-apply state for every remote-owned entity into the
-     * interpolation log. Locally-owned entities are predicted, not
-     * interpolated, so they're skipped.
+     * network timeline. Locally-owned entities are predicted, not
+     * interpolated from the network, so they're skipped.
      *
      * Doesn't fire on the host — the replicator's deferral path doesn't
      * emit `onFrameApplied`, so the host gets no recording naturally.
      */
     #on_frame_applied(_peer_id, frame_number) {
-        this.#interp_log.begin_tick(frame_number);
+        const log = this.#interp_log;
+        const interpolands = this.#interpolands;
+
+        log.begin_tick(frame_number);
         for (const entity_id of this.#remote_entities) {
             const identity = this.world.getComponent(entity_id, NetworkIdentity);
             if (identity === undefined || identity.network_id < 0) continue;
-            for (const [ComponentClass, desc] of this.#replicated) {
-                if (desc.interp === null) continue;
-                const live = this.world.getComponent(entity_id, ComponentClass);
+            for (let i = 0; i < interpolands.length; i++) {
+                const interpoland = interpolands[i];
+                const live = this.world.getComponent(entity_id, interpoland.component_class);
                 if (live === undefined) continue;
-                const adapter = this.binary_registry.getAdapter(ComponentClass.typeName);
-                const rec_buf = this.#interp_log.begin_record(identity.network_id, desc.interp_type_id);
-                adapter.serialize(rec_buf, live);
-                this.#interp_log.end_record();
+                const buffer = log.begin_record(identity.network_id, interpoland.type_id);
+                interpoland.serialization_adapter.serialize(buffer, live);
+                log.end_record();
             }
         }
-        this.#interp_log.end_tick();
+        log.end_tick();
+
+        // hold the whole render delay's worth of frames, however many entities a frame carries
+        log.ensure_ticks(PLAYOUT_HISTORY_FRAMES);
 
-        this.#playout.record_arrival(performance.now(), frame_number);
+        this.#playout.record_arrival(this.#clock_ms, frame_number);
     }
 
     /**
-     * Advance the smooth_render_frame state machine and write
-     * interpolated bytes into each remote-owned entity's live
-     * components. Sets `render_dirty` if anything was written.
+     * The network timeline's window for this render frame.
      *
-     * Host early-returns naturally (no `#latest_received_frame`
-     * recorded — deferred-apply path doesn't fire `onFrameApplied`).
+     * A frame reaches the log only if it carried actions for this peer, and a frame that carried
+     * none is one in which nothing replicated changed. So the value at a frame the log does not
+     * hold is the value at the last one before it that it does: blend from that frame, and to the
+     * next frame if it is held, otherwise hold still. Blending only between adjacent frames instead
+     * would treat an unchanged frame as unknown and show the newest state early, then hold.
+     *
+     * @returns {{tick_a:number, tick_b:number, t:number}}
      */
-    #render_interpolated_entities() {
-        if (!this.#playout.has_frames) return;
-        if (this.#remote_entities.size === 0) return;
+    #sample_playout() {
+        const w = this.#playout.window(this.#clock_ms);
+        const out = this.#playout_window;
+        const log = this.#interp_log;
 
-        const { tick_a, tick_b, t } = this.#playout.window(performance.now());
+        const a = log.latest_tick_at_or_before(w.tick_a);
 
-        const scratch = this.#scratch_interp_buf;
-        let wrote_anything = false;
-        for (const entity_id of this.#remote_entities) {
-            const identity = this.world.getComponent(entity_id, NetworkIdentity);
-            if (identity === undefined || identity.network_id < 0) continue;
-            for (const [ComponentClass, desc] of this.#replicated) {
-                if (desc.interp === null) continue; // snap mode
-                const live = this.world.getComponent(entity_id, ComponentClass);
-                if (live === undefined) continue;
-                scratch.position = 0;
-                const ok = this.#interp_log.interpolate(
-                    scratch, identity.network_id, desc.interp_type_id,
-                    tick_a, tick_b, t, desc.interp,
-                );
-                if (!ok) continue;
-                scratch.position = 0;
-                const adapter = this.binary_registry.getAdapter(ComponentClass.typeName);
-                adapter.deserialize(scratch, live);
-                wrote_anything = true;
-            }
+        if (a < 0) {
+            // The playhead is before anything the log holds — the playout has not started, or it
+            // starts before the first frame this client received (a late join). Hold on the
+            // earliest frame held: it is what the playhead reaches first, so nothing jumps back.
+            const oldest = log.oldest_tick();
+            out.tick_a = oldest;
+            out.tick_b = oldest;
+            out.t = 0;
+            return out;
         }
-        if (wrote_anything) this.render_dirty = true;
+
+        out.tick_a = a;
+        out.tick_b = log.has_tick(w.tick_b) ? w.tick_b : a;
+        out.t = w.t;
+
+        return out;
     }
 
     // ----------------------------------------------------------------