@woosh/meep-engine 3.64.1 → 3.65.0

package/src/engine/network/NetworkSession.js

@@ -262,6 +262,66 @@ function bytes_equal_lengths(a, a_length, b, b_length) {
     return a_length === b_length && bytes_equal(a, b, a_length);
 }
 
+/**
+ * One entity's newest authoritative state, waiting for the next step to be compared with what the
+ * client predicted. Kept per network id and written over by each state that arrives: its arrays are
+ * reused, so taking a state in allocates nothing once they have grown to the entity's components.
+ */
+class PendingAuthState {
+    /**
+     * The host's frame the state is of; -1 while none is waiting.
+     * @type {number}
+     */
+    frame = -1;
+
+    /**
+     * Per replicated component, in the session's replication order: how many bytes of
+     * {@link bytes} are its state, -1 where the entity lacks the component.
+     * @type {number[]}
+     */
+    lengths = [];
+
+    /**
+     * Per replicated component: its wire bytes, the first `lengths[i]` of the array. An array is at
+     * least as long as the state it holds and usually longer; null until the component first arrives.
+     * @type {Array<Uint8Array|null>}
+     */
+    bytes = [];
+
+    /**
+     * @param {number} component_count how many components the session replicates
+     */
+    constructor(component_count) {
+        for (let i = 0; i < component_count; i++) {
+            this.lengths.push(-1);
+            this.bytes.push(null);
+        }
+    }
+
+    /**
+     * Take `length` bytes of `source`, from `offset`, as component `index`'s state.
+     *
+     * @param {number} index
+     * @param {Uint8Array} source
+     * @param {number} offset
+     * @param {number} length
+     */
+    write(index, source, offset, length) {
+        let target = this.bytes[index];
+
+        if (target === null || target.length < length) {
+            target = new Uint8Array(Math.max(length, 32));
+            this.bytes[index] = target;
+        }
+
+        for (let i = 0; i < length; i++) {
+            target[i] = source[offset + i];
+        }
+
+        this.lengths[index] = length;
+    }
+}
+
 /**
  * High-level networking facade. Wraps the orchestrator + state machinery
  * into one config + lifecycle surface. The lower-level orchestrators
@@ -333,6 +393,53 @@ export class NetworkSession {
      */
     #replicated = new Map();
 
+    /**
+     * {@link #replicated}'s classes, in its order, set at `start()`. What runs per entity per tick
+     * walks this by index, with {@link #replicated_descs}: walking the Map's entries builds a
+     * `[key, value]` array for each one.
+     * @private @type {Function[]}
+     */
+    #replicated_classes = [];
+
+    /**
+     * {@link #replicated}'s descriptors, in its order: `#replicated_descs[i]` is
+     * `#replicated_classes[i]`'s.
+     * @private @type {Array<{interp_type_id: number, interpoland: Interpoland|null, interpolator: BinaryInterpolationAdapter|null, correction: Correction|null}>}
+     */
+    #replicated_descs = [];
+
+    /**
+     * Host: the entity whose state {@link #write_auth_state} writes.
+     * @private @type {number}
+     */
+    #auth_state_entity = -1;
+
+    /**
+     * Host: writes every replicated component {@link #auth_state_entity} carries, in
+     * `#replicated` order. One writer for the session, not one per send.
+     * @private @type {function(BinaryBuffer): void}
+     */
+    #write_auth_state = (buffer) => {
+        // read once: an adapter that sends an AUTH_STATE of its own would change it under the walk
+        const entity_id = this.#auth_state_entity;
+
+        const classes = this.#replicated_classes;
+        const world = this.world;
+        const registry = this.binary_registry;
+
+        for (let i = 0; i < classes.length; i++) {
+            const ComponentClass = classes[i];
+
+            const live = world.getComponent(entity_id, ComponentClass);
+
+            if (live === undefined) {
+                continue;
+            }
+
+            registry.getAdapter(ComponentClass.typeName).serialize(buffer, live);
+        }
+    };
+
     /**
      * Type_id → ComponentClass for the synthetic ReplaceComponentAction.
      * @private @type {Function[]}
@@ -478,12 +585,37 @@ export class NetworkSession {
     #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>}>}
+     * Per network id that has been sent an authoritative state: the newest one, waiting for the
+     * next step while its `frame` is not -1. An entry is kept once made and written over by the
+     * next state for its id; what is waiting is {@link #pending_auth_queue}.
+     * @private @type {Map<number, PendingAuthState>}
      */
     #pending_auth = new Map();
 
+    /**
+     * The authoritative states waiting for the next step, in the order their ids first arrived:
+     * the first {@link #pending_auth_count} entries. Parallel to {@link #pending_auth_ids}.
+     * @private @type {PendingAuthState[]}
+     */
+    #pending_auth_queue = [];
+
+    /**
+     * The network id of each state in {@link #pending_auth_queue}.
+     * @private @type {number[]}
+     */
+    #pending_auth_ids = [];
+
+    /** @private @type {number} */
+    #pending_auth_count = 0;
+
+    /**
+     * What an arriving authoritative state is split into. Once the whole state has been read, its
+     * arrays change places with those of the entry for its network id, so a state that fails to
+     * decode part-way leaves the one waiting before it as it was.
+     * @private @type {PendingAuthState|null}
+     */
+    #pending_auth_scratch = null;
+
     /**
      * 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
@@ -573,12 +705,60 @@ export class NetworkSession {
     #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
-     * wrong results; replay reads from here instead.
-     * @private @type {Map<number, Array<{type_id: number, bytes: Uint8Array}>>}
+     * Client: the actions the sampler returned for the frame being predicted, from the sampler's
+     * return until {@link #record_and_predict} has gone through them.
+     * @private @type {Iterable<SimAction>|null}
+     */
+    #sampled_actions = null;
+
+    /**
+     * Client: the input writer of a predicted frame. Each sampled action of a registered class is
+     * written to the frame's slot of the client's input ring — `uint8 type_id, uint32 length`, then
+     * its `length` serialized bytes — and executed 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.
+     *
+     * The input ring is the sampled-action ledger: the sampler reads live input, so a replay cannot
+     * call it again, and reads the frame's actions back from here ({@link #replay_recorded}). The
+     * ring holds as many frames as a replay can reach, and is cleared with the timeline.
+     *
+     * If an action throws, the frame's input is not committed and reads as empty: a replay of the
+     * frame executes none of its actions.
+     * @private @type {function(BinaryBuffer): void}
      */
-    #sampled_actions_per_frame = new Map();
+    #record_and_predict = (buffer) => {
+        const registry = this.#peer.action_registry;
+
+        for (const action of this.#sampled_actions) {
+            if (!action || action.isSimAction !== true) continue;
+
+            const type_id = action.constructor.type_id;
+
+            if (registry.klass_for(type_id) === undefined) {
+                // not a registered action: executed as it is, for the executor to say so, and not
+                // recorded, since no replay could decode it
+                this.#client.executor.execute(action, this.local_peer_id);
+                continue;
+            }
+
+            buffer.writeUint8(type_id);
+
+            // 4 bytes reserved for the length, patched once the action is written
+            const length_position = buffer.position;
+            buffer.writeUint32(0);
+
+            const start = buffer.position;
+            action.serialize(buffer);
+            const end = buffer.position;
+
+            buffer.position = length_position;
+            buffer.writeUint32(end - start);
+            buffer.position = end;
+
+            // raw_bytes read after the write: growing the buffer replaces it
+            this.#execute_recorded(type_id, buffer.raw_bytes, start, end - start);
+        }
+    };
 
     /** @private @type {boolean} */
     #started = false;
@@ -977,7 +1157,8 @@ export class NetworkSession {
             initial_delay_frames: DEFAULT_INITIAL_RENDER_DELAY_FRAMES,
             history_size: 60,
             safety_multiplier: 2.0,
-            decay_per_sample_ms: 1.0,
+            // the playout catches up with a calming link no faster than the clock is steered
+            decay_rate: this.#time_dilation.max_dilation,
         });
         this.#playout = new RenderPlayout({ tick_period_ms: this.tick_period_ms, delay: this.#adaptive_render_delay });
 
@@ -1234,6 +1415,9 @@ export class NetworkSession {
             }
         }
 
+        this.#replicated_classes = Array.from(this.#replicated.keys());
+        this.#replicated_descs = Array.from(this.#replicated.values());
+
         this.#interpolands = this.#build_interpolands();
 
         // Build the synthetic ReplaceComponentAction now so it's in the
@@ -1277,6 +1461,8 @@ export class NetworkSession {
             // Only Replay rewinds, so only Replay needs a late host record put back in its frame.
             this.#client = new ServerAuthoritativeClient({
                 ...orchestrator_opts,
+                // the sampled-action ledger: every frame a replay can reach, the present included
+                input_ring_capacity: this.frame_capacity + 1,
                 time_dilation: this.#time_dilation,
                 auto_reconcile: this.#reconcile === NetworkSessionReconcile.Replay,
                 rebase_on_arrival: this.#reconcile === NetworkSessionReconcile.Replay,
@@ -1383,6 +1569,10 @@ export class NetworkSession {
             });
             this.#peer.onTimeDilationFeedback.add((_peer_id, depth, frame_number) => {
                 if (frame_number > this.#host_frame_seen) this.#host_frame_seen = frame_number;
+                // The host sends nothing of a frame in which nothing replicated changed, and names
+                // its frame every tick regardless: this is what keeps the playhead its delay behind
+                // the host through a pause, so what moves next is drawn that much later and no more.
+                this.#playout.advance_head(frame_number);
                 this.#host_depth_seen = depth;
                 this.#host_marker_seen = frame_number + depth;
             });
@@ -1418,7 +1608,7 @@ export class NetworkSession {
                 if (this.#reconnect_policy.accept_state_resync) {
                     // Tier-3: drop unconfirmed predictions and wait for
                     // the host to deliver a fresh INITIAL_SYNC.
-                    this.#sampled_actions_per_frame.clear();
+                    this.#client.input_ring.clear();
                     this.session_token = null;
                     this.#reconnect_state = ReconnectState.Resyncing;
                     // Restart the elapsed-ms budget so the Resyncing
@@ -1729,7 +1919,7 @@ export class NetworkSession {
         }
         this.#attached_interpolated.clear();
         this.#interpolation_pending.clear();
-        this.#pending_auth.clear();
+        this.#forget_pending_auth();
         this.#reconciled_frame.clear();
         this.#prediction_history.clear();
 
@@ -1744,7 +1934,6 @@ export class NetworkSession {
         this.#remote_entities.clear();
         this.#owned_by.clear();
         this.#owner_of.clear();
-        this.#sampled_actions_per_frame.clear();
         this.#peer_inbound_mark.clear();
         for (const transport of this.#inbound.values()) {
             transport.release();
@@ -1804,7 +1993,7 @@ export class NetworkSession {
 
         this.#apply_pending_interpolation();
 
-        if (this.#client !== null && this.#pending_auth.size > 0) {
+        if (this.#client !== null && this.#pending_auth_count > 0) {
             this.#apply_pending_corrections();
         }
 
@@ -1853,7 +2042,12 @@ export class NetworkSession {
      * transports of peers no longer connected.
      */
     #flush_inbound() {
-        for (const [peer_id, transport] of this.#inbound) {
+        const inbound = this.#inbound;
+
+        // keys, then a lookup: the Map's entries would each be a [key, value] array, every step
+        for (const peer_id of inbound.keys()) {
+            const transport = inbound.get(peer_id);
+
             if (!this.#peer.is_connected(peer_id)) {
                 transport.release();
                 this.#inbound.delete(peer_id);
@@ -2473,6 +2667,10 @@ export class NetworkSession {
         this.#inbound_release_peer = -1;
         if (!this.#peer.is_connected(peer_id)) return;
         this.#peer.release_inbound(peer_id);
+        // What was held was applied in one go, and none of it was late: the wait was this
+        // binding's own. The playout starts here, as a new stream's, from where the host is.
+        this.#playout.reset();
+        this.#playout.advance_head(this.#host_frame_seen);
         if (this.#inbound_release_syncs) {
             this.#inbound_release_syncs = false;
             this.onSynced.send0();
@@ -2507,9 +2705,9 @@ export class NetworkSession {
      */
     #forget_predicted_world() {
         this.#prediction_history.clear();
-        this.#pending_auth.clear();
+        this.#forget_pending_auth();
         this.#reconciled_frame.clear();
-        this.#sampled_actions_per_frame.clear();
+        // the sampled input goes with the timeline
         this.#client.forget_timeline();
     }
 
@@ -2743,24 +2941,9 @@ export class NetworkSession {
             return;
         }
 
-        this.#peer.send_auth_state(peer_id, sim_frame, network_id, (buf) => {
-
-            // Concatenate all replicated components in #replicated order.
-            for (const [ComponentClass, desc] of this.#replicated) {
-
-                const live = this.world.getComponent(entity_id, ComponentClass);
+        this.#auth_state_entity = entity_id;
 
-                if (live === undefined) {
-                    continue;
-                }
-
-                const adapter = this.binary_registry.getAdapter(ComponentClass.typeName);
-
-                adapter.serialize(buf, live);
-
-            }
-
-        });
+        this.#peer.send_auth_state(peer_id, sim_frame, network_id, this.#write_auth_state);
     }
 
     // ----------------------------------------------------------------
@@ -3288,7 +3471,8 @@ export class NetworkSession {
      * entity carries, in `#replicated` order.
      */
     #queue_auth_state(server_frame, network_id, buffer) {
-        const pending = this.#pending_auth.get(network_id);
+        let pending = this.#pending_auth.get(network_id);
+        // a newer frame than the one waiting, or none is: -1 is below every frame
         if (pending !== undefined && pending.frame >= server_frame) return;
 
         const reconciled = this.#reconciled_frame.get(network_id);
@@ -3297,18 +3481,65 @@ export class NetworkSession {
         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) {
+        const classes = this.#replicated_classes;
+
+        let scratch = this.#pending_auth_scratch;
+
+        if (scratch === null) {
+            scratch = new PendingAuthState(classes.length);
+            this.#pending_auth_scratch = scratch;
+        }
+
+        for (let i = 0; i < classes.length; i++) {
+            const ComponentClass = classes[i];
+
             if (this.world.getComponent(entity_id, ComponentClass) === undefined) {
-                parts.push(null);
+                scratch.lengths[i] = -1;
                 continue;
             }
+
+            // decoded only to find where the component's bytes end
             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) });
+
+            scratch.write(i, buffer.raw_bytes, start, buffer.position - start);
+        }
+
+        // read whole: it is the newest state for its id
+
+        if (pending === undefined) {
+            pending = new PendingAuthState(classes.length);
+            this.#pending_auth.set(network_id, pending);
         }
 
-        this.#pending_auth.set(network_id, { frame: server_frame, parts });
+        if (pending.frame < 0) {
+            // not waiting yet: it joins the queue, behind the ids that arrived before it
+            const index = this.#pending_auth_count++;
+
+            this.#pending_auth_queue[index] = pending;
+            this.#pending_auth_ids[index] = network_id;
+        }
+
+        pending.frame = server_frame;
+
+        // the entry takes what was read, and its own arrays are what the next state is read into
+        const lengths = pending.lengths;
+        pending.lengths = scratch.lengths;
+        scratch.lengths = lengths;
+
+        const bytes = pending.bytes;
+        pending.bytes = scratch.bytes;
+        scratch.bytes = bytes;
+    }
+
+    /**
+     * Drop every authoritative state, waiting or not.
+     */
+    #forget_pending_auth() {
+        this.#pending_auth.clear();
+        this.#pending_auth_queue.length = 0;
+        this.#pending_auth_ids.length = 0;
+        this.#pending_auth_count = 0;
     }
 
     /**
@@ -3322,11 +3553,17 @@ export class NetworkSession {
         const owned = this.#owned_by.get(this.local_peer_id);
         if (owned === undefined) return;
 
+        const classes = this.#replicated_classes;
+        const descs = this.#replicated_descs;
+
         for (const entity_id of owned) {
             const identity = world.getComponent(entity_id, NetworkIdentity);
             if (identity === undefined || identity.network_id < 0) continue;
 
-            for (const [ComponentClass, desc] of this.#replicated) {
+            for (let i = 0; i < classes.length; i++) {
+                const ComponentClass = classes[i];
+                const desc = descs[i];
+
                 if (ComponentClass === NetworkIdentity) continue;
                 const live = world.getComponent(entity_id, ComponentClass);
                 if (live === undefined) continue;
@@ -3342,21 +3579,32 @@ export class NetworkSession {
      * Client, start of step: reconcile every queued authoritative state.
      */
     #apply_pending_corrections() {
-        const pending_auth = this.#pending_auth;
+        const queue = this.#pending_auth_queue;
+        const ids = this.#pending_auth_ids;
+
+        // the count is read each time round: a state that arrives while one is reconciled is
+        // reconciled in this step too
+        for (let i = 0; i < this.#pending_auth_count; i++) {
+            const pending = queue[i];
+            const network_id = ids[i];
+
+            const frame = pending.frame;
+
+            // no longer waiting, whatever comes of it
+            pending.frame = -1;
 
-        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);
+            this.#reconciled_frame.set(network_id, frame);
             try {
-                this.#reconcile_entity(entity_id, pending.frame, pending.parts);
+                this.#reconcile_entity(entity_id, frame, pending);
             } 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);
+                console.error(`NetworkSession: reconciling entity ${entity_id} to frame ${frame} failed:`, e);
             }
         }
 
-        pending_auth.clear();
+        this.#pending_auth_count = 0;
     }
 
     /**
@@ -3366,21 +3614,27 @@ export class NetworkSession {
      *
      * @param {number} entity_id
      * @param {number} frame
-     * @param {Array<{type_id: number, bytes: Uint8Array}|null>} parts
+     * @param {PendingAuthState} state the host's state of the entity at `frame`
      */
-    #reconcile_entity(entity_id, frame, parts) {
+    #reconcile_entity(entity_id, frame, state) {
         const history = this.#prediction_history;
         const differs = this.#differs;
 
         // Compare first: every part must have a prediction to compare against.
+        const classes = this.#replicated_classes;
+        const descs = this.#replicated_descs;
+
         let any = false;
-        let index = 0;
-        for (const [ComponentClass, desc] of this.#replicated) {
-            const i = index++;
+        for (let i = 0; i < classes.length; i++) {
+            const ComponentClass = classes[i];
+            const desc = descs[i];
+
             differs[i] = false;
 
-            const part = parts[i];
-            if (part === null || desc.correction === null) continue;
+            const server_length = state.lengths[i];
+            if (server_length < 0 || desc.correction === null) continue;
+
+            const server_bytes = state.bytes[i];
 
             const type_id = desc.interp_type_id;
             const predicted_length = history.length(entity_id, frame, type_id);
@@ -3390,11 +3644,11 @@ export class NetworkSession {
             }
 
             const predicted_bytes = history.bytes(entity_id, frame, type_id);
-            if (bytes_equal_lengths(part.bytes, part.bytes.length, predicted_bytes, predicted_length)) continue;
+            if (bytes_equal_lengths(server_bytes, server_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, server_bytes, server_length, server);
             this.#decode_into(ComponentClass, predicted_bytes, predicted_length, predicted);
 
             if (!desc.correction.same(server, predicted)) {
@@ -3405,15 +3659,16 @@ export class NetworkSession {
 
         if (!any) return;
 
-        index = 0;
-        for (const [ComponentClass, desc] of this.#replicated) {
-            const i = index++;
+        for (let i = 0; i < classes.length; i++) {
             if (!differs[i]) continue;
 
+            const ComponentClass = classes[i];
+            const desc = descs[i];
+
             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);
+            const magnitude = this.#correct_component(entity_id, live, ComponentClass, desc, frame, state.bytes[i], state.lengths[i]);
             this.onCorrection.send4(entity_id, frame, ComponentClass, magnitude);
         }
 
@@ -3424,9 +3679,16 @@ export class NetworkSession {
      * 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.
      *
+     * @param {number} entity_id
+     * @param {object} live the entity's live component
+     * @param {Function} ComponentClass
+     * @param {{interp_type_id: number, correction: Correction}} desc
+     * @param {number} frame
+     * @param {Uint8Array} server_bytes the host's state of the component at `frame`
+     * @param {number} server_length how many of `server_bytes` are that state
      * @returns {number} the correction's size, as the strategy measures it
      */
-    #correct_component(entity_id, live, ComponentClass, desc, frame, server_bytes) {
+    #correct_component(entity_id, live, ComponentClass, desc, frame, server_bytes, server_length) {
         const history = this.#prediction_history;
         const type_id = desc.interp_type_id;
         const correction = desc.correction;
@@ -3434,7 +3696,7 @@ export class NetworkSession {
 
         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, server_bytes, server_length, server);
         this.#decode_into(ComponentClass, history.bytes(entity_id, frame, type_id), history.length(entity_id, frame, type_id), predicted);
 
         // the present
@@ -3455,7 +3717,7 @@ export class NetworkSession {
         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);
+        history.record(entity_id, frame, type_id, server_bytes, server_length);
 
         const state = this.#scratch_of(ComponentClass, 2);
         const buffer = this.#scratch_send_buf;
@@ -3478,40 +3740,26 @@ export class NetworkSession {
         // before_execute normalize hook misses it. Catch it here.
         this.#client.onBeforeReconcile.add(() => this.normalize_if_dirty());
 
-        // 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) => {
+        // Predict: run the sampler, and record and execute what it returns as the frame's input.
+        this.#client.onPredict.add((frame, input_writer) => {
             if (this.#input_sampler === null) return;
             const actions = this.#input_sampler(frame);
             if (!actions) return;
-            const recorded = [];
-            for (const action of actions) {
-                if (!action || action.isSimAction !== true) continue;
-                const type_id = action.constructor.type_id;
-                const scratch = this.#scratch_send_buf;
-                scratch.position = 0;
-                action.serialize(scratch);
-                const bytes = scratch.raw_bytes.slice(0, scratch.position);
-                recorded.push({ type_id, bytes });
-                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 = actions;
+            try {
+                input_writer(this.#record_and_predict);
+            } finally {
+                this.#sampled_actions = null;
             }
-            this.#sampled_actions_per_frame.set(frame, recorded);
-            this.#trim_sampled_action_ledger();
         });
 
-        // Replay: re-execute recorded actions from the ledger. Sampler is
+        // Replay: re-execute the frame's recorded actions. Sampler is
         // NOT called again — live input has moved on.
-        this.#client.onReplay.add((frame, _input_reader) => {
-            const recorded = this.#sampled_actions_per_frame.get(frame);
-            if (!recorded) return;
-            for (const { type_id, bytes } of recorded) {
-                this.#execute_recorded(type_id, bytes);
-            }
+        this.#client.onReplay.add((frame, input_reader) => {
+            if (input_reader === null) return;
+
+            this.#replay_recorded(input_reader, this.#client.input_ring.write_end_for(frame));
         });
 
         // Apply auth state: deserialize concatenated replicated-component
@@ -3519,7 +3767,11 @@ export class NetworkSession {
         this.#client.onApplyAuthState.add((_server_frame, network_id, buffer) => {
             const local = this.#client.slot_table.entity_for(network_id);
             if (local < 0) return;
-            for (const [ComponentClass] of this.#replicated) {
+            const classes = this.#replicated_classes;
+
+            for (let i = 0; i < classes.length; i++) {
+                const ComponentClass = classes[i];
+
                 const live = this.world.getComponent(local, ComponentClass);
                 if (live === undefined) continue;
                 const adapter = this.binary_registry.getAdapter(ComponentClass.typeName);
@@ -3530,36 +3782,46 @@ export class NetworkSession {
     }
 
     /**
-     * Execute the action `bytes` encode, as this client's own.
-     * @param {number} type_id
+     * Execute every action recorded in the first `end` bytes of `input`, a frame's slot of the
+     * client's input ring as {@link #record_and_predict} wrote it, in the order they were recorded.
+     *
+     * @param {BinaryBuffer} input positioned at the frame's first record
+     * @param {number} end how many bytes the frame holds
+     */
+    #replay_recorded(input, end) {
+        while (input.position < end) {
+            const type_id = input.readUint8();
+            const length = input.readUint32();
+            const start = input.position;
+
+            this.#execute_recorded(type_id, input.raw_bytes, start, length);
+
+            input.position = start + length;
+        }
+    }
+
+    /**
+     * Execute the action that `length` bytes of `bytes`, from `offset`, encode, as this client's
+     * own. The action is decoded from a copy, so a decoder cannot write over what was recorded.
+     *
+     * @param {number} type_id a registered action's
      * @param {Uint8Array} bytes
-     * @returns {boolean} false when no action is registered under `type_id`
+     * @param {number} offset
+     * @param {number} length
      */
-    #execute_recorded(type_id, bytes) {
-        const klass = this.#peer.action_registry.klass_for(type_id);
-        if (klass === undefined) return false;
+    #execute_recorded(type_id, bytes, offset, length) {
+        const registry = this.#peer.action_registry;
 
-        const action = this.#peer.action_registry.acquire(klass);
+        const action = registry.acquire(registry.klass_for(type_id));
         try {
             const scratch = this.#scratch_interp_buf;
             scratch.position = 0;
-            scratch.writeBytes(bytes, 0, bytes.length);
+            scratch.writeBytes(bytes, offset, 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;
-        const oldest_keep = Math.max(0, this.#local_frame - action_log.frame_capacity);
-        for (const f of this.#sampled_actions_per_frame.keys()) {
-            if (f < oldest_keep) this.#sampled_actions_per_frame.delete(f);
+            registry.release(action);
         }
     }