@woosh/meep-engine 2.168.0 → 2.169.0

package/src/core/geom/vec3/v3_multiply.js

@@ -6,8 +6,12 @@
  *
  * @param {number[]|Float32Array|Float64Array} result destination
  * @param {number} result_offset offset into `result`
- * @param {number} ax @param {number} ay @param {number} az  first factor
- * @param {number} bx @param {number} by @param {number} bz  second factor
+ * @param {number} ax  first factor x
+ * @param {number} ay  first factor y
+ * @param {number} az  first factor z
+ * @param {number} bx  second factor x
+ * @param {number} by  second factor y
+ * @param {number} bz  second factor z
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/core/geom/vec3/v3_subtract.d.ts

@@ -6,8 +6,12 @@
  *
  * @param {number[]|Float32Array|Float64Array} result destination
  * @param {number} result_offset offset into `result`
- * @param {number} ax @param {number} ay @param {number} az  minuend
- * @param {number} bx @param {number} by @param {number} bz  subtrahend
+ * @param {number} ax  minuend x
+ * @param {number} ay  minuend y
+ * @param {number} az  minuend z
+ * @param {number} bx  subtrahend x
+ * @param {number} by  subtrahend y
+ * @param {number} bz  subtrahend z
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/core/geom/vec3/v3_subtract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_subtract.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_subtract.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,oCARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,MACN,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAStD"}
+{"version":3,"file":"v3_subtract.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_subtract.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB"}

package/src/core/geom/vec3/v3_subtract.js

@@ -6,8 +6,12 @@
  *
  * @param {number[]|Float32Array|Float64Array} result destination
  * @param {number} result_offset offset into `result`
- * @param {number} ax @param {number} ay @param {number} az  minuend
- * @param {number} bx @param {number} by @param {number} bz  subtrahend
+ * @param {number} ax  minuend x
+ * @param {number} ay  minuend y
+ * @param {number} az  minuend z
+ * @param {number} bx  subtrahend x
+ * @param {number} by  subtrahend y
+ * @param {number} bz  subtrahend z
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/core/localization/Localization.js

@@ -139,7 +139,7 @@ export class Localization {
 
         while (_path.endsWith('/') || _path.endsWith('\\')) {
             // remove trailing slash if present
-            _path.slice(0, _path.length - 1);
+            _path = _path.slice(0, _path.length - 1);
         }
 
         const pLoadData = am.promise(`${_path}/${locale}.json`, "json")

package/src/core/math/random/randomSeed.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Draw a child seed from an existing generator.
+ *
+ * Seeded generators here consume an integer. Mulberry32 mixes its seed with
+ * bitwise operators, which coerce to int32 and discard any fractional part, so
+ * handing it a raw `random()` result -- a value in [0,1) -- collapses every
+ * distinct parent seed onto the same stream. Widen to an integer first.
+ *
+ * @param {function():number} random
+ * @returns {number} integer in [0, 2^32)
+ */
+export function randomSeed(random: () => number): number;
+//# sourceMappingURL=randomSeed.d.ts.map

package/src/core/math/random/randomSeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomSeed.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/randomSeed.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,yCAHsB,MAAM,GACf,MAAM,CAIlB"}

package/src/core/math/random/randomSeed.js

@@ -0,0 +1,16 @@
+import { randomIntegerBetween } from "./randomIntegerBetween.js";
+
+/**
+ * Draw a child seed from an existing generator.
+ *
+ * Seeded generators here consume an integer. Mulberry32 mixes its seed with
+ * bitwise operators, which coerce to int32 and discard any fractional part, so
+ * handing it a raw `random()` result -- a value in [0,1) -- collapses every
+ * distinct parent seed onto the same stream. Widen to an integer first.
+ *
+ * @param {function():number} random
+ * @returns {number} integer in [0, 2^32)
+ */
+export function randomSeed(random) {
+    return randomIntegerBetween(random, 0, 0xFFFFFFFF);
+}

package/src/core/math/spline/spline3_hermite_apply_transform.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Apply a 4x4 affine matrix to a 3d cubic Hermite segment.
+ *
+ * The result is written as twelve values in control-point order --
+ * `[p0x, p0y, p0z, p1x, p1y, p1z, m0x, m0y, m0z, m1x, m1y, m1z]` -- matching
+ * the `(p0, p1, m0, m1)` argument order the rest of the `spline3_hermite_*`
+ * family uses, note the stride and offset.
+ *
+ * Endpoints transform as points, so the translation column applies. Tangents
+ * transform as directions, so it does not, and -- unlike
+ * {@link m4_transform_direction_v3_buffer}, which is written for normals -- they
+ * are deliberately NOT re-normalised: a Hermite tangent's magnitude is part of
+ * the curve's shape, and rescaling it would change the geometry rather than
+ * move it. Under this rule the transformed segment is exactly the image of the
+ * original curve: `T(H(u)) = H_transformed(u)` for every `u`.
+ *
+ * The matrix must be AFFINE — the perspective row must be zero and `m4[15]`
+ * must be 1. This is a real restriction, not defensive book-keeping: a
+ * projective map sends a polynomial cubic to a *rational* cubic, which no
+ * Hermite segment can represent, so a perspective matrix here would silently
+ * produce a curve that is merely plausible.
+ *
+ * Matrix layout is meep's usual column-major (OpenGL) convention, so `m4[0..2]`
+ * is the X axis, `m4[4..6]` the Y axis, `m4[8..10]` the Z axis and `m4[12..14]`
+ * the translation.
+ *
+ * Safe to use in place: the inputs are scalars, so they are already read before
+ * anything is written.
+ *
+ * @param {number[]|Float32Array|Float64Array} output where to write the result
+ * @param {number} output_offset where to start writing
+ * @param {number} output_stride step between result values, useful when working in higher dimensions. Typically, this will be 1.
+ * @param {number} p0x
+ * @param {number} p0y
+ * @param {number} p0z
+ * @param {number} p1x
+ * @param {number} p1y
+ * @param {number} p1z
+ * @param {number} m0x tangent at p0
+ * @param {number} m0y tangent at p0
+ * @param {number} m0z tangent at p0
+ * @param {number} m1x tangent at p1
+ * @param {number} m1y tangent at p1
+ * @param {number} m1z tangent at p1
+ * @param {number[]|Float32Array|Float64Array} m4 column-major affine 4x4 matrix
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function spline3_hermite_apply_transform(output: number[] | Float32Array | Float64Array, output_offset: number, output_stride: number, p0x: number, p0y: number, p0z: number, p1x: number, p1y: number, p1z: number, m0x: number, m0y: number, m0z: number, m1x: number, m1y: number, m1z: number, m4: number[] | Float32Array | Float64Array): void;
+//# sourceMappingURL=spline3_hermite_apply_transform.d.ts.map

package/src/core/math/spline/spline3_hermite_apply_transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spline3_hermite_apply_transform.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_apply_transform.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wDAnBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,iBACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAmD5C"}

package/src/core/math/spline/spline3_hermite_apply_transform.js

@@ -0,0 +1,107 @@
+import { assert } from "../../assert.js";
+
+/**
+ * How far the perspective row may drift from `(0, 0, 0, 1)` and still count as
+ * affine. Loose enough to accept a matrix that has been inverted or composed a
+ * few times, tight enough that a real perspective matrix — whose `m4[11]` is
+ * typically −1 — is nowhere near it.
+ * @type {number}
+ */
+const AFFINE_EPSILON = 1e-9;
+
+/**
+ * Apply a 4x4 affine matrix to a 3d cubic Hermite segment.
+ *
+ * The result is written as twelve values in control-point order --
+ * `[p0x, p0y, p0z, p1x, p1y, p1z, m0x, m0y, m0z, m1x, m1y, m1z]` -- matching
+ * the `(p0, p1, m0, m1)` argument order the rest of the `spline3_hermite_*`
+ * family uses, note the stride and offset.
+ *
+ * Endpoints transform as points, so the translation column applies. Tangents
+ * transform as directions, so it does not, and -- unlike
+ * {@link m4_transform_direction_v3_buffer}, which is written for normals -- they
+ * are deliberately NOT re-normalised: a Hermite tangent's magnitude is part of
+ * the curve's shape, and rescaling it would change the geometry rather than
+ * move it. Under this rule the transformed segment is exactly the image of the
+ * original curve: `T(H(u)) = H_transformed(u)` for every `u`.
+ *
+ * The matrix must be AFFINE — the perspective row must be zero and `m4[15]`
+ * must be 1. This is a real restriction, not defensive book-keeping: a
+ * projective map sends a polynomial cubic to a *rational* cubic, which no
+ * Hermite segment can represent, so a perspective matrix here would silently
+ * produce a curve that is merely plausible.
+ *
+ * Matrix layout is meep's usual column-major (OpenGL) convention, so `m4[0..2]`
+ * is the X axis, `m4[4..6]` the Y axis, `m4[8..10]` the Z axis and `m4[12..14]`
+ * the translation.
+ *
+ * Safe to use in place: the inputs are scalars, so they are already read before
+ * anything is written.
+ *
+ * @param {number[]|Float32Array|Float64Array} output where to write the result
+ * @param {number} output_offset where to start writing
+ * @param {number} output_stride step between result values, useful when working in higher dimensions. Typically, this will be 1.
+ * @param {number} p0x
+ * @param {number} p0y
+ * @param {number} p0z
+ * @param {number} p1x
+ * @param {number} p1y
+ * @param {number} p1z
+ * @param {number} m0x tangent at p0
+ * @param {number} m0y tangent at p0
+ * @param {number} m0z tangent at p0
+ * @param {number} m1x tangent at p1
+ * @param {number} m1y tangent at p1
+ * @param {number} m1z tangent at p1
+ * @param {number[]|Float32Array|Float64Array} m4 column-major affine 4x4 matrix
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function spline3_hermite_apply_transform(
+    output,
+    output_offset,
+    output_stride,
+    p0x, p0y, p0z,
+    p1x, p1y, p1z,
+    m0x, m0y, m0z,
+    m1x, m1y, m1z,
+    m4
+) {
+    assert.isNonNegativeInteger(output_offset, 'output_offset');
+    assert.isNonNegativeInteger(output_stride, 'output_stride');
+    assert.greaterThanOrEqual(output_stride, 1, 'output_stride must be at least 1');
+
+    // Tolerance, not equality: an affine matrix that has been through
+    // m4_invert or a chain of m4_multiply comes back with a perspective row
+    // that is affine to rounding rather than exactly so. Measured, 37% of
+    // Float64Array inverses of a random affine matrix land on
+    // `m4[15] = 1 ± 1e-13`; meep's own Float32Array matrices snap back to
+    // exactly 1, which is why the spec's fixtures did not catch this.
+    assert.ok(Math.abs(m4[3]) <= AFFINE_EPSILON, 'm4[3] must be 0, matrix must be affine');
+    assert.ok(Math.abs(m4[7]) <= AFFINE_EPSILON, 'm4[7] must be 0, matrix must be affine');
+    assert.ok(Math.abs(m4[11]) <= AFFINE_EPSILON, 'm4[11] must be 0, matrix must be affine');
+    assert.ok(Math.abs(m4[15] - 1) <= AFFINE_EPSILON, 'm4[15] must be 1, matrix must be affine');
+
+    const a0 = m4[0], a1 = m4[1], a2 = m4[2];
+    const b0 = m4[4], b1 = m4[5], b2 = m4[6];
+    const c0 = m4[8], c1 = m4[9], c2 = m4[10];
+    const tx = m4[12], ty = m4[13], tz = m4[14];
+
+    // endpoints: homogeneous points, translation column included
+    output[output_offset] = a0 * p0x + b0 * p0y + c0 * p0z + tx;
+    output[output_offset + output_stride] = a1 * p0x + b1 * p0y + c1 * p0z + ty;
+    output[output_offset + output_stride * 2] = a2 * p0x + b2 * p0y + c2 * p0z + tz;
+
+    output[output_offset + output_stride * 3] = a0 * p1x + b0 * p1y + c0 * p1z + tx;
+    output[output_offset + output_stride * 4] = a1 * p1x + b1 * p1y + c1 * p1z + ty;
+    output[output_offset + output_stride * 5] = a2 * p1x + b2 * p1y + c2 * p1z + tz;
+
+    // tangents: directions, translation column dropped, magnitude preserved
+    output[output_offset + output_stride * 6] = a0 * m0x + b0 * m0y + c0 * m0z;
+    output[output_offset + output_stride * 7] = a1 * m0x + b1 * m0y + c1 * m0z;
+    output[output_offset + output_stride * 8] = a2 * m0x + b2 * m0y + c2 * m0z;
+
+    output[output_offset + output_stride * 9] = a0 * m1x + b0 * m1y + c0 * m1z;
+    output[output_offset + output_stride * 10] = a1 * m1x + b1 * m1y + c1 * m1z;
+    output[output_offset + output_stride * 11] = a2 * m1x + b2 * m1y + c2 * m1z;
+}

package/src/core/math/spline/spline3_hermite_reverse.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Reverse the parameterisation of a cubic Hermite segment: writes the curve
+ * `R(u) = H(1 - u)`, which traces exactly the same points in the opposite
+ * direction.
+ *
+ * The result is written in the same `[p0, p1, m0, m1]` order every other
+ * `spline3_hermite_*` function uses, note the stride and offset.
+ *
+ * Reversal negates the tangents as well as swapping the endpoints. From
+ * `R'(u) = -H'(1 - u)` we get `R'(0) = -H'(1) = -m1` and `R'(1) = -H'(0) = -m0`,
+ * so the result is `[p1, p0, -m1, -m0]`. Writing `[p1, p0, m1, m0]` without the
+ * sign flip is the classic mistake: it yields a curve through the same two
+ * endpoints that bulges the wrong way, which is easy to miss on a nearly
+ * straight segment and obvious on a curved one.
+ *
+ * Exact — every output is an input or an input with its sign flipped, so there
+ * is no rounding, and reversing twice returns the original four values.
+ *
+ * Safe to use in place: the inputs are scalars, so they are already read before
+ * anything is written. `output` may be the very array the values came from,
+ * at the same offset.
+ *
+ * @param {number[]|Float32Array|Float64Array} output where to write the result
+ * @param {number} output_offset where to start writing
+ * @param {number} output_stride step between result values, useful when working in higher dimensions. Typically, this will be 1.
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0 tangent at p0
+ * @param {number} m1 tangent at p1
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function spline3_hermite_reverse(output: number[] | Float32Array | Float64Array, output_offset: number, output_stride: number, p0: number, p1: number, m0: number, m1: number): void;
+//# sourceMappingURL=spline3_hermite_reverse.d.ts.map

package/src/core/math/spline/spline3_hermite_reverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spline3_hermite_reverse.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_reverse.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,gDAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,iBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB"}

package/src/core/math/spline/spline3_hermite_reverse.js

@@ -0,0 +1,49 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Reverse the parameterisation of a cubic Hermite segment: writes the curve
+ * `R(u) = H(1 - u)`, which traces exactly the same points in the opposite
+ * direction.
+ *
+ * The result is written in the same `[p0, p1, m0, m1]` order every other
+ * `spline3_hermite_*` function uses, note the stride and offset.
+ *
+ * Reversal negates the tangents as well as swapping the endpoints. From
+ * `R'(u) = -H'(1 - u)` we get `R'(0) = -H'(1) = -m1` and `R'(1) = -H'(0) = -m0`,
+ * so the result is `[p1, p0, -m1, -m0]`. Writing `[p1, p0, m1, m0]` without the
+ * sign flip is the classic mistake: it yields a curve through the same two
+ * endpoints that bulges the wrong way, which is easy to miss on a nearly
+ * straight segment and obvious on a curved one.
+ *
+ * Exact — every output is an input or an input with its sign flipped, so there
+ * is no rounding, and reversing twice returns the original four values.
+ *
+ * Safe to use in place: the inputs are scalars, so they are already read before
+ * anything is written. `output` may be the very array the values came from,
+ * at the same offset.
+ *
+ * @param {number[]|Float32Array|Float64Array} output where to write the result
+ * @param {number} output_offset where to start writing
+ * @param {number} output_stride step between result values, useful when working in higher dimensions. Typically, this will be 1.
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} m0 tangent at p0
+ * @param {number} m1 tangent at p1
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function spline3_hermite_reverse(
+    output,
+    output_offset,
+    output_stride,
+    p0, p1, m0, m1
+) {
+    assert.isNonNegativeInteger(output_offset, 'output_offset');
+    assert.isNonNegativeInteger(output_stride, 'output_stride');
+    assert.greaterThanOrEqual(output_stride, 1, 'output_stride must be at least 1');
+
+    output[output_offset] = p1;
+    output[output_offset + output_stride] = p0;
+    output[output_offset + output_stride * 2] = -m1;
+    output[output_offset + output_stride * 3] = -m0;
+}

package/src/core/math/statistics/hammersley_sequence.d.ts

@@ -1,9 +1,22 @@
 /**
- * Low discrepancy sequence
+ * Second coordinate of the Hammersley set: the van der Corput radical inverse
+ * of `i` in base `R`.
+ *
+ * Computed in closed form, as {@link halton_sequence} does. The previous
+ * incremental formulation restarted from zero and applied `i` successive
+ * additions, so for any base whose reciprocal is not exactly representable --
+ * base 3 among them -- rounding accumulated until the comparisons inside it
+ * stopped agreeing with exact arithmetic and the sequence collapsed onto a
+ * short cycle. It was also O(i) per element, and therefore quadratic to
+ * enumerate; this is O(log i).
+ *
+ * The radical inverse does not depend on the size of the set, so the `count`
+ * parameter this used to take is gone: the first Hammersley coordinate is
+ * `i / count` and belongs to the caller. It was never read by the body.
+ *
  * @param {number} i index of sequence element
  * @param {number} R a prime number
- * @param {number} count how many elements in the sequence
- * @returns {number}
+ * @returns {number} value in [0,1)
  */
-export function hammersley_sequence(i: number, R: number, count: number): number;
+export function hammersley_sequence(i: number, R: number): number;
 //# sourceMappingURL=hammersley_sequence.d.ts.map

package/src/core/math/statistics/hammersley_sequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hammersley_sequence.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/hammersley_sequence.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,uCALW,MAAM,KACN,MAAM,SACN,MAAM,GACJ,MAAM,CAkBlB"}
+{"version":3,"file":"hammersley_sequence.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/hammersley_sequence.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAelB"}

package/src/core/math/statistics/hammersley_sequence.js

@@ -1,25 +1,34 @@
 /**
- * Low discrepancy sequence
+ * Second coordinate of the Hammersley set: the van der Corput radical inverse
+ * of `i` in base `R`.
+ *
+ * Computed in closed form, as {@link halton_sequence} does. The previous
+ * incremental formulation restarted from zero and applied `i` successive
+ * additions, so for any base whose reciprocal is not exactly representable --
+ * base 3 among them -- rounding accumulated until the comparisons inside it
+ * stopped agreeing with exact arithmetic and the sequence collapsed onto a
+ * short cycle. It was also O(i) per element, and therefore quadratic to
+ * enumerate; this is O(log i).
+ *
+ * The radical inverse does not depend on the size of the set, so the `count`
+ * parameter this used to take is gone: the first Hammersley coordinate is
+ * `i / count` and belongs to the caller. It was never read by the body.
+ *
  * @param {number} i index of sequence element
  * @param {number} R a prime number
- * @param {number} count how many elements in the sequence
- * @returns {number}
+ * @returns {number} value in [0,1)
  */
-export function hammersley_sequence(i, R, count) {
+export function hammersley_sequence(i, R) {
 
-    let t = i / count;
+    let result = 0;
+    let f = 1;
+    let n = i;
 
-    for (let j = 0; j < i; j++) {
-        const x = 1 - t;
-        let y = 1 / R;
-
-        while (x <= y) {
-            y = y / R;
-        }
-
-        t += (R + 1) * y - 1;
+    while (n > 0) {
+        f = f / R;
+        result = result + f * (n % R);
+        n = (n / R) >>> 0;
     }
 
-    return t;
+    return result;
 }
-

package/src/core/process/Future.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Future.d.ts","sourceRoot":"","sources":["../../../../src/core/process/Future.js"],"names":[],"mappings":"2BAEU,MAAM;;;;;;;;AAiBhB;IACI;;;;;;OAMG;IACH,2BASC;IARG,cAAwB;IACxB,cAAiC;IAEjC,0BAA4B;IAC5B,qBAA2B;IAE3B,2BAA6B;IAC7B,mBAAyB;IAG7B;;;;OAIG;IACH,0BAQC;IAED;;;OAGG;IACH,yBAGC;IAED;;;OAGG;IACH,2BAWC;IAED,gBAmBC;IAED;;;;OAIG;IACH,iGAeC;IAED;;;OAGG;IACH,yCAMC;CACJ"}
+{"version":3,"file":"Future.d.ts","sourceRoot":"","sources":["../../../../src/core/process/Future.js"],"names":[],"mappings":"2BAEU,MAAM;;;;;;;;AAiBhB;IACI;;;;;;OAMG;IACH,2BASC;IARG,cAAwB;IACxB,cAAiC;IAEjC,0BAA4B;IAC5B,qBAA2B;IAE3B,2BAA6B;IAC7B,mBAAyB;IAG7B;;;;OAIG;IACH,0BAaC;IAED;;;OAGG;IACH,yBAGC;IAED;;;OAGG;IACH,2BAkBC;IAED,gBAmBC;IAED;;;;OAIG;IACH,iGAeC;IAED;;;OAGG;IACH,yCAMC;CACJ"}

package/src/core/process/Future.js

@@ -42,6 +42,11 @@ class Future {
      * @private
      */
     __handleRejection(reason) {
+        if (this.state !== FutureStates.PENDING) {
+            // already settled; first settlement wins, as with a Promise
+            return;
+        }
+
         this.state = FutureStates.REJECTED;
         this.rejectionReason = reason;
         fastForEach(this.callbacksRejection, function (cb) {
@@ -65,6 +70,13 @@ class Future {
      * @private
      */
     __handleResolution(v) {
+        if (this.state !== FutureStates.PENDING) {
+            // already settled; without this a resolver that rejects and then
+            // resolves flips a rejected future to resolved, and its rejection
+            // handlers have already run
+            return;
+        }
+
         this.state = FutureStates.RESOLVED;
 
         this.resolvedValue = v;

package/src/core/process/PromiseWatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PromiseWatcher.d.ts","sourceRoot":"","sources":["../../../../src/core/process/PromiseWatcher.js"],"names":[],"mappings":"AAGA;IAEQ;;;OAGG;IACH,YAFU,kBAAa,CAEK;IAE5B;;;OAGG;IACH,iBAFU,OAAO,CAEoB;IAMzC;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,iCAMC;CACJ;iBAhDgB,4BAA4B;oBACzB,oBAAoB"}
+{"version":3,"file":"PromiseWatcher.d.ts","sourceRoot":"","sources":["../../../../src/core/process/PromiseWatcher.js"],"names":[],"mappings":"AAGA;IAEQ;;;OAGG;IACH,YAFU,kBAAa,CAEK;IAE5B;;;OAGG;IACH,iBAFU,OAAO,CAEoB;IAMzC;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,iCAaC;CACJ;iBAvDgB,4BAA4B;oBACzB,oBAAoB"}

package/src/core/process/PromiseWatcher.js

@@ -42,8 +42,15 @@ export class PromiseWatcher {
     add(promise) {
         this.unresolved.add(promise);
 
-        promise.finally(() => {
+        const settled = () => {
             this.unresolved.removeOneOf(promise);
-        });
+        };
+
+        // `finally` returns a *new* promise that rejects with the same reason,
+        // and discarding it leaves that rejection unhandled -- which terminates
+        // the process under Node's default policy, even when the caller has
+        // attached its own catch to `promise`. Handling both outcomes here
+        // settles the derived promise instead of abandoning it.
+        promise.then(settled, settled);
     }
 }

package/src/core/process/executor/ConcurrentExecutor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConcurrentExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/executor/ConcurrentExecutor.js"],"names":[],"mappings":";AAgBA;;GAEG;AACH;IAaI;;;;;OAKG;IACH,wBAJW,MAAM,aACN,MAAM,EAwChB;IApCG;;;OAGG;IACH,WAFU,MAAM,CAEU;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,iBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,YAFU,MAAM,CAEI;IAEpB;;;;MAIC;IAED,cAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,GAAC,gBAAgB,CAES;IAG9C;;;OAGG;IACH,qCAmEC;IAED;;;OAGG;IACH,oCAaC;IAED;;;;OAIG;IACH,wBAFY,OAAO,CAwBlB;IAED;;;OAGG;IACH,sBAGC;IAED;;;OAGG;IACH,eAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,kBAkCC;IAED;;OAEG;IACH,qBA+BC;IAED;;;;OAIG;IACH,sBAFa,OAAO,CAYnB;IAwLD;;;OAGG;IACH,aAQC;IAED,0BAMC;;CACJ;;;;mBAjgBkB,+BAA+B;wBAqgBxC,MAAM"}
+{"version":3,"file":"ConcurrentExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/executor/ConcurrentExecutor.js"],"names":[],"mappings":";AAgBA;;GAEG;AACH;IAaI;;;;;OAKG;IACH,wBAJW,MAAM,aACN,MAAM,EAwChB;IApCG;;;OAGG;IACH,WAFU,MAAM,CAEU;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,iBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,YAFU,MAAM,CAEI;IAEpB;;;;MAIC;IAED,cAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,GAAC,gBAAgB,CAES;IAG9C;;;OAGG;IACH,qCAmEC;IAED;;;OAGG;IACH,oCAaC;IAED;;;;OAIG;IACH,wBAFY,OAAO,CAwBlB;IAED;;;OAGG;IACH,sBAGC;IAED;;;OAGG;IACH,eAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,kBAkCC;IAED;;OAEG;IACH,qBAyCC;IAED;;;;OAIG;IACH,sBAFa,OAAO,CAYnB;IAwLD;;;OAGG;IACH,aAQC;IAED,0BAMC;;CACJ;;;;mBA3gBkB,+BAA+B;wBA+gBxC,MAAM"}

package/src/core/process/executor/ConcurrentExecutor.js

@@ -285,8 +285,18 @@ class ConcurrentExecutor {
                     break;
                 case ResolutionType.FAILED:
                     queueUnresolved.splice(i, 1);
-                    l--;
-                    i--;
+
+                    // Dropping it from the queue is not enough: the task still
+                    // has to reach a terminal state, or its promise never
+                    // settles and everything awaiting it waits forever.
+                    unresolvedTask.state.set(TaskState.FAILED);
+
+                    // its own dependants are now resolvable too, and they may
+                    // sit earlier in the queue, so rescan from the start the
+                    // same way a READY transition does
+                    i = -1;
+                    l = queueUnresolved.length;
+
                     break;
             }
         }

package/src/core/process/worker/WorkerProxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WorkerProxy.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/WorkerProxy.js"],"names":[],"mappings":"2BAIU,MAAM;AADhB;;GAEG;AACH;;;;GAIG;;AAqCH;IA4CI;;;;OAIG;IACH,iBAHW,MAAM,gBAQhB;IApDD;;;;OAIG;IACH,kBAAe;IAEf;;;OAGG;IACH,iBAAgC;IAEhC;;;;OAIG;IACH,kBAAiB;IAEjB;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;OAKG;IACH,eAAiB;IAQb,YAAc;IACd,aAAsB;IAK1B;;;;;;OAMG;IACH,wBAJW,MAAM,2BAsDhB;IAED;;;;OAIG;IACH,qBAgBC;IAED;;;OAGG;IACH,sBAQC;IAED;;;;OAIG;IACH,wBAqCC;IAED,qBAEC;IAED;;OAEG;IACH,aAFa,YAAY,CAIxB;IAED;;;;OAIG;IACH,aAMC;IAED;;;;;OAKG;IACH,kBAJW,MAAM,eACN,MAAM,GACJ,OAAO,CAkCnB;IAED,4BAmBC;IAED;;;;;;OAMG;IACH,cAqBC;IAED;;;;;;;OAOG;IACH,sBAmBC;IAED;;;OAGG;IACH,yBAaC;CACJ"}
+{"version":3,"file":"WorkerProxy.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/WorkerProxy.js"],"names":[],"mappings":"2BAIU,MAAM;AADhB;;GAEG;AACH;;;;GAIG;;AAqCH;IA4CI;;;;OAIG;IACH,iBAHW,MAAM,gBAQhB;IApDD;;;;OAIG;IACH,kBAAe;IAEf;;;OAGG;IACH,iBAAgC;IAEhC;;;;OAIG;IACH,kBAAiB;IAEjB;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;OAKG;IACH,eAAiB;IAQb,YAAc;IACd,aAAsB;IAK1B;;;;;;OAMG;IACH,wBAJW,MAAM,2BAyDhB;IAED;;;;OAIG;IACH,qBAgBC;IAED;;;OAGG;IACH,sBAQC;IAED;;;;OAIG;IACH,wBAqCC;IAED,qBAEC;IAED;;OAEG;IACH,aAFa,YAAY,CAIxB;IAED;;;;OAIG;IACH,aAMC;IAED;;;;;OAKG;IACH,kBAJW,MAAM,eACN,MAAM,GACJ,OAAO,CAkCnB;IAED,4BAmBC;IAED;;;;;;OAMG;IACH,cAqBC;IAED;;;;;;;OAOG;IACH,sBAmBC;IAED;;;OAGG;IACH,yBAaC;CACJ"}

package/src/core/process/worker/WorkerProxy.js

@@ -152,9 +152,12 @@ class WorkerProxy {
                 };
 
                 if (!trySendMessage(this.__worker, message)) {
-                    // failed to send the message
-                    // drop the pending request
+                    // failed to send the message. Dropping the pending request
+                    // is not enough: nothing will ever resolve or reject it, so
+                    // the caller waits forever.
                     array_remove_first(pending, request);
+
+                    reject(new Error(`Failed to send message for method '${name}' to worker`));
                 }
             }
         });

package/src/core/process/worker/extractTransferables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractTransferables.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/extractTransferables.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,iEAHa,MAAM,CAqClB"}
+{"version":3,"file":"extractTransferables.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/worker/extractTransferables.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,iEAHa,MAAM,CAwClB"}

package/src/core/process/worker/extractTransferables.js

@@ -11,8 +11,11 @@ import { isImageBitmap } from "../../dom/isImageBitmap.js";
 export function extractTransferables(value, result) {
     let count = 0;
 
-    if (typeof value !== "object") {
+    if (value === null || typeof value !== "object") {
 
+        // null is typeof "object", and reaching the `value.buffer` branch with
+        // it throws. The inlined copy of this walk in WorkerBuilder already
+        // guards for it.
         // not an object, skip
 
     } else if (value instanceof ArrayBuffer) {

package/src/engine/Engine.d.ts

@@ -10,6 +10,16 @@ declare class Engine {
      * @constructor
      */
     constructor(platform: EnginePlatform, { entityManager, enableGraphics, enableAudio, debug }?: EntityManager);
+    /**
+     * Absent when the engine is constructed with `enableGraphics: false`.
+     * @type {GraphicsEngine|null}
+     */
+    graphics: GraphicsEngine | null;
+    /**
+     * Absent when the engine is constructed with `enableAudio: false`.
+     * @type {SoundEngine|null}
+     */
+    sound: SoundEngine | null;
     viewStack: ViewStack;
     /**
      *
@@ -84,16 +94,6 @@ declare class Engine {
     storage: Storage;
     localization: Localization;
     camera: ThreePerspectiveCamera;
-    /**
-     *
-     * @type {GraphicsEngine}
-     */
-    graphics: GraphicsEngine;
-    /**
-     *
-     * @type {SoundEngine}
-     */
-    sound: SoundEngine;
     /**
      * Graphical User Interface engine
      * @type {GUIEngine}
@@ -145,6 +145,8 @@ declare class Engine {
     readonly isEngine: boolean;
     #private;
 }
+import { GraphicsEngine } from './graphics/GraphicsEngine.js';
+import SoundEngine from './sound/SoundEngine.js';
 import { ViewStack } from "../view/elements/navigation/ViewStack.js";
 import { StaticKnowledgeDatabase } from "./knowledge/database/StaticKnowledgeDatabase.js";
 import { EnginePluginManager } from "./plugin/EnginePluginManager.js";
@@ -163,8 +165,6 @@ declare class EngineSettings {
 }
 import { Localization } from "../core/localization/Localization.js";
 import { PerspectiveCamera as ThreePerspectiveCamera } from 'three';
-import { GraphicsEngine } from './graphics/GraphicsEngine.js';
-import SoundEngine from './sound/SoundEngine.js';
 import GUIEngine from './ui/GUIEngine.js';
 import SceneManager from "./scene/SceneManager.js";
 import { PointerDevice } from "./input/devices/PointerDevice.js";

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";AA8CA;IAqCI;;;;;;;;OAQG;IACH,8FANW,aAAa,EAsOvB;IA3QD,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAmBrC;;;OAGG;IACH,yBAAwB;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,mBAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAOtC,+BAA6E;IAUzE;;;OAGG;IACH,UAFU,cAAc,CAEM;IAiB9B;;;OAGG;IACH,OAFU,WAAW,CAEG;IAK5B;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IAaD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAsBhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAwBC;IAED;;;OAGG;IACH,sBA0CC;IAqBD;;OAEG;IACH,sBAqBC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;0BA/iByB,0CAA0C;wCAa5B,iDAAiD;oCAGrD,iCAAiC;mBAElD,wBAAwB;+BApBZ,gDAAgD;iCAM9C,+CAA+C;6BAFnD,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BAnBvB,iCAAiC;4CAYpB,qDAAqD;AAgBjG;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAjC4B,sCAAsC;4DAHP,OAAO;+BAiBpC,8BAA8B;wBAUrC,wBAAwB;sBAE1B,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAX1C,+BAA+B;+BAItB,qCAAqC;8BAItC,wBAAwB;4BAV1B,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";AAuDA;IAoEI;;;;;;;;OAQG;IACH,8FANW,aAAa,EA0OvB;IA3RD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAmBrC;;;OAGG;IACH,yBAAwB;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,mBAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAOtC,+BAA6E;IA4C7E;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IAaD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAiGhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eA6BC;IAED;;;OAGG;IACH,sBAmDC;IAqBD;;OAEG;IACH,sBA2BC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAhrB8B,8BAA8B;wBAUrC,wBAAwB;0BApBtB,0CAA0C;wCAc5B,iDAAiD;oCAGrD,iCAAiC;mBAElD,wBAAwB;+BArBZ,gDAAgD;iCAO9C,+CAA+C;6BAFnD,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BApBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAlC4B,sCAAsC;4DAHP,OAAO;sBA8B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAZ1C,+BAA+B;+BAKtB,qCAAqC;8BAItC,wBAAwB;4BAX1B,kCAAkC;oBAH1C,yBAAyB"}