@woosh/meep-engine 2.169.0 → 2.169.2

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

@@ -1 +1 @@
-{"version":3,"file":"box_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_triangle_contact.js"],"names":[],"mappings":"AAqOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAtBW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAuGnB;AApRD;;;GAGG;AACH,sCAFU,MAAM,CAEyD"}
+{"version":3,"file":"box_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_triangle_contact.js"],"names":[],"mappings":"AA8OA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAtBW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAuGnB;AA7RD;;;GAGG;AACH,sCAFU,MAAM,CAEyD"}

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

@@ -107,6 +107,15 @@ const closest_pair_st = new Float64Array(2);
  * `(p - (line_ox, line_oy)) · (line_nx, line_ny) ≤ 0`. 2D stride 2;
  * result to `points_out`. Returns surviving vertex count.
  */
+/*
+ * NOT core/geom/2d/polygon/polygon2_clip_halfplane, deliberately. Same Sutherland-Hodgman algorithm, but
+ * the core version carries a POINT_EPS = 1e-9 inside/outside slack where this one tests exactly `<= 0`.
+ * On a point lying exactly on the clip plane -- which is the common case here, since box faces and
+ * triangle edges are routinely coincident -- the two disagree about whether the vertex survives, which
+ * changes the emitted manifold and therefore the solver's contact set. Adopting the core version means
+ * accepting that change; forking core into two epsilon variants means a tolerance sentinel. Left as is;
+ * revisit with the box-triangle suite as the gate.
+ */
 function clip_against_half_plane_uv(points_in, point_count, points_out, line_ox, line_oy, line_nx, line_ny) {
     let out_count = 0;
     for (let i = 0; i < point_count; i++) {

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

@@ -1 +1 @@
-{"version":3,"file":"capsule_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_contacts.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;GAeG;AACH,2CAVW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,eACN,MAAM,QAOhB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAhBW,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,GACJ,OAAO,CA6CnB;AAMD;;;;;GAKG;AACH,6CAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,OAAO,CAuEnB;AA8BD;;;;;;;;;GASG;AACH,oDAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,MAAM,CAyHlB;AASD;;;;;;;;;;;;;GAaG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,4NACnB,OAAO,CA6FnB;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,gDAtBW,YAAY,QACZ,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAsElB;AAtaD;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AAmQ9C;;;;;;;;;;GAUG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B"}
+{"version":3,"file":"capsule_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_contacts.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;GAeG;AACH,2CAVW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,eACN,MAAM,QAOhB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAhBW,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,GACJ,OAAO,CA6CnB;AAMD;;;;;GAKG;AACH,6CAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,OAAO,CAoEnB;AA8BD;;;;;;;;;GASG;AACH,oDAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,MAAM,CAyHlB;AASD;;;;;;;;;;;;;GAaG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,4NACnB,OAAO,CA6FnB;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,gDAtBW,YAAY,QACZ,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAsElB;AAtaD;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AAmQ9C;;;;;;;;;;GAUG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B"}

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/GameStateLoader.d.ts

@@ -26,10 +26,10 @@ declare class GameStateLoader extends EnginePlugin {
      *
      * @param {string} name
      * @param {function(ArrayBuffer)} resolve
-     * @param {function(reason:*)} reject
+     * @param {(reason: *) => void} reject
      * @param {function(number)} [progress]
      */
-    load(name: string, resolve: (arg0: ArrayBuffer) => any, reject: any, progress?: (arg0: number) => any): void;
+    load(name: string, resolve: (arg0: ArrayBuffer) => any, reject: (reason: any) => void, progress?: (arg0: number) => any): void;
     /**
      *
      * @param {string} name

package/src/engine/save/GameStateLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GameStateLoader.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/GameStateLoader.js"],"names":[],"mappings":";AAIA;IAII;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf,yBAEC;IAED,gEAeC;IAED;;;;;;OAMG;IACH,iBALW,MAAM,iEAShB;IAED;;;;;OAKG;IACH,yDAIC;IAED;;;;;;OAMG;IACH,WALW,MAAM,kBACG,WAAW,yCAEX,MAAM,gBA6CzB;IAED;;;;;OAKG;IACH,YAJW,MAAM,kBACG,MAAM,kCAoBzB;IAED;;;;;OAKG;IACH,aAJW,MAAM,kBACG,OAAO,kCAwB1B;CACJ;6BAnK4B,2BAA2B"}
+{"version":3,"file":"GameStateLoader.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/GameStateLoader.js"],"names":[],"mappings":";AAIA;IAII;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf,yBAEC;IAED,gEAeC;IAED;;;;;;OAMG;IACH,iBALW,MAAM,iEAShB;IAED;;;;;OAKG;IACH,yDAIC;IAED;;;;;;OAMG;IACH,WALW,MAAM,kBACG,WAAW,mCACL,IAAI,oBACV,MAAM,gBA6CzB;IAED;;;;;OAKG;IACH,YAJW,MAAM,kBACG,MAAM,kCAoBzB;IAED;;;;;OAKG;IACH,aAJW,MAAM,kBACG,OAAO,kCAwB1B;CACJ;6BAnK4B,2BAA2B"}

package/src/engine/save/GameStateLoader.js

@@ -62,7 +62,7 @@ class GameStateLoader extends EnginePlugin {
      *
      * @param {string} name
      * @param {function(ArrayBuffer)} resolve
-     * @param {function(reason:*)} reject
+     * @param {(reason: *) => void} reject
      * @param {function(number)} [progress]
      */
     load(name, resolve, reject, progress) {

package/src/engine/save/Storage.d.ts

@@ -36,10 +36,10 @@ declare class Storage {
     load(key: any, resolve: any, reject: any, progress: any): void;
     /**
      *
-     * @param {function(list:string[])} resolve
+     * @param {(list: string[]) => void} resolve
      * @param {function} reject
      */
-    list(resolve: any, reject: Function): void;
+    list(resolve: (list: string[]) => void, reject: Function): void;
     /**
      *
      * @returns {Promise<string[]>}
@@ -62,9 +62,9 @@ declare class Storage {
      *
      * @param {string} key
      * @param {function(boolean)} resolve
-     * @param {function(reason:*)} reject
+     * @param {(reason: *) => void} reject
      */
-    contains(key: string, resolve: (arg0: boolean) => any, reject: any): void;
+    contains(key: string, resolve: (arg0: boolean) => any, reject: (reason: any) => void): void;
     /**
      *
      * @param {string} key

package/src/engine/save/Storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Storage.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/Storage.js"],"names":[],"mappings":";AAEA;IAEI;;;;;;;OAOG;IACH,iBANW,MAAM,SACN,WAAW,iEAQrB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,kBACG,WAAW,sDAO9B;IAED;;;;;OAKG;IACH,uBAJW,MAAM,wBAEJ,QAAQ,WAAW,CAAC,CAMhC;IAED;;;;;;OAMG;IACH,wBALW,MAAM,SACN,WAAW,qCAQrB;IAED,4EAEC;IAED,+DAEC;IAED;;;;OAIG;IACH,2CAEC;IAED;;;OAGG;IACH,eAFa,QAAQ,MAAM,EAAE,CAAC,CAI7B;IAED;;;;;OAKG;IACH,+DAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAI5B;IAED;;;;;OAKG;IACH,cAJW,MAAM,kBACG,OAAO,6BAQ1B;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAI5B;CACJ"}
+{"version":3,"file":"Storage.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/Storage.js"],"names":[],"mappings":";AAEA;IAEI;;;;;;;OAOG;IACH,iBANW,MAAM,SACN,WAAW,iEAQrB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,kBACG,WAAW,sDAO9B;IAED;;;;;OAKG;IACH,uBAJW,MAAM,wBAEJ,QAAQ,WAAW,CAAC,CAMhC;IAED;;;;;;OAMG;IACH,wBALW,MAAM,SACN,WAAW,qCAQrB;IAED,4EAEC;IAED,+DAEC;IAED;;;;OAIG;IACH,qBAHkB,MAAM,EAAE,KAAK,IAAI,0BAKlC;IAED;;;OAGG;IACH,eAFa,QAAQ,MAAM,EAAE,CAAC,CAI7B;IAED;;;;;OAKG;IACH,+DAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAI5B;IAED;;;;;OAKG;IACH,cAJW,MAAM,kBACG,OAAO,mCACD,IAAI,QAO7B;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAI5B;CACJ"}

package/src/engine/save/Storage.js

@@ -62,7 +62,7 @@ class Storage {
 
     /**
      *
-     * @param {function(list:string[])} resolve
+     * @param {(list: string[]) => void} resolve
      * @param {function} reject
      */
     list(resolve, reject) {
@@ -100,7 +100,7 @@ class Storage {
      *
      * @param {string} key
      * @param {function(boolean)} resolve
-     * @param {function(reason:*)} reject
+     * @param {(reason: *) => void} reject
      */
     contains(key, resolve, reject) {
         let resolved = false;

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;IAwED,sCAkBC;CACJ;oBAtKmB,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 = run(transaction.objectStore(MAIN_STORE_NAME));
 
-                const idbRequest = objectStore.put(value, key);
-
-                // 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) => {
@@ -125,16 +129,17 @@ export class IndexedDBStorage extends Storage {
 
                 if (typeof reject === "function") {
 
-                    idbRequest.addEventListener('error', (event) => {
-                        reject(event);
-                    });
-
-                    transaction.addEventListener('abort', (event) => {
-                        reject(event);
-                    });
-
-                    transaction.addEventListener('error', (event) => {
-                        reject(event);
+                    // One failed write raises `error` on the request, bubbles to
+                    // `error` on the transaction, and then aborts it. Listening
+                    // on all three reports a single lost save three times, and
+                    // `reject` here is the caller's own callback, not a promise
+                    // settle function that would swallow the repeats.
+                    //
+                    // `abort` is the one that always fires for a transaction
+                    // that will not commit -- including an explicit abort, which
+                    // raises no error at all -- so it is the only one needed.
+                    transaction.addEventListener('abort', () => {
+                        reject(transaction.error);
                     });
 
                 }
@@ -145,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"}