@woosh/meep-engine 3.45.0 → 3.47.0

package/src/core/collection/array/combine_hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combine_hash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/combine_hash.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,uCAHc,MAAM,KACP,MAAM,CAMlB"}
+{"version":3,"file":"combine_hash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/combine_hash.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,uCAHc,MAAM,KACP,MAAM,CAMlB"}

package/src/core/collection/array/combine_hash.js

@@ -3,6 +3,12 @@ import { computeIntegerArrayHash } from "./computeIntegerArrayHash.js";
 
 /**
  * Computes hash on integer values, useful for building composite hashes
+ *
+ * @deprecated Varargs, so every call allocates a rest array. Use `hash_mix2` / `hash_mix3` from
+ * `core/math/hash/`, which fold the same `h * 31 + x` step without allocating. Their values differ
+ * from this function's: it seeds the fold with the argument count and returns uint32, while the
+ * mixers are unseeded and return int32. Kept, with its values unchanged, for code outside the engine.
+ *
  * @param {...number} value
  * @returns {number}
  */

package/src/core/function/FunctionCompiler.js

@@ -1,6 +1,6 @@
 import { assert } from "../assert.js";
 import { Cache } from "../cache/Cache.js";
-import { combine_hash } from "../collection/array/combine_hash.js";
+import { hash_mix3 } from "../math/hash/hash_mix3.js";
 import { computeHashArray } from "../collection/array/computeHashArray.js";
 import { isArrayEqualStrict } from "../collection/array/isArrayEqualStrict.js";
 import { invokeObjectEquals } from "../model/object/invokeObjectEquals.js";
@@ -50,7 +50,7 @@ class FunctionDefinition {
     }
 
     updateHash() {
-        this.__hash = combine_hash(
+        this.__hash = hash_mix3(
             computeStringHash(this.name),
             computeStringHash(this.body),
             computeHashArray(this.args, computeStringHash)

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

@@ -0,0 +1,37 @@
+/**
+ * The rotation that points local +Z along `forward`, with local +Y turned as close to `up` as it can be:
+ * the orientation of a camera, a turret or a walking body told where to face.
+ *
+ * Neither vector has to be unit length, within what their squares can hold: lanes from about 1e-154
+ * to 1e154. Below that a square is 0 and the vector reads as zero, above it Infinity. The frame is built
+ * from them the usual way — `right = up × forward` and `up' = forward × right`, each normalised — and the
+ * rotation is read off that matrix, so it maps +X to `right`, +Y to `up'` and +Z to `forward`.
+ *
+ * **When `up` is parallel to `forward` there is no frame to build**: their cross product is the zero
+ * vector, and any roll about `forward` would do. The forward direction is then nudged by 0.001 along X
+ * when `up` is ±Z, and along Z otherwise, and renormalised. For a unit `up` the answer is then a unit
+ * rotation within about a milliradian of `forward`, rolled however the nudge leaves it; do not rely on
+ * the roll there. The ±Z test reads `|uz| === 1`, so a longer `up` along Z is nudged along Z, stays
+ * parallel, and gets a rotation that is not unit length. Pass a unit `up` where it can be parallel.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * Everything is worked in locals and only the result is written, so it allocates nothing, and a caller
+ * that hands its own parameters straight on boxes nothing either. {@link Quaternion#_lookRotation} and
+ * `t64_look_rotation` both answer through this.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} fx forward, any length
+ * @param {number} fy
+ * @param {number} fz
+ * @param {number} ux up, any length
+ * @param {number} uy
+ * @param {number} uz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quat3_look_rotation(out: number[] | Float32Array | Float64Array, out_offset: number, fx: number, fy: number, fz: number, ux: number, uy: number, uz: number): void;
+//# sourceMappingURL=quat3_look_rotation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_look_rotation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_look_rotation.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,yCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkIhB"}

package/src/core/geom/3d/quaternion/quat3_look_rotation.js

@@ -0,0 +1,172 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * @param {number} length
+ * @returns {number} what normalises a vector of that length: `1 / length`, or 1 for a zero vector, which
+ *   leaves it as it is
+ */
+function inverse_or_one(length) {
+    return length === 0 ? 1 : 1 / length;
+}
+
+/**
+ * The rotation that points local +Z along `forward`, with local +Y turned as close to `up` as it can be:
+ * the orientation of a camera, a turret or a walking body told where to face.
+ *
+ * Neither vector has to be unit length, within what their squares can hold: lanes from about 1e-154
+ * to 1e154. Below that a square is 0 and the vector reads as zero, above it Infinity. The frame is built
+ * from them the usual way — `right = up × forward` and `up' = forward × right`, each normalised — and the
+ * rotation is read off that matrix, so it maps +X to `right`, +Y to `up'` and +Z to `forward`.
+ *
+ * **When `up` is parallel to `forward` there is no frame to build**: their cross product is the zero
+ * vector, and any roll about `forward` would do. The forward direction is then nudged by 0.001 along X
+ * when `up` is ±Z, and along Z otherwise, and renormalised. For a unit `up` the answer is then a unit
+ * rotation within about a milliradian of `forward`, rolled however the nudge leaves it; do not rely on
+ * the roll there. The ±Z test reads `|uz| === 1`, so a longer `up` along Z is nudged along Z, stays
+ * parallel, and gets a rotation that is not unit length. Pass a unit `up` where it can be parallel.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * Everything is worked in locals and only the result is written, so it allocates nothing, and a caller
+ * that hands its own parameters straight on boxes nothing either. {@link Quaternion#_lookRotation} and
+ * `t64_look_rotation` both answer through this.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} fx forward, any length
+ * @param {number} fy
+ * @param {number} fz
+ * @param {number} ux up, any length
+ * @param {number} uy
+ * @param {number} uz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quat3_look_rotation(out, out_offset, fx, fy, fz, ux, uy, uz) {
+    assert.isFinite(fx, 'fx');
+    assert.isFinite(fy, 'fy');
+    assert.isFinite(fz, 'fz');
+    assert.isFinite(ux, 'ux');
+    assert.isFinite(uy, 'uy');
+    assert.isFinite(uz, 'uz');
+
+    /*
+     Forward, normalised; a zero vector is left as it is.
+
+     Every normalisation here scales unconditionally, by 1 for a zero vector, which leaves each lane as it
+     was bit for bit. Written as `if (length !== 0) { ax *= 1 / length; }` it merged a computed number
+     with the incoming argument, and V8 then held `ax` as a boxed number: 32 B a call.
+    */
+    let scale = inverse_or_one(Math.sqrt(fx * fx + fy * fy + fz * fz));
+
+    let ax = fx * scale;
+    let ay = fy * scale;
+    let az = fz * scale;
+
+    // right = up × forward
+    let cx = uy * az - uz * ay;
+    let cy = uz * ax - ux * az;
+    let cz = ux * ay - uy * ax;
+
+    if (cx * cx + cy * cy + cz * cz === 0) {
+        // up and forward are parallel; adjust forward slightly, as three.js does
+        // https://github.com/mrdoob/three.js/blob/88e8954b69377dad4ad1ceaf1a383f3536e88e5a/src/math/Matrix4.js#L304
+
+        if (Math.abs(uz) === 1) {
+            ax += 0.001;
+        } else {
+            az += 0.001;
+        }
+
+        scale = inverse_or_one(Math.sqrt(ax * ax + ay * ay + az * az));
+
+        ax *= scale;
+        ay *= scale;
+        az *= scale;
+
+        cx = uy * az - uz * ay;
+        cy = uz * ax - ux * az;
+        cz = ux * ay - uy * ax;
+    }
+
+    scale = inverse_or_one(Math.sqrt(cx * cx + cy * cy + cz * cz));
+
+    cx *= scale;
+    cy *= scale;
+    cz *= scale;
+
+    // up' = forward × right
+    const bx = ay * cz - az * cy;
+    const by = az * cx - ax * cz;
+    const bz = ax * cy - ay * cx;
+
+    // the rotation of the matrix whose columns are right, up' and forward
+    const m11 = cx, m12 = bx, m13 = ax;
+    const m21 = cy, m22 = by, m23 = ay;
+    const m31 = cz, m32 = bz, m33 = az;
+
+    const trace = m11 + m22 + m33;
+
+    let x, y, z, w, s;
+
+    if (trace > 0) {
+
+        s = Math.sqrt(trace + 1.0);
+
+        w = 0.5 * s;
+
+        s = 0.5 / s;
+
+        x = (m32 - m23) * s;
+        y = (m13 - m31) * s;
+        z = (m21 - m12) * s;
+
+    } else if (m11 > m22 && m11 > m33) {
+
+        s = Math.sqrt(1.0 + m11 - m22 - m33);
+
+        x = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (m32 - m23) * s;
+        y = (m12 + m21) * s;
+        z = (m13 + m31) * s;
+
+    } else if (m22 > m33) {
+
+        s = Math.sqrt(1.0 + m22 - m11 - m33);
+
+        y = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (m13 - m31) * s;
+        x = (m12 + m21) * s;
+        z = (m23 + m32) * s;
+
+    } else {
+
+        s = Math.sqrt(1.0 + m33 - m11 - m22);
+
+        z = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (m21 - m12) * s;
+        x = (m13 + m31) * s;
+        y = (m23 + m32) * s;
+
+    }
+
+    // Finite inputs can still come out NaN, when a square or a cross product overflows. One check of one
+    // boolean, so a build keeping assertions boxes nothing for it.
+    assert.ok(x === x && y === y && z === z && w === w, 'look rotation is NaN: forward or up is too large for its square');
+
+    out[out_offset] = x;
+    out[out_offset + 1] = y;
+    out[out_offset + 2] = z;
+    out[out_offset + 3] = w;
+}

package/src/core/geom/ConicRay.js

@@ -1,5 +1,5 @@
 import { assert } from "../assert.js";
-import { combine_hash } from "../collection/array/combine_hash.js";
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
 import { EPSILON } from "../math/EPSILON.js";
 import { epsilonEquals } from "../math/epsilonEquals.js";
 import { PI2 } from "../math/PI2.js";
@@ -90,7 +90,7 @@ export class ConicRay {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeHashFloat(this.angle),
             this.direction.hash()
         );

package/src/core/geom/Quaternion.d.ts

@@ -125,6 +125,7 @@ export class Quaternion extends Float64Array implements Iterable<number> {
      * @param {number} uy up vector
      * @param {number} uz up vector
      * @returns {this}
+     * @see quat3_look_rotation the arithmetic, which this hands its arguments to unchanged
      */
     _lookRotation(fx: number, fy: number, fz: number, ux: number, uy: number, uz: number): this;
     /**

package/src/core/geom/Quaternion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Quaternion.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Quaternion.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Quaternion.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Quaternion.js"],"names":[],"mappings":"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"}

package/src/core/geom/Quaternion.js

@@ -8,6 +8,7 @@ import { epsilonEquals } from "../math/epsilonEquals.js";
 import { lerp } from "../math/lerp.js";
 import { PI2 } from "../math/PI2.js";
 import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
+import { quat3_look_rotation } from "./3d/quaternion/quat3_look_rotation.js";
 import { v3_dot } from "./vec3/v3_dot.js";
 import { v4_length } from "./vec4/v4_length.js";
 import Vector3 from "./Vector3.js";
@@ -17,8 +18,13 @@ import Vector3 from "./Vector3.js";
  */
 
 const scratch_v3_a = new Vector3();
-const scratch_v3_b = new Vector3();
-const scratch_v3_c = new Vector3();
+
+/**
+ * Where {@link Quaternion#_lookRotation} has its answer worked out before setting it.
+ *
+ * @type {Float64Array}
+ */
+const scratch_rotation = new Float64Array(4);
 
 const sin = Math.sin;
 const cos = Math.cos;
@@ -158,58 +164,16 @@ export class Quaternion extends Float64Array {
      * @param {number} uy up vector
      * @param {number} uz up vector
      * @returns {this}
+     * @see quat3_look_rotation the arithmetic, which this hands its arguments to unchanged
      */
     _lookRotation(
         fx, fy, fz,
         ux, uy, uz
     ) {
+        quat3_look_rotation(scratch_rotation, 0, fx, fy, fz, ux, uy, uz);
 
-        scratch_v3_a.set(fx, fy, fz);
-        scratch_v3_a.normalize();
-
-        scratch_v3_c._crossVectors(ux, uy, uz, scratch_v3_a.x, scratch_v3_a.y, scratch_v3_a.z);
-
-        if (scratch_v3_c.lengthSq() === 0) {
-            // up and forward are parallel
-
-            /*
-             adjust forward direction slightly
-             code take from : https://github.com/mrdoob/three.js/blob/88e8954b69377dad4ad1ceaf1a383f3536e88e5a/src/math/Matrix4.js#L304
-             */
-
-            if (Math.abs(uz) === 1) {
-                scratch_v3_a.x += 0.001;
-            } else {
-                scratch_v3_a.z += 0.001;
-            }
-
-            scratch_v3_a.normalize();
-            scratch_v3_c._crossVectors(ux, uy, uz, scratch_v3_a.x, scratch_v3_a.y, scratch_v3_a.z);
-
-        }
-
-        scratch_v3_c.normalize();
-
-        scratch_v3_b.crossVectors(scratch_v3_a, scratch_v3_c);
-
-        // construct partial transform matrix
-        const m00 = scratch_v3_c.x;
-        const m10 = scratch_v3_c.y;
-        const m20 = scratch_v3_c.z;
-
-        const m01 = scratch_v3_b.x;
-        const m11 = scratch_v3_b.y;
-        const m21 = scratch_v3_b.z;
-
-        const m02 = scratch_v3_a.x;
-        const m12 = scratch_v3_a.y;
-        const m22 = scratch_v3_a.z;
-
-        return this.__setFromRotationMatrix(
-            m00, m01, m02,
-            m10, m11, m12,
-            m20, m21, m22
-        );
+        // through set(), so the change is announced as any other write is
+        return this.set(scratch_rotation[0], scratch_rotation[1], scratch_rotation[2], scratch_rotation[3]);
     }
 
     /**

package/src/core/geom/Vector4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAMA;;;GAGG;AAGH;;GAEG;AACH;;;;;;;;;;;;;GAaG;AACH,8DAFwB,MAAM;IAuc1B;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IApbD;;;;OAIG;IACH,uDAEC;IArCD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAuBhB;IAXG,UAAW;IACX,UAAW;IACX,UAAW;IACX,UAAW;IAEX;;;;OAIG;IACH,wBAA6B;IAoBjC;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,oBAFW,OAAO,QAQjB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,OAAO,GAAC,OAAO,GACb,OAAO,CASnB;IAED;;;;;;;OAOG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,iBAJW,OAAO,SACP,MAAM,GACJ,IAAI,CAShB;IAED;;;;OAIG;IACH,qBAHW;QAAC,QAAQ,EAAE,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC/B,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAyBpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CASjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAGD;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAStB;IAmBL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBAlXe,MAAM,EAAE,WACR,MAAM,UAiXM;IAC3B,iBArWe,MAAM,EAAE,WACR,MAAM,UAoWI;CATxB;;kBAaS,MAAM;;;yBAvfH,OAAO,iBAAiB,EAAE,UAAU;sBACpC,OAAO,cAAc,EAAE,OAAO;2BAK9B,OAAO,2BAA2B,EAAE,YAAY"}
+{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAOA;;;GAGG;AAGH;;GAEG;AACH;;;;;;;;;;;;;GAaG;AACH,8DAFwB,MAAM;IAyc1B;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IAtbD;;;;OAIG;IACH,uDAEC;IArCD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAuBhB;IAXG,UAAW;IACX,UAAW;IACX,UAAW;IACX,UAAW;IAEX;;;;OAIG;IACH,wBAA6B;IAoBjC;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,oBAFW,OAAO,QAQjB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,OAAO,GAAC,OAAO,GACb,OAAO,CASnB;IAED;;;;;;;OAOG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,iBAJW,OAAO,SACP,MAAM,GACJ,IAAI,CAShB;IAED;;;;OAIG;IACH,qBAHW;QAAC,QAAQ,EAAE,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC/B,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAyBpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAWjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAGD;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAStB;IAmBL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBApXe,MAAM,EAAE,WACR,MAAM,UAmXM;IAC3B,iBAvWe,MAAM,EAAE,WACR,MAAM,UAsWI;CATxB;;kBAaS,MAAM;;;yBAzfH,OAAO,iBAAiB,EAAE,UAAU;sBACpC,OAAO,cAAc,EAAE,OAAO;2BAK9B,OAAO,2BAA2B,EAAE,YAAY"}

package/src/core/geom/Vector4.js

@@ -1,5 +1,6 @@
 import { assert } from "../assert.js";
-import { combine_hash } from "../collection/array/combine_hash.js";
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
+import { hash_mix3 } from "../math/hash/hash_mix3.js";
 import { Signal } from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
 import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
@@ -405,10 +406,12 @@ export class Vector4 extends Float64Array {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this[0]),
-            computeHashFloat(this[1]),
-            computeHashFloat(this[2]),
+        return hash_mix2(
+            hash_mix3(
+                computeHashFloat(this[0]),
+                computeHashFloat(this[1]),
+                computeHashFloat(this[2])
+            ),
             computeHashFloat(this[3])
         );
     }

package/src/core/math/hash/XXH128Hash.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A 128-bit xxHash3 result, kept as its two 64-bit halves because that is how the reference
+ * implementation names them and how every serialized form writes them.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class XXH128Hash {
+    /**
+     * @param {bigint} low64
+     * @param {bigint} high64
+     */
+    constructor(low64: bigint, high64: bigint);
+    /**
+     * @type {bigint}
+     */
+    low64: bigint;
+    /**
+     * @type {bigint}
+     */
+    high64: bigint;
+    /**
+     * @param {XXH128Hash} other
+     * @returns {boolean}
+     */
+    equals(other: XXH128Hash): boolean;
+    /**
+     * @returns {string} 32 lowercase hex digits, high half first
+     */
+    toString(): string;
+    /**
+     * Useful for type checking
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isXXH128Hash: boolean;
+}
+//# sourceMappingURL=XXH128Hash.d.ts.map

package/src/core/math/hash/XXH128Hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XXH128Hash.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/XXH128Hash.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH;IAWI;;;OAGG;IACH,mBAHW,MAAM,UACN,MAAM,EAQhB;IApBD;;OAEG;IACH,OAFU,MAAM,CAEL;IAEX;;OAEG;IACH,QAFU,MAAM,CAEJ;IAcZ;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAInB;IAED;;OAEG;IACH,YAFa,MAAM,CAIlB;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}