@woosh/meep-engine 2.169.0 → 2.169.2

package/src/engine/intelligence/optimization/RandomOptimizer.d.ts

@@ -27,9 +27,9 @@ export class RandomOptimizer<S> {
     scoreFunction: (arg0: S) => number;
     /**
      *
-     * @type {function(S,random:function():number)|null}
+     * @type {((state: S, random: () => number) => void)|null}
      */
-    randomAction: (arg0: S, arg1: random) => () => number;
+    randomAction: (state: S, random: () => number) => void;
     /**
      *
      * @type {function():number}
@@ -41,7 +41,7 @@ export class RandomOptimizer<S> {
      * @param {function(S):Function[]} [computeValidActions]
      * @param {function(S):S} cloneState
      * @param {function(S):number} scoreFunction
-     * @param {function(S,random:function():number)} [randomAction]
+     * @param {(state: S, random: () => number) => void} [randomAction]
      */
     initialize({ state, computeValidActions, cloneState, scoreFunction, randomAction }: S): void;
     /**

package/src/engine/intelligence/optimization/RandomOptimizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RandomOptimizer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/intelligence/optimization/RandomOptimizer.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;IAGI;;;OAGG;IACH,OAFU,CAAC,GAAC,IAAI,CAEH;IAEb;;;OAGG;IACH,mBAFmB,CAAC,KAAE,CAAC,CAEL;IAElB;;;OAGG;IACH,4BAFmB,CAAC,KAAE,UAAU,CAEL;IAE3B;;;OAGG;IACH,sBAFmB,CAAC,KAAE,MAAM,CAEP;IAErB;;;OAGG;IACH,qBAFmB,CAAC,yBAAmB,MAAM,CAEzB;IAGpB;;;OAGG;IACH,cAFqB,MAAM,CAEF;IAGzB;;;;;;;OAOG;IACH,oFANW,CAAC,QA4BX;IAED;;;OAGG;IACH,QAFa,OAAO,CA2CnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;CACJ"}
+{"version":3,"file":"RandomOptimizer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/intelligence/optimization/RandomOptimizer.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;IAGI;;;OAGG;IACH,OAFU,CAAC,GAAC,IAAI,CAEH;IAEb;;;OAGG;IACH,mBAFmB,CAAC,KAAE,CAAC,CAEL;IAElB;;;OAGG;IACH,4BAFmB,CAAC,KAAE,UAAU,CAEL;IAE3B;;;OAGG;IACH,sBAFmB,CAAC,KAAE,MAAM,CAEP;IAErB;;;OAGG;IACH,sBAFmB,CAAC,UAAU,MAAM,MAAM,KAAK,IAAI,CAE/B;IAGpB;;;OAGG;IACH,cAFqB,MAAM,CAEF;IAGzB;;;;;;;OAOG;IACH,oFANW,CAAC,QA4BX;IAED;;;OAGG;IACH,QAFa,OAAO,CA2CnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;CACJ"}

package/src/engine/intelligence/optimization/RandomOptimizer.js

@@ -36,7 +36,7 @@ export class RandomOptimizer {
 
     /**
      *
-     * @type {function(S,random:function():number)|null}
+     * @type {((state: S, random: () => number) => void)|null}
      */
     randomAction = null;
 
@@ -54,7 +54,7 @@ export class RandomOptimizer {
      * @param {function(S):Function[]} [computeValidActions]
      * @param {function(S):S} cloneState
      * @param {function(S):number} scoreFunction
-     * @param {function(S,random:function():number)} [randomAction]
+     * @param {(state: S, random: () => number) => void} [randomAction]
      */
     initialize(
         {

package/src/engine/intelligence/optimization/optimize_cyclic_sequence_pairwise.d.ts

@@ -5,8 +5,8 @@
  * @param {number} dimensions
  * @param {number} offset
  * @param {number} count
- * @param {function(address0:number, address1:number, sequence:T[]):number} cost_function
+ * @param {(address0: number, address1: number, sequence: T[]) => number} cost_function
  * @param {*} [cost_function_ctx]
  */
-export function optimize_cyclic_sequence_pairwise<T>(sequence: T[], dimensions: number, offset: number, count: number, cost_function: any, cost_function_ctx?: any): void;
+export function optimize_cyclic_sequence_pairwise<T>(sequence: T[], dimensions: number, offset: number, count: number, cost_function: (address0: number, address1: number, sequence: T[]) => number, cost_function_ctx?: any): void;
 //# sourceMappingURL=optimize_cyclic_sequence_pairwise.d.ts.map

package/src/engine/intelligence/optimization/optimize_cyclic_sequence_pairwise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimize_cyclic_sequence_pairwise.d.ts","sourceRoot":"","sources":["../../../../../src/engine/intelligence/optimization/optimize_cyclic_sequence_pairwise.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,gFANW,MAAM,UACN,MAAM,SACN,MAAM,qDAiFhB"}
+{"version":3,"file":"optimize_cyclic_sequence_pairwise.d.ts","sourceRoot":"","sources":["../../../../../src/engine/intelligence/optimization/optimize_cyclic_sequence_pairwise.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,gFANW,MAAM,UACN,MAAM,SACN,MAAM,4BACK,MAAM,YAAY,MAAM,oBAAoB,MAAM,iCAgFvE"}

package/src/engine/intelligence/optimization/optimize_cyclic_sequence_pairwise.js

@@ -7,7 +7,7 @@ import { assert } from "../../../core/assert.js";
  * @param {number} dimensions
  * @param {number} offset
  * @param {number} count
- * @param {function(address0:number, address1:number, sequence:T[]):number} cost_function
+ * @param {(address0: number, address1: number, sequence: T[]) => number} cost_function
  * @param {*} [cost_function_ctx]
  */
 export function optimize_cyclic_sequence_pairwise(

package/src/engine/knowledge/database/StaticKnowledgeDataTable.d.ts

@@ -118,23 +118,22 @@ export class StaticKnowledgeDataTable<T> {
      * @protected
      * @param element
      * @param {StaticKnowledgeDatabase} database
-     * @param {function(problem:string)} errorConsumer
+     * @param {(problem: string) => void} errorConsumer
      * @returns {boolean}
      */
-    protected validateOne(element: any, database: StaticKnowledgeDatabase, errorConsumer: any): boolean;
+    protected validateOne(element: any, database: StaticKnowledgeDatabase, errorConsumer: (problem: string) => void): boolean;
     /**
      * @param {StaticKnowledgeDatabase} database
-     * @param {function(problem:string)} errorConsumer
+     * @param {(problem: string) => void} errorConsumer
      * @throws {Error}
      * @returns {Task} Task succeeds if validation succeeds, and fails if validation fails
      */
-    validate(database: StaticKnowledgeDatabase, errorConsumer?: typeof noop): Task;
+    validate(database: StaticKnowledgeDatabase, errorConsumer?: (problem: string) => void): Task;
     /**
      * @readonly
      * @type {boolean}
      */
     readonly isStaticKnowledgeDataTable: boolean;
 }
-import { noop } from "../../../core/function/noop.js";
 import Task from "../../../core/process/task/Task.js";
 //# sourceMappingURL=StaticKnowledgeDataTable.d.ts.map

package/src/engine/knowledge/database/StaticKnowledgeDataTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticKnowledgeDataTable.d.ts","sourceRoot":"","sources":["../../../../../src/engine/knowledge/database/StaticKnowledgeDataTable.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH;IAEI;;;OAGG;IACH,cAAc;IAEd;;;;OAIG;IACH,kBAHU,IAAI,MAAM,EAAE,MAAM,CAAC,CAGV;IAEnB;;;;OAIG;IACH,mBAHU,CAAC,EAAE,CAGA;IAEb;;;;OAIG;IACH,2BAHU,OAAO,CAGO;IAExB;;;;OAIG;IACH,+BAHU,MAAM,CAGgB;IAEhC,cAQC;IAED,gBAQC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACL,OAAO,CAIlB;IAGD;;;;OAIG;IACH,QAHW,MAAM,GACJ,CAAC,GAAC,IAAI,CAalB;IAED;;;;;OAKG;IACH,gBAHW,CAAC,EAAE,OADH,QAAQ,QAkBlB;IAGD;;;;OAIG;IACH,yBAHoB,CAAC,+BAapB;IAED;;;;;OAKG;IACH,iBAJoB,CAAC,KAAE,OAAO,kBAElB,CAAC,EAAE,CAkBd;IAED;;;OAGG;IACH,WAFY,CAAC,EAAE,CAId;IAED;;;;OAIG;IACH,UAHW,CAAC,GACC,OAAO,CAenB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,CAAC,GAAC;QAAC,EAAE,EAAC,MAAM,CAAA;KAAC,CAIzB;IAED;;;;;OAKG;IACH,8DAuFC;IAED;;;;;;;OAOG;IACH,iBANW,CAAC,QACD,MAAM,+EAOhB;IAED;;;;;;OAMG;IACH,gHAuEC;IAED;;;;;;OAMG;IACH,4FAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,0EAFa,IAAI,CA0DhB;IAIL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;CAP5D;qBA3eoB,gCAAgC;iBACpC,oCAAoC"}
+{"version":3,"file":"StaticKnowledgeDataTable.d.ts","sourceRoot":"","sources":["../../../../../src/engine/knowledge/database/StaticKnowledgeDataTable.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH;IAEI;;;OAGG;IACH,cAAc;IAEd;;;;OAIG;IACH,kBAHU,IAAI,MAAM,EAAE,MAAM,CAAC,CAGV;IAEnB;;;;OAIG;IACH,mBAHU,CAAC,EAAE,CAGA;IAEb;;;;OAIG;IACH,2BAHU,OAAO,CAGO;IAExB;;;;OAIG;IACH,+BAHU,MAAM,CAGgB;IAEhC,cAQC;IAED,gBAQC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACL,OAAO,CAIlB;IAGD;;;;OAIG;IACH,QAHW,MAAM,GACJ,CAAC,GAAC,IAAI,CAalB;IAED;;;;;OAKG;IACH,gBAHW,CAAC,EAAE,OADH,QAAQ,QAkBlB;IAGD;;;;OAIG;IACH,yBAHoB,CAAC,+BAapB;IAED;;;;;OAKG;IACH,iBAJoB,CAAC,KAAE,OAAO,kBAElB,CAAC,EAAE,CAkBd;IAED;;;OAGG;IACH,WAFY,CAAC,EAAE,CAId;IAED;;;;OAIG;IACH,UAHW,CAAC,GACC,OAAO,CAenB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,CAAC,GAAC;QAAC,EAAE,EAAC,MAAM,CAAA;KAAC,CAIzB;IAED;;;;;OAKG;IACH,8DAuFC;IAED;;;;;;;OAOG;IACH,iBANW,CAAC,QACD,MAAM,+EAOhB;IAED;;;;;;OAMG;IACH,gHAuEC;IAED;;;;;;OAMG;IACH,gGAHqB,MAAM,KAAK,IAAI,GACvB,OAAO,CAInB;IAED;;;;;OAKG;IACH,sEAJqB,MAAM,KAAK,IAAI,GAEvB,IAAI,CA0DhB;IAIL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;CAP5D;iBA1egB,oCAAoC"}

package/src/engine/knowledge/database/StaticKnowledgeDataTable.js

@@ -420,7 +420,7 @@ export class StaticKnowledgeDataTable {
      * @protected
      * @param element
      * @param {StaticKnowledgeDatabase} database
-     * @param {function(problem:string)} errorConsumer
+     * @param {(problem: string) => void} errorConsumer
      * @returns {boolean}
      */
     validateOne(element, database, errorConsumer) {
@@ -429,7 +429,7 @@ export class StaticKnowledgeDataTable {
 
     /**
      * @param {StaticKnowledgeDatabase} database
-     * @param {function(problem:string)} errorConsumer
+     * @param {(problem: string) => void} errorConsumer
      * @throws {Error}
      * @returns {Task} Task succeeds if validation succeeds, and fails if validation fails
      */

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts

@@ -17,11 +17,6 @@ declare class PathFollowingSystem extends System<any> {
      * @param {number} entity Entity ID
      */
     __visit_entity(pathFollower: PathFollower, transform: Transform, path: Path, entity: number): void;
-    /**
-     *
-     * @param {number} timeDelta Time in seconds
-     */
-    update(timeDelta: number): void;
 }
 import { System } from '../../../ecs/System.js';
 import PathFollower from './PathFollower.js';

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAwHA;IACI,cAiBC;IAdG,sCAAkC;IAElC,iKAIC;IAED;;;;OAIG;IACH,qBAAqB;IAGzB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,SAAS,QACT,IAAI,UACJ,MAAM,QAuBhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAWhB;CACJ;uBAnLsB,wBAAwB;yBAGtB,mBAAmB;0BAFlB,qCAAqC;4CAFnB,uDAAuD;iBAGlF,uBAAuB"}
+{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAwHA;IACI,cAiBC;IAdG,sCAAkC;IAElC,iKAIC;IAED;;;;OAIG;IACH,qBAAqB;IAGzB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,SAAS,QACT,IAAI,UACJ,MAAM,QAuBhB;CAgBJ;uBAnLsB,wBAAwB;yBAGtB,mBAAmB;0BAFlB,qCAAqC;4CAFnB,uDAAuD;iBAGlF,uBAAuB"}

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,
+        );
     }
 
     /**