@woosh/meep-engine 3.45.0 → 3.47.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/array_insert_at.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Insert `value` at `index`, keeping the order of the rest: what `array.splice(index, 0, value)` does to
+ * the array, in place, without the empty array `splice` builds and returns every call.
+ *
+ * The elements from `index` on move up one slot each, and the array ends one longer.
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index where `value` lands, `0 <= index <= array.length`
+ * @param {T} value
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function array_insert_at<T>(array: T[], index: number, value: T): void;
+//# sourceMappingURL=array_insert_at.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_insert_at.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_insert_at.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,sDANW,MAAM,kBAqBhB"}

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

@@ -0,0 +1,32 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Insert `value` at `index`, keeping the order of the rest: what `array.splice(index, 0, value)` does to
+ * the array, in place, without the empty array `splice` builds and returns every call.
+ *
+ * The elements from `index` on move up one slot each, and the array ends one longer.
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index where `value` lands, `0 <= index <= array.length`
+ * @param {T} value
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function array_insert_at(array, index, value) {
+    // past the end, splice appends, and this would leave a hole; below 0 it writes a "-1" property
+    assert.isNonNegativeInteger(index, 'index');
+    assert.lessThanOrEqual(index, array.length, 'index');
+
+    let i = array.length;
+
+    // grow by one first, through push, so the store grows the way an append grows it
+    array.push(value);
+
+    for (; i > index; i--) {
+        array[i] = array[i - 1];
+    }
+
+    array[index] = value;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Remove the element at `index`, keeping the order of the rest: what `array.splice(index, 1)` does to
+ * the array, in place, without the array of removed elements `splice` builds and returns every call.
+ *
+ * The elements after `index` move down one slot each, and the array ends one shorter.
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index an index into `array`, `0 <= index < array.length`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function array_remove_at<T>(array: T[], index: number): void;
+//# sourceMappingURL=array_remove_at.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_remove_at.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_remove_at.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,sDALW,MAAM,QAmBhB"}

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

@@ -0,0 +1,30 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Remove the element at `index`, keeping the order of the rest: what `array.splice(index, 1)` does to
+ * the array, in place, without the array of removed elements `splice` builds and returns every call.
+ *
+ * The elements after `index` move down one slot each, and the array ends one shorter.
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index an index into `array`, `0 <= index < array.length`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function array_remove_at(array, index) {
+    // outside the array, splice removes nothing, and this would drop the last element instead
+    assert.isNonNegativeInteger(index, 'index');
+    assert.lessThan(index, array.length, 'index');
+
+    const last = array.length - 1;
+
+    for (let i = index; i < last; i++) {
+        array[i] = array[i + 1];
+    }
+
+    // pop rather than `length = last`: setting the length lets V8 trim the store, which a pool removing and
+    // inserting every frame would only grow back
+    array.pop();
+}

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}
  */