@woosh/meep-engine 2.169.1 → 2.169.2

package/src/engine/physics/narrowphase/capsule_contacts.js

@@ -1,3 +1,5 @@
+import { line3_segment_segment_closest_point_pair } from "../../../core/geom/3d/line/line3_segment_segment_closest_point_pair.js";
+const scratch_pair = new Float64Array(6);
 import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
 import { line3_compute_segment_closest_point_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_t.js";
 import { line3_compute_segment_closest_point_to_aabb3_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js";
@@ -139,21 +141,18 @@ export function capsule_capsule_contact(
     const b0x = scratch_seg_b[0], b0y = scratch_seg_b[1], b0z = scratch_seg_b[2];
     const b1x = scratch_seg_b[3], b1y = scratch_seg_b[4], b1z = scratch_seg_b[5];
 
-    line3_compute_segment_segment_closest_points(
-        scratch_st,
+    const closest_distance_sqr = line3_segment_segment_closest_point_pair(
+        scratch_pair, 0,
         a0x, a0y, a0z, a1x, a1y, a1z,
         b0x, b0y, b0z, b1x, b1y, b1z
     );
 
-    const s = scratch_st[0];
-    const t = scratch_st[1];
-
-    const pax = a0x + (a1x - a0x) * s;
-    const pay = a0y + (a1y - a0y) * s;
-    const paz = a0z + (a1z - a0z) * s;
-    const pbx = b0x + (b1x - b0x) * t;
-    const pby = b0y + (b1y - b0y) * t;
-    const pbz = b0z + (b1z - b0z) * t;
+    const pax = scratch_pair[0];
+    const pay = scratch_pair[1];
+    const paz = scratch_pair[2];
+    const pbx = scratch_pair[3];
+    const pby = scratch_pair[4];
+    const pbz = scratch_pair[5];
 
     const dx = pax - pbx;
     const dy = pay - pby;

package/src/engine/physics/narrowphase/sphere_triangle_contact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sphere_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_triangle_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,6CAhBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAwFnB"}
+{"version":3,"file":"sphere_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_triangle_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,6CAhBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmFnB"}

package/src/engine/physics/narrowphase/sphere_triangle_contact.js

@@ -1,4 +1,4 @@
-import { tri3_closest_point_barycentric } from "../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
+import { tri3_closest_point } from "../../../core/geom/3d/triangle/tri3_closest_point.js";
 
 /**
  * Closest-point on triangle, written into the first two floats of `out`
@@ -6,7 +6,7 @@ import { tri3_closest_point_barycentric } from "../../../core/geom/3d/triangle/t
  * across the {@link sphere_triangle_contact} body to avoid allocation.
  * @type {Float64Array}
  */
-const scratch_bary = new Float64Array(2);
+const scratch_closest = new Float64Array(3);
 
 /**
  * Closed-form contact generation for a sphere vs. a triangle.
@@ -79,21 +79,16 @@ export function sphere_triangle_contact(
     if (fn_mag_sqr === 0) return false;
 
     // Closest-point on triangle to sphere centre — barycentric output.
-    tri3_closest_point_barycentric(
-        scratch_bary, 0,
+    tri3_closest_point(
+        scratch_closest, 0,
         sx, sy, sz,
         ax, ay, az,
         bx, by, bz,
         cx, cy, cz
     );
-    const alpha_a = scratch_bary[0];
-    const alpha_b = scratch_bary[1];
-    const alpha_c = 1 - alpha_a - alpha_b;
-
-    // Reconstruct the closest world-space point.
-    const px = alpha_a * ax + alpha_b * bx + alpha_c * cx;
-    const py = alpha_a * ay + alpha_b * by + alpha_c * cy;
-    const pz = alpha_a * az + alpha_b * bz + alpha_c * cz;
+    const px = scratch_closest[0];
+    const py = scratch_closest[1];
+    const pz = scratch_closest[2];
 
     // Vector from closest point to sphere centre.
     const dx = sx - px;

package/src/engine/physics/solver/apply_impulse_to_body.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Apply impulse `P` at lever arm `r` to one body's solver state:
+ *
+ *   dv = P * invM
+ *   dw = Iw^-1 * (r x P)
+ *
+ * `sign` folds in which side of the pair this body is (+1 for A, -1 for B) without the caller having to
+ * negate the impulse itself.
+ *
+ * This is the single most load-bearing routine in the step — it runs per constraint row per solver
+ * iteration — and it was previously written out twice, identically, in the contact solver and the
+ * constraint solver.
+ *
+ * `scratch` is supplied by the caller rather than closed over: the two copies disagreed on this, and an
+ * explicit buffer keeps the routine free of shared mutable state between call sites.
+ *
+ * A zero inverse mass means a static/kinematic body, which absorbs impulses without responding — so this
+ * returns immediately rather than writing zeros.
+ *
+ * @param {Float64Array} ss solver body state array
+ * @param {number} base offset of this body's span within `ss`
+ * @param {number} invM inverse mass
+ * @param {number} rx lever arm x, from centre of mass to the application point
+ * @param {number} ry
+ * @param {number} rz
+ * @param {number} Px impulse x
+ * @param {number} Py
+ * @param {number} Pz
+ * @param {number} sign +1 for body A, -1 for body B
+ * @param {Float64Array} scratch at least 3 elements, overwritten
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function apply_impulse_to_body(ss: Float64Array, base: number, invM: number, rx: number, ry: number, rz: number, Px: number, Py: number, Pz: number, sign: number, scratch: Float64Array): void;
+//# sourceMappingURL=apply_impulse_to_body.d.ts.map

package/src/engine/physics/solver/apply_impulse_to_body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_impulse_to_body.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/apply_impulse_to_body.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,0CAfW,YAAY,QACZ,MAAM,QACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,WACN,YAAY,QAuCtB"}

package/src/engine/physics/solver/apply_impulse_to_body.js

@@ -0,0 +1,86 @@
+import {
+    SBS_AV_X,
+    SBS_AV_Y,
+    SBS_AV_Z,
+    SBS_INV_I_X,
+    SBS_INV_I_Y,
+    SBS_INV_I_Z,
+    SBS_LV_X,
+    SBS_LV_Y,
+    SBS_LV_Z,
+    SBS_QW,
+    SBS_QX,
+    SBS_QY,
+    SBS_QZ,
+} from "../body/SolverBodyState.js";
+import { world_inverse_inertia_apply_raw } from "../inertia/world_inverse_inertia.js";
+
+/**
+ * Apply impulse `P` at lever arm `r` to one body's solver state:
+ *
+ *   dv = P * invM
+ *   dw = Iw^-1 * (r x P)
+ *
+ * `sign` folds in which side of the pair this body is (+1 for A, -1 for B) without the caller having to
+ * negate the impulse itself.
+ *
+ * This is the single most load-bearing routine in the step — it runs per constraint row per solver
+ * iteration — and it was previously written out twice, identically, in the contact solver and the
+ * constraint solver.
+ *
+ * `scratch` is supplied by the caller rather than closed over: the two copies disagreed on this, and an
+ * explicit buffer keeps the routine free of shared mutable state between call sites.
+ *
+ * A zero inverse mass means a static/kinematic body, which absorbs impulses without responding — so this
+ * returns immediately rather than writing zeros.
+ *
+ * @param {Float64Array} ss solver body state array
+ * @param {number} base offset of this body's span within `ss`
+ * @param {number} invM inverse mass
+ * @param {number} rx lever arm x, from centre of mass to the application point
+ * @param {number} ry
+ * @param {number} rz
+ * @param {number} Px impulse x
+ * @param {number} Py
+ * @param {number} Pz
+ * @param {number} sign +1 for body A, -1 for body B
+ * @param {Float64Array} scratch at least 3 elements, overwritten
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function apply_impulse_to_body(
+    ss, base, invM,
+    rx, ry, rz,
+    Px, Py, Pz,
+    sign,
+    scratch
+) {
+
+    if (invM === 0) {
+        return;
+    }
+
+    const sPx = sign * Px;
+    const sPy = sign * Py;
+    const sPz = sign * Pz;
+
+    ss[base + SBS_LV_X] += sPx * invM;
+    ss[base + SBS_LV_Y] += sPy * invM;
+    ss[base + SBS_LV_Z] += sPz * invM;
+
+    const tx = ry * sPz - rz * sPy;
+    const ty = rz * sPx - rx * sPz;
+    const tz = rx * sPy - ry * sPx;
+
+    world_inverse_inertia_apply_raw(
+        scratch, 0,
+        ss[base + SBS_INV_I_X], ss[base + SBS_INV_I_Y], ss[base + SBS_INV_I_Z],
+        ss[base + SBS_QX], ss[base + SBS_QY], ss[base + SBS_QZ], ss[base + SBS_QW],
+        tx, ty, tz
+    );
+
+    ss[base + SBS_AV_X] += scratch[0];
+    ss[base + SBS_AV_Y] += scratch[1];
+    ss[base + SBS_AV_Z] += scratch[2];
+}

package/src/engine/physics/solver/solve_contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AAsjBA;;;;;;;;;;;;;GAaG;AACH,0FAHW,MAAM,GACJ,MAAM,CAoNlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,2FA0CC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAFW,WAAW,QAmGrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iGA2GC;AAED;;;;;;;;GAQG;AACH,uFAFW,MAAM,4BAwJhB;AAED;;;;;;;;;;;GAWG;AACH,yFAuDC;AAED;;;;;;;;;;;;;;GAcG;AACH,2FAFW,MAAM,QA2EhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oFAJW,MAAM,UACN,MAAM,cACN,MAAM,QAkDhB;AArzCD;;;mBAGmB;AACnB,oCAAmC;AA3FnC;;;;;GAKG;AACH,0CAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAEsB"}
+{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AAkgBA;;;;;;;;;;;;;GAaG;AACH,0FAHW,MAAM,GACJ,MAAM,CAoNlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,2FA0CC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAFW,WAAW,QAmGrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iGA2GC;AAED;;;;;;;;GAQG;AACH,uFAFW,MAAM,4BAwJhB;AAED;;;;;;;;;;;GAWG;AACH,yFAuDC;AAED;;;;;;;;;;;;;;GAcG;AACH,2FAFW,MAAM,QA2EhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oFAJW,MAAM,UACN,MAAM,cACN,MAAM,QAkDhB;AAhwCD;;;mBAGmB;AACnB,oCAAmC;AA3FnC;;;;;GAKG;AACH,0CAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAEsB"}

package/src/engine/physics/solver/solve_contacts.js

@@ -1,3 +1,4 @@
+import { apply_impulse_to_body } from "./apply_impulse_to_body.js";
 import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
 import { v3_quaternion_apply_inverse } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 import { body_id_index } from "../body/BodyStorage.js";
@@ -380,59 +381,6 @@ const scratch_clamp = new Float64Array(2);
 const scratch_inertia_a = new Float64Array(3);
 const scratch_inertia_b = new Float64Array(3);
 
-/**
- * Apply an impulse `P` at body-relative offset `r` to persistent velocity
- * (Δv = P/m, Δω = I⁻¹·(r × P)), reading and writing the body's
- * {@link SolverBodyState} span instead of its `RigidBody` / `Transform`
- * objects — flat typed-array access, no dereference, on the hot path.
- *
- * @param {Float64Array} ss   solver-body-state data array
- * @param {number} base       `body_index * SBS_STRIDE`
- * @param {number} invM
- * @param {number} rx
- * @param {number} ry
- * @param {number} rz
- * @param {number} Px
- * @param {number} Py
- * @param {number} Pz
- * @param {number} sign +1 for body A, -1 for body B
- * @param {Float64Array} scratch_inertia
- */
-function apply_impulse_to_body(
-    ss, base, invM,
-    rx, ry, rz,
-    Px, Py, Pz,
-    sign,
-    scratch_inertia
-) {
-
-    if (invM === 0) {
-        return;
-    }
-
-    const sPx = sign * Px;
-    const sPy = sign * Py;
-    const sPz = sign * Pz;
-
-    ss[base + SBS_LV_X] += sPx * invM;
-    ss[base + SBS_LV_Y] += sPy * invM;
-    ss[base + SBS_LV_Z] += sPz * invM;
-
-    const tx = ry * sPz - rz * sPy;
-    const ty = rz * sPx - rx * sPz;
-    const tz = rx * sPy - ry * sPx;
-
-    world_inverse_inertia_apply_raw(
-        scratch_inertia, 0,
-        ss[base + SBS_INV_I_X], ss[base + SBS_INV_I_Y], ss[base + SBS_INV_I_Z],
-        ss[base + SBS_QX], ss[base + SBS_QY], ss[base + SBS_QZ], ss[base + SBS_QW],
-        tx, ty, tz
-    );
-
-    ss[base + SBS_AV_X] += scratch_inertia[0];
-    ss[base + SBS_AV_Y] += scratch_inertia[1];
-    ss[base + SBS_AV_Z] += scratch_inertia[2];
-}
 
 /**
  * Apply a position-pass impulse `P` at body-relative offset `r` to the

package/src/engine/plugin/EnginePlugin.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Generally wired in via {@link Engine.plugins}
+ */
 export class EnginePlugin extends BaseProcess {
     /**
      *

package/src/engine/plugin/EnginePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnginePlugin.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePlugin.js"],"names":[],"mappings":"AAGA;IAEI;;;;OAIG;IACH,uBAAoB;IAEpB;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd,eAYC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,iCAQC;IAOD;;;OAGG;IACH,wBAIC;IAGD;;;OAGG;IACH,yBAIC;CACJ;4BA9E2B,mCAAmC"}
+{"version":3,"file":"EnginePlugin.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePlugin.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAEI;;;;OAIG;IACH,uBAAoB;IAEpB;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd,eAYC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,iCAQC;IAOD;;;OAGG;IACH,wBAIC;IAGD;;;OAGG;IACH,yBAIC;CACJ;4BAjF2B,mCAAmC"}

package/src/engine/plugin/EnginePlugin.js

@@ -1,6 +1,9 @@
 import { assert } from "../../core/assert.js";
 import { BaseProcess } from "../../core/process/BaseProcess.js";
 
+/**
+ * Generally wired in via {@link Engine.plugins}
+ */
 export class EnginePlugin extends BaseProcess {
 
     /**

package/src/engine/save/storage/IndexedDBStorage.d.ts

@@ -10,6 +10,7 @@ export class IndexedDBStorage extends Storage {
     db: Promise<IDBDatabase>;
     remove(key: any, resolve: any, reject: any): void;
     list(resolve: any, reject: any): void;
+    #private;
 }
 import Storage from "../Storage.js";
 //# sourceMappingURL=IndexedDBStorage.d.ts.map

package/src/engine/save/storage/IndexedDBStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IndexedDBStorage.d.ts","sourceRoot":"","sources":["../../../../../src/engine/save/storage/IndexedDBStorage.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACI,uBAgCC;IAnBG;;;OAGG;IACH,IAFU,QAAQ,WAAW,CAAC,CAe5B;IAIN,kDA+BC;IAyED,sCAkBC;CACJ;oBAvKmB,eAAe"}
+{"version":3,"file":"IndexedDBStorage.d.ts","sourceRoot":"","sources":["../../../../../src/engine/save/storage/IndexedDBStorage.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACI,uBAgCC;IAnBG;;;OAGG;IACH,IAFU,QAAQ,WAAW,CAAC,CAe5B;IAgHN,kDAEC;IAUD,sCAEC;;CACJ;oBAvKmB,eAAe"}

package/src/engine/save/storage/IndexedDBStorage.js

@@ -42,15 +42,30 @@ export class IndexedDBStorage extends Storage {
 
     }
 
-    remove(key, resolve, reject) {
+    /**
+     * Run a read against the main object store.
+     *
+     * Reads settle on the request: nothing a later transaction event can do
+     * invalidates a value that has already been handed back, so `success` is
+     * the whole story and the request's own `error` is the only failure.
+     *
+     * Exists so that {@link load} and {@link list} state the *read* contract
+     * once. Its sibling {@link #write} states a materially different one, and
+     * the two were previously open-coded four times over -- which is how the
+     * commit-durability fix reached `store` and missed `remove`.
+     *
+     * @param {function(IDBObjectStore): IDBRequest} run issues the read and returns its request
+     * @param {function(*)} [resolve] receives the request result
+     * @param {function(*)} [reject] receives the failure event, or the error that broke `db`
+     * @private
+     */
+    #read(run, resolve, reject) {
 
         const p = this.db
-            .then(db => {
-                const transaction = db.transaction(MAIN_STORE_NAME, IndexedDBTransactionMode.ReadWrite);
-
-                const objectStore = transaction.objectStore(MAIN_STORE_NAME);
+            .then((db) => {
+                const transaction = db.transaction(MAIN_STORE_NAME, IndexedDBTransactionMode.ReadOnly);
 
-                const idbRequest = objectStore.delete(key);
+                const idbRequest = run(transaction.objectStore(MAIN_STORE_NAME));
 
                 if (typeof resolve === "function") {
 
@@ -67,7 +82,6 @@ export class IndexedDBStorage extends Storage {
                     });
 
                 }
-
             });
 
         if (typeof reject === "function") {
@@ -75,40 +89,30 @@ export class IndexedDBStorage extends Storage {
         }
     }
 
-    load(key, resolve, reject, progress) {
-
-        this.db
-            .then((db) => {
-                const transaction = db.transaction(MAIN_STORE_NAME, IndexedDBTransactionMode.ReadOnly);
-
-                const objectStore = transaction.objectStore(MAIN_STORE_NAME);
-
-                const idbRequest = objectStore.get(key);
-
-                idbRequest.addEventListener('success', (event) => {
-                    resolve(event.target.result);
-                });
-
-                idbRequest.addEventListener('error', (event) => {
-                    reject(event);
-                });
-            }).catch(reject);
-    }
-
-    store(key, value, resolve, reject, progress) {
+    /**
+     * Run a write against the main object store.
+     *
+     * A successful request only means the write was queued. Durability is
+     * guaranteed at transaction commit, and a transaction can still abort
+     * afterwards -- on quota exhaustion, for instance. Reporting success off
+     * the request turns a lost save into a reported save.
+     *
+     * Exists so that every write goes through that rule by construction
+     * rather than by each method remembering it.
+     *
+     * @param {function(IDBObjectStore): IDBRequest} run issues the write and returns its request
+     * @param {function(*)} [resolve] receives the request result, once the transaction commits
+     * @param {function(*)} [reject] receives the transaction error, or the error that broke `db`
+     * @private
+     */
+    #write(run, resolve, reject) {
 
         const p = this.db
             .then((db) => {
                 const transaction = db.transaction(MAIN_STORE_NAME, IndexedDBTransactionMode.ReadWrite);
 
-                const objectStore = transaction.objectStore(MAIN_STORE_NAME);
-
-                const idbRequest = objectStore.put(value, key);
+                const idbRequest = run(transaction.objectStore(MAIN_STORE_NAME));
 
-                // A successful request only means the write was queued. Durability
-                // is guaranteed at transaction commit, and a transaction can still
-                // abort afterwards -- on quota exhaustion, for instance. Reporting
-                // success off the request turns a lost save into a reported save.
                 let result;
 
                 idbRequest.addEventListener('success', (event) => {
@@ -146,23 +150,19 @@ export class IndexedDBStorage extends Storage {
         }
     }
 
-    list(resolve, reject) {
-        this.db
-            .then((db) => {
-                const transaction = db.transaction(MAIN_STORE_NAME, IndexedDBTransactionMode.ReadOnly);
-
-                const objectStore = transaction.objectStore(MAIN_STORE_NAME);
+    remove(key, resolve, reject) {
+        this.#write((objectStore) => objectStore.delete(key), resolve, reject);
+    }
 
-                const idbRequest = objectStore.getAllKeys();
+    load(key, resolve, reject, progress) {
+        this.#read((objectStore) => objectStore.get(key), resolve, reject);
+    }
 
-                idbRequest.addEventListener('success', (event) => {
-                    resolve(event.target.result);
-                });
+    store(key, value, resolve, reject, progress) {
+        this.#write((objectStore) => objectStore.put(value, key), resolve, reject);
+    }
 
-                idbRequest.addEventListener('error', (event) => {
-                    reject(event);
-                });
-            })
-            .catch(reject);
+    list(resolve, reject) {
+        this.#read((objectStore) => objectStore.getAllKeys(), resolve, reject);
     }
 }

package/src/engine/sound/ecs/SoundControllerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoundControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/sound/ecs/SoundControllerSystem.js"],"names":[],"mappings":";AAyBA;;;;GAIG;AACH;IACI,cAUC;IARG,yCAAqC;IAGrC,oEAEC;IAED,gBAAkB;IAGtB;;;;OAIG;IACH,gBAHW,eAAe,UACf,MAAM,QAsDhB;CAaJ;uBA/GsB,qBAAqB;4BAGhB,sBAAsB;6BAFrB,2BAA2B;4CAFZ,oDAAoD"}
+{"version":3,"file":"SoundControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/sound/ecs/SoundControllerSystem.js"],"names":[],"mappings":";AAiBA;;;;GAIG;AACH;IACI,cAUC;IARG,yCAAqC;IAGrC,oEAEC;IAED,gBAAkB;IAGtB;;;;OAIG;IACH,gBAHW,eAAe,UACf,MAAM,QAsDhB;CAaJ;uBAtGsB,qBAAqB;4BAGhB,sBAAsB;6BAFrB,2BAA2B;4CAFZ,oDAAoD"}

package/src/engine/sound/ecs/SoundControllerSystem.js

@@ -1,3 +1,4 @@
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
 import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { System } from '../../ecs/System.js';
@@ -11,16 +12,7 @@ import SoundController from './SoundController.js';
  * @returns {string}
  */
 function pickTackFromRule(rule) {
-
-    const randomNumber = Math.random();
-
-    const tracks = rule.tracks;
-
-    const numTracks = tracks.length;
-
-    const index = Math.floor(randomNumber * numTracks);
-
-    return tracks[index];
+    return randomFromArray(Math.random, rule.tracks);
 }
 
 /**

package/src/engine/sound/simulation/AcousticSimulator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticSimulator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/sound/simulation/AcousticSimulator.js"],"names":[],"mappings":"AAyCA;;;;;;;;;GASG;AACH;IACI;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;OAMG;IACH,gBAFU,OAAO,CAEM;IAEvB;;;;OAIG;IACH,eAFU,MAAM,CAEE;IAgGlB,6BAGC;IAZD;;;;OAIG;IACH,0BAEC;IAiBD,gCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAMD;;;;OAIG;IACH,2CAEC;IAED;;;;;;;OAOG;IACH,yEAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAIlB;IAED;;;OAGG;IACH,6BAHW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,QAI/B;IAED;;OAEG;IACH,uBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,8DAEC;IAED;;OAEG;IACH,iDAEC;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;OAKG;IACH,qBAFW,qBAAmB,IAAI,QAMjC;IAED;;;;;;;;OAQG;IACH,mBAPW,OAAO,UACP,OAAO,gBACP,MAAM,SAEN,mBAAmB,OACnB,gBAAgB,QAkB1B;IAED;;;;;;OAMG;IACH,qBAHW,eAAe,YACf,OAAO,QAuFjB;IAgPD;;;OAGG;IACH,sCAOC;;CACJ;+BA/nB8B,0BAA0B;sCACnB,iCAAiC;wBAL/C,+BAA+B;oCAQW,+BAA+B;iCADhE,4BAA4B"}
+{"version":3,"file":"AcousticSimulator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/sound/simulation/AcousticSimulator.js"],"names":[],"mappings":"AA0CA;;;;;;;;;GASG;AACH;IACI;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;OAMG;IACH,gBAFU,OAAO,CAEM;IAEvB;;;;OAIG;IACH,eAFU,MAAM,CAEE;IAgGlB,6BAGC;IAZD;;;;OAIG;IACH,0BAEC;IAiBD,gCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAMD;;;;OAIG;IACH,2CAEC;IAED;;;;;;;OAOG;IACH,yEAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAIlB;IAED;;;OAGG;IACH,6BAHW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,QAI/B;IAED;;OAEG;IACH,uBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,8DAEC;IAED;;OAEG;IACH,iDAEC;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;OAKG;IACH,qBAFW,qBAAmB,IAAI,QAMjC;IAED;;;;;;;;OAQG;IACH,mBAPW,OAAO,UACP,OAAO,gBACP,MAAM,SAEN,mBAAmB,OACnB,gBAAgB,QAkB1B;IAED;;;;;;OAMG;IACH,qBAHW,eAAe,YACf,OAAO,QAuFjB;IAgPD;;;OAGG;IACH,sCAOC;;CACJ;+BA/nB8B,0BAA0B;sCACnB,iCAAiC;wBAN/C,+BAA+B;oCASW,+BAA+B;iCADhE,4BAA4B"}

package/src/engine/sound/simulation/AcousticSimulator.js

@@ -3,6 +3,7 @@ import { Vector3 } from "../../../core/geom/Vector3.js";
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { INVALID_NODE } from "../../../core/graph/csr/csr_graph_build_distance_field.js";
 import { line3_compute_segment_closest_point_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_t.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import { AcousticMedium } from "./core/AcousticMedium.js";
 import { AcousticOccluderIndex } from "./core/AcousticOccluderIndex.js";
 import { AcousticRegionIndex } from "./core/AcousticRegionIndex.js";
@@ -602,7 +603,7 @@ export class AcousticSimulator {
         let dy = ty - source.y;
         let dz = tz - source.z;
 
-        const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        const len = v3_length(dx, dy, dz);
 
         if (len === 0) {
             return 1; // target at the source — radiation direction undefined

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

@@ -1 +1 @@
-{"version":3,"file":"AcousticOccluderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticOccluderIndex.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IA0BI;;;;;;OAMG;IACH,qEAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAelB;IAED;;;;OAIG;IACH,qBAHW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,QAO/B;IAgBD;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAED;;;;;;OAMG;IACH,gBAJW,IAAI,gBAEF,OAAO,CA6CnB;IAED;;;;;OAKG;IACH,YAHW,IAAI,GACF,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAPW,MAAM,KACN,MAAM,KACN,MAAM,gBACN,MAAM,GAEJ,MAAM,CA4BlB;IAED;;;;;;OAMG;IACH,wBAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CA6BlB;;CAmCJ;qBAlToB,sCAAsC"}
+{"version":3,"file":"AcousticOccluderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticOccluderIndex.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IA0BI;;;;;;OAMG;IACH,qEAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAelB;IAED;;;;OAIG;IACH,qBAHW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,QAO/B;IAgBD;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAED;;;;;;OAMG;IACH,gBAJW,IAAI,gBAEF,OAAO,CA6CnB;IAED;;;;;OAKG;IACH,YAHW,IAAI,GACF,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAPW,MAAM,KACN,MAAM,KACN,MAAM,gBACN,MAAM,GAEJ,MAAM,CA4BlB;IAED;;;;;;OAMG;IACH,wBAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CA0BlB;;CAmCJ;qBA/SoB,sCAAsC"}

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

@@ -4,6 +4,7 @@ import {
     bvh_query_user_data_intersects_sphere
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_sphere.js";
 import { bvh_query_user_data_ray_segment } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js";
+import { aabb3_array_combine } from "../../../../core/geom/3d/aabb/aabb3_array_combine.js";
 import { M4_IDENTITY } from "../../../../core/geom/3d/mat4/M4_IDENTITY.js";
 import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
 import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
@@ -261,15 +262,12 @@ export class AcousticOccluderIndex {
 
             const b = body.worldAABB;
             if (n === 0) {
+                // seed the accumulator; `out` is documented as untouched when there are no live bodies, so
+                // it cannot be pre-filled with ±Infinity and unconditionally combined
                 out[0] = b[0]; out[1] = b[1]; out[2] = b[2];
                 out[3] = b[3]; out[4] = b[4]; out[5] = b[5];
             } else {
-                if (b[0] < out[0]) out[0] = b[0];
-                if (b[1] < out[1]) out[1] = b[1];
-                if (b[2] < out[2]) out[2] = b[2];
-                if (b[3] > out[3]) out[3] = b[3];
-                if (b[4] > out[4]) out[4] = b[4];
-                if (b[5] > out[5]) out[5] = b[5];
+                aabb3_array_combine(out, 0, out, 0, b, 0);
             }
 
             n++;

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

@@ -1 +1 @@
-{"version":3,"file":"OcclusionSolver.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/OcclusionSolver.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;;;;;OAUG;IACH,wDARW,MAAM,0CAEN,MAAM,aACN,MAAM,gBACK,MAAM,2DAgF3B;CACJ"}
+{"version":3,"file":"OcclusionSolver.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/OcclusionSolver.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;;;;;OAUG;IACH,wDARW,MAAM,0CAEN,MAAM,aACN,MAAM,gBACK,MAAM,2DAyE3B;CACJ"}

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

@@ -1,7 +1,7 @@
 import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
 import { sphere_fibonacci_point } from "../../../../core/geom/3d/sphere/sphere_fibonacci_point.js";
+import { random_orthonormal_basis } from "../../../../core/geom/random/random_orthonormal_basis.js";
 import { v3_matrix3_rotate } from "../../../../core/geom/vec3/v3_matrix3_rotate.js";
-import { v3_orthonormal_matrix_from_normal } from "../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
 import { RayHit } from "./RayHit.js";
 
 // module-static scratch — reused across calls so a solve allocates nothing. Typed throughout (the
@@ -41,14 +41,7 @@ export class OcclusionSolver {
      */
     solve(listener, source, sourceRadius, index, rayCount, smoothing, random, state, out) {
         // a per-tick random orientation for the fibonacci set (decorrelation over frames)
-        const z = 2 * random() - 1;
-        const azimuth = 2 * Math.PI * random();
-        const ring = Math.sqrt(Math.max(0, 1 - z * z));
-
-        v3_orthonormal_matrix_from_normal(
-            ROTATION, 0,
-            ring * Math.cos(azimuth), ring * Math.sin(azimuth), z
-        );
+        random_orthonormal_basis(ROTATION, 0, random);
 
         const lx = listener.x;
         const ly = listener.y;

package/src/engine/sound/simulation/probe/ProbeVisibilityRecheck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeVisibilityRecheck.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/ProbeVisibilityRecheck.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,kCAFU,MAAM,CAEyC;AAEzD;;;;;;;;;;GAUG;AACH;IAuBI;;;OAGG;IACH,qEAGC;IAED;;;OAGG;IACH,sBAEC;IAaD;;;;;;OAMG;IACH,YAHW,MAAM,KACN,MAAM,QAShB;IAED;;;;;;OAMG;IACH,eAHW,MAAM,GACJ,MAAM,CAsClB;;CACJ"}
+{"version":3,"file":"ProbeVisibilityRecheck.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/ProbeVisibilityRecheck.js"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,kCAFU,MAAM,CAEyC;AAEzD;;;;;;;;;;GAUG;AACH;IAuBI;;;OAGG;IACH,qEAGC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,YAHW,MAAM,KACN,MAAM,QAShB;IAED;;;;;;OAMG;IACH,eAHW,MAAM,GACJ,MAAM,CAwClB;;CACJ"}

package/src/engine/sound/simulation/probe/ProbeVisibilityRecheck.js

@@ -1,6 +1,10 @@
 import { csr_graph_find_edge } from "../../../../core/graph/csr/csr_graph_find_edge.js";
+import { probe_edge_key, probe_edge_key_decode } from "./probe_edge_key.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
 
+// module-static scratch — the decoded `[low, high]` probe pair of the edge currently being rechecked
+const EDGE_PAIR = new Uint32Array(2);
+
 /**
  * Float32 max — a finite, in-range sentinel weight that makes a baked visibility edge **effectively
  * untraversable** without a topology change. Dijkstra still sees the edge, but its astronomically large
@@ -63,17 +67,6 @@ export class ProbeVisibilityRecheck {
         return this.#queue.length;
     }
 
-    /**
-     * Canonical undirected edge id (order-independent), `min·size + max`.
-     * @param {number} a
-     * @param {number} b
-     * @returns {number}
-     */
-    #edgeId(a, b) {
-        const size = this.#field.size;
-        return a < b ? a * size + b : b * size + a;
-    }
-
     /**
      * Mark the edge `(a, b)` — traversed by a leak this frame — as needing a visibility recheck. Cheap: just
      * enqueues (deduped); the ray is cast later in {@link update}. PRECONDITION: `(a, b)` is a real edge of
@@ -82,7 +75,7 @@ export class ProbeVisibilityRecheck {
      * @param {number} b probe index
      */
     markEdge(a, b) {
-        const id = this.#edgeId(a, b);
+        const id = probe_edge_key(a, b, this.#field.size);
 
         if (!this.#queued.has(id)) {
             this.#queued.add(id);
@@ -109,8 +102,10 @@ export class ProbeVisibilityRecheck {
             const id = this.#queue.shift();
             this.#queued.delete(id);
 
-            const a = (id / size) | 0;
-            const b = id % size;
+            probe_edge_key_decode(EDGE_PAIR, 0, id, size);
+
+            const a = EDGE_PAIR[0];
+            const b = EDGE_PAIR[1];
 
             const ka = csr_graph_find_edge(graph, a, b);
             const kb = csr_graph_find_edge(graph, b, a);

package/src/engine/sound/simulation/probe/bakeReverbBands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bakeReverbBands.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/bakeReverbBands.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iEARW,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,gBACK,MAAM,YACjB,YAAY,iBACZ,YAAY,QA2DtB"}
+{"version":3,"file":"bakeReverbBands.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/bakeReverbBands.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iEARW,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,gBACK,MAAM,YACjB,YAAY,iBACZ,YAAY,QAuDtB"}