@woosh/meep-engine 3.44.0 → 3.46.0

package/src/core/geom/3d/aabb/aabb3_array_round_outward_f32.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Round a box outward to float32: each lower bound down and each upper bound up to the nearest
+ * float32 on that side, so the result is the tightest float32 box that contains the input.
+ *
+ * A float32 store — a BVH node, a GPU buffer — rounds to the NEAREST float32, which is inward on
+ * any side that rounds that way, by up to half a float32 step. That step is a proportion of the
+ * magnitude, so the inward error is too: 3 cm at 1e6 m, half a metre at 1e7. A box stored that way
+ * stops containing what it
+ * bounded, and a query reaching the content through the box misses whatever lay outside it — far
+ * from the origin only, and silently. Rounding through this first makes the store exact.
+ * Measured in the rigid-body broadphase before it did this: a ray dropped onto a 2 mm plate 1e6 m
+ * out missed it, and so did rays a millimetre inside a 1 m crate's faces 1e5 m out.
+ *
+ * A bound that is already a float32 is kept as it is. A bound beyond the largest finite float32
+ * on its own side — a lower bound below `-F32_MAX`, an upper bound above `F32_MAX` — goes to that
+ * side's infinity; one beyond it on the other side becomes `±F32_MAX`. A NaN stays NaN.
+ *
+ * `result` may be `aabb` at the same offset.
+ *
+ * @param {number[]|Float32Array|Float64Array} result receives `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} result_offset
+ * @param {number[]|Float32Array|Float64Array} aabb `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} aabb_offset
+ * @returns {void}
+ */
+export function aabb3_array_round_outward_f32(result: number[] | Float32Array | Float64Array, result_offset: number, aabb: number[] | Float32Array | Float64Array, aabb_offset: number): void;
+//# sourceMappingURL=aabb3_array_round_outward_f32.d.ts.map

package/src/core/geom/3d/aabb/aabb3_array_round_outward_f32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_array_round_outward_f32.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_array_round_outward_f32.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,GACJ,IAAI,CAYhB"}

package/src/core/geom/3d/aabb/aabb3_array_round_outward_f32.js

@@ -0,0 +1,39 @@
+import { f32_next_down } from "../../../math/f32_next_down.js";
+import { f32_next_up } from "../../../math/f32_next_up.js";
+
+/**
+ * Round a box outward to float32: each lower bound down and each upper bound up to the nearest
+ * float32 on that side, so the result is the tightest float32 box that contains the input.
+ *
+ * A float32 store — a BVH node, a GPU buffer — rounds to the NEAREST float32, which is inward on
+ * any side that rounds that way, by up to half a float32 step. That step is a proportion of the
+ * magnitude, so the inward error is too: 3 cm at 1e6 m, half a metre at 1e7. A box stored that way
+ * stops containing what it
+ * bounded, and a query reaching the content through the box misses whatever lay outside it — far
+ * from the origin only, and silently. Rounding through this first makes the store exact.
+ * Measured in the rigid-body broadphase before it did this: a ray dropped onto a 2 mm plate 1e6 m
+ * out missed it, and so did rays a millimetre inside a 1 m crate's faces 1e5 m out.
+ *
+ * A bound that is already a float32 is kept as it is. A bound beyond the largest finite float32
+ * on its own side — a lower bound below `-F32_MAX`, an upper bound above `F32_MAX` — goes to that
+ * side's infinity; one beyond it on the other side becomes `±F32_MAX`. A NaN stays NaN.
+ *
+ * `result` may be `aabb` at the same offset.
+ *
+ * @param {number[]|Float32Array|Float64Array} result receives `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} result_offset
+ * @param {number[]|Float32Array|Float64Array} aabb `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} aabb_offset
+ * @returns {void}
+ */
+export function aabb3_array_round_outward_f32(result, result_offset, aabb, aabb_offset) {
+    for (let i = 0; i < 3; i++) {
+        const lower = aabb[aabb_offset + i];
+        const lower_f32 = Math.fround(lower);
+        result[result_offset + i] = lower_f32 > lower ? f32_next_down(lower_f32) : lower_f32;
+
+        const upper = aabb[aabb_offset + i + 3];
+        const upper_f32 = Math.fround(upper);
+        result[result_offset + i + 3] = upper_f32 < upper ? f32_next_up(upper_f32) : upper_f32;
+    }
+}

package/src/core/geom/3d/aabb/aabb3_from_v3_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_from_v3_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,4CAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAAM,SAC7C,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,QA6BhB"}
+{"version":3,"file":"aabb3_from_v3_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,4CAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAAM,SAC7C,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,QAgChB"}

package/src/core/geom/3d/aabb/aabb3_from_v3_array.js

@@ -10,7 +10,10 @@ import { aabb3_array_set } from "./aabb3_array_set.js";
  * @param {number} input_length length of the input array
  */
 export function aabb3_from_v3_array(result, input, input_length) {
-    assert.equal(input_length % 3, 0, `Input must be divisible by 3, instead was ${input_length}`)
+    // the message is built only on failure: this runs per step in physics
+    if (input_length % 3 !== 0) {
+        assert.ok(false, `Input must be divisible by 3, instead was ${input_length}`);
+    }
 
     let x0 = Infinity;
     let y0 = Infinity;

package/src/core/geom/3d/aabb/aabb3_transform_oriented.d.ts

@@ -37,9 +37,9 @@ export function aabb3_transform_oriented(result: number[] | Float32Array | Float
  * @param {number} result_offset
  * @param {number[]|Float32Array|Float64Array} aabb local box `[x0, y0, z0, x1, y1, z1]`
  * @param {number} aabb_offset
- * @param {number[]|Float64Array} pose translation then orientation (unit quaternion):
+ * @param {number[]|Float32Array|Float64Array} pose translation then orientation (unit quaternion):
  *   `[px, py, pz, qx, qy, qz, qw]`
  * @param {number} pose_offset
  */
-export function aabb3_transform_oriented_array(result: number[] | Float32Array | Float64Array, result_offset: number, aabb: number[] | Float32Array | Float64Array, aabb_offset: number, pose: number[] | Float64Array, pose_offset: number): void;
+export function aabb3_transform_oriented_array(result: number[] | Float32Array | Float64Array, result_offset: number, aabb: number[] | Float32Array | Float64Array, aabb_offset: number, pose: number[] | Float32Array | Float64Array, pose_offset: number): void;
 //# sourceMappingURL=aabb3_transform_oriented.d.ts.map

package/src/core/geom/3d/aabb/aabb3_transform_oriented.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_transform_oriented.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAhBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,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,QAkBhB;AAMD;;;;;;;;;;;;;GAaG;AACH,uDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,eAErB,MAAM,QAuEhB"}
+{"version":3,"file":"aabb3_transform_oriented.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAhBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,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,QAkBhB;AAMD;;;;;;;;;;;;;GAaG;AACH,uDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAElC,MAAM,QAuEhB"}

package/src/core/geom/3d/aabb/aabb3_transform_oriented.js

@@ -58,7 +58,7 @@ const scratch_pose = new Float64Array(7);
  * @param {number} result_offset
  * @param {number[]|Float32Array|Float64Array} aabb local box `[x0, y0, z0, x1, y1, z1]`
  * @param {number} aabb_offset
- * @param {number[]|Float64Array} pose translation then orientation (unit quaternion):
+ * @param {number[]|Float32Array|Float64Array} pose translation then orientation (unit quaternion):
  *   `[px, py, pz, qx, qy, qz, qw]`
  * @param {number} pose_offset
  */

package/src/core/geom/3d/mat4/m4_multiply.d.ts

@@ -2,6 +2,9 @@
  * Multiplies two 4x4 matrices.
  * `out = a * b`.
  *
+ * Hot code on `Float64Array` storage (`Transform64` included) calls {@link m4_multiply_f64} instead, an
+ * identical copy: this one is reached with every array kind, so V8 boxes each element it writes.
+ *
  * @param {number[]|ArrayLike<number>|Float32Array} out the receiving matrix
  * @param {number[]|ArrayLike<number>|Float32Array} a the first operand
  * @param {number[]|ArrayLike<number>|Float32Array} b the second operand

package/src/core/geom/3d/mat4/m4_multiply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m4_multiply.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_multiply.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,iCALW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,KACvC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,KACvC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACrC,MAAM,EAAE,CA0EpB"}
+{"version":3,"file":"m4_multiply.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_multiply.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,iCALW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,KACvC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,KACvC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACrC,MAAM,EAAE,CA0EpB"}

package/src/core/geom/3d/mat4/m4_multiply.js

@@ -4,6 +4,9 @@ import { assert } from "../../../assert.js";
  * Multiplies two 4x4 matrices.
  * `out = a * b`.
  *
+ * Hot code on `Float64Array` storage (`Transform64` included) calls {@link m4_multiply_f64} instead, an
+ * identical copy: this one is reached with every array kind, so V8 boxes each element it writes.
+ *
  * @param {number[]|ArrayLike<number>|Float32Array} out the receiving matrix
  * @param {number[]|ArrayLike<number>|Float32Array} a the first operand
  * @param {number[]|ArrayLike<number>|Float32Array} b the second operand

package/src/core/geom/3d/mat4/m4_multiply_f64.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Multiplies two 4x4 matrices held in `Float64Array`s.
+ * `out = a * b`.
+ *
+ * A deliberate duplicate of {@link m4_multiply}: the same arithmetic in the same order, so the two give
+ * the same result bit for bit, and they must stay identical. Change one, change the other.
+ *
+ * It exists because {@link m4_multiply} is shared. About twenty modules call it, with `Float32Array`,
+ * `Float64Array`, `Transform64` and plain `Array` operands, and V8 keeps one set of type feedback per
+ * function, so its element loads and stores go megamorphic. A megamorphic store boxes every number it
+ * writes into a fresh HeapNumber. Measured in the dance-stage example (2026-10-12), on `Transform64`
+ * operands: 193 B per call through the shared {@link m4_multiply}, ~10 B through an identical copy no
+ * other caller reached. `Transform64#multiplyTransforms` composes every attached entity, ~1,700 calls a
+ * frame there, and that boxing was a third of the main thread's allocation.
+ *
+ * So this copy must only ever see `Float64Array` storage; a `Transform64` is one. A single caller passing
+ * a `Float32Array` or an `Array` would pollute this copy's feedback too, and bring the boxing back for
+ * every caller. The assertions are what keep such a caller out: anything else goes through
+ * {@link m4_multiply}.
+ *
+ * All of `a` is read before the first write, and each column of `b` before the column of `out` it
+ * produces, so `out` may be `a` or `b`.
+ *
+ * @param {Float64Array} out the receiving matrix
+ * @param {Float64Array} a the first operand
+ * @param {Float64Array} b the second operand
+ * @returns {Float64Array} `out` parameter
+ */
+export function m4_multiply_f64(out: Float64Array, a: Float64Array, b: Float64Array): Float64Array;
+//# sourceMappingURL=m4_multiply_f64.d.ts.map

package/src/core/geom/3d/mat4/m4_multiply_f64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_multiply_f64.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_multiply_f64.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qCALW,YAAY,KACZ,YAAY,KACZ,YAAY,GACV,YAAY,CA6ExB"}

package/src/core/geom/3d/mat4/m4_multiply_f64.js

@@ -0,0 +1,106 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Multiplies two 4x4 matrices held in `Float64Array`s.
+ * `out = a * b`.
+ *
+ * A deliberate duplicate of {@link m4_multiply}: the same arithmetic in the same order, so the two give
+ * the same result bit for bit, and they must stay identical. Change one, change the other.
+ *
+ * It exists because {@link m4_multiply} is shared. About twenty modules call it, with `Float32Array`,
+ * `Float64Array`, `Transform64` and plain `Array` operands, and V8 keeps one set of type feedback per
+ * function, so its element loads and stores go megamorphic. A megamorphic store boxes every number it
+ * writes into a fresh HeapNumber. Measured in the dance-stage example (2026-10-12), on `Transform64`
+ * operands: 193 B per call through the shared {@link m4_multiply}, ~10 B through an identical copy no
+ * other caller reached. `Transform64#multiplyTransforms` composes every attached entity, ~1,700 calls a
+ * frame there, and that boxing was a third of the main thread's allocation.
+ *
+ * So this copy must only ever see `Float64Array` storage; a `Transform64` is one. A single caller passing
+ * a `Float32Array` or an `Array` would pollute this copy's feedback too, and bring the boxing back for
+ * every caller. The assertions are what keep such a caller out: anything else goes through
+ * {@link m4_multiply}.
+ *
+ * All of `a` is read before the first write, and each column of `b` before the column of `out` it
+ * produces, so `out` may be `a` or `b`.
+ *
+ * @param {Float64Array} out the receiving matrix
+ * @param {Float64Array} a the first operand
+ * @param {Float64Array} b the second operand
+ * @returns {Float64Array} `out` parameter
+ */
+export function m4_multiply_f64(out, a, b) {
+    // A bare instanceof, not assert.isInstanceOf: that one is shared by every call site in the engine,
+    // and once it had seen their mix of classes, this function took 21 ns a call through it against
+    // 15.5 ns this way (node 24, 2026-10-12, a build that keeps assertions). Each check throws before
+    // the first element access, so a rejected operand never reaches this copy's element feedback.
+    assert.ok(out instanceof Float64Array, 'out is not a Float64Array');
+    assert.greaterThanOrEqual(out.length, 16, 'out.length');
+
+    assert.ok(a instanceof Float64Array, 'a is not a Float64Array');
+    assert.greaterThanOrEqual(a.length, 16, 'a.length');
+
+    assert.ok(b instanceof Float64Array, 'b is not a Float64Array');
+    assert.greaterThanOrEqual(b.length, 16, 'b.length');
+
+    // Adapted from gl-matrix, by way of m4_multiply
+
+    const a00 = a[0],
+        a01 = a[1],
+        a02 = a[2],
+        a03 = a[3],
+        a10 = a[4],
+        a11 = a[5],
+        a12 = a[6],
+        a13 = a[7],
+        a20 = a[8],
+        a21 = a[9],
+        a22 = a[10],
+        a23 = a[11],
+        a30 = a[12],
+        a31 = a[13],
+        a32 = a[14],
+        a33 = a[15];
+
+    // Cache only the current line of the second matrix
+    let b0 = b[0],
+        b1 = b[1],
+        b2 = b[2],
+        b3 = b[3];
+
+    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[4];
+    b1 = b[5];
+    b2 = b[6];
+    b3 = b[7];
+
+    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[8];
+    b1 = b[9];
+    b2 = b[10];
+    b3 = b[11];
+
+    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[12];
+    b1 = b[13];
+    b2 = b[14];
+    b3 = b[15];
+
+    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    return out;
+}

package/src/core/geom/3d/pose/pose3_apply_inverse_point_array.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bring a point into a rigid pose's frame: `out = q⁻¹·(p − t)`.
+ *
+ * The inverse of {@link pose3_apply_point_array}, and with the same operands: translation and unit
+ * rotation separately, each an array and an offset, so a `Transform64`'s lanes, a cloth's split frame
+ * arrays and a packed seven-float record are all read where they sit. Nothing is allocated.
+ *
+ * `out` may be `p`, and may be `t` at the same offset: the difference is held aside before the first
+ * write. It may not otherwise overlap `t` or `q`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation `[x, y, z]`
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, a unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float32Array|Float64Array} p the point, in the frame the pose is expressed in
+ * @param {number} p_offset
+ */
+export function pose3_apply_inverse_point_array(out: number[] | Float32Array | Float64Array, out_offset: number, t: number[] | Float32Array | Float64Array, t_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number, p: number[] | Float32Array | Float64Array, p_offset: number): void;
+//# sourceMappingURL=pose3_apply_inverse_point_array.d.ts.map

package/src/core/geom/3d/pose/pose3_apply_inverse_point_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pose3_apply_inverse_point_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/pose/pose3_apply_inverse_point_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qDATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAUhB"}

package/src/core/geom/3d/pose/pose3_apply_inverse_point_array.js

@@ -0,0 +1,36 @@
+import { v3_quaternion_apply_inverse_array } from "../../vec3/v3_quaternion_apply_inverse.js";
+
+/**
+ * Bring a point into a rigid pose's frame: `out = q⁻¹·(p − t)`.
+ *
+ * The inverse of {@link pose3_apply_point_array}, and with the same operands: translation and unit
+ * rotation separately, each an array and an offset, so a `Transform64`'s lanes, a cloth's split frame
+ * arrays and a packed seven-float record are all read where they sit. Nothing is allocated.
+ *
+ * `out` may be `p`, and may be `t` at the same offset: the difference is held aside before the first
+ * write. It may not otherwise overlap `t` or `q`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation `[x, y, z]`
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, a unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float32Array|Float64Array} p the point, in the frame the pose is expressed in
+ * @param {number} p_offset
+ */
+export function pose3_apply_inverse_point_array(out, out_offset, t, t_offset, q, q_offset, p, p_offset) {
+    const offset = scratch_offset;
+
+    offset[0] = p[p_offset] - t[t_offset];
+    offset[1] = p[p_offset + 1] - t[t_offset + 1];
+    offset[2] = p[p_offset + 2] - t[t_offset + 2];
+
+    v3_quaternion_apply_inverse_array(out, out_offset, offset, 0, q, q_offset);
+}
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const scratch_offset = new Float64Array(3);

package/src/core/geom/3d/pose/pose3_apply_point_array.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bring a point out of a rigid pose's frame: `out = t + q·p`.
+ *
+ * A rigid pose here is a translation and a unit rotation with no scale — what a body, a holder, a
+ * cloth's local frame or a joint is — and the two are separate operands rather than one packed record,
+ * because the poses that use them are kept both ways: a `Transform64` holds its translation at lane 12
+ * and its rotation at lane 16, a cloth keeps its frame in two arrays, a contact record packs seven
+ * floats. Each operand is an array and an offset; nothing is allocated.
+ *
+ * The inverse is {@link pose3_apply_inverse_point_array}.
+ *
+ * `out` may be `p`, and may be `t` at the same offset: the rotated point is held aside before the
+ * first write. It may not otherwise overlap `t` or `q`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation `[x, y, z]`
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, a unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float32Array|Float64Array} p the point, in the pose's frame
+ * @param {number} p_offset
+ */
+export function pose3_apply_point_array(out: number[] | Float32Array | Float64Array, out_offset: number, t: number[] | Float32Array | Float64Array, t_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number, p: number[] | Float32Array | Float64Array, p_offset: number): void;
+//# sourceMappingURL=pose3_apply_point_array.d.ts.map

package/src/core/geom/3d/pose/pose3_apply_point_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pose3_apply_point_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/pose/pose3_apply_point_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAUhB"}

package/src/core/geom/3d/pose/pose3_apply_point_array.js

@@ -0,0 +1,40 @@
+import { v3_quaternion_apply_array } from "../../vec3/v3_quaternion_apply.js";
+
+/**
+ * Bring a point out of a rigid pose's frame: `out = t + q·p`.
+ *
+ * A rigid pose here is a translation and a unit rotation with no scale — what a body, a holder, a
+ * cloth's local frame or a joint is — and the two are separate operands rather than one packed record,
+ * because the poses that use them are kept both ways: a `Transform64` holds its translation at lane 12
+ * and its rotation at lane 16, a cloth keeps its frame in two arrays, a contact record packs seven
+ * floats. Each operand is an array and an offset; nothing is allocated.
+ *
+ * The inverse is {@link pose3_apply_inverse_point_array}.
+ *
+ * `out` may be `p`, and may be `t` at the same offset: the rotated point is held aside before the
+ * first write. It may not otherwise overlap `t` or `q`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation `[x, y, z]`
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, a unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float32Array|Float64Array} p the point, in the pose's frame
+ * @param {number} p_offset
+ */
+export function pose3_apply_point_array(out, out_offset, t, t_offset, q, q_offset, p, p_offset) {
+    const rotated = scratch_rotated;
+
+    v3_quaternion_apply_array(rotated, 0, p, p_offset, q, q_offset);
+
+    out[out_offset] = t[t_offset] + rotated[0];
+    out[out_offset + 1] = t[t_offset + 1] + rotated[1];
+    out[out_offset + 2] = t[t_offset + 2] + rotated[2];
+}
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const scratch_rotated = new Float64Array(3);

package/src/core/geom/3d/pose/pose3_compose_array.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Compose two rigid poses, a local one hung from a parent: `t' = t_p + q_p·t_l`, `q' = q_p ⊗ q_l`.
+ *
+ * What a child's pose is once its parent's is known — a bind pose built down a hierarchy, a seeded
+ * subtree's rest pose. The inverse is {@link pose3_to_local_array}.
+ *
+ * Every operand is an array and an offset, translation and rotation apart — see
+ * {@link pose3_apply_point_array} for why. Nothing is allocated.
+ *
+ * `out_t` may be `parent_t` or `local_t` at the same offset, and `out_q` may be `parent_q` or
+ * `local_q` at the same offset; the translation is written before the rotations are read, so `out_t`
+ * may not otherwise overlap any operand.
+ *
+ * @param {number[]|Float32Array|Float64Array} out_t receives 3 floats
+ * @param {number} out_t_offset
+ * @param {number[]|Float32Array|Float64Array} out_q receives 4 floats
+ * @param {number} out_q_offset
+ * @param {number[]|Float32Array|Float64Array} parent_t the parent's translation
+ * @param {number} parent_t_offset
+ * @param {number[]|Float32Array|Float64Array} parent_q the parent's rotation, a unit quaternion
+ * @param {number} parent_q_offset
+ * @param {number[]|Float32Array|Float64Array} local_t the local pose's translation, in the parent's frame
+ * @param {number} local_t_offset
+ * @param {number[]|Float32Array|Float64Array} local_q the local pose's rotation, likewise
+ * @param {number} local_q_offset
+ */
+export function pose3_compose_array(out_t: number[] | Float32Array | Float64Array, out_t_offset: number, out_q: number[] | Float32Array | Float64Array, out_q_offset: number, parent_t: number[] | Float32Array | Float64Array, parent_t_offset: number, parent_q: number[] | Float32Array | Float64Array, parent_q_offset: number, local_t: number[] | Float32Array | Float64Array, local_t_offset: number, local_q: number[] | Float32Array | Float64Array, local_q_offset: number): void;
+//# sourceMappingURL=pose3_compose_array.d.ts.map

package/src/core/geom/3d/pose/pose3_compose_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pose3_compose_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/pose/pose3_compose_array.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2CAbW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,QAahB"}

package/src/core/geom/3d/pose/pose3_compose_array.js

@@ -0,0 +1,41 @@
+import { quat3_multiply_array } from "../quaternion/quat3_multiply.js";
+import { pose3_apply_point_array } from "./pose3_apply_point_array.js";
+
+/**
+ * Compose two rigid poses, a local one hung from a parent: `t' = t_p + q_p·t_l`, `q' = q_p ⊗ q_l`.
+ *
+ * What a child's pose is once its parent's is known — a bind pose built down a hierarchy, a seeded
+ * subtree's rest pose. The inverse is {@link pose3_to_local_array}.
+ *
+ * Every operand is an array and an offset, translation and rotation apart — see
+ * {@link pose3_apply_point_array} for why. Nothing is allocated.
+ *
+ * `out_t` may be `parent_t` or `local_t` at the same offset, and `out_q` may be `parent_q` or
+ * `local_q` at the same offset; the translation is written before the rotations are read, so `out_t`
+ * may not otherwise overlap any operand.
+ *
+ * @param {number[]|Float32Array|Float64Array} out_t receives 3 floats
+ * @param {number} out_t_offset
+ * @param {number[]|Float32Array|Float64Array} out_q receives 4 floats
+ * @param {number} out_q_offset
+ * @param {number[]|Float32Array|Float64Array} parent_t the parent's translation
+ * @param {number} parent_t_offset
+ * @param {number[]|Float32Array|Float64Array} parent_q the parent's rotation, a unit quaternion
+ * @param {number} parent_q_offset
+ * @param {number[]|Float32Array|Float64Array} local_t the local pose's translation, in the parent's frame
+ * @param {number} local_t_offset
+ * @param {number[]|Float32Array|Float64Array} local_q the local pose's rotation, likewise
+ * @param {number} local_q_offset
+ */
+export function pose3_compose_array(
+    out_t, out_t_offset,
+    out_q, out_q_offset,
+    parent_t, parent_t_offset,
+    parent_q, parent_q_offset,
+    local_t, local_t_offset,
+    local_q, local_q_offset
+) {
+    pose3_apply_point_array(out_t, out_t_offset, parent_t, parent_t_offset, parent_q, parent_q_offset, local_t, local_t_offset);
+
+    quat3_multiply_array(out_q, out_q_offset, parent_q, parent_q_offset, local_q, local_q_offset);
+}

package/src/core/geom/3d/pose/pose3_to_local_array.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Express a rigid pose in another pose's frame: `t' = q_f⁻¹·(t − t_f)`, `q' = q_f⁻¹ ⊗ q`.
+ *
+ * What a world pose is relative to a parent, a holder in a cloth's moving frame, a collider in the
+ * frame its contacts are solved in. The inverse is {@link pose3_compose_array}: composing the frame
+ * with the result gives the pose back.
+ *
+ * Every operand is an array and an offset, translation and rotation apart — see
+ * {@link pose3_apply_point_array} for why. Nothing is allocated.
+ *
+ * `out_t` may be `t` at the same offset and `out_q` may be `q` at the same offset; the translation is
+ * written before the rotation is read, so `out_t` may not overlap `q`, `frame_q` or `frame_t`
+ * otherwise, and `out_q` may not overlap `frame_q` otherwise.
+ *
+ * @param {number[]|Float32Array|Float64Array} out_t receives 3 floats
+ * @param {number} out_t_offset
+ * @param {number[]|Float32Array|Float64Array} out_q receives 4 floats
+ * @param {number} out_q_offset
+ * @param {number[]|Float32Array|Float64Array} frame_t the frame's translation
+ * @param {number} frame_t_offset
+ * @param {number[]|Float32Array|Float64Array} frame_q the frame's rotation, a unit quaternion
+ * @param {number} frame_q_offset
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation, in the frame the frame is in
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, likewise
+ * @param {number} q_offset
+ */
+export function pose3_to_local_array(out_t: number[] | Float32Array | Float64Array, out_t_offset: number, out_q: number[] | Float32Array | Float64Array, out_q_offset: number, frame_t: number[] | Float32Array | Float64Array, frame_t_offset: number, frame_q: number[] | Float32Array | Float64Array, frame_q_offset: number, t: number[] | Float32Array | Float64Array, t_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number): void;
+//# sourceMappingURL=pose3_to_local_array.d.ts.map

package/src/core/geom/3d/pose/pose3_to_local_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pose3_to_local_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/pose/pose3_to_local_array.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAbW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAahB"}

package/src/core/geom/3d/pose/pose3_to_local_array.js

@@ -0,0 +1,42 @@
+import { quat3_multiply_conjugate_left_array } from "../quaternion/quat3_multiply_conjugate_left_array.js";
+import { pose3_apply_inverse_point_array } from "./pose3_apply_inverse_point_array.js";
+
+/**
+ * Express a rigid pose in another pose's frame: `t' = q_f⁻¹·(t − t_f)`, `q' = q_f⁻¹ ⊗ q`.
+ *
+ * What a world pose is relative to a parent, a holder in a cloth's moving frame, a collider in the
+ * frame its contacts are solved in. The inverse is {@link pose3_compose_array}: composing the frame
+ * with the result gives the pose back.
+ *
+ * Every operand is an array and an offset, translation and rotation apart — see
+ * {@link pose3_apply_point_array} for why. Nothing is allocated.
+ *
+ * `out_t` may be `t` at the same offset and `out_q` may be `q` at the same offset; the translation is
+ * written before the rotation is read, so `out_t` may not overlap `q`, `frame_q` or `frame_t`
+ * otherwise, and `out_q` may not overlap `frame_q` otherwise.
+ *
+ * @param {number[]|Float32Array|Float64Array} out_t receives 3 floats
+ * @param {number} out_t_offset
+ * @param {number[]|Float32Array|Float64Array} out_q receives 4 floats
+ * @param {number} out_q_offset
+ * @param {number[]|Float32Array|Float64Array} frame_t the frame's translation
+ * @param {number} frame_t_offset
+ * @param {number[]|Float32Array|Float64Array} frame_q the frame's rotation, a unit quaternion
+ * @param {number} frame_q_offset
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation, in the frame the frame is in
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, likewise
+ * @param {number} q_offset
+ */
+export function pose3_to_local_array(
+    out_t, out_t_offset,
+    out_q, out_q_offset,
+    frame_t, frame_t_offset,
+    frame_q, frame_q_offset,
+    t, t_offset,
+    q, q_offset
+) {
+    pose3_apply_inverse_point_array(out_t, out_t_offset, frame_t, frame_t_offset, frame_q, frame_q_offset, t, t_offset);
+
+    quat3_multiply_conjugate_left_array(out_q, out_q_offset, frame_q, frame_q_offset, q, q_offset);
+}

package/src/core/geom/3d/quaternion/quat3_clamp_angle_array.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Limit a rotation's angle: `out` turns about the same axis as `q` by `min(θ, max_angle)`, exactly.
+ *
+ * The rotation is read as an axis and an angle and the angle is replaced, so the answer is the
+ * limit itself and not an approximation of it. The alternative it exists to replace — nlerp from
+ * the identity towards `q` by `max_angle / θ` — follows the chord rather than the arc and
+ * undershoots more the larger `θ` is: at `θ = π` asked for `π/4` it turns `0.64` rad, not `0.785`.
+ *
+ * `q` and `-q` name the same rotation; the angle is measured on the one with `w ≥ 0`, so `θ` is
+ * the shorter turn, in `[0, π]`. A rotation within the limit is passed through unchanged, sign
+ * included; one beyond it is written with `w ≥ 0`. The identity (no axis) is within any limit.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `q`: every component is read before the first write.
+ *
+ * **Precondition: `q` is a unit quaternion.** The angle is `2·atan2(|v|, w)`, which does not care,
+ * but a limited rotation is written unit and an unlimited one as it came.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} q `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number} max_angle radians, `≥ 0`
+ */
+export function quat3_clamp_angle_array(out: number[] | Float32Array | Float64Array, out_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number, max_angle: number): void;
+//# sourceMappingURL=quat3_clamp_angle_array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_clamp_angle_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_clamp_angle_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,6CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,aACN,MAAM,QAuChB"}