@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -1,12 +1,22 @@
 import { assert } from "../../../core/assert.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 import { Uint32Map } from "../../../core/collection/Uint32Map.js";
 import Signal from "../../../core/events/signal/Signal.js";
 import { AlwaysRelevantScope } from "../replication/ScopeFilter.js";
+import { ActionRecordCursor } from "../sim/ActionRecordCursor.js";
 import { RewindEngine } from "../sim/RewindEngine.js";
 import { InputRing } from "../state/InputRing.js";
 import { TimeDilation } from "../time/TimeDilation.js";
 import { NetworkPeer } from "./NetworkPeer.js";
 
+/**
+ * Ints per harvested record in {@link ServerAuthoritativeClient}'s replay index:
+ * action type id, sender id, and the offset of its payload.
+ *
+ * @type {number}
+ */
+const HARVEST_STRIDE = 3;
+
 /**
  * Client-side orchestrator for the predict-reconcile model.
  *
@@ -27,6 +37,19 @@ import { NetworkPeer } from "./NetworkPeer.js";
  *    {@link onReplay} handler re-executes the same SimActions the original
  *    predict path produced.
  *
+ *  - A replay also reapplies the records in the rewound window that ARRIVED
+ *    from a peer, which {@link onReplay} cannot: it re-executes this client's
+ *    own input, and the AUTH_STATE that precedes it carries one `network_id`.
+ *    Without this step a rewind about one entity discards the owner's published
+ *    state for every OTHER entity in the window — permanently, for anything
+ *    published on change rather than every frame, because nothing re-sends it
+ *    and nothing else restores it. This is the client half of the rule
+ *    `SimAction` states and `ServerAuthoritativeServer.#read_historical`
+ *    implements: a record's `sender_id` says whether it arrived, was authored,
+ *    or was derived, and a replay reapplies the first two and recomputes the
+ *    third. Here the authored half is `onReplay`'s job and the arrived half is
+ *    this one's.
+ *
  *  - 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
@@ -55,6 +78,30 @@ export class ServerAuthoritativeClient {
     #expected_scratch;
     #measured_scratch;
 
+    /**
+     * Records of one log frame that arrived from a peer, indexed
+     * {@link HARVEST_STRIDE} ints apiece into {@link #harvest_payloads}. Filled
+     * by {@link #harvest_arrived} before the frame is reopened and drained by
+     * {@link #execute_harvested} once it is.
+     * @type {Int32Array}
+     */
+    #harvest_index = new Int32Array(HARVEST_STRIDE * 32);
+
+    /** @type {number} records currently described by {@link #harvest_index} */
+    #harvest_count = 0;
+
+    /**
+     * The harvested records' action payloads, back to back. A frame's bytes have
+     * to be copied out before the frame is reopened: opening it rewinds its
+     * buffer to zero and the re-execution then writes over exactly the bytes
+     * being read.
+     * @type {BinaryBuffer}
+     */
+    #harvest_payloads = new BinaryBuffer();
+
+    /** @type {ActionRecordCursor} */
+    #harvest_cursor = new ActionRecordCursor();
+
     // Counters
     /** @type {number} */
     reconcile_count = 0;
@@ -62,6 +109,22 @@ export class ServerAuthoritativeClient {
     /** @type {number} */
     replay_frame_count = 0;
 
+    /**
+     * Records that arrived from a peer and were reapplied by a replay, over the
+     * life of this client. Zero on a client whose peers publish nothing the
+     * rewind window covers; non-zero is the fix for the discard above doing
+     * work, and is what a test can assert on rather than inferring from a value.
+     * @type {number}
+     */
+    replayed_arrived_count = 0;
+
+    /**
+     * Reconciliations abandoned because the action log no longer held the frames
+     * the rewind needed. See {@link onReconcileAbandoned}.
+     * @type {number}
+     */
+    reconcile_abandoned_count = 0;
+
     /**
      * @param {{
      *   world: EntityComponentDataset,
@@ -261,6 +324,30 @@ export class ServerAuthoritativeClient {
          */
         this.onReconcileComplete = new Signal();
 
+        /**
+         * Fires when a reconciliation is abandoned because the action log no
+         * longer holds the frames its rewind needed. Args:
+         * `(server_frame, network_id)`.
+         *
+         * 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
+         * carried for every entity other than `network_id` is gone. The server
+         * would normally back-fill via `RECOVERY_REQUEST`/`STATE_BURST`, which
+         * is request-driven, so something has to know to ask. That is what this
+         * signal is for; {@link reconcile_abandoned_count} is the same event as
+         * a counter.
+         *
+         * A client seeing this repeatedly is running further ahead of the server
+         * frame than its `frame_capacity` covers.
+         *
+         * @type {Signal}
+         */
+        this.onReconcileAbandoned = new Signal();
+
+        // One packet's worth of action payloads, grown on demand from there.
+        this.#harvest_payloads.setCapacity(1024);
+
         // Wire the AUTH_STATE handler to the algorithm above.
         this.peer.onAuthState.add((_peer_id, server_frame, network_id, buffer) => {
             this.#handle_auth_state(server_frame, network_id, buffer);
@@ -379,17 +466,51 @@ export class ServerAuthoritativeClient {
 
         // Real divergence: rewind, apply server's bytes, replay forward.
         const rewind_target = server_frame - 1;
+        let rewound = false;
         if (this.#current_frame > rewind_target) {
             try {
                 this.rewind_engine.rewind_to(this.#current_frame, rewind_target);
+                rewound = true;
             } catch (e) {
-                // The action_log probably rolled past server_frame. The
-                // server would normally back-fill us via STATE_BURST; for now
-                // skip this reconciliation.
+                /*
+                 The action_log rolled past server_frame, 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.
+                */
+                this.reconcile_abandoned_count++;
+                this.onReconcileAbandoned.send2(server_frame, network_id);
                 return;
             }
         }
 
+        /*
+         Frame `server_frame` was just undone and is NOT replayed below: the
+         AUTH_STATE is the server's state at the END of it, so re-running this
+         client's own input for that frame would apply that input twice.
+
+         Its ARRIVED records are the other half of the frame, and the half that
+         was being dropped. The bytes below repair one `network_id`; every other
+         entity the frame touched has nothing else to restore it. They go back in
+         BEFORE those bytes, so the authoritative value still wins wherever the
+         two describe the same component.
+
+         In the ordinary owner-scoped arrangement this is the frame that matters
+         most: the owner's records for a frame land in the log at the owner's
+         frame number, which is at or below `server_frame`, so they sit at the
+         very bottom of the rewound window rather than inside the replay range.
+        */
+        if (rewound && this.#harvest_arrived(server_frame) > 0) {
+            this.action_log.begin_frame(server_frame);
+            try {
+                this.#execute_harvested();
+            } finally {
+                this.action_log.end_frame();
+            }
+        }
+
         // Apply the server's authoritative state bytes. The handler does the
         // adapter-specific deserialize.
         this.onApplyAuthState.send3(server_frame, network_id, buffer);
@@ -397,6 +518,10 @@ export class ServerAuthoritativeClient {
         // Replay forward from (server_frame + 1) through current_frame.
         let replay_count = 0;
         for (let f = server_frame + 1; f <= this.#current_frame; f++) {
+            // Harvested before `begin_frame`, which rewinds the frame's buffer
+            // over the bytes being read. Nothing to harvest if nothing was undone.
+            const arrived = rewound ? this.#harvest_arrived(f) : 0;
+
             this.action_log.begin_frame(f);
             try {
                 let input_reader = null;
@@ -405,6 +530,15 @@ export class ServerAuthoritativeClient {
                     input_reader.position = 0;
                 }
                 this.onReplay.send2(f, input_reader);
+
+                /*
+                 After the local input, which is the order the frame was written
+                 in the first time: this client's prediction was logged as it
+                 ticked the frame, and the owner's mutations for that frame
+                 arrived later. It also leaves the owner's value last, which is
+                 the one that should win where both touch a component.
+                */
+                if (arrived > 0) this.#execute_harvested();
             } finally {
                 this.action_log.end_frame();
             }
@@ -416,6 +550,115 @@ export class ServerAuthoritativeClient {
         this.onReconcileComplete.send2(server_frame, replay_count);
     }
 
+    /**
+     * Copy the records of `frame` that arrived from a peer out of the action
+     * log, ready for {@link #execute_harvested} to put back.
+     *
+     * 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
+     * {@link #harvest_payloads} rather than read in place.
+     *
+     * Provenance decides what a replay does with a record, and this client keeps
+     * a narrower set than the server does:
+     *
+     *  - a CONNECTED peer's id — it arrived from that peer, and nothing else
+     *    here reproduces it. `onApplyAuthState` covers one `network_id` and
+     *    {@link onReplay} covers this client's own input. Kept.
+     *  - `SENDER_DERIVED` — output a replay recomputes. Skipped, same as
+     *    `ServerAuthoritativeServer.#read_historical` skips it.
+     *  - `SENDER_LOCAL`, and this client's own peer id — its own input, which
+     *    {@link onReplay} reapplies from the sampled-action ledger. Skipped:
+     *    reapplying it from the log as well would apply it twice.
+     *
+     * Connectedness is the test rather than a comparison against the local peer
+     * id because it is the same question stated directly — the sender byte of an
+     * arrived record is the peer it arrived from, and a client never connects to
+     * itself, so its own records can never match.
+     *
+     * @param {number} frame
+     * @returns {number} how many records were harvested
+     * @private
+     */
+    #harvest_arrived(frame) {
+        this.#harvest_count = 0;
+        this.#harvest_payloads.position = 0;
+
+        if (!this.action_log.has_frame(frame)) return 0;
+
+        const cursor = this.#harvest_cursor;
+        cursor.open(this.action_log, frame);
+        const bytes = cursor.buffer.raw_bytes;
+
+        while (cursor.next()) {
+            if (!this.peer.is_connected(cursor.sender_id)) continue;
+
+            if ((this.#harvest_count + 1) * HARVEST_STRIDE > this.#harvest_index.length) {
+                this.#grow_harvest_index();
+            }
+
+            const i = this.#harvest_count * HARVEST_STRIDE;
+            this.#harvest_index[i] = cursor.action_type_id;
+            this.#harvest_index[i + 1] = cursor.sender_id;
+            this.#harvest_index[i + 2] = this.#harvest_payloads.position;
+            this.#harvest_count++;
+
+            this.#harvest_payloads.writeBytes(bytes, cursor.payload_start, cursor.payload_len);
+        }
+
+        return this.#harvest_count;
+    }
+
+    /**
+     * Re-execute what {@link #harvest_arrived} took, in log order, into the
+     * currently-open frame.
+     *
+     * Going back through the executor is the point rather than an implementation
+     * detail: it captures each record's prior bytes again as it applies, so the
+     * reopened frame describes what is now live and the next rewind can undo it.
+     * A record whose action class is no longer registered is skipped — the same
+     * thing `Replicator.#apply_groups` does on the way in.
+     *
+     * @private
+     */
+    #execute_harvested() {
+        const payloads = this.#harvest_payloads;
+
+        for (let record = 0; record < this.#harvest_count; record++) {
+            const i = record * HARVEST_STRIDE;
+            const type_id = this.#harvest_index[i];
+            const sender_id = this.#harvest_index[i + 1];
+            const payload_start = this.#harvest_index[i + 2];
+
+            const klass = this.action_registry.klass_for(type_id);
+            if (klass === undefined) continue;
+
+            const action = this.action_registry.acquire(klass);
+            try {
+                payloads.position = payload_start;
+                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.
+                if (this.executor.execute(action, sender_id)) {
+                    this.replayed_arrived_count++;
+                }
+            } finally {
+                this.action_registry.release(action);
+            }
+        }
+    }
+
+    /**
+     * @private
+     */
+    #grow_harvest_index() {
+        const old = this.#harvest_index;
+        const next = new Int32Array(old.length * 2);
+        next.set(old);
+        this.#harvest_index = next;
+    }
+
     /**
      * Helper for the {@link onComputeExpected} handler: stash the
      * computed scalar so the orchestrator can read it. Called inside the

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

@@ -55,9 +55,11 @@ export class Replicator {
     /**
      * Per-peer delivery accounting. Read it, log it, put it on a HUD, fail a test on it.
      *
-     * `skipped_unapplied` is the one that matters: frames that reached this receiver and were
-     * dropped below the watermark without ever being applied. It should be zero. It is not zero
-     * when slices reorder on a sender pinned to the ring floor, which is what
+     * `skipped_unapplied` is the one that matters: frames that reached this receiver and will
+     * never run — dropped below the watermark without ever being applied, or held for a gap that
+     * the cap on held slices outlived. It should be zero, on every configuration, however the link
+     * reorders; a slice held and applied late is not counted, because nothing was lost. It is not
+     * zero when slices reorder on a sender pinned to the ring floor, which is what
      * `max_packets_per_tick: 1` produces under jitter.
      *
      * `skipped_duplicate` is the healthy counterpart — the action stream's own redundancy arriving

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":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IA4JI;;;;;;;;OAQG;IACH;;;;;;wCAHiD,MAAM,cAAc,MAAM,GAAG,OAAO;;OA8BpF;IA/HD;;;;;;;;;;;;;OAaG;IACH,wBAHW,MAAM,GACJ;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,CAUlE;IA0BD;;;;;;;;;;;;;OAaG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFqB,MAAM,gBAAgB,MAAM,kBAAkB,MAAM,aAAa,YAAY,kBAAkB,MAAM,eAAe,MAAM,KAAK,IAAI,CAE/H;IAmBrB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,4BAAwB;IAExB;;OAEG;IACH,iCAA4B;IAE5B;;;;OAIG;IACH;oCAFwC,MAAM,cAAc,MAAM,GAAG,OAAO;MAE5C;IAGpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAVW,MAAM,eACN,MAAM,aACN,MAAM,cACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA4ElB;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,QAmEtE;IAiND;;;;;;;OAOG;IACH,qBAFW,MAAM,QAKhB;;CA8CJ;mBA1rBkB,uCAAuC;6BAD7B,sCAAsC"}
+{"version":3,"file":"Replicator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/replication/Replicator.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAsKI;;;;;;;;OAQG;IACH;;;;;;wCAHiD,MAAM,cAAc,MAAM,GAAG,OAAO;;OA8BpF;IAjID;;;;;;;;;;;;;;;OAeG;IACH,wBAHW,MAAM,GACJ;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,CAUlE;IA0BD;;;;;;;;;;;;;OAaG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFqB,MAAM,gBAAgB,MAAM,kBAAkB,MAAM,aAAa,YAAY,kBAAkB,MAAM,eAAe,MAAM,KAAK,IAAI,CAE/H;IAmBrB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,4BAAwB;IAExB;;OAEG;IACH,iCAA4B;IAE5B;;;;OAIG;IACH;oCAFwC,MAAM,cAAc,MAAM,GAAG,OAAO;MAE5C;IAGpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAVW,MAAM,eACN,MAAM,aACN,MAAM,cACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA4ElB;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,QAoEtE;IAuPD;;;;;;;OAOG;IACH,qBAFW,MAAM,QAKhB;;CA8CJ;mBA3uBkB,uCAAuC;6BAD7B,sCAAsC"}

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

@@ -114,6 +114,14 @@ export class Replicator {
      * skipped frame can ask "was I ever applied?" in constant time and constant memory. A frame
      * older than the window answers "no", which is right: it is beyond recovery either way.
      *
+     * There is a third kind of skip and it is neither: a frame walked past on the validation walk
+     * that precedes a hold. Nothing has happened to it — the bytes are kept and it runs a few
+     * packets later — so it is not booked at all, and the frames of a held slice are booked when
+     * the slice is applied, or when it is thrown away, whichever comes. `count_skipped` in
+     * {@link #apply_groups} is that distinction. It has to be a distinction: on a jittery link
+     * holding is the common case, and counting a held frame as lost buries the real losses under
+     * a number twenty times larger that grows with the length of the session.
+     *
      * @type {Map<number, {applied: Int32Array, skipped_unapplied: number, skipped_duplicate: number}>}
      * @private
      */
@@ -122,9 +130,11 @@ export class Replicator {
     /**
      * Per-peer delivery accounting. Read it, log it, put it on a HUD, fail a test on it.
      *
-     * `skipped_unapplied` is the one that matters: frames that reached this receiver and were
-     * dropped below the watermark without ever being applied. It should be zero. It is not zero
-     * when slices reorder on a sender pinned to the ring floor, which is what
+     * `skipped_unapplied` is the one that matters: frames that reached this receiver and will
+     * never run — dropped below the watermark without ever being applied, or held for a gap that
+     * the cap on held slices outlived. It should be zero, on every configuration, however the link
+     * reorders; a slice held and applied late is not counted, because nothing was lost. It is not
+     * zero when slices reorder on a sender pinned to the ring floor, which is what
      * `max_packets_per_tick: 1` produces under jitter.
      *
      * `skipped_duplicate` is the healthy counterpart — the action stream's own redundancy arriving
@@ -426,6 +436,7 @@ export class Replicator {
             peer_id, in_buffer, in_buffer_end, state.next_frame,
             slice !== null ? slice.frame_start : 0,
             slice !== null ? slice.frame_end : Infinity,
+            true,
         );
         const covered_through = slice !== null ? slice.frame_end : last_frame;
         if (covered_through + 1 > state.next_frame) {
@@ -444,16 +455,24 @@ export class Replicator {
      * the header's end, so a frame beyond it would be applied again by the
      * slice that genuinely carries it.
      *
+     * `count_skipped` is the other half, and it is not the same question:
+     * `min_frame` says which frames this walk applies, `count_skipped` says
+     * whether the walk decides the skipped ones' fate. A validation walk before
+     * a hold decides nothing — the bytes are kept and every frame in them still
+     * runs, a few packets later — so it books nothing. The walks that do decide
+     * are the ones that apply, and the walk over a held slice being discarded.
+     *
      * @param {number} peer_id
      * @param {BinaryBuffer} in_buffer
      * @param {number} in_buffer_end
      * @param {number} min_frame
      * @param {number} frame_start
      * @param {number} frame_end
+     * @param {boolean} count_skipped book each skipped frame on the delivery counters
      * @returns {number} the highest frame number the packet carries, or -1 if none
      * @private
      */
-    #apply_groups(peer_id, in_buffer, in_buffer_end, min_frame, frame_start, frame_end) {
+    #apply_groups(peer_id, in_buffer, in_buffer_end, min_frame, frame_start, frame_end, count_skipped) {
         const registry = this.action_registry;
         let last_frame = -1;
 
@@ -479,14 +498,19 @@ export class Replicator {
                  this is the action stream's own redundancy doing its job; anything else means the
                  watermark moved past a frame that never ran, and nothing will re-send it because
                  its channel-level ack already told the sender it arrived.
-                */
-                const delivery = this.#delivery_state(peer_id);
-                const slot = frame_number % delivery.applied.length;
 
-                if (delivery.applied[slot] === frame_number) {
-                    delivery.skipped_duplicate++;
-                } else {
-                    delivery.skipped_unapplied++;
+                 Asked only where the answer is final. A frame walked past by a validation walk is
+                 not being lost and is not a duplicate: it is about to be copied aside and run.
+                */
+                if (count_skipped) {
+                    const delivery = this.#delivery_state(peer_id);
+                    const slot = frame_number % delivery.applied.length;
+
+                    if (delivery.applied[slot] === frame_number) {
+                        delivery.skipped_duplicate++;
+                    } else {
+                        delivery.skipped_unapplied++;
+                    }
                 }
 
                 for (let i = 0; i < action_count; i++) {
@@ -565,7 +589,7 @@ export class Replicator {
      */
     #hold_slice(peer_id, state, slice, in_buffer, in_buffer_end) {
         const start = in_buffer.position;
-        this.#apply_groups(peer_id, in_buffer, in_buffer_end, Infinity, slice.frame_start, slice.frame_end);
+        this.#apply_groups(peer_id, in_buffer, in_buffer_end, Infinity, slice.frame_start, slice.frame_end, false);
 
         const held = state.held;
         let i = 0;
@@ -579,13 +603,21 @@ export class Replicator {
         // copy covered, so a frame only one copy covers is never sent again:
         // keep the copy that reaches further, and between equals the newer,
         // which carries the sender's latest content for those frames.
+        // Either way round, the copy that loses covers no frame the winner does
+        // not, so nothing is dropped here and nothing is booked.
         const same_start = i < held.length && held[i].frame_start === slice.frame_start;
         if (same_start && held[i].frame_end > slice.frame_end) return;
         if (!same_start && held.length >= MAX_HELD_SLICES) {
             // Keep the slices nearest the gap — the ones the next head is most
-            // likely to release — and drop the farthest.
-            if (i === held.length) return;
-            held.pop();
+            // likely to release — and drop the farthest. Those frames are gone:
+            // acked at the channel level, so the sender credits them and never
+            // sends them again. Book them, or the cap loses frames in silence.
+            if (i === held.length) {
+                in_buffer.position = start;
+                this.#apply_groups(peer_id, in_buffer, in_buffer_end, Infinity, slice.frame_start, slice.frame_end, true);
+                return;
+            }
+            this.#discard_held(peer_id, held.pop());
         }
 
         const length = in_buffer_end - start;
@@ -610,6 +642,7 @@ export class Replicator {
         while (held.length > 0 && held[0].frame_start < frame) {
             const h = held.shift();
             if (h.frame_end >= state.next_frame) this.#apply_held(peer_id, state, h);
+            else this.#discard_held(peer_id, h);
         }
     }
 
@@ -624,6 +657,7 @@ export class Replicator {
             const h = held[0];
             if (h.frame_end < state.next_frame) {
                 held.shift();
+                this.#discard_held(peer_id, h);
                 continue;
             }
             if (h.frame_start > state.next_frame) break;
@@ -635,12 +669,27 @@ export class Replicator {
     /** @private */
     #apply_held(peer_id, state, h) {
         h.buffer.position = 0;
-        this.#apply_groups(peer_id, h.buffer, h.length, state.next_frame, h.frame_start, h.frame_end);
+        this.#apply_groups(peer_id, h.buffer, h.length, state.next_frame, h.frame_start, h.frame_end, true);
         if (h.frame_end + 1 > state.next_frame) {
             state.next_frame = h.frame_end + 1;
         }
     }
 
+    /**
+     * A held slice that will never be applied — overtaken by the watermark, or
+     * dropped at the cap. This walk is the last thing that happens to those
+     * frames, so it is the one that books them: the ring separates the copy
+     * whose frames ran from the slice that carried the only copy there was.
+     *
+     * The bytes were validated when they were held, so this cannot throw.
+     *
+     * @private
+     */
+    #discard_held(peer_id, h) {
+        h.buffer.position = 0;
+        this.#apply_groups(peer_id, h.buffer, h.length, Infinity, h.frame_start, h.frame_end, true);
+    }
+
     /**
      * Forget a peer's inbound state — its apply watermark and any slices held
      * for it. Call when a peer disconnects so a later peer reusing the same id

package/src/engine/physics/broadphase/compute_fat_world_aabb.js

@@ -33,15 +33,15 @@ const FAT_VELOCITY_MULTIPLIER = 2;
 export function compute_world_aabb(result, result_offset, shape, transform) {
     shape.compute_bounding_box(scratch_local);
 
-    const p = transform.position;
+    const p = transform.translation;
     const q = transform.rotation;
 
     aabb3_transform_oriented(
         result, result_offset,
         scratch_local[0], scratch_local[1], scratch_local[2],
         scratch_local[3], scratch_local[4], scratch_local[5],
-        p.x, p.y, p.z,
-        q.x, q.y, q.z, q.w
+        transform.translation_x, transform.translation_y, transform.translation_z,
+        transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
     );
 }
 

package/src/engine/physics/ccd/linear_sweep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AAgKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAdW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,MACrC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA2ClB;AAuID;;;;;;;;;;;;GAYG;AACH,6CAFW,OAAO,yBAAyB,EAAE,aAAa,QAezD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAFW,OAAO,yBAAyB,EAAE,aAAa,QAoHzD;AArgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCAtDP,mCAAmC"}
+{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AAgKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAdW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,MACrC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA2ClB;AA2ID;;;;;;;;;;;;GAYG;AACH,6CAFW,OAAO,yBAAyB,EAAE,aAAa,QAezD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAFW,OAAO,yBAAyB,EAAE,aAAa,QAsHzD;AA3gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCAtDP,mCAAmC"}

package/src/engine/physics/ccd/linear_sweep.js

@@ -320,7 +320,11 @@ function record_ccd_contact(system, body_idx, collider, tr, hit) {
     // near the actual contact patch — a large blocker's support along a face
     // axis is a corner metres away, which is why the narrowphase's EPA fallback
     // refuses support witnesses and falls back to body centres.
-    _clamped.setup(collider.shape, tr.position, tr.rotation);
+    _clamped.setup_components(
+        collider.shape,
+        tr.translation_x, tr.translation_y, tr.translation_z,
+        tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w
+    );
     _clamped.support(_witness, 0, -n[0], -n[1], -n[2]);
 
     const wx = _witness[0], wy = _witness[1], wz = _witness[2];
@@ -463,7 +467,7 @@ export function ccd_resolve(system) {
         const list = lists[idx];
         const primary = list[0];
         const tr = primary.transform;
-        const p = tr.position;
+        const p = tr.translation;
 
         const base = idx * 3;
         const sx = start[base];
@@ -502,7 +506,9 @@ export function ccd_resolve(system) {
         // Clamp the body to the first-contact pose (swept-shape centre at the
         // TOI), so it cannot end the step on the far side of the blocker.
         const hp = _hit.position;
-        p.set(hp[0], hp[1], hp[2]);
+        p[0] = hp[0];
+            p[1] = hp[1];
+            p[2] = hp[2];
 
         // Remove the inbound normal component of velocity (inelastic stop).
         // `_hit.normal` is the blocker's outward surface normal; the body is

package/src/engine/physics/constraint/solve_constraints.js

@@ -596,11 +596,11 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
         // World anchor A and its lever arm rA = R_A · localAnchorA.
         const la = joint.localAnchorA;
         v3_quaternion_apply(scratch_anchor, 0, la.x, la.y, la.z,
-            trA.rotation[0], trA.rotation[1], trA.rotation[2], trA.rotation[3]);
+            trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w);
         const rAx = scratch_anchor[0], rAy = scratch_anchor[1], rAz = scratch_anchor[2];
-        const anchorAx = trA.position.x + rAx;
-        const anchorAy = trA.position.y + rAy;
-        const anchorAz = trA.position.z + rAz;
+        const anchorAx = trA.translation_x + rAx;
+        const anchorAy = trA.translation_y + rAy;
+        const anchorAz = trA.translation_z + rAz;
 
         // World anchor B + lever arm rB. For a world anchor, localAnchorB is a
         // fixed world point and there is no body B lever.
@@ -611,11 +611,11 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
             anchorBx = lb.x; anchorBy = lb.y; anchorBz = lb.z;
         } else {
             v3_quaternion_apply(scratch_anchor, 0, lb.x, lb.y, lb.z,
-                trB.rotation[0], trB.rotation[1], trB.rotation[2], trB.rotation[3]);
+                trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w);
             rBx = scratch_anchor[0]; rBy = scratch_anchor[1]; rBz = scratch_anchor[2];
-            anchorBx = trB.position.x + rBx;
-            anchorBy = trB.position.y + rBy;
-            anchorBz = trB.position.z + rBz;
+            anchorBx = trB.translation_x + rBx;
+            anchorBy = trB.translation_y + rBy;
+            anchorBz = trB.translation_z + rBz;
         }
 
         // Position error C = anchorA − anchorB (its projection on a frame axis
@@ -632,7 +632,7 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
         // body-A rotation ⊗ localBasisA; the rows of its matrix are the frame
         // axes in world (see quat3_to_matrix3).
         const lba = joint.localBasisA;
-        quat3_multiply(scratch_q, 0, trA.rotation[0], trA.rotation[1], trA.rotation[2], trA.rotation[3], lba[0], lba[1], lba[2], lba[3]);
+        quat3_multiply(scratch_q, 0, trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w, lba[0], lba[1], lba[2], lba[3]);
         const qAx = scratch_q[0], qAy = scratch_q[1], qAz = scratch_q[2], qAw = scratch_q[3];
         quat3_to_matrix3(scratch_frame_a, 0, qAx, qAy, qAz, qAw);
         const fa = scratch_frame_a;
@@ -693,7 +693,7 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
             let qBx = 0, qBy = 0, qBz = 0, qBw = 1;
             if (!to_world) {
                 const lbb = joint.localBasisB;
-                quat3_multiply(scratch_q, 0, trB.rotation[0], trB.rotation[1], trB.rotation[2], trB.rotation[3], lbb[0], lbb[1], lbb[2], lbb[3]);
+                quat3_multiply(scratch_q, 0, trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w, lbb[0], lbb[1], lbb[2], lbb[3]);
                 qBx = scratch_q[0]; qBy = scratch_q[1]; qBz = scratch_q[2]; qBw = scratch_q[3];
             }
             // qD = conj(qA) ⊗ qB → the per-axis angular position in frame-A