@woosh/meep-engine 3.45.0 → 3.47.0

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

@@ -0,0 +1,476 @@
+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}'`);
+}

package/src/core/math/lookup/ParameterLookupTable.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { combine_hash } from "../../collection/array/combine_hash.js";
+import { hash_mix3 } from "../hash/hash_mix3.js";
 import { isArrayEqualStrict } from "../../collection/array/isArrayEqualStrict.js";
 import { computeHashFloatArray } from "../hash/computeHashFloatArray.js";
 import { inverseLerp } from "../inverseLerp.js";
@@ -377,7 +377,7 @@ export class ParameterLookupTable {
             const dataHash = computeHashFloatArray(this.data);
             const positionHash = computeHashFloatArray(this.positions);
 
-            return combine_hash(
+            return hash_mix3(
                 dataHash,
                 positionHash,
                 this.itemSize

package/src/core/model/node-graph/node/NodeInstancePortReference.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";
 
 /**
  * @typedef {import("../Connection.js").Connection} Connection
@@ -137,7 +137,7 @@ export class NodeInstancePortReference {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.instance.hash(),
             this.port.hash()
         );

package/src/core/model/reactive/model/ReactiveBinaryExpression.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import { combine_hash } from "../../../collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../math/hash/hash_mix3.js";
 import { ReactiveExpression } from "./ReactiveExpression.js";
 
 /**
@@ -60,7 +60,7 @@ export class ReactiveBinaryExpression extends ReactiveExpression {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix3(
             this.left.hash(),
             this.right.hash(),
             super.hash()

package/src/core/model/reactive/model/terminal/ReactiveReference.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 DataType from "../../../../parser/simple/DataType.js";
 import { computeStringHash } from "../../../../primitives/strings/computeStringHash.js";
 import { ReactiveExpression } from "../ReactiveExpression.js";
@@ -124,7 +124,7 @@ export class ReactiveReference extends ReactiveExpression {
 
 
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeStringHash(this.name),
             super.hash()
         );

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IA4FI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBA0GC;IAoBD;;OAEG;IACH,sBA+DC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BA94B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IA4FI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IA6IhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBA0GC;IAoBD;;OAEG;IACH,sBA+DC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAn5B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -477,10 +477,12 @@ class Engine {
     }
 
     /**
-     * @param {ShadeDeviceFailure} reason carries a message written to be shown to a person
+     * There is no usable device, so there will be no rendering at all.
+     *
+     * @param {ShadeDeviceFailure} failure carries a message written to be shown to a person
      */
-    #handle_context_failed(reason) {
-        logger.error(`Graphics context recovery abandoned (${reason}), no further rendering is possible`);
+    #handle_context_failed(failure) {
+        logger.error(`Graphics could not start (${failure}), no rendering is possible`);
 
         this.#clear_context_loss_pause_timer();
 
@@ -488,7 +490,10 @@ class Engine {
         // Application state is left intact, which keeps a save-on-failure handler viable.
         this.#pause_simulation_for_context_loss();
 
-        this.viewStack.addChild(new GraphicsContextFailureView());
+        this.viewStack.addChild(new GraphicsContextFailureView({
+            title: 'Graphics unavailable',
+            text: failure.message,
+        }));
     }
 
     #initialize_audio() {

package/src/engine/asset/AssetDescription.js

@@ -1,5 +1,5 @@
 import { assert } from "../../core/assert.js";
-import { combine_hash } from "../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../core/math/hash/hash_mix2.js";
 import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
 
 export class AssetDescription {
@@ -39,7 +39,7 @@ export class AssetDescription {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeStringHash(this.path),
             computeStringHash(this.type)
         );

package/src/engine/ecs/animation/Animation.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
 import List from '../../../core/collection/list/List.js';
 import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 import { AnimationClip } from "./AnimationClip.js";
@@ -139,7 +139,7 @@ export class Animation {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.clips.hash(),
             computeHashFloat(this.debtTime)
         );

package/src/engine/ecs/animation/AnimationClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/AnimationClip.js"],"names":[],"mappings":"AAKA;IA2DI;;;;OAIG;IACH,yBAFa,aAAa,CAQzB;IApED,qBAA8B;IAC9B,6BAAqC;IAErC;;;OAGG;IACH,QAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,WAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAQnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAUlB;IAED;;;;OAIG;IACH,WAHW,MAAM,oBAAkB,GACtB,OAAO,CAInB;IAeD,0BA4BC;IAED;;;;;;MAQC;IAED;;;OAGG;IACH,2CAQC;IAED;;;OAGG;IACH,6CAOC;CACJ;2BA5I0B,uCAAuC;4BADtC,wCAAwC;oBADhD,+BAA+B"}
+{"version":3,"file":"AnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/AnimationClip.js"],"names":[],"mappings":"AAKA;IA6DI;;;;OAIG;IACH,yBAFa,aAAa,CAQzB;IAtED,qBAA8B;IAC9B,6BAAqC;IAErC;;;OAGG;IACH,QAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,WAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAQnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAYlB;IAED;;;;OAIG;IACH,WAHW,MAAM,oBAAkB,GACtB,OAAO,CAInB;IAeD,0BA4BC;IAED;;;;;;MAQC;IAED;;;OAGG;IACH,2CAQC;IAED;;;OAGG;IACH,6CAOC;CACJ;2BA9I0B,uCAAuC;4BADtC,wCAAwC;oBADhD,+BAA+B"}

package/src/engine/ecs/animation/AnimationClip.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
 import Vector1 from "../../../core/geom/Vector1.js";
 import ObservedInteger from "../../../core/model/ObservedInteger.js";
 import ObservedString from "../../../core/model/ObservedString.js";
@@ -44,10 +44,12 @@ export class AnimationClip {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
-            this.name.hash(),
-            this.repeatCount.hash(),
-            this.weight.hash(),
+        return hash_mix3(
+            hash_mix3(
+                this.name.hash(),
+                this.repeatCount.hash(),
+                this.weight.hash()
+            ),
             this.timeScale.hash(),
             this.flags
         );

package/src/engine/ecs/gui/GUIElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GUIElement.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElement.js"],"names":[],"mappings":"6BASU,MAAM;;;;;;AAahB;IAyII;;;;OAIG;IACH,6BAFa,UAAU,CAYtB;IAED;;;;OAIG;IACH,yBAFY,UAAU,CAQrB;IApKD;;;OAGG;IACH,WAAY;IAEZ;;;OAGG;IACH,cAAa;IAEb;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,QAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,gBAFU,SAAO,IAAI,CAER;IAEb;;;OAGG;IACH,cAA+B;IAG/B;;;OAGG;IACH,SAFU,eAAe,CAEW;IAGpC;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACR,OAAO,CAgCnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAUjB;IAgCD;;;;;;aAUC;IAED;;;;;;;;;MAQC;CAEJ;;;;;oBAjNmB,+BAA+B;4BAEvB,wCAAwC"}
+{"version":3,"file":"GUIElement.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElement.js"],"names":[],"mappings":"6BASU,MAAM;;;;;;AAahB;IA2II;;;;OAIG;IACH,6BAFa,UAAU,CAYtB;IAED;;;;OAIG;IACH,yBAFY,UAAU,CAQrB;IAtKD;;;OAGG;IACH,WAAY;IAEZ;;;OAGG;IACH,cAAa;IAEb;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,QAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,gBAFU,SAAO,IAAI,CAER;IAEb;;;OAGG;IACH,cAA+B;IAG/B;;;OAGG;IACH,SAFU,eAAe,CAEW;IAGpC;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACR,OAAO,CAgCnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAYjB;IAgCD;;;;;;aAUC;IAED;;;;;;;;;MAQC;CAEJ;;;;;oBAnNmB,+BAA+B;4BAEvB,wCAAwC"}

package/src/engine/ecs/gui/GUIElement.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
 import Vector2 from '../../../core/geom/Vector2.js';
 import { objectDeepEquals } from "../../../core/model/object/objectDeepEquals.js";
 import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
@@ -148,10 +148,12 @@ class GUIElement {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            this.flags,
-            computeStringHash(this.klass),
-            this.anchor.hash(),
+        return hash_mix3(
+            hash_mix3(
+                this.flags,
+                computeStringHash(this.klass),
+                this.anchor.hash()
+            ),
             computeStringHash(this.group),
             this.visible.hash()
         )