@woosh/meep-engine 2.169.1 → 2.169.2

package/src/engine/input/ecs/util/TopDownCameraControllerHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopDownCameraControllerHelper.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/util/TopDownCameraControllerHelper.js"],"names":[],"mappings":";AAkDA,+GAmCC;mBA5EkB,wBAAwB"}
+{"version":3,"file":"TopDownCameraControllerHelper.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/util/TopDownCameraControllerHelper.js"],"names":[],"mappings":";AAoBA,+GAmCC;mBA/CkB,wBAAwB"}

package/src/engine/input/ecs/util/TopDownCameraControllerHelper.js

@@ -6,7 +6,6 @@ import {
     MeshLambertMaterial,
     SphereGeometry as ThreeSphereGeometry
 } from 'three';
-import Vector3 from '../../../../core/geom/Vector3.js';
 import Entity from '../../../ecs/Entity.js';
 import Renderable from '../../../ecs/renderable/Renderable.js';
 import { Transform } from '../../../ecs/transform/Transform.js';
@@ -16,38 +15,9 @@ const tMarkerFromMaterial = new MeshLambertMaterial({ color: 0xFF0000 });
 
 const tMarkerToMaterial = new MeshLambertMaterial({ color: 0xffff00 });
 
-const lookAt = (function () {
-    // just in case you need that function also
-    function CreateFromAxisAngle(axis, angle, result) {
-        const halfAngle = angle / 2;
-        const s = Math.sin(halfAngle);
-        result.set(axis.x * s, axis.y * s, axis.z * s, Math.cos(halfAngle));
-    }
-
-    const forwardVector = new Vector3();
-    const __forwardVector = new Vector3(0, 0, 1);
-    const __upVector = new Vector3(0, 1, 0);
-    const rotAxis = new Vector3();
-
-    function lookAt(sourcePoint, destPoint, result) {
-        forwardVector.copy(destPoint).sub(sourcePoint).normalize();
-        const dot = __forwardVector.dot(forwardVector);
-        if (Math.abs(dot - (-1.0)) < 0.000001) {
-            return result.set(__upVector.x, __upVector.y, __upVector.z, 3.1415926535897932);
-        }
-        if (Math.abs(dot - (1.0)) < 0.000001) {
-            return result.set(0, 0, 0, 1);
-        }
-
-        const rotAngle = Math.acos(dot);
-        rotAxis.copy(__forwardVector);
-        rotAxis.cross(forwardVector);
-        rotAxis.normalize();
-        return CreateFromAxisAngle(rotAxis, rotAngle, result);
-    }
-
-    return lookAt;
-})();
+// NOTE: this module used to carry private `CreateFromAxisAngle` / `lookAt` copies of
+// `Quaternion.fromAxisAngle` / `Quaternion.lookRotation`. They were never called from here;
+// use the spec-covered methods on `core/geom/Quaternion.js` instead.
 const TopDownCameraControllerHelper = function (targetController, targetTransform, size) {
     const tMarkerFromGeometry = new ThreeCylinderGeometry(0, size * 0.5, size, 10, 1);
     const tMarkerToGeometry = new ThreeSphereGeometry(size / 2, 32, 32);

package/src/engine/intelligence/behavior/util/RandomDelayBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RandomDelayBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/util/RandomDelayBehavior.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IA6BI;;;;OAIG;IACH,4BAFY,mBAAmB,CAM9B;IAED;;;;;OAKG;IACH,iCAJY,mBAAmB,CAU9B;;IAlDD;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,eAAe,CAEU;IAEnC;;;;OAIG;IACH,gBAAY;IAEZ;;;MAAiC;IAGjC;;;aAGC;IAkCD,6BAQC;CACJ;yBAnFwB,gBAAgB;gCAFT,mDAAmD"}
+{"version":3,"file":"RandomDelayBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/util/RandomDelayBehavior.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH;IA6BI;;;;OAIG;IACH,4BAFY,mBAAmB,CAM9B;IAED;;;;;OAKG;IACH,iCAJY,mBAAmB,CAU9B;;IAlDD;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,eAAe,CAEU;IAEnC;;;;OAIG;IACH,gBAAY;IAEZ;;;MAAiC;IAGjC;;;aAGC;IAkCD,6BAQC;CACJ;yBAxFwB,gBAAgB;gCAFT,mDAAmD"}

package/src/engine/intelligence/behavior/util/RandomDelayBehavior.js

@@ -5,6 +5,11 @@ import { Behavior } from "../Behavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 
 
+/**
+ * DETERMINISM HOLE: seeds behaviour-tree delays from wall-clock time XOR an unseeded global, so a
+ * replayed world takes different branches at different times. Both sources have to go for this to be
+ * reproducible; the replacement is a run-level seeded stream threaded in by the owner of the tree.
+ */
 function nextSeed() {
     return Date.now() ^ (Math.random() * UINT32_MAX);
 }

package/src/engine/network/adapters/QuaternionInterpolationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QuaternionInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/QuaternionInterpolationAdapter.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH;IAEI,kBAAkB;IAClB,+FA6BC;CACJ;2CA3C0C,mDAAmD"}
+{"version":3,"file":"QuaternionInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/QuaternionInterpolationAdapter.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH;IAEI,kBAAkB;IAClB,+FAmBC;CACJ;2CAzC0C,mDAAmD"}

package/src/engine/network/adapters/QuaternionInterpolationAdapter.js

@@ -1,5 +1,14 @@
+import { quat3_nlerp } from "../../../core/geom/3d/quaternion/quat3_nlerp.js";
 import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 
+/**
+ * Module-level scratch for the blend result. Float64 so the blend keeps full
+ * precision right up to the Float32 write. Safe because `interpolate` is
+ * synchronous and non-reentrant.
+ * @type {Float64Array}
+ */
+const scratch = new Float64Array(4);
+
 /**
  * Shortest-path nlerp for a 4 × Float32 quaternion payload (16 bytes).
  * Switch to a slerp variant if you need it for wide per-tick angular
@@ -19,26 +28,16 @@ export class QuaternionInterpolationAdapter extends BinaryInterpolationAdapter {
         const aw = source.readFloat32();
 
         source.position = second_offset;
-        let bx = source.readFloat32();
-        let by = source.readFloat32();
-        let bz = source.readFloat32();
-        let bw = source.readFloat32();
-
-        if (ax * bx + ay * by + az * bz + aw * bw < 0) {
-            bx = -bx; by = -by; bz = -bz; bw = -bw;
-        }
-
-        let qx = ax + (bx - ax) * t;
-        let qy = ay + (by - ay) * t;
-        let qz = az + (bz - az) * t;
-        let qw = aw + (bw - aw) * t;
+        const bx = source.readFloat32();
+        const by = source.readFloat32();
+        const bz = source.readFloat32();
+        const bw = source.readFloat32();
 
-        const len2 = qx * qx + qy * qy + qz * qz + qw * qw;
-        const inv_len = len2 > 0 ? 1 / Math.sqrt(len2) : 1;
+        quat3_nlerp(scratch, 0, ax, ay, az, aw, bx, by, bz, bw, t);
 
-        out_buffer.writeFloat32(qx * inv_len);
-        out_buffer.writeFloat32(qy * inv_len);
-        out_buffer.writeFloat32(qz * inv_len);
-        out_buffer.writeFloat32(qw * inv_len);
+        out_buffer.writeFloat32(scratch[0]);
+        out_buffer.writeFloat32(scratch[1]);
+        out_buffer.writeFloat32(scratch[2]);
+        out_buffer.writeFloat32(scratch[3]);
     }
 }

package/src/engine/network/adapters/TransformInterpolationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformInterpolationAdapter.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH;IAEI,kBAAkB;IAClB,+FAiDC;CACJ;2CA1E0C,mDAAmD"}
+{"version":3,"file":"TransformInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformInterpolationAdapter.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;GAWG;AACH;IAEI,kBAAkB;IAClB,+FA6CC;CACJ;2CA9E0C,mDAAmD"}

package/src/engine/network/adapters/TransformInterpolationAdapter.js

@@ -1,5 +1,6 @@
 import { quat3_decode_from_uint32 } from "../../../core/geom/3d/quaternion/quat3_decode_from_uint32.js";
 import { quat3_encode_to_uint32 } from "../../../core/geom/3d/quaternion/quat3_encode_to_uint32.js";
+import { quat3_nlerp } from "../../../core/geom/3d/quaternion/quat3_nlerp.js";
 import { v3_binary_equality_decode } from "../../../core/geom/vec3/serialization/v3_binary_equality_decode.js";
 import { v3_binary_equality_encode } from "../../../core/geom/vec3/serialization/v3_binary_equality_encode.js";
 import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
@@ -11,6 +12,14 @@ import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolat
  */
 const scratch = new Float32Array(16);
 
+/**
+ * Module-level scratch for the blended rotation. Kept separate from
+ * {@link scratch} and at Float64 so the blend feeds the smallest-three
+ * encoder at full precision, exactly as the previous inline math did.
+ * @type {Float64Array}
+ */
+const rotation_scratch = new Float64Array(4);
+
 /**
  * Linear-blend interpolation for {@link Transform}, matching the wire
  * layout of {@link TransformReplicationAdapter}: 3×Float32 position +
@@ -51,18 +60,12 @@ export class TransformInterpolationAdapter extends BinaryInterpolationAdapter {
         const out_z = az + (bz - az) * t;
 
         // ---- Rotation nlerp with shortest-path correction ----
-        const aqx = scratch[0], aqy = scratch[1], aqz = scratch[2], aqw = scratch[3];
-        let bqx = scratch[4], bqy = scratch[5], bqz = scratch[6], bqw = scratch[7];
-        if (aqx * bqx + aqy * bqy + aqz * bqz + aqw * bqw < 0) {
-            bqx = -bqx; bqy = -bqy; bqz = -bqz; bqw = -bqw;
-        }
-        let qx = aqx + (bqx - aqx) * t;
-        let qy = aqy + (bqy - aqy) * t;
-        let qz = aqz + (bqz - aqz) * t;
-        let qw = aqw + (bqw - aqw) * t;
-        const len2 = qx * qx + qy * qy + qz * qz + qw * qw;
-        const inv_len = len2 > 0 ? 1 / Math.sqrt(len2) : 1;
-        qx *= inv_len; qy *= inv_len; qz *= inv_len; qw *= inv_len;
+        quat3_nlerp(
+            rotation_scratch, 0,
+            scratch[0], scratch[1], scratch[2], scratch[3],
+            scratch[4], scratch[5], scratch[6], scratch[7],
+            t,
+        );
 
         // ---- Scale lerp ----
         const out_sx = scratch[8]  + (scratch[11] - scratch[8])  * t;
@@ -73,7 +76,9 @@ export class TransformInterpolationAdapter extends BinaryInterpolationAdapter {
         out_buffer.writeFloat32(out_x);
         out_buffer.writeFloat32(out_y);
         out_buffer.writeFloat32(out_z);
-        out_buffer.writeUint32(quat3_encode_to_uint32(qx, qy, qz, qw));
+        out_buffer.writeUint32(quat3_encode_to_uint32(
+            rotation_scratch[0], rotation_scratch[1], rotation_scratch[2], rotation_scratch[3],
+        ));
         v3_binary_equality_encode(out_buffer, out_sx, out_sy, out_sz);
     }
 }

package/src/engine/network/orchestrator/NetworkPeer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkPeer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/NetworkPeer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"NetworkPeer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/NetworkPeer.js"],"names":[],"mappings":"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"}

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

@@ -2,6 +2,7 @@ import { assert } from "../../../core/assert.js";
 import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 import Signal from "../../../core/events/signal/Signal.js";
 import { MalformedPacketError } from "../core/MalformedPacketError.js";
+import { seq16_advance } from "../core/sequence/seq16.js";
 import { Replicator } from "../replication/Replicator.js";
 import { AlwaysRelevantScope } from "../replication/ScopeFilter.js";
 import { ActionLog } from "../sim/ActionLog.js";
@@ -914,7 +915,7 @@ export class NetworkPeer {
             return conn.channel.send(payload, length);
         }
         const message_id = this.#next_fragment_message_id;
-        this.#next_fragment_message_id = (this.#next_fragment_message_id + 1) & 0xFFFF;
+        this.#next_fragment_message_id = seq16_advance(this.#next_fragment_message_id);
         // Retain the source bytes so we can satisfy NACK retransmits.
         // Copy happens inside retain(); `payload` is the orchestrator's
         // shared send buffer and will be overwritten by the next call.

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

@@ -28,7 +28,10 @@
  * from the inbound packet's peer_id, so a hostile peer cannot impersonate.
  *
  * Ring depth is set at construction. When the ring fills, the oldest frame's
- * buffer is recycled for the new frame.
+ * buffer is recycled for the new frame. Storage and addressing live in
+ * {@link FrameBufferRing}; what this class adds is the open-frame discipline —
+ * exactly one frame may be written at a time, and it must be closed before the
+ * next is opened.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -42,10 +45,11 @@ export class ActionLog {
         initial_buffer_size?: number;
     });
     /**
+     * Number of frames retained before the oldest is recycled.
      * @readonly
-     * @type {number}
+     * @returns {number}
      */
-    readonly frame_capacity: number;
+    readonly get frame_capacity(): number;
     /**
      * Open a new frame for writing. Recycles the oldest slot if the ring is full.
      *
@@ -74,8 +78,8 @@ export class ActionLog {
      * The buffer's `position` will be set to 0 and its valid byte length is `write_end_for(frame)`.
      *
      * **Only valid for frames that have been closed via {@link end_frame}.** While a
-     * frame is open, `__write_ends[slot]` still holds the previous occupant's
-     * length — `buffer_for`/`write_end_for` would return mismatched
+     * frame is open, its slot's recorded length still holds the previous
+     * occupant's — `buffer_for`/`write_end_for` would return mismatched
      * buffer-contents-vs-length and any reader would walk garbage.
      *
      * @param {number} frame
@@ -90,5 +94,4 @@ export class ActionLog {
     write_end_for(frame: number): number;
     #private;
 }
-import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 //# sourceMappingURL=ActionLog.d.ts.map

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":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAOI;;OAEG;IACH,qDAFW;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,EAgDlE;IAzCG;;;OAGG;IACH,yBAFU,MAAM,CAEoB;IAuCxC;;;;OAIG;IACH,mBAFW,MAAM,QAehB;IAED;;OAEG;IACH,kBAOC;IAED;;;;OAIG;IACH,kBAFa,YAAY,CAOxB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,MAAM,GACJ,YAAY,CAWxB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,MAAM,CASlB;;CACJ;6BA3L4B,sCAAsC"}
+{"version":3,"file":"ActionLog.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/ActionLog.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAoBI;;OAEG;IACH,qDAFW;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,EAIlE;IAED;;;;OAIG;IACH,sCAEC;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAShB;IAED;;OAEG;IACH,kBASC;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"}

package/src/engine/network/sim/ActionLog.js

@@ -1,5 +1,4 @@
-import { assert } from "../../../core/assert.js";
-import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+import { FrameBufferRing } from "../state/FrameBufferRing.js";
 
 /**
  * Per-frame ring of action records.
@@ -31,67 +30,48 @@ import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
  * from the inbound packet's peer_id, so a hostile peer cannot impersonate.
  *
  * Ring depth is set at construction. When the ring fills, the oldest frame's
- * buffer is recycled for the new frame.
+ * buffer is recycled for the new frame. Storage and addressing live in
+ * {@link FrameBufferRing}; what this class adds is the open-frame discipline —
+ * exactly one frame may be written at a time, and it must be closed before the
+ * next is opened.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
 export class ActionLog {
-    #buffers;
-    #frame_numbers;
-    #write_ends;
-    #current_frame;
+    /**
+     * @type {FrameBufferRing}
+     */
+    #ring;
 
+    /**
+     * Frame number currently being written to, or -1 if no frame is open.
+     * @type {number}
+     */
+    #current_frame = -1;
+
+    /**
+     * Buffer of the currently-open frame, or null if no frame is open. Held so
+     * that {@link current_buffer} — called once per action executed — is a
+     * field read rather than a ring lookup.
+     * @type {BinaryBuffer|null}
+     */
+    #current_buffer = null;
 
     /**
      * @param {{ frame_capacity: number, initial_buffer_size?: number }} options
      */
     constructor({ frame_capacity, initial_buffer_size = 4096 }) {
-        if (!Number.isInteger(frame_capacity) || frame_capacity <= 0) {
-            throw new Error(`ActionLog: frame_capacity must be a positive integer, got ${frame_capacity}`);
-        }
-
-        /**
-         * @readonly
-         * @type {number}
-         */
-        this.frame_capacity = frame_capacity;
-
-        /**
-         * Per-frame buffers. Index by `frame % frame_capacity`.
-         * @type {BinaryBuffer[]}
-         * @private
-         */
-        this.#buffers = new Array(frame_capacity);
-
-        /**
-         * Per-frame absolute frame numbers (so we can detect "this slot is stale").
-         * `-1` means the slot has not yet been used.
-         * @type {Int32Array}
-         * @private
-         */
-        this.#frame_numbers = new Int32Array(frame_capacity).fill(-1);
-
-        /**
-         * Per-frame "write end" position. The buffer's own `position` is reused
-         * when actively writing; this is captured at frame_end so readers know
-         * where the meaningful data ends.
-         * @type {Int32Array}
-         * @private
-         */
-        this.#write_ends = new Int32Array(frame_capacity);
-
-        for (let i = 0; i < frame_capacity; i++) {
-            this.#buffers[i] = new BinaryBuffer();
-            this.#buffers[i].setCapacity(initial_buffer_size);
-        }
+        this.#ring = new FrameBufferRing({ owner: 'ActionLog', frame_capacity, initial_buffer_size });
+    }
 
-        /**
-         * Frame number currently being written to, or -1 if no frame is open.
-         * @type {number}
-         * @private
-         */
-        this.#current_frame = -1;
+    /**
+     * Number of frames retained before the oldest is recycled.
+     * @readonly
+     * @returns {number}
+     */
+    get frame_capacity() {
+        return this.#ring.frame_capacity;
     }
 
     /**
@@ -100,17 +80,11 @@ export class ActionLog {
      * @param {number} frame absolute frame number
      */
     begin_frame(frame) {
-        assert.isNonNegativeInteger(frame, 'frame');
-
         if (this.#current_frame !== -1) {
             throw new Error(`ActionLog.begin_frame: previous frame ${this.#current_frame} still open; call end_frame first`);
         }
 
-        const slot = frame % this.frame_capacity;
-        const buffer = this.#buffers[slot];
-
-        buffer.position = 0;
-        this.#frame_numbers[slot] = frame;
+        this.#current_buffer = this.#ring.open(frame);
         this.#current_frame = frame;
     }
 
@@ -121,9 +95,11 @@ export class ActionLog {
         if (this.#current_frame === -1) {
             throw new Error(`ActionLog.end_frame: no frame is open`);
         }
-        const slot = this.#current_frame % this.frame_capacity;
-        this.#write_ends[slot] = this.#buffers[slot].position;
+
+        this.#ring.commit(this.#current_frame);
+
         this.#current_frame = -1;
+        this.#current_buffer = null;
     }
 
     /**
@@ -135,7 +111,8 @@ export class ActionLog {
         if (this.#current_frame === -1) {
             throw new Error(`ActionLog.current_buffer: no frame is open`);
         }
-        return this.#buffers[this.#current_frame % this.frame_capacity];
+
+        return this.#current_buffer;
     }
 
     /**
@@ -145,9 +122,7 @@ export class ActionLog {
      * @returns {boolean}
      */
     has_frame(frame) {
-        assert.isNonNegativeInteger(frame, 'frame');
-        const slot = frame % this.frame_capacity;
-        return this.#frame_numbers[slot] === frame;
+        return this.#ring.has(frame);
     }
 
     /**
@@ -155,22 +130,15 @@ export class ActionLog {
      * The buffer's `position` will be set to 0 and its valid byte length is `write_end_for(frame)`.
      *
      * **Only valid for frames that have been closed via {@link end_frame}.** While a
-     * frame is open, `__write_ends[slot]` still holds the previous occupant's
-     * length — `buffer_for`/`write_end_for` would return mismatched
+     * frame is open, its slot's recorded length still holds the previous
+     * occupant's — `buffer_for`/`write_end_for` would return mismatched
      * buffer-contents-vs-length and any reader would walk garbage.
      *
      * @param {number} frame
      * @returns {BinaryBuffer}
      */
     buffer_for(frame) {
-        assert.isNonNegativeInteger(frame, 'frame');
-        if (!this.has_frame(frame)) {
-            throw new Error(`ActionLog.buffer_for: frame ${frame} is not present in the ring`);
-        }
-        const slot = frame % this.frame_capacity;
-        const buffer = this.#buffers[slot];
-        buffer.position = 0;
-        return buffer;
+        return this.#ring.buffer_for(frame);
     }
 
     /**
@@ -179,11 +147,6 @@ export class ActionLog {
      * @returns {number}
      */
     write_end_for(frame) {
-        assert.isNonNegativeInteger(frame, 'frame');
-        if (!this.has_frame(frame)) {
-            throw new Error(`ActionLog.write_end_for: frame ${frame} is not present in the ring`);
-        }
-        const slot = frame % this.frame_capacity;
-        return this.#write_ends[slot];
+        return this.#ring.write_end_for(frame);
     }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"SmoothingState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SmoothingState.js"],"names":[],"mappings":"AA6CA;IAKI;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,qCAJW,MAAM,kBACN,OAAO,GAAC,UAAU,MAAM,CAAC,uBACzB,OAAO,GAAC,UAAU,MAAM,CAAC,QAanC;IAED;;;;;;;;;;;;;;OAcG;IACH,wCAJW,MAAM,kBACN,UAAU,GAAC,UAAU,MAAM,CAAC,uBAC5B,UAAU,GAAC,UAAU,MAAM,CAAC,QAiBtC;IAED;;;;;;;;OAQG;IACH,iBAFW,MAAM,QAqChB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,WACN,OAAO,GAAC,UAAU,MAAM,CAAC,WACzB,OAAO,GAAC,UAAU,MAAM,CAAC,QAanC;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ;QAAC,cAAc,EAAE,OAAO,CAAC;QAAC,iBAAiB,EAAE,UAAU,CAAA;KAAC,GAAC,SAAS,CAI9E;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;;CACJ;oBA5NmB,+BAA+B;uBAD5B,kCAAkC"}
+{"version":3,"file":"SmoothingState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SmoothingState.js"],"names":[],"mappings":"AAgDA;IAKI;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,qCAJW,MAAM,kBACN,OAAO,GAAC,UAAU,MAAM,CAAC,uBACzB,OAAO,GAAC,UAAU,MAAM,CAAC,QAanC;IAED;;;;;;;;;;;;;;OAcG;IACH,wCAJW,MAAM,kBACN,UAAU,GAAC,UAAU,MAAM,CAAC,uBAC5B,UAAU,GAAC,UAAU,MAAM,CAAC,QAkBtC;IAED;;;;;;;;OAQG;IACH,iBAFW,MAAM,QAgChB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,WACN,OAAO,GAAC,UAAU,MAAM,CAAC,WACzB,OAAO,GAAC,UAAU,MAAM,CAAC,QAanC;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ;QAAC,cAAc,EAAE,OAAO,CAAC;QAAC,iBAAiB,EAAE,UAAU,CAAA;KAAC,GAAC,SAAS,CAI9E;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;;CACJ;oBAxNmB,+BAA+B;uBAF5B,kCAAkC"}

package/src/engine/network/sim/SmoothingState.js

@@ -1,5 +1,8 @@
 import { assert } from "../../../core/assert.js";
+import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { quat3_nlerp } from "../../../core/geom/3d/quaternion/quat3_nlerp.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 
 /**
@@ -129,12 +132,13 @@ export class SmoothingState {
         }
         // error = pre * inverse(post). With render = error * post, this
         // satisfies render = pre — continuous across the correction.
-        const px = pre_render_rot[0], py = pre_render_rot[1], pz = pre_render_rot[2], pw = pre_render_rot[3];
-        const ix = -post_correction_rot[0], iy = -post_correction_rot[1], iz = -post_correction_rot[2], iw = post_correction_rot[3];
-        s.orientation_error[0] = pw*ix + px*iw + py*iz - pz*iy;
-        s.orientation_error[1] = pw*iy - px*iz + py*iw + pz*ix;
-        s.orientation_error[2] = pw*iz + px*iy - py*ix + pz*iw;
-        s.orientation_error[3] = pw*iw - px*ix - py*iy - pz*iz;
+        // `post` is a unit quaternion, so its inverse is its conjugate:
+        // negate the vector part and hand the pair to the shared product.
+        quat3_multiply(
+            s.orientation_error, 0,
+            pre_render_rot[0], pre_render_rot[1], pre_render_rot[2], pre_render_rot[3],
+            -post_correction_rot[0], -post_correction_rot[1], -post_correction_rot[2], post_correction_rot[3],
+        );
     }
 
     /**
@@ -152,35 +156,30 @@ export class SmoothingState {
         if (s === undefined) return;
 
         const ex = s.position_error[0], ey = s.position_error[1], ez = s.position_error[2];
-        const magnitude = Math.sqrt(ex*ex + ey*ey + ez*ez);
+        const magnitude = v3_length(ex, ey, ez);
         const factor = position_decay_factor(magnitude);
 
         s.position_error[0] = ex * factor;
         s.position_error[1] = ey * factor;
         s.position_error[2] = ez * factor;
 
-        // Orientation: slerp toward identity by (1 - factor). The existing
-        // Quaternion.slerp mutates `this`; use the static helper variant if
-        // available. For now, do a manual lerp+normalize since identity is
-        // (0,0,0,1) and we want to bias toward it.
-        const qx = s.orientation_error[0], qy = s.orientation_error[1], qz = s.orientation_error[2], qw = s.orientation_error[3];
-        // Choose the shorter arc (q vs -q both represent the same rotation).
+        // Orientation: nlerp toward identity by `1 - factor`, so `factor` of the
+        // error survives — the same easing the position error just got.
+        //
+        // The sign flip is applied to the error term rather than left to
+        // `quat3_nlerp`'s own hemisphere check: the primitive would flip the
+        // *other* operand (identity), which names the same rotation but stores
+        // the whole result negated. Pre-flipping keeps `w` non-negative, so the
+        // stored error stays in the hemisphere the decay walks toward.
+        const qw = s.orientation_error[3];
         const sign = qw < 0 ? -1 : 1;
-        const ax = qx * sign, ay = qy * sign, az = qz * sign, aw = qw * sign;
-        // Lerp toward identity by `1 - factor` (factor stays, identity gets the rest).
-        const nx = ax * factor;
-        const ny = ay * factor;
-        const nz = az * factor;
-        const nw = aw * factor + (1 - factor);
-        // Normalize.
-        const len = Math.sqrt(nx*nx + ny*ny + nz*nz + nw*nw);
-        if (len > 0) {
-            const inv = 1 / len;
-            s.orientation_error[0] = nx * inv;
-            s.orientation_error[1] = ny * inv;
-            s.orientation_error[2] = nz * inv;
-            s.orientation_error[3] = nw * inv;
-        }
+
+        quat3_nlerp(
+            s.orientation_error, 0,
+            s.orientation_error[0] * sign, s.orientation_error[1] * sign, s.orientation_error[2] * sign, qw * sign,
+            0, 0, 0, 1,
+            1 - factor,
+        );
     }
 
     /**

package/src/engine/network/state/FrameBufferRing.d.ts

@@ -0,0 +1,84 @@
+/**
+ * A fixed-depth ring of {@link BinaryBuffer} slots, addressed by absolute frame
+ * number.
+ *
+ * Slot `frame % frame_capacity` holds that frame's bytes. Each slot remembers
+ * which absolute frame currently occupies it, so a wrapped-over frame reports
+ * as absent rather than silently handing back its successor's bytes — the one
+ * piece of bookkeeping that makes "index by modulo" safe.
+ *
+ * Exists because two classes needed exactly this and each grew its own copy:
+ * {@link ActionLog} (per-frame action records, for rollback) and
+ * {@link InputRing} (per-frame player input, for redundancy and replay). Their
+ * constructors, presence checks and both accessors were token-identical; only
+ * the *framing policy* differed, and that is what stayed with them. This class
+ * owns storage and addressing and nothing else — it has no opinion about when a
+ * frame may be opened or whether two may be open at once.
+ *
+ * Writers go through {@link open} then {@link commit}. Readers go through
+ * {@link has}, {@link buffer_for} and {@link write_end_for}. A slot is claimed
+ * by `open`, so it reads as present from that moment; its recorded length only
+ * becomes meaningful at `commit`, which is why reading a frame that is still
+ * being written yields the previous occupant's length. Owners that allow a
+ * frame to stay open across calls are responsible for saying so.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class FrameBufferRing {
+    /**
+     * @param {{owner: string, frame_capacity: number, initial_buffer_size: number}} options
+     */
+    constructor({ owner, frame_capacity, initial_buffer_size }: {
+        owner: string;
+        frame_capacity: number;
+        initial_buffer_size: number;
+    });
+    /**
+     * Number of frames retained. Writing frame `f` evicts frame
+     * `f - frame_capacity`.
+     * @readonly
+     * @type {number}
+     */
+    readonly frame_capacity: number;
+    /**
+     * Claim the slot for `frame` and hand back its buffer, rewound to 0.
+     * Whatever the slot held is now unreachable.
+     *
+     * @param {number} frame absolute frame number
+     * @returns {BinaryBuffer} positioned at 0, ready to be written
+     */
+    open(frame: number): BinaryBuffer;
+    /**
+     * Record how far the writer got, fixing the frame's length for readers.
+     *
+     * @param {number} frame absolute frame number, previously passed to {@link open}
+     */
+    commit(frame: number): void;
+    /**
+     * Has this frame been written, and is it still in the ring?
+     *
+     * @param {number} frame
+     * @returns {boolean}
+     */
+    has(frame: number): boolean;
+    /**
+     * The frame's buffer, rewound to 0. Its valid byte count is
+     * {@link write_end_for}; the buffer itself is longer.
+     *
+     * @param {number} frame
+     * @returns {BinaryBuffer}
+     */
+    buffer_for(frame: number): BinaryBuffer;
+    /**
+     * Number of meaningful bytes in the frame's buffer, as of its last
+     * {@link commit}.
+     *
+     * @param {number} frame
+     * @returns {number}
+     */
+    write_end_for(frame: number): number;
+    #private;
+}
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+//# sourceMappingURL=FrameBufferRing.d.ts.map