@woosh/meep-engine 3.45.0 → 3.46.0

package/src/core/binary/hash/xxh3_common.js

@@ -1,476 +1,90 @@
-import { assert } from "../../assert.js";
-import { XXH3_SECRET } from "./XXH3_SECRET.js";
-
-/**
- * The pieces of xxHash3 that the 64-bit and 128-bit variants share: the primes, the mixing stages,
- * and the long-input accumulator loop. Everything here is a direct transcription of the reference
- * implementation's scalar path — the vectorized paths produce identical results by construction, so
- * the scalar one is the whole specification.
- *
- * Arithmetic is `BigInt` masked to 64 bits after every operation. This is a build-time hash (asset
- * identity, container checksums), never a per-frame one, so clarity against the reference wins over
- * the 32-bit-lane decomposition a runtime implementation would need.
- *
- * @see https://github.com/Cyan4973/xxHash/blob/dev/xxhash.h
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-/**
- * @readonly
- * @type {bigint}
- */
-export const XXH_MASK_64 = 0xFFFFFFFFFFFFFFFFn;
-
-const MASK_32 = 0xFFFFFFFFn;
-
-export const XXH_PRIME32_1 = 0x9E3779B1n;
-export const XXH_PRIME32_2 = 0x85EBCA77n;
-export const XXH_PRIME32_3 = 0xC2B2AE3Dn;
-
-export const XXH_PRIME64_1 = 0x9E3779B185EBCA87n;
-export const XXH_PRIME64_2 = 0xC2B2AE3D27D4EB4Fn;
-export const XXH_PRIME64_3 = 0x165667B19E3779F9n;
-export const XXH_PRIME64_4 = 0x85EBCA77C2B2AE63n;
-export const XXH_PRIME64_5 = 0x27D4EB2F165667C5n;
-
-export const XXH_PRIME_MX1 = 0x165667919E3779F9n;
-export const XXH_PRIME_MX2 = 0x9FB21C651E98DF25n;
-
-/**
- * Shortest secret any variant accepts, and the anchor for the mid-size tail offsets.
- * @readonly
- * @type {number}
- */
-export const XXH3_SECRET_SIZE_MIN = 136;
-
-/**
- * Longest input still handled by the "mid size" single-shot paths.
- * @readonly
- * @type {number}
- */
-export const XXH3_MIDSIZE_MAX = 240;
-
-export const XXH3_MIDSIZE_STARTOFFSET = 3;
-export const XXH3_MIDSIZE_LASTOFFSET = 17;
-
-export const XXH_STRIPE_LEN = 64;
-export const XXH_SECRET_CONSUME_RATE = 8;
-export const XXH_ACC_NB = 8;
-export const XXH_SECRET_LASTACC_START = 7;
-export const XXH_SECRET_MERGEACCS_START = 11;
-
-/**
- * Truncate to 64 bits.
- * @param {bigint} v
- * @returns {bigint}
- */
-export function u64(v) {
-    return v & XXH_MASK_64;
-}
-
-/**
- * @param {bigint} a
- * @param {bigint} b
- * @returns {bigint}
- */
-export function mul64(a, b) {
-    return (a * b) & XXH_MASK_64;
-}
-
-/**
- * @param {bigint} a
- * @param {bigint} b
- * @returns {bigint}
- */
-export function add64(a, b) {
-    return (a + b) & XXH_MASK_64;
-}
-
-/**
- * Two's-complement 64-bit subtraction.
- * @param {bigint} a
- * @param {bigint} b
- * @returns {bigint}
- */
-export function sub64(a, b) {
-    return (a - b) & XXH_MASK_64;
-}
-
-/**
- * @param {bigint} v
- * @param {number} bits
- * @returns {bigint}
- */
-export function rotl64(v, bits) {
-    const n = BigInt(bits);
-
-    return ((v << n) | (v >> (64n - n))) & XXH_MASK_64;
-}
-
-/**
- * Rotate within 32 bits, as the reference's `XXH_rotl32`.
- * @param {bigint} v
- * @param {number} bits
- * @returns {bigint}
- */
-export function rotl32(v, bits) {
-    const x = v & MASK_32;
-    const n = BigInt(bits);
-
-    return ((x << n) | (x >> (32n - n))) & MASK_32;
-}
-
-/**
- * @param {bigint} v
- * @param {number} bits
- * @returns {bigint}
- */
-export function xorshift64(v, bits) {
-    return v ^ (v >> BigInt(bits));
-}
-
-/**
- * Byte-reverse a 32-bit value, as the reference's `XXH_swap32`.
- * @param {bigint} v
- * @returns {bigint}
- */
-export function swap32(v) {
-    const x = v & MASK_32;
-
-    return ((x << 24n) | ((x & 0xFF00n) << 8n) | ((x >> 8n) & 0xFF00n) | (x >> 24n)) & MASK_32;
-}
-
-/**
- * Byte-reverse a 64-bit value, as the reference's `XXH_swap64`.
- * @param {bigint} v
- * @returns {bigint}
- */
-export function swap64(v) {
-    return ((v & 0x00000000000000FFn) << 56n)
-        | ((v & 0x000000000000FF00n) << 40n)
-        | ((v & 0x0000000000FF0000n) << 24n)
-        | ((v & 0x00000000FF000000n) << 8n)
-        | ((v & 0x000000FF00000000n) >> 8n)
-        | ((v & 0x0000FF0000000000n) >> 24n)
-        | ((v & 0x00FF000000000000n) >> 40n)
-        | ((v & 0xFF00000000000000n) >> 56n);
-}
-
-/**
- * Widening 32x32 -> 64 multiply of the low halves of both operands, as the reference's
- * `XXH_mult32to64`.
- *
- * @param {bigint} a
- * @param {bigint} b
- * @returns {bigint}
- */
-export function mult32to64(a, b) {
-    return (a & MASK_32) * (b & MASK_32);
-}
-
-/**
- * 64x64 -> 128 multiply, folded down by XOR of the two halves.
- *
- * @param {bigint} a
- * @param {bigint} b
- * @returns {bigint}
- */
-export function mul128_fold64(a, b) {
-    const product = a * b;
-
-    return (product ^ (product >> 64n)) & XXH_MASK_64;
-}
-
-/**
- * The fast finalizing mix, for input whose bits are already partially mixed.
- * @param {bigint} h64
- * @returns {bigint}
- */
-export function xxh3_avalanche(h64) {
-    let h = xorshift64(h64, 37);
-
-    h = mul64(h, XXH_PRIME_MX1);
-    h = xorshift64(h, 32);
-
-    return h & XXH_MASK_64;
-}
-
-/**
- * The stronger finalizing mix (after Pelle Evensen's rrmxmx), for input that has not been mixed yet.
- * @param {bigint} h64
- * @param {number} len
- * @returns {bigint}
- */
-export function xxh3_rrmxmx(h64, len) {
-    let h = h64 ^ rotl64(h64, 49) ^ rotl64(h64, 24);
-
-    h = mul64(h, XXH_PRIME_MX2);
-    h = u64(h ^ add64(h >> 35n, BigInt(len)));
-    h = mul64(h, XXH_PRIME_MX2);
-
-    return xorshift64(h, 28) & XXH_MASK_64;
-}
-
-/**
- * XXH64's finalizing mix, which XXH3 reuses for its shortest inputs.
- * @param {bigint} hash
- * @returns {bigint}
- */
-export function xxh64_avalanche(hash) {
-    let h = hash ^ (hash >> 33n);
-
-    h = mul64(h, XXH_PRIME64_2);
-    h ^= h >> 29n;
-    h = mul64(h, XXH_PRIME64_3);
-    h ^= h >> 32n;
-
-    return h & XXH_MASK_64;
-}
-
-/**
- * Read a little-endian u32 at `offset`.
- *
- * @param {Uint8Array} bytes
- * @param {number} offset
- * @returns {bigint}
- */
-export function read_u32(bytes, offset) {
-    return BigInt(
-        bytes[offset]
-        | (bytes[offset + 1] << 8)
-        | (bytes[offset + 2] << 16)
-        | (bytes[offset + 3] << 24)
-    ) & MASK_32;
-}
-
-/**
- * Read a little-endian u64 at `offset`.
- *
- * @param {Uint8Array} bytes
- * @param {number} offset
- * @returns {bigint}
- */
-export function read_u64(bytes, offset) {
-    return read_u32(bytes, offset) | (read_u32(bytes, offset + 4) << 32n);
-}
-
-/**
- * Write a little-endian u64 at `offset`.
- *
- * @param {Uint8Array} bytes
- * @param {number} offset
- * @param {bigint} value
- */
-export function write_u64(bytes, offset, value) {
-    let v = value & XXH_MASK_64;
-
-    for (let i = 0; i < 8; i++) {
-        bytes[offset + i] = Number(v & 0xFFn);
-        v >>= 8n;
-    }
-}
-
-/**
- * The 16-byte mixing step shared by every mid-size path.
- *
- * @param {Uint8Array} input
- * @param {number} input_offset
- * @param {Uint8Array} secret
- * @param {number} secret_offset
- * @param {bigint} seed
- * @returns {bigint}
- */
-export function xxh3_mix16b(input, input_offset, secret, secret_offset, seed) {
-    const input_lo = read_u64(input, input_offset);
-    const input_hi = read_u64(input, input_offset + 8);
-
-    return mul128_fold64(
-        input_lo ^ add64(read_u64(secret, secret_offset), seed),
-        input_hi ^ sub64(read_u64(secret, secret_offset + 8), seed)
-    );
-}
-
-/**
- * Derive a 192-byte secret from `seed`, as the reference's `XXH3_initCustomSecret`. This is what
- * makes a seeded hash of a long input differ from the unseeded one.
- *
- * @param {bigint} seed
- * @returns {Uint8Array} freshly allocated, {@link XXH3_SECRET}'s length
- */
-export function xxh3_init_custom_secret(seed) {
-    const result = new Uint8Array(XXH3_SECRET.length);
-
-    const pair_count = XXH3_SECRET.length / 16;
-
-    for (let i = 0; i < pair_count; i++) {
-        const lo = add64(read_u64(XXH3_SECRET, 16 * i), seed);
-        const hi = sub64(read_u64(XXH3_SECRET, 16 * i + 8), seed);
-
-        write_u64(result, 16 * i, lo);
-        write_u64(result, 16 * i + 8, hi);
-    }
-
-    return result;
-}
-
-/**
- * Accumulate one 64-byte stripe into the eight lanes.
- *
- * @param {BigUint64Array} acc
- * @param {Uint8Array} input
- * @param {number} input_offset
- * @param {Uint8Array} secret
- * @param {number} secret_offset
- */
-function accumulate_512(acc, input, input_offset, secret, secret_offset) {
-    for (let lane = 0; lane < XXH_ACC_NB; lane++) {
-        const data_val = read_u64(input, input_offset + lane * 8);
-        const data_key = data_val ^ read_u64(secret, secret_offset + lane * 8);
-
-        acc[lane ^ 1] = add64(acc[lane ^ 1], data_val);
-        acc[lane] = add64(mult32to64(data_key, data_key >> 32n), acc[lane]);
-    }
-}
-
-/**
- * Accumulate `stripe_count` consecutive stripes, advancing the secret by
- * {@link XXH_SECRET_CONSUME_RATE} per stripe.
- *
- * @param {BigUint64Array} acc
- * @param {Uint8Array} input
- * @param {number} input_offset
- * @param {Uint8Array} secret
- * @param {number} stripe_count
- */
-function accumulate(acc, input, input_offset, secret, stripe_count) {
-    for (let n = 0; n < stripe_count; n++) {
-        accumulate_512(
-            acc,
-            input, input_offset + n * XXH_STRIPE_LEN,
-            secret, n * XXH_SECRET_CONSUME_RATE
-        );
-    }
-}
-
-/**
- * Scramble the lanes between blocks, so that a block's contribution cannot be undone by a later one.
- *
- * @param {BigUint64Array} acc
- * @param {Uint8Array} secret
- * @param {number} secret_offset
- */
-function scramble_acc(acc, secret, secret_offset) {
-    for (let lane = 0; lane < XXH_ACC_NB; lane++) {
-        const key64 = read_u64(secret, secret_offset + lane * 8);
-
-        let acc64 = xorshift64(acc[lane], 47);
-
-        acc64 ^= key64;
-        acc64 = mul64(acc64, XXH_PRIME32_1);
-
-        acc[lane] = acc64;
-    }
-}
-
-/**
- * Run the whole long-input accumulator loop: whole blocks with a scramble after each, then the
- * trailing partial block, then the (possibly overlapping) final stripe.
- *
- * @param {BigUint64Array} acc
- * @param {Uint8Array} input
- * @param {Uint8Array} secret
- */
-export function xxh3_hash_long_loop(acc, input, secret) {
-    const len = input.length;
-    const secret_size = secret.length;
-
-    const stripes_per_block = ((secret_size - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE) | 0;
-    const block_len = XXH_STRIPE_LEN * stripes_per_block;
-    const block_count = ((len - 1) / block_len) | 0;
-
-    for (let n = 0; n < block_count; n++) {
-        accumulate(acc, input, n * block_len, secret, stripes_per_block);
-        scramble_acc(acc, secret, secret_size - XXH_STRIPE_LEN);
-    }
-
-    const trailing_stripes = (((len - 1) - (block_len * block_count)) / XXH_STRIPE_LEN) | 0;
-
-    accumulate(acc, input, block_count * block_len, secret, trailing_stripes);
-
-    accumulate_512(
-        acc,
-        input, len - XXH_STRIPE_LEN,
-        secret, secret_size - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START
-    );
-}
-
-/**
- * Fold the eight lanes down to one 64-bit value.
- *
- * @param {BigUint64Array} acc
- * @param {Uint8Array} secret
- * @param {number} secret_offset
- * @param {bigint} start
- * @returns {bigint}
- */
-export function xxh3_merge_accs(acc, secret, secret_offset, start) {
-    let result = start & XXH_MASK_64;
-
-    for (let i = 0; i < 4; i++) {
-        result = add64(result, mul128_fold64(
-            acc[2 * i] ^ read_u64(secret, secret_offset + 16 * i),
-            acc[2 * i + 1] ^ read_u64(secret, secret_offset + 16 * i + 8)
-        ));
-    }
-
-    return xxh3_avalanche(result);
-}
-
-/**
- * The accumulator lanes' initial state.
- * @returns {BigUint64Array} freshly allocated, {@link XXH_ACC_NB} lanes
- */
-export function xxh3_init_acc() {
-    const acc = new BigUint64Array(XXH_ACC_NB);
-
-    acc[0] = XXH_PRIME32_3;
-    acc[1] = XXH_PRIME64_1;
-    acc[2] = XXH_PRIME64_2;
-    acc[3] = XXH_PRIME64_3;
-    acc[4] = XXH_PRIME64_4;
-    acc[5] = XXH_PRIME32_2;
-    acc[6] = XXH_PRIME64_5;
-    acc[7] = XXH_PRIME32_1;
-
-    return acc;
-}
-
-/**
- * The secret a seeded hash of a long input runs against: the default one for seed 0, a derived one
- * otherwise. Shared by both variants so they agree on the seed-0 shortcut.
- *
- * @param {bigint} seed
- * @returns {Uint8Array}
- */
-export function xxh3_long_secret(seed) {
-    if (seed === 0n) {
-        return XXH3_SECRET;
-    }
-
-    return xxh3_init_custom_secret(seed);
-}
-
-/**
- * Common argument checks for the public entry points.
- *
- * @param {Uint8Array} input
- * @param {bigint} seed
- */
-export function xxh3_assert_arguments(input, seed) {
-    assert.defined(input, 'input');
-    assert.notNull(input, 'input');
-    assert.isArrayLike(input, 'input');
-    assert.equal(typeof seed, 'bigint', `seed must be a bigint, instead was '${typeof seed}'`);
-}
+export {
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_MASK_64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME32_1,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME32_2,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME32_3,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME64_1,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME64_2,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME64_3,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME64_4,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME64_5,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME_MX1,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_PRIME_MX2,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH3_SECRET_SIZE_MIN,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH3_MIDSIZE_MAX,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH3_MIDSIZE_STARTOFFSET,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH3_MIDSIZE_LASTOFFSET,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_STRIPE_LEN,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_SECRET_CONSUME_RATE,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_ACC_NB,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_SECRET_LASTACC_START,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    XXH_SECRET_MERGEACCS_START,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    u64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    mul64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    add64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    sub64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    rotl64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    rotl32,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xorshift64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    swap32,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    swap64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    mult32to64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    mul128_fold64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_avalanche,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_rrmxmx,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh64_avalanche,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    read_u32,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    read_u64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    write_u64,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_mix16b,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_init_custom_secret,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_hash_long_loop,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_merge_accs,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_init_acc,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_long_secret,
+    /** @deprecated moved to core/math/hash/xxh3_common.js; import it from there */
+    xxh3_assert_arguments
+} from "../../math/hash/xxh3_common.js";

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

@@ -1,5 +1,11 @@
 /**
  * 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/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