@woosh/meep-engine 3.60.9 → 3.61.1

package/src/engine/network/orchestrator/ServerAuthoritativeClient.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+import { PairUint32Map } from "../../../core/collection/PairUint32Map.js";
 import { Uint32Map } from "../../../core/collection/Uint32Map.js";
 import Signal from "../../../core/events/signal/Signal.js";
 import { AlwaysRelevantScope } from "../replication/ScopeFilter.js";
@@ -74,6 +75,27 @@ const HARVEST_STRIDE = 4;
  *    third. Here the authored half is `onReplay`'s job and the arrived half is
  *    this one's.
  *
+ *  - Records that arrive from a peer for a frame this client has already
+ *    predicted past belong in that frame, under the prediction since, and
+ *    before the frame's corrections, which already hold what they did. The
+ *    frames after it were predicted without them and hold the prior state they
+ *    captured then, so a rewind across those frames would put back what the
+ *    records changed — a rewind about any other entity included. Where the
+ *    records write something a frame after theirs, or a correction of their
+ *    own frame, holds prior state of, the client takes them back off the
+ *    world, rewinds to the end of their frame and back past its corrections,
+ *    applies them there, the corrections after them, and replays what came
+ *    after, as a reconciliation replays. Records about nothing written since
+ *    stay where they landed: for everything they write, the present still holds
+ *    what the end of their frame held. The test is on what records write, not
+ *    what they read: one that only reads state written since — copying a
+ *    predicted value into an entity nothing else writes — keeps what it read at
+ *    the present until a replay crosses its frame. The replay is a
+ *    reconciliation's, so a local record {@link onReplay} does not produce is
+ *    lost from the frames it rebuilds. Records for a frame the action log has
+ *    moved past have no frame to go in: they are applied where they land, and
+ *    not logged.
+ *
  *  - A no-op short-circuit is built in: before doing the rewind+replay, the
  *    orchestrator gives the user a chance to compute what the replay WOULD
  *    produce via {@link onComputeExpected}; if that matches the current
@@ -138,11 +160,25 @@ export class ServerAuthoritativeClient {
      */
     #correction_payload = new BinaryBuffer();
 
+    /**
+     * The `(entity, component type)` pairs that state written after an arrived frame's records holds
+     * prior state of — what those records are checked against. Filled by
+     * {@link #overwrites_later_state}.
+     * @type {PairUint32Map}
+     */
+    #written_later = new PairUint32Map();
+
+    /** @type {ActionRecordCursor} */
+    #arrival_cursor = new ActionRecordCursor();
+
     // Counters
     /** @type {number} */
     reconcile_count = 0;
 
-    /** @type {number} */
+    /**
+     * Frames replayed, by reconciliations and by records put back in their frame.
+     * @type {number}
+     */
     replay_frame_count = 0;
 
     /**
@@ -161,6 +197,14 @@ export class ServerAuthoritativeClient {
      */
     reconcile_abandoned_count = 0;
 
+    /**
+     * Frames of records from a peer that arrived after this client had predicted past them, wrote
+     * something written later — in a frame after theirs, or by a correction of their own — and so
+     * were put back in their frame by a rewind and a replay. See {@link #land_arrived}.
+     * @type {number}
+     */
+    rebase_count = 0;
+
     /**
      * @param {{
      *   world: EntityComponentDataset,
@@ -176,6 +220,7 @@ export class ServerAuthoritativeClient {
      *   time_dilation?: TimeDilation,
      *   max_packets_per_tick?: number,
      *   auto_reconcile?: boolean,
+     *   rebase_on_arrival?: boolean,
      *   clock: function(): number,
      *   tick_period_ms: number,
      *   send_rate_bytes_per_second?: number,
@@ -189,8 +234,8 @@ export class ServerAuthoritativeClient {
      * `time_dilation`: optional pre-configured {@link TimeDilation}.
      * On TIME_DILATION feedback the client recomputes
      * {@link dilation_factor} for the caller to scale its tick cadence.
-     * Defaults to a stock instance; `dilation_factor` is 1.0 until the
-     * first feedback arrives.
+     * Defaults to one built for round trips up to `frame_capacity` frames;
+     * `dilation_factor` is 1.0 until the first feedback arrives.
      *
      * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
      * action-stream packets a tick may send the server.
@@ -200,6 +245,13 @@ export class ServerAuthoritativeClient {
      * own reconciliation — `NetworkSession` corrects by comparison instead —
      * turns it off and listens to `peer.onAuthState` itself; {@link reconcile}
      * remains available to it.
+     *
+     * `rebase_on_arrival` (default true): put the records a peer sends for a
+     * frame this client has already predicted past in that frame, under what it
+     * predicted since, by rewind and replay — see the class notes. It keeps the
+     * log true for the rewinds this client reconciles by. A caller that never
+     * rewinds — `NetworkSession` correcting by comparison — turns it off, and
+     * the records are applied to the world as it is when they arrive.
      */
     constructor({
         world,
@@ -212,9 +264,10 @@ export class ServerAuthoritativeClient {
         input_ring_capacity = 256,
         input_byte_size = 4,
         reconcile_epsilon = 1e-4,
-        time_dilation = new TimeDilation(),
+        time_dilation = new TimeDilation({ max_round_trip_frames: frame_capacity }),
         max_packets_per_tick,
         auto_reconcile = true,
+        rebase_on_arrival = true,
         clock,
         tick_period_ms,
         send_rate_bytes_per_second,
@@ -294,7 +347,10 @@ export class ServerAuthoritativeClient {
         /**
          * Tick-period multiplier from the latest TIME_DILATION feedback.
          * `< 1.0` ⇒ caller should run faster, `> 1.0` ⇒ slower. 1.0 until
-         * the first feedback arrives.
+         * the first feedback arrives. It follows every report, and holds while
+         * none come: a caller that seeks its frames back, or loses the host,
+         * judges whether the latest report still holds before running at it, as
+         * `NetworkSession` does.
          *
          *   scheduled_tick_period_ms = TICK_PERIOD_MS * client.dilation_factor;
          *
@@ -401,6 +457,9 @@ export class ServerAuthoritativeClient {
          * longer holds the frames its rewind needed. Args:
          * `(server_frame, network_id)`.
          *
+         * Nothing of it is done: the world stays at the present, and the
+         * server's state is not applied.
+         *
          * This is a real loss of replicated state and not a hiccup: state a peer
          * does not own reaches it on the action stream, and an owner that
          * publishes on change never sends it again — so whatever that window
@@ -426,6 +485,12 @@ export class ServerAuthoritativeClient {
                 this.#handle_auth_state(server_frame, network_id, buffer);
             });
         }
+
+        if (rebase_on_arrival) {
+            this.peer.replicator.onFrameApplied.add((_peer_id, frame, records_start) => {
+                this.#land_arrived(frame, records_start);
+            });
+        }
     }
 
     /**
@@ -617,21 +682,26 @@ export class ServerAuthoritativeClient {
          to the same frame undid the first one's correction again.
         */
         if (this.#current_frame > server_frame) {
-            try {
-                this.rewind_engine.rewind_to(this.#current_frame, server_frame);
-            } catch (e) {
-                /*
-                 The action_log rolled past `server_frame + 1`, so the window this
-                 reconciliation needs no longer exists and skipping it is the
-                 only option left. Counted and announced rather than swallowed:
-                 what the window carried for every entity other than this one is
-                 gone for good, and an application that cannot see that happen
-                 cannot ask for the back-fill that would repair it.
-                */
+            /*
+             The rewind undoes every frame after `server_frame`. Where the action
+             log no longer holds one of them, the window this reconciliation
+             needs is gone and skipping it is the only option left — found
+             before anything is undone, so the world stays at the present this
+             client predicts on from. Counted and announced rather than
+             swallowed: what the window carried for every entity other than this
+             one is gone for good, and an application that cannot see that
+             happen cannot ask for the back-fill that would repair it.
+            */
+            const log = this.action_log;
+            for (let f = server_frame + 1; f <= this.#current_frame; f++) {
+                if (log.has_frame(f)) continue;
+
                 this.reconcile_abandoned_count++;
                 this.onReconcileAbandoned.send2(server_frame, network_id);
                 return;
             }
+
+            this.rewind_engine.rewind_to(this.#current_frame, server_frame);
         }
 
         // Apply the server's authoritative state bytes, logged as a correction
@@ -639,12 +709,34 @@ export class ServerAuthoritativeClient {
         // deserialize, and what it read is the correction.
         this.#apply_correction(server_frame, network_id, local, buffer);
 
-        // Replay forward from (server_frame + 1) through current_frame.
+        const replay_count = this.#replay(server_frame + 1);
+
+        this.reconcile_count++;
+        this.replay_frame_count += replay_count;
+        this.onReconcileComplete.send2(server_frame, replay_count);
+    }
+
+    /**
+     * Replay every frame from `from` through the current frame over the world as it stands, the end
+     * of frame `from - 1`: each frame's local input through {@link onReplay}, then the records that
+     * arrived from a peer, then corrections, last in their frame.
+     *
+     * Every frame is replayed whatever one of them throws: a frame that throws keeps what it applied
+     * before the throw, and its corrections; the first error is thrown once the world is back at the
+     * current frame. Stopped there instead, the world would be left in the past and the frames after
+     * it holding their old records, and the client would predict on from there.
+     *
+     * @param {number} from
+     * @returns {number} how many frames were replayed
+     * @private
+     */
+    #replay(from) {
         let replay_count = 0;
-        for (let f = server_frame + 1; f <= this.#current_frame; f++) {
+        let failure = null;
+        for (let f = from; f <= this.#current_frame; f++) {
             // Harvested before `begin_frame`, which rewinds the frame's buffer
             // over the bytes being read.
-            const harvested = this.#harvest(f);
+            const harvested = this.#harvest(f, 0);
 
             this.action_log.begin_frame(f);
             try {
@@ -663,20 +755,194 @@ export class ServerAuthoritativeClient {
                  the one that should win where both touch a component.
                 */
                 if (harvested > 0) {
-                    this.#execute_harvested();
-
-                    // Last of all: a correction is the server's word on the END of its frame.
-                    this.#reapply_corrections(f);
+                    this.replayed_arrived_count += this.#apply_harvested(f);
                 }
+            } catch (e) {
+                if (failure === null) failure = e;
             } finally {
                 this.action_log.end_frame();
             }
             replay_count++;
         }
 
-        this.reconcile_count++;
-        this.replay_frame_count += replay_count;
-        this.onReconcileComplete.send2(server_frame, replay_count);
+        if (failure !== null) throw failure;
+
+        return replay_count;
+    }
+
+    /**
+     * Put the records a peer's frame has just had appended, from byte `arrived_start` on, where they
+     * belong on this client's timeline.
+     *
+     * The {@link Replicator} appends a peer's records to the frame the peer sent them for, after
+     * whatever the frame holds, and applies them to the world as it is — on a client, usually some
+     * frames past that one. The records' prior state is then the present's, every frame after
+     * `frame` holds prior state captured before they arrived, and a correction already in `frame`
+     * stands before them where a replay would write it after them. Where none of that holds prior
+     * state of anything the records wrote — nothing written later wrote it — the present held what
+     * the end of `frame` held there, and they stay. Otherwise they are taken back off the world,
+     * which puts it back as the frames after `frame` left it; those frames are rewound to the end of
+     * `frame` and its corrections undone; the records are applied there, the corrections after them,
+     * and what this client predicted since is replayed over them.
+     *
+     * A record that throws where it belongs is left out of the frame, as the executor leaves out any
+     * action that throws. The frame keeps its corrections, the world is brought back to the present
+     * all the same, and the error is thrown after.
+     *
+     * Records for a frame the log has moved past, which it applied without logging, and records for
+     * a frame the log no longer holds the frames after, are left where they landed: a rewind could
+     * not cross them either.
+     *
+     * @param {number} frame
+     * @param {number} arrived_start where in the frame the records just appended begin
+     * @private
+     */
+    #land_arrived(frame, arrived_start) {
+        const present = this.#current_frame;
+        if (frame >= present) return;
+
+        const log = this.action_log;
+        for (let f = frame; f <= present; f++) {
+            if (!log.has_frame(f)) return;
+        }
+        if (arrived_start >= log.write_end_for(frame)) return;
+
+        // Before the records just appended: this client's own records, then what a replay puts
+        // back — what arrived before them, if their frame was applied before, and the corrections.
+        const cursor = this.#arrival_cursor;
+        let tail_start = arrived_start;
+        cursor.open(log, frame);
+        while (cursor.next() && cursor.record_start < arrived_start) {
+            const sender_id = cursor.sender_id;
+            if (sender_id === SENDER_CORRECTED || this.peer.is_connected(sender_id)) {
+                tail_start = cursor.record_start;
+                break;
+            }
+        }
+
+        if (!this.#overwrites_later_state(frame, tail_start, arrived_start)) return;
+
+        // Copies of the frame's tail — its corrections, then the records just appended — taken
+        // before any of it is written over.
+        this.#harvest(frame, tail_start);
+
+        // The records just appended, off the world and off the frame: the world is the present as
+        // the frames after `frame` left it, and the frame is what it was before they came.
+        this.rewind_engine.undo_frame_from(frame, arrived_start);
+        log.resume_frame_at(frame, arrived_start);
+        log.end_frame();
+
+        // To the end of the frame, and back past its corrections.
+        this.rewind_engine.rewind_to(present, frame);
+        this.rewind_engine.undo_frame_from(frame, tail_start);
+
+        // The tail again, in the order a replay writes a frame: what arrived, then the corrections.
+        // Then forward to the present whatever became of the records: a world left in the past would
+        // be predicted on from there.
+        let failure = null;
+        log.resume_frame_at(frame, tail_start);
+        try {
+            this.#apply_harvested(frame);
+        } catch (e) {
+            failure = e;
+        } finally {
+            log.end_frame();
+        }
+
+        this.replay_frame_count += this.#replay(frame + 1);
+        this.rebase_count++;
+
+        if (failure !== null) throw failure;
+    }
+
+    /**
+     * Whether the records from byte `arrived_start` on in `frame` write anything that state written
+     * after them holds prior state of: a correction in the frame from `tail_start` up to them, which
+     * a replay writes after them, and any record in a frame after `frame`.
+     *
+     * @param {number} frame
+     * @param {number} tail_start
+     * @param {number} arrived_start
+     * @returns {boolean}
+     * @private
+     */
+    #overwrites_later_state(frame, tail_start, arrived_start) {
+        const later = this.#written_later;
+        later.clear();
+
+        const cursor = this.#arrival_cursor;
+
+        cursor.open(this.action_log, frame);
+        while (cursor.next() && cursor.record_start < arrived_start) {
+            if (cursor.record_start >= tail_start && cursor.sender_id === SENDER_CORRECTED) {
+                this.#collect_prior_entries(cursor, later);
+            }
+        }
+
+        for (let f = frame + 1; f <= this.#current_frame; f++) {
+            cursor.open(this.action_log, f);
+            while (cursor.next()) {
+                this.#collect_prior_entries(cursor, later);
+            }
+        }
+
+        if (later.size === 0) return false;
+
+        cursor.open(this.action_log, frame);
+        while (cursor.next()) {
+            if (cursor.record_start < arrived_start) continue;
+
+            const buffer = cursor.buffer;
+            buffer.position = cursor.prior_start;
+            for (let i = 0; i < cursor.prior_count; i++) {
+                const entity_id = buffer.readUintVar();
+                const component_type_id = buffer.readUint8();
+                buffer.position += buffer.readUint32();
+
+                if (later.has(entity_id, component_type_id)) return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Add the `(entity, component type)` of every prior-state entry of the record under `cursor`
+     * that captured something to `into` — an entry that captured nothing puts nothing back.
+     *
+     * @param {ActionRecordCursor} cursor
+     * @param {PairUint32Map} into
+     * @private
+     */
+    #collect_prior_entries(cursor, into) {
+        const buffer = cursor.buffer;
+        buffer.position = cursor.prior_start;
+        for (let i = 0; i < cursor.prior_count; i++) {
+            const entity_id = buffer.readUintVar();
+            const component_type_id = buffer.readUint8();
+            const prior_length = buffer.readUint32();
+            buffer.position += prior_length;
+
+            if (prior_length > 0) into.set(entity_id, component_type_id, 1);
+        }
+    }
+
+    /**
+     * Apply what {@link #harvest} took from `frame` into it, open: the records that arrived from a
+     * peer, then the corrections, last — those whatever the records do, since the frame has been
+     * opened over them and they live nowhere else.
+     *
+     * @param {number} frame
+     * @returns {number} how many arrived records were applied
+     * @private
+     */
+    #apply_harvested(frame) {
+        try {
+            return this.#execute_harvested();
+        } finally {
+            // Last of all: a correction is the server's word on the END of its frame.
+            this.#reapply_corrections(frame);
+        }
     }
 
     /**
@@ -769,12 +1035,13 @@ export class ServerAuthoritativeClient {
     }
 
     /**
-     * Copy the records of `frame` that a replay puts back out of the action
-     * log, ready for {@link #execute_harvested} and {@link #reapply_corrections}.
+     * Copy the records of `frame` from byte `from` on that a replay puts back out
+     * of the action log, ready for {@link #execute_harvested} and
+     * {@link #reapply_corrections}.
      *
-     * MUST be called before `action_log.begin_frame(frame)`. Opening a frame
-     * rewinds its buffer to zero without clearing it, and the re-execution
-     * writes over exactly the bytes this reads, so the payloads are copied into
+     * MUST be called before the frame is opened over them. Opening a frame
+     * rewinds its buffer without clearing it, and the re-execution writes over
+     * exactly the bytes this reads, so the payloads are copied into
      * {@link #harvest_payloads} rather than read in place.
      *
      * Provenance decides what a replay does with a record, and this client keeps
@@ -797,10 +1064,11 @@ export class ServerAuthoritativeClient {
      * itself, so its own records can never match.
      *
      * @param {number} frame
+     * @param {number} from offset of the first record looked at, a record boundary in the frame
      * @returns {number} how many records were harvested
      * @private
      */
-    #harvest(frame) {
+    #harvest(frame, from) {
         this.#harvest_count = 0;
         this.#harvest_payloads.position = 0;
 
@@ -811,6 +1079,8 @@ export class ServerAuthoritativeClient {
         const bytes = cursor.buffer.raw_bytes;
 
         while (cursor.next()) {
+            if (cursor.record_start < from) continue;
+
             const sender_id = cursor.sender_id;
             if (sender_id !== SENDER_CORRECTED && !this.peer.is_connected(sender_id)) continue;
 
@@ -841,10 +1111,12 @@ export class ServerAuthoritativeClient {
      * A record whose action class is no longer registered is skipped — the same
      * thing `Replicator.#apply_groups` does on the way in.
      *
+     * @returns {number} how many were applied
      * @private
      */
     #execute_harvested() {
         const payloads = this.#harvest_payloads;
+        let applied = 0;
 
         for (let record = 0; record < this.#harvest_count; record++) {
             const i = record * HARVEST_STRIDE;
@@ -862,14 +1134,16 @@ export class ServerAuthoritativeClient {
                 action.deserialize(payloads);
                 // `execute` returns false when an authorization policy rejects
                 // the action, in which case nothing was applied or logged — so
-                // the counter follows the return value rather than the attempt.
+                // the count follows the return value rather than the attempt.
                 if (this.executor.execute(action, sender_id)) {
-                    this.replayed_arrived_count++;
+                    applied++;
                 }
             } finally {
                 this.action_registry.release(action);
             }
         }
+
+        return applied;
     }
 
     /**

package/src/engine/network/replication/Replicator.d.ts

@@ -90,7 +90,11 @@ export class Replicator {
     };
     /**
      * Fired after each per-frame action group is fully applied via
-     * {@link unpack_from_peer}. Args: `(peer_id, frame_number)`.
+     * {@link unpack_from_peer}. Args: `(peer_id, frame_number, records_start)`:
+     * the records just applied are logged in the action log's frame from
+     * byte `records_start` to its end, after whatever it held before. A frame
+     * the action log has moved past is applied without being logged, and the
+     * log does not hold it.
      *
      * Subscribe to drive interpolation buffers, replay logs, diagnostics,
      * or anything else that needs to know "frame N from peer P has just
@@ -177,7 +181,9 @@ export class Replicator {
      * Parse and apply actions from `in_buffer` into the local world via the executor.
      * Each frame in the packet opens a new entry in the local action log under the
      * sender's frame number, ensuring the rewind/replay machinery sees consistent
-     * frame indexing across peers.
+     * frame indexing across peers. A frame the log has moved past — older than the
+     * frame its slot holds — is applied to the world as it stands and not logged:
+     * no rewind reaches it, and logging it would erase that later frame.
      *
      * `slice` is the sender's description of the packet, from the
      * {@link NetworkPeer} slice header: the frame range it covers and whether

package/src/engine/network/replication/Replicator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Replicator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/replication/Replicator.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IAmLI;;;;;;;;OAQG;IACH,iFARW;QACV,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,QAAY,oBAAoB;QAChC,UAAc,uBAAuB;QACrC,YAAgB,EAAE;YAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAC;KACpF,EA6BH;IA9ID;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,wBAHW,MAAM,GACJ;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC,CAc1F;IA2BD;;;;;;;;;;;;;OAaG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBAFU,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAExJ;IAmBrB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,4BAAwB;IAExB;;OAEG;IACH,iCAA4B;IAE5B;;;;OAIG;IACH,cAFU;QAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAE9C;IAGpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAVW,MAAM,eACN,MAAM,aACN,MAAM,cACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA0FlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,0BALW,MAAM,aACN,YAAY,iBACZ,MAAM,UACN;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI,QA2EtE;IA+RD;;;;;;;OAOG;IACH,qBAFW,MAAM,QAKhB;;CA8CJ;mBA/zBkB,uCAAuC;6BAD7B,sCAAsC"}
+{"version":3,"file":"Replicator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/replication/Replicator.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IAuLI;;;;;;;;OAQG;IACH,iFARW;QACV,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,QAAY,oBAAoB;QAChC,UAAc,uBAAuB;QACrC,YAAgB,EAAE;YAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAC;KACpF,EA6BH;IAlJD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,wBAHW,MAAM,GACJ;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC,CAc1F;IA2BD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBAFU,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAExJ;IAmBrB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,4BAAwB;IAExB;;OAEG;IACH,iCAA4B;IAE5B;;;;OAIG;IACH,cAFU;QAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAE9C;IAGpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAVW,MAAM,eACN,MAAM,aACN,MAAM,cACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA0FlB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,0BALW,MAAM,aACN,YAAY,iBACZ,MAAM,UACN;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI,QA2EtE;IAkSD;;;;;;;OAOG;IACH,qBAFW,MAAM,QAKhB;;CA8CJ;mBAx0BkB,uCAAuC;6BAD7B,sCAAsC"}

package/src/engine/network/replication/Replicator.js

@@ -200,7 +200,11 @@ export class Replicator {
 
     /**
      * Fired after each per-frame action group is fully applied via
-     * {@link unpack_from_peer}. Args: `(peer_id, frame_number)`.
+     * {@link unpack_from_peer}. Args: `(peer_id, frame_number, records_start)`:
+     * the records just applied are logged in the action log's frame from
+     * byte `records_start` to its end, after whatever it held before. A frame
+     * the action log has moved past is applied without being logged, and the
+     * log does not hold it.
      *
      * Subscribe to drive interpolation buffers, replay logs, diagnostics,
      * or anything else that needs to know "frame N from peer P has just
@@ -396,7 +400,9 @@ export class Replicator {
      * Parse and apply actions from `in_buffer` into the local world via the executor.
      * Each frame in the packet opens a new entry in the local action log under the
      * sender's frame number, ensuring the rewind/replay machinery sees consistent
-     * frame indexing across peers.
+     * frame indexing across peers. A frame the log has moved past — older than the
+     * frame its slot holds — is applied to the world as it stands and not logged:
+     * no rewind reaches it, and logging it would erase that later frame.
      *
      * `slice` is the sender's description of the packet, from the
      * {@link NetworkPeer} slice header: the frame range it covers and whether
@@ -576,7 +582,10 @@ export class Replicator {
             }
 
             // After what the frame already holds: on a client this frame is usually one it has
-            // already predicted, and its own records are what a rewind undoes.
+            // already predicted, and its own records are what a rewind undoes. A frame the log has
+            // moved past is not logged at all (ActionLog.resume_frame): the frame in its slot is
+            // one of this peer's own.
+            const records_start = this.action_log.has_frame(frame_number) ? this.action_log.write_end_for(frame_number) : 0;
             this.action_log.resume_frame(frame_number);
             try {
                 for (let i = 0; i < action_count; i++) {
@@ -651,7 +660,7 @@ export class Replicator {
 
             // Fire AFTER end_frame so handlers see consistent state and can
             // safely query the action log for the just-applied frame.
-            this.onFrameApplied.send2(peer_id, frame_number);
+            this.onFrameApplied.send3(peer_id, frame_number, records_start);
         }
 
         return last_frame;

package/src/engine/network/sim/ActionLog.d.ts

@@ -76,17 +76,31 @@ export class ActionLog {
     begin_frame(frame: number): void;
     /**
      * Open a frame for writing after the records it already holds, rather than over them. A frame
-     * the ring does not hold is opened empty, as {@link begin_frame} opens it.
+     * the ring does not hold is opened empty, as {@link begin_frame} opens it — unless the log has
+     * moved past it, its slot holding a later frame: the later frame keeps its records, and what is
+     * written for this one is dropped at {@link end_frame}.
      *
      * For a writer adding to a frame someone else wrote: records arriving from a peer for a frame
      * this peer has already simulated. Opened with {@link begin_frame} instead, they would erase
      * this peer's own records for the frame — and with them the prior state a rewind needs to undo
      * that input, so a replay would apply it a second time, and the outbound stream, which packs
-     * from this log, would lose it before the peer it was for had confirmed it.
+     * from this log, would lose it before the peer it was for had confirmed it. A frame the log has
+     * moved past would erase the later frame's records the same way.
      *
      * @param {number} frame absolute frame number
      */
     resume_frame(frame: number): void;
+    /**
+     * Open a frame the log holds for writing from byte `offset` of what it holds: the records from
+     * there on are dropped, and what is written takes their place.
+     *
+     * For a writer that has taken records back off the world and writes them again — the frame's
+     * earlier records stay, the later ones are written over.
+     *
+     * @param {number} frame absolute frame number
+     * @param {number} offset a record boundary in the frame, at most its end
+     */
+    resume_frame_at(frame: number, offset: number): void;
     /**
      * Drop every record the log holds, keeping each frame it holds present and empty.
      *

package/src/engine/network/sim/ActionLog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionLog.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/ActionLog.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IAoBI;;OAEG;IACH,qDAFW;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,EAIlE;IAED;;;OAGG;IACH,6BAEC;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,oBAFW,MAAM,QAShB;IAED;;;;;;;;OAQG;IACH,qBAMC;IAED;;OAEG;IACH,kBASC;IAED;;;;;;OAMG;IACH,kBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,+BAMC;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,MAAM,gBAKhB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,MAAM,CAIlB;;CACJ"}
+{"version":3,"file":"ActionLog.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/ActionLog.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IAoBI;;OAEG;IACH,qDAFW;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,EAIlE;IAED;;;OAGG;IACH,6BAEC;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,uBAHW,MAAM,UACN,MAAM,QAkBhB;IAED;;;;;;;;OAQG;IACH,qBAMC;IAED;;OAEG;IACH,kBASC;IAED;;;;;;OAMG;IACH,kBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,+BAMC;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,MAAM,gBAKhB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,MAAM,CAIlB;;CACJ"}