@woosh/meep-engine 3.17.2 → 3.18.0

package/src/engine/interpolation/InterpolationSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAOI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA6CvE;IAnDD,sCAA8B;IAC9B,oEAEE;IAQE;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;;OAKG;IACH,mBAA2B;IAE3B;;;;OAIG;IACH,kBAAmC;IAGnC;;;;;;;OAOG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,yBAAiC;IAGrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAI7D;IASD;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAShB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAIhB;IAED,sBA0FC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CANlD;uBA9NsB,kBAAkB;6BAEyC,mBAAmB;4CAHzD,iDAAiD;iCAE5D,uBAAuB"}
+{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAOI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA6CvE;IAnDD,sCAA8B;IAC9B,oEAEE;IAQE;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;;OAKG;IACH,mBAA2B;IAE3B;;;;OAIG;IACH,kBAAmC;IAGnC;;;;;;;OAOG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,yBAAiC;IAGrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAI7D;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IASD;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAShB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAIhB;IAED,sBA0FC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CANlD;uBAxOsB,kBAAkB;6BAEyC,mBAAmB;4CAHzD,iDAAiD;iCAE5D,uBAAuB"}

package/src/engine/interpolation/InterpolationSystem.js

@@ -104,6 +104,16 @@ export class InterpolationSystem extends System {
         this.__sources.set(sourceId, { log, sample });
     }
 
+    /**
+     * Forget a source (its peer left). Entities still marked with it are left where they are
+     * until their marker goes; the system does not blend from a source it does not have.
+     * @param {number} sourceId
+     * @returns {boolean} whether it was registered
+     */
+    unregisterSource(sourceId) {
+        return this.__sources.delete(sourceId);
+    }
+
     /**
      * @param {EntityManager} entityManager
      */

package/src/engine/network/NetworkSession.d.ts.map

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

package/src/engine/network/NetworkSession.js

@@ -18,6 +18,7 @@ import { InterpolationLog } from "../interpolation/InterpolationLog.js";
 import { SimAction } from "./sim/SimAction.js";
 import { snapshotter_emit } from "./sim/Snapshotter.js";
 import { AdaptiveRenderDelay } from "./time/AdaptiveRenderDelay.js";
+import { RenderPlayout } from "./time/RenderPlayout.js";
 import { TimeDilation } from "./time/TimeDilation.js";
 
 /**
@@ -65,7 +66,6 @@ const DEFAULT_INITIAL_RENDER_DELAY_FRAMES = 6;
  * orchestrator, so it is cheap to grow).
  */
 const DEFAULT_ACTION_LOG_FRAME_CAPACITY = 32;
-const PULL_PER_MS = 0.0005;        // wall-clock low-pass on render frame state machine
 const MAX_CLIENT_DILATED_TICKS_PER_STEP = 3;
 const MAX_FIXED_STEPS_PER_TICK = 8;
 
@@ -207,9 +207,12 @@ export class NetworkSession {
 
     // ---- Render-frame interpolation state ----
 
-    /** @private @type {number} */ #latest_received_frame = -1;
-    /** @private @type {number} */ #smooth_render_frame = -1;
-    /** @private @type {number} */ #smooth_last_wall_ms = -1;
+    /**
+     * The render-delayed playhead over the remote frame stream (latest frame, adaptive delay,
+     * smoothed head). Shared with anything else that plays out a fixed-period stream.
+     * @private @type {RenderPlayout}
+     */
+    #playout;
 
     /**
      * Set after `#render_interpolated_entities` writes interp values into
@@ -532,6 +535,7 @@ export class NetworkSession {
             safety_multiplier: 2.0,
             decay_per_sample_ms: 1.0,
         });
+        this.#playout = new RenderPlayout({ tick_period_ms: this.tick_period_ms, delay: this.#adaptive_render_delay });
 
         this.#scratch_send_buf = new BinaryBuffer();
         this.#scratch_send_buf.setCapacity(SCRATCH_BUFFER_BYTES);
@@ -950,7 +954,7 @@ export class NetworkSession {
             // we don't speak is one the host has to time out.
             const token = this.session_token;
             if (token !== null || this.#has_ever_connected) {
-                const last_acked = Math.max(0, this.#latest_received_frame);
+                const last_acked = Math.max(0, this.#playout.latest_frame);
                 this.#peer.send_resume_hello(
                     remote_peer_id, this.local_peer_id, last_acked,
                     token !== null, token !== null ? token.data : NO_SESSION_TOKEN,
@@ -1138,11 +1142,11 @@ export class NetworkSession {
         if (!this.render_dirty) return;
         this.render_dirty = false;
 
-        if (this.#latest_received_frame < 0) return;
+        if (!this.#playout.has_frames) return;
         if (this.#remote_entities.size === 0) return;
 
         const scratch = this.#scratch_interp_buf;
-        const tick = this.#latest_received_frame;
+        const tick = this.#playout.latest_frame;
 
         for (const entity_id of this.#remote_entities) {
             const identity = this.world.getComponent(entity_id, NetworkIdentity);
@@ -2247,10 +2251,7 @@ export class NetworkSession {
         }
         this.#interp_log.end_tick();
 
-        if (frame_number > this.#latest_received_frame) {
-            this.#adaptive_render_delay.record_arrival(performance.now(), frame_number);
-            this.#latest_received_frame = frame_number;
-        }
+        this.#playout.record_arrival(performance.now(), frame_number);
     }
 
     /**
@@ -2262,31 +2263,10 @@ export class NetworkSession {
      * recorded — deferred-apply path doesn't fire `onFrameApplied`).
      */
     #render_interpolated_entities() {
-        if (this.#latest_received_frame < 0) return;
+        if (!this.#playout.has_frames) return;
         if (this.#remote_entities.size === 0) return;
 
-        const now_ms = performance.now();
-        const render_delay_frames = this.#adaptive_render_delay.delay_ms() / this.tick_period_ms;
-        const target = this.#latest_received_frame - render_delay_frames;
-
-        if (this.#smooth_render_frame < 0) {
-            this.#smooth_render_frame = target < 0 ? 0 : target;
-            this.#smooth_last_wall_ms = now_ms;
-        } else {
-            const dt_ms = now_ms - this.#smooth_last_wall_ms;
-            this.#smooth_last_wall_ms = now_ms;
-            this.#smooth_render_frame += dt_ms / this.tick_period_ms;
-            const alpha = 1 - Math.exp(-PULL_PER_MS * dt_ms);
-            this.#smooth_render_frame += (target - this.#smooth_render_frame) * alpha;
-        }
-        if (this.#smooth_render_frame > this.#latest_received_frame) {
-            this.#smooth_render_frame = this.#latest_received_frame;
-        }
-        if (this.#smooth_render_frame < 0) this.#smooth_render_frame = 0;
-
-        const tick_a = Math.floor(this.#smooth_render_frame);
-        const tick_b = tick_a + 1;
-        const t = this.#smooth_render_frame - tick_a;
+        const { tick_a, tick_b, t } = this.#playout.window(performance.now());
 
         const scratch = this.#scratch_interp_buf;
         let wrote_anything = false;

package/src/engine/network/time/RenderPlayout.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The render-delayed playhead over a sender's fixed-period frame stream — the piece of snapshot
+ * interpolation that decides *which two frames to blend and by how much* on each render.
+ *
+ * Owns an {@link AdaptiveRenderDelay} (or is given one). Feed it every arriving frame with
+ * {@link record_arrival}; ask it for the {@link window} once per render. The playhead advances
+ * with wall time, is pulled toward `latest_frame - delay` by a low-pass so changes in the delay
+ * never skip, and is clamped to `[0, latest_frame]` so the blend never extrapolates past what has
+ * arrived. Extracted from `NetworkSession` so any fixed-period stream — a peer's netcode frames, a
+ * remote editor's presence samples — plays out the same way.
+ *
+ * No allocation per call: {@link window} fills and returns one reused object.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RenderPlayout {
+    /**
+     * @param {{
+     *   tick_period_ms: number,
+     *   delay?: AdaptiveRenderDelay,
+     *   pull_per_ms?: number
+     * }} options `tick_period_ms` MUST be the sender's real period (see {@link AdaptiveRenderDelay})
+     */
+    constructor({ tick_period_ms, delay, pull_per_ms }: {
+        tick_period_ms: number;
+        delay?: AdaptiveRenderDelay;
+        pull_per_ms?: number;
+    });
+    /** @readonly @type {number} */
+    readonly tick_period_ms: number;
+    /** @readonly @type {AdaptiveRenderDelay} */
+    readonly delay: AdaptiveRenderDelay;
+    /** @readonly @type {number} */
+    readonly pull_per_ms: number;
+    /** @type {number} highest frame number recorded; -1 before the first */
+    latest_frame: number;
+    /**
+     * A frame from the sender has been applied locally. Frames at or below the latest are
+     * accepted data (a reordered or retransmitted frame) but do not move the head.
+     *
+     * @param {number} now_ms wall clock
+     * @param {number} frame_number the sender's frame index
+     * @returns {boolean} true when this frame advanced the head
+     */
+    record_arrival(now_ms: number, frame_number: number): boolean;
+    /**
+     * @returns {boolean} whether anything has arrived yet
+     */
+    get has_frames(): boolean;
+    /**
+     * The smoothed playhead in frames after the last {@link window} call (or -1).
+     * @returns {number}
+     */
+    get playhead(): number;
+    /**
+     * Advance the playhead to `now_ms` and return the frames to blend. `tick_b` may not have
+     * arrived (the playhead sits on `latest_frame`): the log's `interpolate` snaps to the frame it
+     * has. Before the first arrival the window is `(0, 0, 0)`.
+     *
+     * @param {number} now_ms wall clock
+     * @returns {{tick_a:number, tick_b:number, t:number}} a reused object — read it, do not keep it
+     */
+    window(now_ms: number): {
+        tick_a: number;
+        tick_b: number;
+        t: number;
+    };
+    /**
+     * Forget the stream (a reconnect, a new sender).
+     */
+    reset(): void;
+    #private;
+}
+import { AdaptiveRenderDelay } from "./AdaptiveRenderDelay.js";
+//# sourceMappingURL=RenderPlayout.d.ts.map

package/src/engine/network/time/RenderPlayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderPlayout.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/time/RenderPlayout.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;GAeG;AACH;IAsBI;;;;;;OAMG;IACH,oDANW;QACV,cAAkB,EAAE,MAAM,CAAC;QAC3B,KAAS,CAAC,EAAE,mBAAmB,CAAC;QAChC,WAAe,CAAC,EAAE,MAAM,CAAA;KACrB,EAWH;IArCD,+BAA+B;IAC/B,yBADqB,MAAM,CACZ;IAEf,4CAA4C;IAC5C,gBADqB,mBAAmB,CAClC;IAEN,+BAA+B;IAC/B,sBADqB,MAAM,CACf;IAEZ,wEAAwE;IACxE,cADW,MAAM,CACC;IA6BlB;;;;;;;OAOG;IACH,uBAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CAWnB;IAED;;OAEG;IACH,0BAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,eAHW,MAAM;gBACI,MAAM;gBAAS,MAAM;WAAI,MAAM;MA4CnD;IAED;;OAEG;IACH,cAKC;;CACJ;oCAjKmC,0BAA0B"}

package/src/engine/network/time/RenderPlayout.js

@@ -0,0 +1,163 @@
+import { assert } from "../../../core/assert.js";
+import { AdaptiveRenderDelay } from "./AdaptiveRenderDelay.js";
+
+/**
+ * Wall-clock low-pass on the render frame state machine: how hard the smoothed playhead is
+ * pulled toward its target per millisecond. Small, so a jump in the target (the delay widening
+ * after a jitter spike, a burst of late frames) is absorbed over ~2 s instead of a visible skip.
+ * @type {number}
+ */
+const PULL_PER_MS = 0.0005;
+
+/**
+ * The render-delayed playhead over a sender's fixed-period frame stream — the piece of snapshot
+ * interpolation that decides *which two frames to blend and by how much* on each render.
+ *
+ * Owns an {@link AdaptiveRenderDelay} (or is given one). Feed it every arriving frame with
+ * {@link record_arrival}; ask it for the {@link window} once per render. The playhead advances
+ * with wall time, is pulled toward `latest_frame - delay` by a low-pass so changes in the delay
+ * never skip, and is clamped to `[0, latest_frame]` so the blend never extrapolates past what has
+ * arrived. Extracted from `NetworkSession` so any fixed-period stream — a peer's netcode frames, a
+ * remote editor's presence samples — plays out the same way.
+ *
+ * No allocation per call: {@link window} fills and returns one reused object.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RenderPlayout {
+    /** @readonly @type {number} */
+    tick_period_ms;
+
+    /** @readonly @type {AdaptiveRenderDelay} */
+    delay;
+
+    /** @readonly @type {number} */
+    pull_per_ms;
+
+    /** @type {number} highest frame number recorded; -1 before the first */
+    latest_frame = -1;
+
+    /** @private @type {number} smoothed playhead in frames; -1 until the first window */
+    #smooth_frame = -1;
+
+    /** @private @type {number} */
+    #last_wall_ms = -1;
+
+    /** @private @type {{tick_a:number, tick_b:number, t:number}} */
+    #window = { tick_a: 0, tick_b: 0, t: 0 };
+
+    /**
+     * @param {{
+     *   tick_period_ms: number,
+     *   delay?: AdaptiveRenderDelay,
+     *   pull_per_ms?: number
+     * }} options `tick_period_ms` MUST be the sender's real period (see {@link AdaptiveRenderDelay})
+     */
+    constructor({ tick_period_ms, delay = undefined, pull_per_ms = PULL_PER_MS }) {
+        assert.isNumber(tick_period_ms, 'tick_period_ms');
+        assert.ok(tick_period_ms > 0, 'tick_period_ms must be > 0');
+        assert.isNumber(pull_per_ms, 'pull_per_ms');
+        assert.ok(pull_per_ms >= 0, 'pull_per_ms must be >= 0');
+
+        this.tick_period_ms = tick_period_ms;
+        this.delay = delay === undefined ? new AdaptiveRenderDelay({ tick_period_ms }) : delay;
+        this.pull_per_ms = pull_per_ms;
+    }
+
+    /**
+     * A frame from the sender has been applied locally. Frames at or below the latest are
+     * accepted data (a reordered or retransmitted frame) but do not move the head.
+     *
+     * @param {number} now_ms wall clock
+     * @param {number} frame_number the sender's frame index
+     * @returns {boolean} true when this frame advanced the head
+     */
+    record_arrival(now_ms, frame_number) {
+        if (frame_number <= this.latest_frame) {
+            return false;
+        }
+
+        this.delay.record_arrival(now_ms, frame_number);
+        this.latest_frame = frame_number;
+
+        return true;
+    }
+
+    /**
+     * @returns {boolean} whether anything has arrived yet
+     */
+    get has_frames() {
+        return this.latest_frame >= 0;
+    }
+
+    /**
+     * The smoothed playhead in frames after the last {@link window} call (or -1).
+     * @returns {number}
+     */
+    get playhead() {
+        return this.#smooth_frame;
+    }
+
+    /**
+     * Advance the playhead to `now_ms` and return the frames to blend. `tick_b` may not have
+     * arrived (the playhead sits on `latest_frame`): the log's `interpolate` snaps to the frame it
+     * has. Before the first arrival the window is `(0, 0, 0)`.
+     *
+     * @param {number} now_ms wall clock
+     * @returns {{tick_a:number, tick_b:number, t:number}} a reused object — read it, do not keep it
+     */
+    window(now_ms) {
+        const w = this.#window;
+        const latest = this.latest_frame;
+
+        if (latest < 0) {
+            w.tick_a = 0;
+            w.tick_b = 0;
+            w.t = 0;
+            return w;
+        }
+
+        const period = this.tick_period_ms;
+        const target = latest - this.delay.delay_ms() / period;
+        let frame = this.#smooth_frame;
+
+        if (frame < 0) {
+            frame = target < 0 ? 0 : target;
+        } else {
+            const dt_ms = now_ms - this.#last_wall_ms;
+            frame += dt_ms / period;
+            const alpha = 1 - Math.exp(-this.pull_per_ms * dt_ms);
+            frame += (target - frame) * alpha;
+        }
+
+        this.#last_wall_ms = now_ms;
+
+        if (frame > latest) {
+            frame = latest;
+        }
+
+        if (frame < 0) {
+            frame = 0;
+        }
+
+        this.#smooth_frame = frame;
+
+        const tick_a = Math.floor(frame);
+        w.tick_a = tick_a;
+        w.tick_b = tick_a + 1;
+        w.t = frame - tick_a;
+
+        return w;
+    }
+
+    /**
+     * Forget the stream (a reconnect, a new sender).
+     */
+    reset() {
+        this.latest_frame = -1;
+        this.#smooth_frame = -1;
+        this.#last_wall_ms = -1;
+        this.delay.reset();
+    }
+}

package/src/engine/network/transport/adapters/WebSocketTransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebSocketTransport.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/adapters/WebSocketTransport.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAUI;;OAEG;IACH,8BAFW;QAAE,MAAM,CAAC,EAAE,SAAS,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,EA8C9C;IAtCG,wBAAwB;IACxB,QADW,SAAS,CAC4C;IAmDpE;;;;;;;;;;OAUG;IACH,WAFa,QAAQ,IAAI,CAAC,CA4BzB;;CAmBJ;0BAxJyB,iBAAiB"}
+{"version":3,"file":"WebSocketTransport.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/adapters/WebSocketTransport.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAUI;;OAEG;IACH,8BAFW;QAAE,MAAM,CAAC,EAAE,SAAS,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,EAqD9C;IA7CG,wBAAwB;IACxB,QADW,SAAS,CAC4C;IA0DpE;;;;;;;;;;OAUG;IACH,WAFa,QAAQ,IAAI,CAAC,CA4BzB;;CAmBJ;0BA/JyB,iBAAiB"}

package/src/engine/network/transport/adapters/WebSocketTransport.js

@@ -54,11 +54,18 @@ export class WebSocketTransport extends Transport {
         this.#on_message = (event) => {
             // event.data is ArrayBuffer (binaryType set above) for binary frames,
             // or string for text frames. We treat strings as text payloads converted to UTF-8 bytes.
+            //
+            // The buffer may come from another realm — a socket created in an iframe, a worker,
+            // or a node socket under a jsdom test — where `instanceof ArrayBuffer` is false for a
+            // perfectly good ArrayBuffer. The brand check and `isView` see through that.
+            const data = event.data;
             let bytes;
-            if (event.data instanceof ArrayBuffer) {
-                bytes = new Uint8Array(event.data);
-            } else if (typeof event.data === "string") {
-                bytes = new TextEncoder().encode(event.data);
+            if (typeof data === "string") {
+                bytes = new TextEncoder().encode(data);
+            } else if (data instanceof ArrayBuffer || Object.prototype.toString.call(data) === "[object ArrayBuffer]") {
+                bytes = new Uint8Array(data);
+            } else if (ArrayBuffer.isView(data)) {
+                bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
             } else {
                 // Some browsers wrap as Blob if binaryType is misset; ignore.
                 return;

package/src/engine/physics/ecs/PhysicsSystem.d.ts

@@ -468,17 +468,13 @@ export class PhysicsSystem extends System<any> {
      * @param {RigidBody} rigidBody
      * @param {Transform64} transform body's current world Transform (used for r and I_w)
      * @param {Vector3|{x:number,y:number,z:number}} impulse
-     * @param {Vector3|{x:number,y:number,z:number}} worldPoint
+     * @param {Vector3|ArrayLike<number>} worldPoint world-space point indexed as [x, y, z]
      */
     applyImpulseAt(rigidBody: RigidBody, transform: Transform64, impulse: Vector3 | {
         x: number;
         y: number;
         z: number;
-    }, worldPoint: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
+    }, worldPoint: Vector3 | ArrayLike<number>): void;
     /**
      * Accumulate a continuous torque (world-space) for integration on the
      * next fixedUpdate. Pairs with {@link applyForce} for the rotational case.
@@ -503,17 +499,13 @@ export class PhysicsSystem extends System<any> {
      * @param {RigidBody} rigidBody
      * @param {Transform64} transform body's current world Transform
      * @param {Vector3|{x:number,y:number,z:number}} force
-     * @param {Vector3|{x:number,y:number,z:number}} worldPoint
+     * @param {Vector3|ArrayLike<number>} worldPoint world-space point indexed as [x, y, z]
      */
     applyForceAt(rigidBody: RigidBody, transform: Transform64, force: Vector3 | {
         x: number;
         y: number;
         z: number;
-    }, worldPoint: Vector3 | {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
+    }, worldPoint: Vector3 | ArrayLike<number>): void;
     /**
      * Accumulate a continuous force to be integrated next fixedUpdate step.
      * Wakes the body if asleep.

package/src/engine/physics/ecs/PhysicsSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"AAuGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAiRI,cAqBC;IApSD,wDAAwC;IACxC,oKAIE;IAEF;;;;OAIG;IACH,kBAHU,WAAW,CAGO;IAE5B;;;;OAIG;IACH,WAFU,GAAG,CAES;IAEtB;;;;OAIG;IACH,YAFU,GAAG,CAEU;IAEvB;;;;OAIG;IACH,oBAHU,aAAa,CAGS;IAEhC;;;;;OAKG;IACH,OAFU,QAAQ,CAEK;IAEvB;;;;OAIG;IACH,eAFU,kBAAkB,CAEa;IAEzC;;;;;OAKG;IACH,SAFU,aAAa,CAEO;IAE9B;;;;;;;;;OASG;IACH,gBAFU,eAAe,CAEc;IAEvC;;;;;;OAMG;IACH,2BAFU,MAAM,CAEiB;IAEjC;;;;OAIG;IACH,oBAFU,MAAM,CAES;IAEzB;;;;;;OAMG;IACH,UAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;;;OAOG;IACH,cAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,qBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,0BAOE;IAEF;;;;OAIG;IACH,kBAFU,OAAO,CAEkB;IAEnC;;;;;OAKG;IACH,yBAAwB;IAExB;;;;;OAKG;IACH,UAFU,SAAS,EAAE,CAEP;IAEd;;;OAGG;IACH,uBAHU,WAAW,EAAE,CAGL;IAElB;;;;;;;;OAQG;IACH,uBAFU,MAAM,MAAM;QAAC,QAAQ,EAAE,QAAQ,CAAC;QAAC,SAAS,YAAY;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC,CAExE;IAE3B;;;;;OAKG;IACH,UAFU,OAAO,CAEH;IAEd;;;;;;OAMG;IACH,qBAAkB;IAElB;;;;;;;;;;;;;OAaG;IACH,wBAAqB;IAErB;;;;;;OAMG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;;;;;;;;;;;;OAgBG;IACH,mBAFU,YAAY,CAEkB;IAExC;;;;OAIG;IACH,YAFU,OAAO,CAEC;IAElB;;;;;;;OAOG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;;;;;OAOG;IACH,kBAFU,mBAAiB,IAAI,CAEP;IAExB,yEAAyE;IACzE,gCAA4B;IAKxB;;;;OAIG;IACH,yBAA0C;IAG1C;;;;;;;;OAQG;IACH,0BAA4C;IAGhD;;;;;;;;;;;;;OAaG;IACH,sBA6BC;IAED;;;;;;;;;;;;;;OAcG;IACH,2BAGC;IAED;;;;;;;;;;OAUG;IACH,gCAOC;IAED;;;OAGG;IACH,cAFW,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAI9C;IAED;;;OAGG;IACH,+BAFqB,MAAM,WAAU,MAAM,aAAY,QAAQ,aAAY,QAAQ,KAAK,OAAO,QAI9F;IAED;;OAEG;IACH,8BAFuB,MAAM,WAAU,MAAM,aAAY,QAAQ,aAAY,QAAQ,KAAK,OAAO,CAIhG;IAED;;;;;;OAMG;IACH,iCA6BC;IAED;;;;OAIG;IACH,iCAIC;IAED;;;;;;;;;;;;;;;OAeG;IACH,yCAmBC;IAED;;;;;;;;;;OAUG;IACH,gBAJW,SAAS,aACT,WAAW,UACX,MAAM,QAkChB;IAED;;;;;;;OAOG;IACH,kBAJW,SAAS,aACT,WAAW,UACX,MAAM,QAyDhB;IAED;;;;;;;;;;;;;OAaG;IACH,6BALW,MAAM,YACN,QAAQ,aACR,WAAW,oBACX,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,YACN,QAAQ,QAiClB;IAED;;;;;;;;OAQG;IACH,oCAEC;IAED;;;;;;;;;OASG;IACH,+BAyCC;IAED;;;;OAIG;IACH,iCAUC;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,wBAEC;IAED;;;;;;;;;OASG;IACH,wBAHW,SAAS,WACT,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAU9C;IAED;;;;;;;;;;;OAWG;IACH,0BALW,SAAS,aACT,WAAW,WACX,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,cACpC,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAyC9C;IAED;;;;;;;;OAQG;IACH,uBAHW,SAAS,UACT,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAY9C;IAED;;;;;;;;;;;OAWG;IACH,wBALW,SAAS,aACT,WAAW,SACX,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,cACpC,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAwB9C;IAED;;;;;;OAMG;IACH,sBAHW,SAAS,SACT,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAQ9C;IAED;;;;;OAKG;IACH,6BAHW,SAAS,KACT,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAO9C;IAED;;;;;;;;OAQG;IACH,8BAHW,SAAS,KACT,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAO9C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,mBAJW,SAAS,YACT,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAgE1D;IAED;;;OAGG;IACH,gBAFW,SAAS,QAInB;IAED;;;;OAIG;IACH,iBAFW,SAAS,QAkBnB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAmCC;IAED;;;;;;;;;;;;;;OAcG;IACH,oCAwCC;IAED;;;;;;;;;;;;;;OAcG;IACH,kEAJmB,MAAM,YAAW,QAAQ,KAAG,OAAO,GAEzC,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,uDALW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,iDAE7B,MAAM,YAAW,QAAQ,KAAG,OAAO,GACzC,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,0CATW,UAAU,MAAM,CAAC,YAEjB,UAAU,MAAM,CAAC,UACjB,WAAW,GAAC,MAAM,EAAE,iBACpB,MAAM,oBACE,MAAM,YAAW,QAAQ,KAAG,OAAO,GAEzC,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,YAFa,IAAI,CAMhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,qBA8DC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAiCC;IAED;;;;;;;;;;;;OAYG;IACH,sBAoCC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,qBAgEC;IAED;;;;;;;;;;OAUG;IACH,kCA0FC;IAED;;;;;;;;;OASG;IACH,yBA+CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,wBA6CC;IA0ZL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;uBAxwEsB,qBAAqB;4BAChB,oCAAoC;0BAmCd,gBAAgB;4CArCtB,oDAAoD;yBAgCrD,eAAe;4BA5Bf,wBAAwB;oBAb/C,gCAAgC;8BAoBtB,6BAA6B;yBAHlC,2BAA2B;mCAIC,iCAAiC;8BAKxD,4BAA4B;gCAZd,4BAA4B;oBAPpD,+BAA+B;yBAiC1B,eAAe;+BAOT,qBAAqB"}
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}

package/src/engine/physics/ecs/PhysicsSystem.js

@@ -11,6 +11,7 @@ import Vector3 from "../../../core/geom/Vector3.js";
 import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { System } from "../../ecs/System.js";
+import { t64_announce_change } from "../../ecs/transform/t64_announce_change.js";
 import { Transform64 } from "../../ecs/transform/Transform64.js";
 import { Interpolated } from "../../interpolation/Interpolated.js";
 import { body_id_index, BodyStorage } from "../body/BodyStorage.js";
@@ -49,7 +50,6 @@ import { PhysicsEvents } from "./PhysicsEvents.js";
 import { RIGID_BODY_UNALLOCATED, RigidBody } from "./RigidBody.js";
 import { RigidBodyFlags } from "./RigidBodyFlags.js";
 import { SleepState } from "./SleepState.js";
-import { t64_announce_change } from "../../ecs/transform/t64_announce_change.js";
 
 /**
  * Scratch for {@link applyImpulseAt}'s angular delta calculation.
@@ -594,7 +594,7 @@ export class PhysicsSystem extends System {
         bvh.node_get_aabb(node, scratch_world_aabb);
 
         let n;
-        for (;;) {
+        for (; ;) {
             n = bvh_query_user_data_intersects_aabb(scratch_wake_candidates, 0, this.dynamicBvh, scratch_world_aabb);
             if (n <= scratch_wake_candidates.length) break;
             // TRUE count returned, overflow writes dropped — grow and re-query.
@@ -924,29 +924,50 @@ export class PhysicsSystem extends System {
      * @param {RigidBody} rigidBody
      * @param {Transform64} transform body's current world Transform (used for r and I_w)
      * @param {Vector3|{x:number,y:number,z:number}} impulse
-     * @param {Vector3|{x:number,y:number,z:number}} worldPoint
+     * @param {Vector3|ArrayLike<number>} worldPoint world-space point indexed as [x, y, z]
      */
-    applyImpulseAt(rigidBody, transform, impulse, worldPoint) {
+    applyImpulseAt(
+        rigidBody,
+        transform,
+        impulse,
+        worldPoint
+    ) {
+
+        assert.defined(impulse, 'impulse');
+        assert.defined(worldPoint, 'worldPoint');
+        assert.isNumber(worldPoint[0], 'worldPoint[0]');
+        assert.isNumber(worldPoint[1], 'worldPoint[1]');
+        assert.isNumber(worldPoint[2], 'worldPoint[2]');
+
         if (rigidBody.kind !== BodyKind.Dynamic) {
             return;
         }
+
         const inv_m = rigidBody.mass > 0 ? 1 / rigidBody.mass : 0;
 
+        const impulse_x = impulse.x;
+        const impulse_y = impulse.y;
+        const impulse_z = impulse.z;
+
+        assert.isNumber(impulse_x, 'impulse_x');
+        assert.isNumber(impulse_y, 'impulse_y');
+        assert.isNumber(impulse_z, 'impulse_z');
+
         rigidBody.linearVelocity.set(
-            rigidBody.linearVelocity.x + impulse.x * inv_m,
-            rigidBody.linearVelocity.y + impulse.y * inv_m,
-            rigidBody.linearVelocity.z + impulse.z * inv_m
+            rigidBody.linearVelocity.x + impulse_x * inv_m,
+            rigidBody.linearVelocity.y + impulse_y * inv_m,
+            rigidBody.linearVelocity.z + impulse_z * inv_m
         );
 
-        // read by index: the world point is commonly a transform translation view, which has no .x
+        // World points use indexed coordinates, including Transform64 translation views.
         const rx = worldPoint[0] - transform.translation_x;
         const ry = worldPoint[1] - transform.translation_y;
         const rz = worldPoint[2] - transform.translation_z;
 
         // Δω = I_w⁻¹ · (r × P)
-        const tx = ry * impulse.z - rz * impulse.y;
-        const ty = rz * impulse.x - rx * impulse.z;
-        const tz = rx * impulse.y - ry * impulse.x;
+        const tx = ry * impulse_z - rz * impulse_y;
+        const ty = rz * impulse_x - rx * impulse_z;
+        const tz = rx * impulse_y - ry * impulse_x;
 
         // LockRot* masks the BODY-LOCAL inverse-inertia diagonal here exactly
         // as the solver gather does, so a user impulse cannot spin a locked
@@ -998,9 +1019,14 @@ export class PhysicsSystem extends System {
      * @param {RigidBody} rigidBody
      * @param {Transform64} transform body's current world Transform
      * @param {Vector3|{x:number,y:number,z:number}} force
-     * @param {Vector3|{x:number,y:number,z:number}} worldPoint
+     * @param {Vector3|ArrayLike<number>} worldPoint world-space point indexed as [x, y, z]
      */
     applyForceAt(rigidBody, transform, force, worldPoint) {
+        assert.defined(worldPoint, 'worldPoint');
+        assert.isNumber(worldPoint[0], 'worldPoint[0]');
+        assert.isNumber(worldPoint[1], 'worldPoint[1]');
+        assert.isNumber(worldPoint[2], 'worldPoint[2]');
+
         if (rigidBody.kind !== BodyKind.Dynamic) {
             return;
         }
@@ -1010,7 +1036,7 @@ export class PhysicsSystem extends System {
             rigidBody.accumulatedForce.z + force.z
         );
 
-        // read by index: the world point is commonly a transform translation view, which has no .x
+        // World points use indexed coordinates, including Transform64 translation views.
         const rx = worldPoint[0] - transform.translation_x;
         const ry = worldPoint[1] - transform.translation_y;
         const rz = worldPoint[2] - transform.translation_z;

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#377@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#380@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#377@#clear_field"(fluid: FluidComponent): void;
+    static "__#380@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#377@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#380@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#377@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#380@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/engine/sound/simulation/core/VolumeField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VolumeField.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/VolumeField.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH;IAMI;;OAEG;IACH,4BAFW,cAAc,EAIxB;IASD;;OAEG;IACH,uCAEC;IAZD;;OAEG;IACH,oCAEC;IASD;;;;;;;;;;;;OAYG;IACH,4CALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,cAAc,QA0BxB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gEARW,MAAM,YACN,MAAM,YACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,WACN,YAAY,QA0DtB;;CACJ;+BAnK8B,qBAAqB"}
+{"version":3,"file":"VolumeField.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/VolumeField.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH;IAMI;;OAEG;IACH,4BAFW,cAAc,EAIxB;IASD;;OAEG;IACH,uCAEC;IAZD;;OAEG;IACH,oCAEC;IASD;;;;;;;;;;;;OAYG;IACH,4CALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,cAAc,QA0BxB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gEARW,MAAM,YACN,MAAM,YACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,WACN,YAAY,QA0DtB;;CACJ;+BAtK8B,qBAAqB"}

package/src/engine/sound/simulation/core/VolumeField.js

@@ -9,7 +9,10 @@ const AIR_INTEGRAL_SAMPLES = 8;
 // module-static scratch for the per-step blended medium during integration (allocation-free)
 const STEP_MEDIUM = new AcousticMedium();
 
-// module-static scratch — regions gathered at a query point (reused; sample is synchronous)
+/**
+ * module-static scratch — regions gathered at a query point (reused; sample is synchronous)
+ * @type {AcousticVolumeRegion[]}
+ */
 const GATHERED = [];
 
 /**