@woosh/meep-engine 2.156.0 → 2.157.0

package/src/{engine/physics/integration/quat_integrate.d.ts → core/geom/3d/quaternion/quat3_integrate.d.ts}

@@ -23,5 +23,5 @@
  * @param {number} omega_z
  * @param {number} dt
  */
-export function quat_integrate(result_q: number[] | Float64Array | Quaternion, qx: number, qy: number, qz: number, qw: number, omega_x: number, omega_y: number, omega_z: number, dt: number): void;
-//# sourceMappingURL=quat_integrate.d.ts.map
+export function quat3_integrate(result_q: number[] | Float64Array | Quaternion, qx: number, qy: number, qz: number, qw: number, omega_x: number, omega_y: number, omega_z: number, dt: number): void;
+//# sourceMappingURL=quat3_integrate.d.ts.map

package/src/core/geom/3d/quaternion/quat3_integrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_integrate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_integrate.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,0CAVW,MAAM,EAAE,GAAC,YAAY,aAAW,MAChC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,MACN,MAAM,QAsChB"}

package/src/{engine/physics/integration/quat_integrate.js → core/geom/3d/quaternion/quat3_integrate.js}

@@ -23,7 +23,7 @@
  * @param {number} omega_z
  * @param {number} dt
  */
-export function quat_integrate(
+export function quat3_integrate(
     result_q,
     qx, qy, qz, qw,
     omega_x, omega_y, omega_z,

package/src/{engine/physics/narrowphase/PosedShape.d.ts → core/geom/3d/shape/PosedShape3D.d.ts}

@@ -5,11 +5,12 @@
  * query direction into body space, ask the shape, then rotate the support
  * point back to world.
  *
- * Existing TransformedShape3D solves a more general case (arbitrary matrix
- * including scale) and crucially does *not* rotate the query direction into
- * body space before calling support — that path is correct for unscaled
- * identity rotations but wrong for rotated bodies, which is what narrowphase
- * needs.
+ * Relationship to {@link TransformedShape3D}: that class solves the more
+ * general case (arbitrary affine matrix including scale) at the cost of
+ * storing a matrix pair and running a matrix inversion on every transform
+ * update. This class is the rigid-pose specialization for hot paths: no
+ * matrix is ever built, rebinding via {@link setup} is seven scalar copies,
+ * and `support` is pure inlined quaternion math.
  *
  * Reusable: physics narrowphase keeps two long-lived instances and calls
  * {@link setup} each pair. No per-pair allocation.
@@ -17,7 +18,7 @@
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export class PosedShape extends AbstractShape3D {
+export class PosedShape3D extends AbstractShape3D {
     /** @type {AbstractShape3D|null} */
     shape: AbstractShape3D | null;
     px: number;
@@ -47,5 +48,5 @@ export class PosedShape extends AbstractShape3D {
     }): void;
     compute_bounding_box(result: any): void;
 }
-import { AbstractShape3D } from "../../../core/geom/3d/shape/AbstractShape3D.js";
-//# sourceMappingURL=PosedShape.d.ts.map
+import { AbstractShape3D } from "./AbstractShape3D.js";
+//# sourceMappingURL=PosedShape3D.d.ts.map

package/src/{engine/physics/narrowphase/PosedShape.d.ts.map → core/geom/3d/shape/PosedShape3D.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"PosedShape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/PosedShape.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAKQ,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CACd;IAEjB,WAAW;IAAE,WAAW;IAAE,WAAW;IACrC,WAAW;IAAE,WAAW;IAAE,WAAW;IAAE,WAAW;IAGtD;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAM1D;IAgDD,wCASC;CACJ;gCA1G+B,gDAAgD"}
+{"version":3,"file":"PosedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PosedShape3D.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAKQ,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CACd;IAEjB,WAAW;IAAE,WAAW;IAAE,WAAW;IACrC,WAAW;IAAE,WAAW;IAAE,WAAW;IAAE,WAAW;IAGtD;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAM1D;IAgDD,wCASC;CACJ;gCA3G+B,sBAAsB"}

package/src/{engine/physics/narrowphase/PosedShape.js → core/geom/3d/shape/PosedShape3D.js}

@@ -1,5 +1,5 @@
-import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
-import { AbstractShape3D } from "../../../core/geom/3d/shape/AbstractShape3D.js";
+import { aabb3_transform_oriented } from "../aabb/aabb3_transform_oriented.js";
+import { AbstractShape3D } from "./AbstractShape3D.js";
 
 const scratch_local = new Float64Array(3);
 const scratch_local_aabb = new Float64Array(6);
@@ -11,11 +11,12 @@ const scratch_local_aabb = new Float64Array(6);
  * query direction into body space, ask the shape, then rotate the support
  * point back to world.
  *
- * Existing TransformedShape3D solves a more general case (arbitrary matrix
- * including scale) and crucially does *not* rotate the query direction into
- * body space before calling support — that path is correct for unscaled
- * identity rotations but wrong for rotated bodies, which is what narrowphase
- * needs.
+ * Relationship to {@link TransformedShape3D}: that class solves the more
+ * general case (arbitrary affine matrix including scale) at the cost of
+ * storing a matrix pair and running a matrix inversion on every transform
+ * update. This class is the rigid-pose specialization for hot paths: no
+ * matrix is ever built, rebinding via {@link setup} is seven scalar copies,
+ * and `support` is pure inlined quaternion math.
  *
  * Reusable: physics narrowphase keeps two long-lived instances and calls
  * {@link setup} each pair. No per-pair allocation.
@@ -23,7 +24,7 @@ const scratch_local_aabb = new Float64Array(6);
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export class PosedShape extends AbstractShape3D {
+export class PosedShape3D extends AbstractShape3D {
 
     constructor() {
         super();
@@ -57,7 +58,7 @@ export class PosedShape extends AbstractShape3D {
      * @param {number} dz world-space query direction z
      */
     support(result, result_offset, dx, dy, dz) {
-        // Inline q·v·q* math: PosedShape.support is the hottest GJK call
+        // Inline q·v·q* math: PosedShape3D.support is the hottest GJK call
         // (twice per iteration of the body-level fallback, once per
         // triangle for concave dispatch). V8 declines to inline
         // v3_quat3_apply at 9-arg call sites, so the math is repeated

package/src/core/geom/3d/shape/TransformedShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AAkBA;IA4CI;;;;;OAKG;IACH,wBAHW,eAAe,MADf,MAAM,EAAE,GAAC,YAAY,OAAK,GAExB,kBAAkB,CAS9B;IAED;;;;;OAKG;IACH,uCAJW,eAAe,eACf,MAAM,EAAE,SACR,MAAM,EAAE,sBAclB;IAED;;;;OAIG;IACH,iCAHW,eAAe,eACf,MAAM,EAAE,sBAIlB;IAED;;;;;OAKG;IACH,2BAHW,eAAe,SACf,MAAM,EAAE,GAAC,YAAY,OAAK,GAFxB,kBAAkB,CAW9B;IAjGG;;;;OAIG;IACH,iBAAoC;IAEpC;;;;OAIG;IACH,yBAA4C;IAE5C;;;;OAIG;IACH,kBAAqB;IAGzB;;;OAGG;IACH,+BAEC;IAuED;;;OAGG;IACH,4CAIC;IAED,yCAEC;IAUD,wCAKC;IAED,mEAyDC;IAED,6CAEC;IAED,oCAKC;IAED,kFAIC;IAED,qGAwCC;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;CAMJ;;8BAIS,OAAO;;gCAtRe,sBAAsB"}
+{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AAwBA;IA4CI;;;;;OAKG;IACH,wBAHW,eAAe,MADf,MAAM,EAAE,GAAC,YAAY,OAAK,GAExB,kBAAkB,CAS9B;IAED;;;;;OAKG;IACH,uCAJW,eAAe,eACf,MAAM,EAAE,SACR,MAAM,EAAE,sBAiBlB;IAED;;;;OAIG;IACH,iCAHW,eAAe,eACf,MAAM,EAAE,sBAIlB;IAED;;;;;OAKG;IACH,2BAHW,eAAe,SACf,MAAM,EAAE,GAAC,YAAY,OAAK,GAFxB,kBAAkB,CAM9B;IA/FG;;;;OAIG;IACH,iBAAoC;IAEpC;;;;OAIG;IACH,yBAA4C;IAE5C;;;;OAIG;IACH,kBAAqB;IAGzB;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,4CAIC;IAED,yCAEC;IAUD,wCAKC;IAED,mEAyDC;IAED,6CAEC;IAED,oCAKC;IAED,kFAIC;IAED,qGAwCC;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;CAMJ;;8BAIS,OAAO;;gCA1Re,sBAAsB"}

package/src/core/geom/3d/shape/TransformedShape3D.js

@@ -1,4 +1,3 @@
-import { Transform } from "../../../../engine/ecs/transform/Transform.js";
 import { assert } from "../../../assert.js";
 import { isArrayEqualStrict } from "../../../collection/array/isArrayEqualStrict.js";
 import { computeHashFloatArray } from "../../../math/hash/computeHashFloatArray.js";
@@ -8,6 +7,7 @@ import { v3_matrix4_multiply } from "../../vec3/v3_matrix4_multiply.js";
 import { aabb3_matrix4_project } from "../aabb/aabb3_matrix4_project.js";
 import { m4_extract_scale } from "../mat4/m4_extract_scale.js";
 import { m4_invert } from "../mat4/m4_invert.js";
+import { m4_make_scale } from "../mat4/m4_make_scale.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 
 /**
@@ -16,6 +16,12 @@ import { AbstractShape3D } from "./AbstractShape3D.js";
  */
 const scratch_v3_0 = new Float32Array(3);
 
+/**
+ *
+ * @type {Float32Array|mat4}
+ */
+const scratch_m4_0 = new Float32Array(16);
+
 export class TransformedShape3D extends AbstractShape3D {
     constructor() {
         super();
@@ -88,11 +94,14 @@ export class TransformedShape3D extends AbstractShape3D {
         assert.isArrayLike(scale, 'scale');
         assert.greaterThanOrEqual(scale.length, 3, 'scale length must be >= 3');
 
-        const t = new Transform();
-        t.scale.fromArray(scale);
-        t.position.fromArray(translation);
+        // T·S: scale is applied in the subject's local frame, translation is not scaled
+        const m = m4_make_scale(scratch_m4_0, scale);
 
-        return TransformedShape3D.from_m4(subject, t.matrix);
+        m[12] = translation[0];
+        m[13] = translation[1];
+        m[14] = translation[2];
+
+        return TransformedShape3D.from_m4(subject, m);
     }
 
     /**
@@ -111,12 +120,7 @@ export class TransformedShape3D extends AbstractShape3D {
      * @param {number[]|Float32Array|vec3} scale
      */
     static from_scale(subject, scale) {
-
-        const t = new Transform();
-        t.scale.fromArray(scale);
-
-
-        return TransformedShape3D.from_m4(subject, t.matrix);
+        return TransformedShape3D.from_m4(subject, m4_make_scale(scratch_m4_0, scale));
     }
 
     /**

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

@@ -13,7 +13,7 @@
  * and simplifying produces the closed form below — different sign
  * pattern than {@link v3_quat3_apply}, NOT just a call with negated
  * components (the optimisation matters for hot-path callers such as
- * `PosedShape.support` and the per-triangle concave dispatch in
+ * `PosedShape3D.support` and the per-triangle concave dispatch in
  * `narrowphase_step`).
  *
  * @param {number[]|Float32Array|Float64Array} out

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

@@ -13,7 +13,7 @@
  * and simplifying produces the closed form below — different sign
  * pattern than {@link v3_quat3_apply}, NOT just a call with negated
  * components (the optimisation matters for hot-path callers such as
- * `PosedShape.support` and the per-triangle concave dispatch in
+ * `PosedShape3D.support` and the per-triangle concave dispatch in
  * `narrowphase_step`).
  *
  * @param {number[]|Float32Array|Float64Array} out

package/src/core/math/complex/complex_add.d.ts

@@ -1,6 +1,6 @@
 /**
  * Add two complex numbers
- * @param {number[]|Float64Array|Float32Array} result
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
  * @param {number[]|Float64Array|Float32Array} a
  * @param {number[]|Float64Array|Float32Array} b
  */

package/src/core/math/complex/complex_add.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex_add.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_add.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAK5C"}
+{"version":3,"file":"complex_add.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_add.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAc5C"}

package/src/core/math/complex/complex_add.js

@@ -1,11 +1,20 @@
 /**
  * Add two complex numbers
- * @param {number[]|Float64Array|Float32Array} result
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
  * @param {number[]|Float64Array|Float32Array} a
  * @param {number[]|Float64Array|Float32Array} b
  */
 export function complex_add(result, a, b) {
-    result[0] = a[0] + b[0];
-    result[1] = a[1] + b[1];
+    // Snapshot inputs before writing, so the function is safe even when `result`
+    // overlaps `a` or `b` — including partial overlaps from differently-offset
+    // TypedArray .subarray() views, where writing result[0] could clobber the
+    // cell that a[1]/b[1] reads.
+    const a0 = a[0];
+    const a1 = a[1];
+    const b0 = b[0];
+    const b1 = b[1];
+
+    result[0] = a0 + b0;
+    result[1] = a1 + b1;
 }
 

package/src/core/math/complex/complex_div.d.ts

@@ -1,6 +1,6 @@
 /**
  * Divide two complex numbers
- * @param {number[]|Float64Array|Float32Array} result
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
  * @param {number[]|Float64Array|Float32Array} a
  * @param {number[]|Float64Array|Float32Array} b
  */

package/src/core/math/complex/complex_div.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex_div.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_div.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAO5C"}
+{"version":3,"file":"complex_div.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_div.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAc5C"}

package/src/core/math/complex/complex_div.js

@@ -1,12 +1,19 @@
 /**
  * Divide two complex numbers
- * @param {number[]|Float64Array|Float32Array} result
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
  * @param {number[]|Float64Array|Float32Array} a
  * @param {number[]|Float64Array|Float32Array} b
  */
 export function complex_div(result, a, b) {
-    const sqr_norm_b = b[0] * b[0] + b[1] * b[1];
+    // Snapshot inputs so the function is safe when `result` aliases `a` or `b`;
+    // otherwise writing result[0] would corrupt the read of a[0]/b[0] below.
+    const a0 = a[0];
+    const a1 = a[1];
+    const b0 = b[0];
+    const b1 = b[1];
 
-    result[0] = (a[0] * b[0] + a[1] * b[1]) / sqr_norm_b;
-    result[1] = (a[1] * b[0] - a[0] * b[1]) / sqr_norm_b;
+    const sqr_norm_b = b0 * b0 + b1 * b1;
+
+    result[0] = (a0 * b0 + a1 * b1) / sqr_norm_b;
+    result[1] = (a1 * b0 - a0 * b1) / sqr_norm_b;
 }

package/src/core/math/complex/complex_mul.d.ts

@@ -1,6 +1,6 @@
 /**
  * Multiply two complex numbers
- * @param {number[]|Float64Array|Float32Array} result
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
  * @param {number[]|Float64Array|Float32Array} a
  * @param {number[]|Float64Array|Float32Array} b
  */

package/src/core/math/complex/complex_mul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex_mul.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_mul.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAK5C"}
+{"version":3,"file":"complex_mul.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_mul.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAY5C"}

package/src/core/math/complex/complex_mul.js

@@ -1,10 +1,17 @@
 /**
  * Multiply two complex numbers
- * @param {number[]|Float64Array|Float32Array} result
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
  * @param {number[]|Float64Array|Float32Array} a
  * @param {number[]|Float64Array|Float32Array} b
  */
 export function complex_mul(result, a, b) {
-    result[0] = a[0] * b[0] - a[1] * b[1];
-    result[1] = a[0] * b[1] + a[1] * b[0];
+    // Snapshot inputs so the function is safe when `result` aliases `a` or `b`;
+    // otherwise writing result[0] would corrupt the read of a[0]/b[0] below.
+    const a0 = a[0];
+    const a1 = a[1];
+    const b0 = b[0];
+    const b1 = b[1];
+
+    result[0] = a0 * b0 - a1 * b1;
+    result[1] = a0 * b1 + a1 * b0;
 }

package/src/core/math/complex/complex_sub.d.ts

@@ -1,6 +1,6 @@
 /**
  * Subtract two complex numbers
- * @param {number[]|Float64Array|Float32Array} result
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
  * @param {number[]|Float64Array|Float32Array} a
  * @param {number[]|Float64Array|Float32Array} b
  */

package/src/core/math/complex/complex_sub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex_sub.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_sub.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAK5C"}
+{"version":3,"file":"complex_sub.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_sub.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAc5C"}

package/src/core/math/complex/complex_sub.js

@@ -1,10 +1,19 @@
 /**
  * Subtract two complex numbers
- * @param {number[]|Float64Array|Float32Array} result
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
  * @param {number[]|Float64Array|Float32Array} a
  * @param {number[]|Float64Array|Float32Array} b
  */
 export function complex_sub(result, a, b) {
-    result[0] = a[0] - b[0];
-    result[1] = a[1] - b[1];
+    // Snapshot inputs before writing, so the function is safe even when `result`
+    // overlaps `a` or `b` — including partial overlaps from differently-offset
+    // TypedArray .subarray() views, where writing result[0] could clobber the
+    // cell that a[1]/b[1] reads.
+    const a0 = a[0];
+    const a1 = a[1];
+    const b0 = b[0];
+    const b1 = b[1];
+
+    result[0] = a0 - b0;
+    result[1] = a1 - b1;
 }

package/src/{engine/physics/fluid/solver/optimal_sor_omega.d.ts → core/math/linalg/sor_optimal_omega.d.ts}

@@ -1,6 +1,7 @@
 /**
  * Optimal SOR relaxation factor for the 7-point Laplacian on a cell-centered grid
- * with Neumann boundaries (the discretisation {@link v3_grid_solve_pressure} uses).
+ * with Neumann boundaries (the discretisation the fluid pressure solver,
+ * `v3_grid_solve_pressure`, uses).
  *
  * For a Poisson problem on a uniform grid of side `N`, the Jacobi iteration matrix
  * has spectral radius `ρ_J ≈ cos(π/N)`. The classical optimal SOR factor is
@@ -29,5 +30,5 @@
  * @param {number} res_z
  * @returns {number} ω in (0, 2)
  */
-export function optimal_sor_omega(res_x: number, res_y: number, res_z: number): number;
-//# sourceMappingURL=optimal_sor_omega.d.ts.map
+export function sor_optimal_omega(res_x: number, res_y: number, res_z: number): number;
+//# sourceMappingURL=sor_optimal_omega.d.ts.map

package/src/core/math/linalg/sor_optimal_omega.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sor_optimal_omega.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/sor_optimal_omega.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCALW,MAAM,SACN,MAAM,SACN,MAAM,GACJ,MAAM,CASlB"}

package/src/{engine/physics/fluid/solver/optimal_sor_omega.js → core/math/linalg/sor_optimal_omega.js}

@@ -1,8 +1,9 @@
-import { assert } from "../../../../core/assert.js";
+import { assert } from "../../assert.js";
 
 /**
  * Optimal SOR relaxation factor for the 7-point Laplacian on a cell-centered grid
- * with Neumann boundaries (the discretisation {@link v3_grid_solve_pressure} uses).
+ * with Neumann boundaries (the discretisation the fluid pressure solver,
+ * `v3_grid_solve_pressure`, uses).
  *
  * For a Poisson problem on a uniform grid of side `N`, the Jacobi iteration matrix
  * has spectral radius `ρ_J ≈ cos(π/N)`. The classical optimal SOR factor is
@@ -31,7 +32,7 @@ import { assert } from "../../../../core/assert.js";
  * @param {number} res_z
  * @returns {number} ω in (0, 2)
  */
-export function optimal_sor_omega(res_x, res_y, res_z) {
+export function sor_optimal_omega(res_x, res_y, res_z) {
     assert.isPositiveInteger(res_x, "res_x");
     assert.isPositiveInteger(res_y, "res_y");
     assert.isPositiveInteger(res_z, "res_z");

package/src/core/math/lookup/ParameterLookupTable.d.ts

@@ -0,0 +1,123 @@
+export class ParameterLookupTable {
+    /**
+     *
+     * @param {number} itemSize
+     * @param {number[]} values
+     * @param {number[]} [positions]
+     */
+    static from(itemSize: number, values: number[], positions?: number[]): ParameterLookupTable;
+    /**
+     *
+     * @param {Color} colors
+     * @returns {ParameterLookupTable}
+     */
+    static color_uint8_uniform(...colors: Color): ParameterLookupTable;
+    /**
+     *
+     * @param {number} [itemSize]
+     * @constructor
+     */
+    constructor(itemSize?: number);
+    /**
+     *
+     * @type {number[]|Float32Array}
+     */
+    data: number[] | Float32Array;
+    /**
+     *
+     * @type {number[]|Float32Array}
+     */
+    positions: number[] | Float32Array;
+    /**
+     * Transient value
+     * @type {number}
+     */
+    valueMin: number;
+    /**
+     * Transient value
+     * @type {number}
+     */
+    valueMax: number;
+    /**
+     * @private
+     * @type {number}
+     */
+    private flags;
+    /**
+     *
+     * @type {number}
+     */
+    itemSize: number;
+    /**
+     *
+     * @param {ParameterLookupTableFlags} f
+     */
+    setFlag(f: ParameterLookupTableFlags): void;
+    /**
+     *
+     * @param {ParameterLookupTableFlags|number} f
+     */
+    clearFlag(f: ParameterLookupTableFlags | number): void;
+    /**
+     *
+     * @param {ParameterLookupTableFlags} f
+     * @returns {boolean}
+     */
+    getFlag(f: ParameterLookupTableFlags): boolean;
+    disableWriteMode(): void;
+    fromJSON(json: any): void;
+    toJSON(): {
+        itemSize: number;
+        data: number[];
+        positions: number[];
+    };
+    /**
+     *
+     * @deprecated Use serialization adapter instead
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     * @deprecated Use serialization adapter instead
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     *
+     * @param {number} position
+     * @param {number[]|Float32Array|Float64Array} result
+     */
+    sample(position: number, result: number[] | Float32Array | Float64Array): void;
+    computeUniformPositions(): void;
+    /**
+     *
+     * @param {number[]|Float64Array|Float32Array|Uint8Array} values
+     * @param {number[]|Float64Array|Float32Array} [positions]
+     */
+    write(values: number[] | Float64Array | Float32Array | Uint8Array, positions?: number[] | Float64Array | Float32Array): void;
+    /**
+     *
+     * @param {number} position
+     * @param {number[]} value
+     */
+    addValue(position: number, value: number[]): void;
+    /**
+     * Populates statistics values
+     */
+    computeStatistics(): void;
+    hash(): number;
+    /**
+     *
+     * @param {ParameterLookupTable} other
+     * @returns {boolean}
+     */
+    equals(other: ParameterLookupTable): boolean;
+    validate(): boolean;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isParameterLookupTable: boolean;
+}
+import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
+//# sourceMappingURL=ParameterLookupTable.d.ts.map

package/src/core/math/lookup/ParameterLookupTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParameterLookupTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/ParameterLookupTable.js"],"names":[],"mappings":"AAWA;IAibI;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,EAAE,cACR,MAAM,EAAE,wBAQlB;IAED;;;;OAIG;IACH,8CAFa,oBAAoB,CA0BhC;IA5bD;;;;OAIG;IACH,uBAHW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,MAFU,MAAM,EAAE,GAAC,YAAY,CAErB;IAEV;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,CAEhB;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,cAA4C;IAUxC;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAI5B;;;OAGG;IACH,WAFW,yBAAyB,QAInC;IAED;;;OAGG;IACH,aAFW,yBAAyB,GAAC,MAAM,QAI1C;IAED;;;;OAIG;IACH,WAHW,yBAAyB,GACvB,OAAO,CAInB;IAED,yBAEC;IAED,0BAGC;IAED;;;;MAMC;IAED;;;;OAIG;IACH,2CA2CC;IAED;;;OAGG;IACH,6CAkCC;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA0D5C;IAED,gCAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,cAC7C,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA4B5C;IAED;;;;OAIG;IACH,mBAHW,MAAM,SACN,MAAM,EAAE,QAqClB;IAED;;OAEG;IACH,0BAkBC;IAED,eAgBC;IAED;;;;OAIG;IACH,cAHW,oBAAoB,GAClB,OAAO,CAenB;IAED,oBAwCC;IAgDL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;0CAheyC,gCAAgC"}