@woosh/meep-engine 3.29.0 → 3.31.0

package/src/core/binary/type/DataTypeIndices.d.ts

@@ -1,14 +1,53 @@
+/**
+ * The serialization index of a type, or a throw when there is none.
+ *
+ * Prefer this to reading {@link DataTypeIndices} directly at a write site. The surrounding writers
+ * take a byte, and an unmapped type reaching one of them writes `0` — a valid index belonging to
+ * another type — rather than failing. This is an ordinary `throw` rather than an `assert` because it
+ * has to survive the assert stripping the consuming build does.
+ *
+ * @param {BinaryDataType} type
+ * @returns {number}
+ * @throws {Error} when the type has no index assigned
+ */
+export function dataTypeIndex(type: BinaryDataType): number;
 /**
  * *
  * Provides stable indices, mainly useful for serialization where other data is subject to change
+ *
+ * **Append-only.** These numbers are written into save files and asset containers as a single byte
+ * (see {@link serializeRowFirstTable }, {@link TextureBinaryBufferSerializer }, `serialize_scene`), so
+ * an existing entry can never be renumbered — every stored column would read back as a different
+ * type. That is also why this table is written out by hand rather than derived from the declaration
+ * order of {@link BinaryDataType }: reordering that enum is a harmless tidy-up, and it must stay one.
+ *
+ * A new member of {@link BinaryDataType } therefore takes the next free index here. Forgetting to add
+ * one used to be silent — `writeUint8(undefined)` coerces to `0`, the index of `Uint8`, so the
+ * stream deserialized a 64-bit column as an 8-bit one with no error anywhere. `DataTypeIndices.spec`
+ * is the ratchet against that now, and {@link dataTypeIndex } is the accessor that refuses instead of
+ * answering `undefined`.
  */
 export type DataTypeIndices = number;
 /***
  * Provides stable indices, mainly useful for serialization where other data is subject to change
+ *
+ * **Append-only.** These numbers are written into save files and asset containers as a single byte
+ * (see {@link serializeRowFirstTable}, {@link TextureBinaryBufferSerializer}, `serialize_scene`), so
+ * an existing entry can never be renumbered — every stored column would read back as a different
+ * type. That is also why this table is written out by hand rather than derived from the declaration
+ * order of {@link BinaryDataType}: reordering that enum is a harmless tidy-up, and it must stay one.
+ *
+ * A new member of {@link BinaryDataType} therefore takes the next free index here. Forgetting to add
+ * one used to be silent — `writeUint8(undefined)` coerces to `0`, the index of `Uint8`, so the
+ * stream deserialized a 64-bit column as an 8-bit one with no error anywhere. `DataTypeIndices.spec`
+ * is the ratchet against that now, and {@link dataTypeIndex} is the accessor that refuses instead of
+ * answering `undefined`.
+ *
  * @readonly
  * @enum {number}
  */
 export const DataTypeIndices: {
     [x: string]: number;
 };
+import { BinaryDataType } from "./BinaryDataType.js";
 //# sourceMappingURL=DataTypeIndices.d.ts.map

package/src/core/binary/type/DataTypeIndices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataTypeIndices.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/type/DataTypeIndices.js"],"names":[],"mappings":";;;;8BAKU,MAAM;AAHhB;;;;GAIG;AACH;;EAUE"}
+{"version":3,"file":"DataTypeIndices.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/type/DataTypeIndices.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;GAWG;AACH,oCAJW,cAAc,GACZ,MAAM,CAWlB;;;;;;;;;;;;;;;;;8BApCS,MAAM;AAhBhB;;;;;;;;;;;;;;;;;GAiBG;AACH;;EAYE;+BAhC6B,qBAAqB"}

package/src/core/binary/type/DataTypeIndices.js

@@ -2,6 +2,19 @@ import { BinaryDataType } from "./BinaryDataType.js";
 
 /***
  * Provides stable indices, mainly useful for serialization where other data is subject to change
+ *
+ * **Append-only.** These numbers are written into save files and asset containers as a single byte
+ * (see {@link serializeRowFirstTable}, {@link TextureBinaryBufferSerializer}, `serialize_scene`), so
+ * an existing entry can never be renumbered — every stored column would read back as a different
+ * type. That is also why this table is written out by hand rather than derived from the declaration
+ * order of {@link BinaryDataType}: reordering that enum is a harmless tidy-up, and it must stay one.
+ *
+ * A new member of {@link BinaryDataType} therefore takes the next free index here. Forgetting to add
+ * one used to be silent — `writeUint8(undefined)` coerces to `0`, the index of `Uint8`, so the
+ * stream deserialized a 64-bit column as an 8-bit one with no error anywhere. `DataTypeIndices.spec`
+ * is the ratchet against that now, and {@link dataTypeIndex} is the accessor that refuses instead of
+ * answering `undefined`.
+ *
  * @readonly
  * @enum {number}
  */
@@ -14,5 +27,29 @@ export const DataTypeIndices = {
     [BinaryDataType.Int32]: 5,
     [BinaryDataType.Float32]: 6,
     [BinaryDataType.Float64]: 7,
-    [BinaryDataType.Float16]: 8
+    [BinaryDataType.Float16]: 8,
+    [BinaryDataType.Uint64]: 9,
+    [BinaryDataType.Int64]: 10
 };
+
+/**
+ * The serialization index of a type, or a throw when there is none.
+ *
+ * Prefer this to reading {@link DataTypeIndices} directly at a write site. The surrounding writers
+ * take a byte, and an unmapped type reaching one of them writes `0` — a valid index belonging to
+ * another type — rather than failing. This is an ordinary `throw` rather than an `assert` because it
+ * has to survive the assert stripping the consuming build does.
+ *
+ * @param {BinaryDataType} type
+ * @returns {number}
+ * @throws {Error} when the type has no index assigned
+ */
+export function dataTypeIndex(type) {
+    const index = DataTypeIndices[type];
+
+    if (index === undefined) {
+        throw new Error(`Unsupported type '${type}', it has no serialization index`);
+    }
+
+    return index;
+}

package/src/core/binary/type/Type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Type.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/type/Type.js"],"names":[],"mappings":";oBAIa,OAAO,YAAY,EAAE,OAAO;AADzC;;GAEG;AAEH;IAmBI;;;;OAIG;IACH,0BAQC;IA/BD;;;OAGG;IACH,QAFU,MAAO,KAAK,CAAC,CAEX;IAEZ;;;OAGG;IACH,aAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,eAFU,OAAO,CAEK;IAUlB;;;OAGG;IACH,aAAgB;IAGpB;;;;OAIG;IACH,8BAFa,KAAK,GAAC,IAAI,CAatB;IAED;;;;;OAKG;IACH,6BAHW,IAAI,GACF,KAAK,CAWjB;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;CACJ"}
+{"version":3,"file":"Type.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/type/Type.js"],"names":[],"mappings":";oBAIa,OAAO,YAAY,EAAE,OAAO;AADzC;;GAEG;AAEH;IAmBI;;;;OAIG;IACH,0BAQC;IA/BD;;;OAGG;IACH,QAFU,MAAO,KAAK,CAAC,CAEX;IAEZ;;;OAGG;IACH,aAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,eAFU,OAAO,CAEK;IAUlB;;;OAGG;IACH,aAAgB;IAGpB;;;;OAIG;IACH,8BAFa,KAAK,GAAC,IAAI,CAatB;IAED;;;;;OAKG;IACH,6BAHW,IAAI,GACF,KAAK,CAWjB;IAED;;;OAGG;IACH,SAFa,IAAI,CAWhB;CACJ"}

package/src/core/binary/type/Type.js

@@ -79,8 +79,13 @@ class Type {
      * @returns {Type}
      */
     clone() {
-        const result = new Type();
+        const result = new Type(this.name);
+
         result.fields = this.fields.slice();
+
+        result.isPrimitive = this.isPrimitive;
+        result.isFixedLength = this.isFixedLength;
+
         return result;
     }
 }

package/src/core/bvh2/bvh3/BVH.d.ts.map

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

package/src/core/bvh2/bvh3/BVH.js

@@ -1176,7 +1176,20 @@ export class BVH {
         }
 
         if (best_rotation === 0) {
-            return iA; // no beneficial rotation
+            /**
+             * No swap reduces the surface area. That is the ordinary case for a well-shaped subtree,
+             * but it is also what happens when the candidate boxes are identical or one contains the
+             * other: every rotation then changes the area by exactly zero, `imp > best_improvement`
+             * is false four times over, and nothing moves. Left there, each new leaf inserted into
+             * such a cluster goes one level deeper than the last and the subtree becomes a linked
+             * list — 1,500 leaves sharing one AABB gave depth 1,531 rather than ~11, which is 1,500
+             * box tests on every query that reaches them and an O(N^2) insert.
+             *
+             * The height-AVL rotation is the tie-break. It is itself a no-op unless the subtree is
+             * out of balance by more than one level, so a subtree the SAH pass is already happy with
+             * is left exactly as it was.
+             */
+            return this.balance_height(iA);
         }
 
         // Apply the chosen rotation: re-wire one child↔grandchild pair, then

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { lsb_32 } from "../../binary/lsb_32.js";
+import { ctz32 } from "../../binary/ctz32.js";
 import { bitCount } from "../../binary/operations/bitCount.js";
 import { ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 
@@ -23,7 +23,7 @@ function assemble_mask(bvh, leaves, mask) {
     const leaf_count = bitCount(mask);
 
     if (leaf_count === 1) {
-        const leaf_index = lsb_32(mask);
+        const leaf_index = ctz32(mask);
         return leaves[leaf_index];
     }
 
@@ -90,7 +90,7 @@ function optimize_treelet(bvh, root, leaves, leaf_count) {
         if (is_a_leaf) {
             // --- CASE A: LEAF ---
             // Map the mask bit back to a linear index (0..7)
-            const leaf_index = lsb_32(s);
+            const leaf_index = ctz32(s);
 
             // Read from your compact linear array
             const node = leaves[leaf_index];

package/src/core/bvh8/bvh8_geometry_validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh8_geometry_validate.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_geometry_validate.js"],"names":[],"mappings":"AA4FA;;;;;;;;;;;;;GAaG;AACH,+DAHW,MAAM,EAAE,kBACR,MAAM,EAAE,QAiClB"}
+{"version":3,"file":"bvh8_geometry_validate.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_geometry_validate.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,+DAHW,MAAM,EAAE,kBACR,MAAM,EAAE,QAiClB"}

package/src/core/bvh8/bvh8_geometry_validate.js

@@ -1,95 +1,9 @@
 import { aabb3_round_to_float32 } from "./aabb3_round_to_float32.js";
-import { bitCount } from "../binary/operations/bitCount.js";
+import { bvh8_geometry_validate_bounds } from "./bvh8_geometry_validate_bounds.js";
 import { AABB3 } from "../geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../geom/3d/aabb/aabb3_from_v3_array.js";
 import { number_compare_ascending } from "../primitives/numbers/number_compare_ascending.js";
-import { aabb3_from_triangle_by_index } from "./build/aabb3_from_triangle_by_index.js";
 import { bvh8_collect_primitives } from "./bvh8_count_primitives.js";
-import { bvh8_get_node_child_bounds } from "./bvh8_get_node_child_bounds.js";
-
-
-/**
- *
- * @param {BVH8} bvh
- * @param {AABB3} root_bounds
- * @param {number[]} index_array
- * @param {number[]} position_array
- */
-function bvh8_geometry_validate_bounds(bvh, root_bounds, index_array, position_array) {
-    const child_aabb3 = new AABB3();
-    const triangle_aabb = new AABB3();
-
-    // (node index, bounds the node was reached through) pairs
-    const stack = [0, root_bounds];
-
-    while (stack.length > 0) {
-        const node_bounds = stack.pop();
-        const node = stack.pop();
-
-        const base_index_child = bvh.node_get_base_index_child(node);
-        const base_index_triangle = bvh.node_get_base_index_triangle(node);
-
-        const imask = bvh.node_get_imask(node);
-
-        // check triangles
-        for (let i = 0; i < 8; i++) {
-
-            if ((imask & (1 << i)) !== 0) {
-                // intermediate node
-                continue;
-            }
-
-            const meta = bvh.node_get_meta(node, i);
-
-
-            if (meta === 0) {
-                // empty
-                continue;
-            }
-
-            const triangle_count = bitCount((meta >> 5) & 0b111);
-
-            const triangle_offset = (meta & 0b00011111);
-
-            bvh8_get_node_child_bounds(child_aabb3, 0, bvh, node, i);
-
-
-            for (let j = 0; j < triangle_count; j++) {
-                const triangle_index = triangle_offset + base_index_triangle + j;
-
-                aabb3_from_triangle_by_index(triangle_aabb, 0, triangle_index, index_array, position_array);
-
-                // the tree stores bounds at float32 precision; validate at the same precision
-                // (round-to-nearest is exactly what Float32Array storage did on every build path)
-                aabb3_round_to_float32(triangle_aabb);
-
-                if (!child_aabb3.containsBox(triangle_aabb)) {
-                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates child bounds`);
-                }
-
-                if (!node_bounds.containsBox(triangle_aabb)) {
-                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates parent bounds`);
-                }
-            }
-
-
-        }
-
-        // queue intermediate children
-        let intermediate_index = 0;
-        for (let i = 0; i < 8; i++) {
-            if ((imask & (1 << i)) !== 0) {
-                // intermediate node
-                const child_bounds = new AABB3();
-                bvh8_get_node_child_bounds(child_bounds, 0, bvh, node, i);
-
-                stack.push(base_index_child + intermediate_index, child_bounds);
-                intermediate_index++;
-            }
-        }
-    }
-}
-
 /**
  * Validate a BVH8 against the geometry it was built for.
  *
@@ -134,5 +48,5 @@ export function bvh8_geometry_validate(bvh, index_array, position_array) {
     aabb3_round_to_float32(geometry_bounds);
 
     // check bounds
-    bvh8_geometry_validate_bounds(bvh, geometry_bounds, index_array, position_array);
+    bvh8_geometry_validate_bounds(bvh, geometry_bounds, index_array, position_array, null);
 }

package/src/core/bvh8/bvh8_geometry_validate_bounds.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Walk a BVH8 and check that every triangle a leaf slot claims fits inside that slot's quantized child
+ * bounds and inside the bounds the node was reached through.
+ *
+ * This is the only automated check that the BVH8 quantizer has not inverted or shrunk a child box, and
+ * both addressing conventions run it. It used to exist twice — the direct and the pool-indirect
+ * validators each carried a copy, identical apart from one expression — so every tightening of it had to
+ * be applied twice, and a miss would have silently stopped validating one of the two build paths with
+ * nothing to notice. `aabb3_round_to_float32`'s own header records that a previous round of the same
+ * duplication was factored out of these two files.
+ *
+ * @param {BVH8} bvh
+ * @param {AABB3} root_bounds
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ * @param {Uint32Array|null} primitive_pool `null` for the direct convention, where a slot's offsets are
+ * geometry triangle indices. For the indirect convention, the {@link BVH8#primitives} pool the offsets
+ * index into, whose entries are the geometry triangle indices.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bvh8_geometry_validate_bounds(bvh: BVH8, root_bounds: AABB3, index_array: number[], position_array: number[], primitive_pool: Uint32Array | null): void;
+import { AABB3 } from "../geom/3d/aabb/AABB3.js";
+//# sourceMappingURL=bvh8_geometry_validate_bounds.d.ts.map

package/src/core/bvh8/bvh8_geometry_validate_bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_geometry_validate_bounds.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_geometry_validate_bounds.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,sEAVW,KAAK,eACL,MAAM,EAAE,kBACR,MAAM,EAAE,kBACR,WAAW,GAAC,IAAI,QAmF1B;sBAvGqB,0BAA0B"}

package/src/core/bvh8/bvh8_geometry_validate_bounds.js

@@ -0,0 +1,105 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+import { AABB3 } from "../geom/3d/aabb/AABB3.js";
+import { aabb3_round_to_float32 } from "./aabb3_round_to_float32.js";
+import { aabb3_from_triangle_by_index } from "./build/aabb3_from_triangle_by_index.js";
+import { bvh8_get_node_child_bounds } from "./bvh8_get_node_child_bounds.js";
+
+/**
+ * Walk a BVH8 and check that every triangle a leaf slot claims fits inside that slot's quantized child
+ * bounds and inside the bounds the node was reached through.
+ *
+ * This is the only automated check that the BVH8 quantizer has not inverted or shrunk a child box, and
+ * both addressing conventions run it. It used to exist twice — the direct and the pool-indirect
+ * validators each carried a copy, identical apart from one expression — so every tightening of it had to
+ * be applied twice, and a miss would have silently stopped validating one of the two build paths with
+ * nothing to notice. `aabb3_round_to_float32`'s own header records that a previous round of the same
+ * duplication was factored out of these two files.
+ *
+ * @param {BVH8} bvh
+ * @param {AABB3} root_bounds
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ * @param {Uint32Array|null} primitive_pool `null` for the direct convention, where a slot's offsets are
+ * geometry triangle indices. For the indirect convention, the {@link BVH8#primitives} pool the offsets
+ * index into, whose entries are the geometry triangle indices.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bvh8_geometry_validate_bounds(bvh, root_bounds, index_array, position_array, primitive_pool) {
+    const child_aabb3 = new AABB3();
+    const triangle_aabb = new AABB3();
+
+    // (node index, bounds the node was reached through) pairs
+    const stack = [0, root_bounds];
+
+    while (stack.length > 0) {
+        const node_bounds = stack.pop();
+        const node = stack.pop();
+
+        const base_index_child = bvh.node_get_base_index_child(node);
+        const base_index_triangle = bvh.node_get_base_index_triangle(node);
+
+        const imask = bvh.node_get_imask(node);
+
+        // check triangles
+        for (let i = 0; i < 8; i++) {
+
+            if ((imask & (1 << i)) !== 0) {
+                // intermediate node
+                continue;
+            }
+
+            const meta = bvh.node_get_meta(node, i);
+
+
+            if (meta === 0) {
+                // empty
+                continue;
+            }
+
+            const triangle_count = bitCount((meta >> 5) & 0b111);
+
+            const triangle_offset = (meta & 0b00011111);
+
+            bvh8_get_node_child_bounds(child_aabb3, 0, bvh, node, i);
+
+
+            for (let j = 0; j < triangle_count; j++) {
+                const address = triangle_offset + base_index_triangle + j;
+
+                // the whole of the difference between the two conventions
+                const triangle_index = primitive_pool === null ? address : primitive_pool[address];
+
+                aabb3_from_triangle_by_index(triangle_aabb, 0, triangle_index, index_array, position_array);
+
+                // the tree stores bounds at float32 precision; validate at the same precision
+                // (round-to-nearest is exactly what Float32Array storage did on every build path)
+                aabb3_round_to_float32(triangle_aabb);
+
+                if (!child_aabb3.containsBox(triangle_aabb)) {
+                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates child bounds`);
+                }
+
+                if (!node_bounds.containsBox(triangle_aabb)) {
+                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates parent bounds`);
+                }
+            }
+
+
+        }
+
+        // queue intermediate children
+        let intermediate_index = 0;
+        for (let i = 0; i < 8; i++) {
+            if ((imask & (1 << i)) !== 0) {
+                // intermediate node
+                const child_bounds = new AABB3();
+                bvh8_get_node_child_bounds(child_bounds, 0, bvh, node, i);
+
+                stack.push(base_index_child + intermediate_index, child_bounds);
+                intermediate_index++;
+            }
+        }
+    }
+}

package/src/core/bvh8/bvh8_geometry_validate_indirect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh8_geometry_validate_indirect.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_geometry_validate_indirect.js"],"names":[],"mappings":"AA+FA;;;;;;;;;;;;;GAaG;AACH,wEAHW,MAAM,EAAE,kBACR,MAAM,EAAE,QA0DlB"}
+{"version":3,"file":"bvh8_geometry_validate_indirect.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_geometry_validate_indirect.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,wEAHW,MAAM,EAAE,kBACR,MAAM,EAAE,QA0DlB"}

package/src/core/bvh8/bvh8_geometry_validate_indirect.js

@@ -1,98 +1,9 @@
 import { aabb3_round_to_float32 } from "./aabb3_round_to_float32.js";
-import { bitCount } from "../binary/operations/bitCount.js";
+import { bvh8_geometry_validate_bounds } from "./bvh8_geometry_validate_bounds.js";
 import { AABB3 } from "../geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../geom/3d/aabb/aabb3_from_v3_array.js";
 import { number_compare_ascending } from "../primitives/numbers/number_compare_ascending.js";
-import { aabb3_from_triangle_by_index } from "./build/aabb3_from_triangle_by_index.js";
 import { bvh8_collect_primitives } from "./bvh8_count_primitives.js";
-import { bvh8_get_node_child_bounds } from "./bvh8_get_node_child_bounds.js";
-
-
-/**
- *
- * @param {BVH8} bvh
- * @param {AABB3} root_bounds
- * @param {number[]} index_array
- * @param {number[]} position_array
- */
-function bvh8_geometry_validate_bounds_indirect(bvh, root_bounds, index_array, position_array) {
-    const pool = bvh.primitives.data_uint32;
-
-    const child_aabb3 = new AABB3();
-    const triangle_aabb = new AABB3();
-
-    // (node index, bounds the node was reached through) pairs
-    const stack = [0, root_bounds];
-
-    while (stack.length > 0) {
-        const node_bounds = stack.pop();
-        const node = stack.pop();
-
-        const base_index_child = bvh.node_get_base_index_child(node);
-        const base_index_triangle = bvh.node_get_base_index_triangle(node);
-
-        const imask = bvh.node_get_imask(node);
-
-        // check triangles
-        for (let i = 0; i < 8; i++) {
-
-            if ((imask & (1 << i)) !== 0) {
-                // intermediate node
-                continue;
-            }
-
-            const meta = bvh.node_get_meta(node, i);
-
-
-            if (meta === 0) {
-                // empty
-                continue;
-            }
-
-            const triangle_count = bitCount((meta >> 5) & 0b111);
-
-            const triangle_offset = (meta & 0b00011111);
-
-            bvh8_get_node_child_bounds(child_aabb3, 0, bvh, node, i);
-
-
-            for (let j = 0; j < triangle_count; j++) {
-                // resolve through the primitive pool
-                const triangle_index = pool[triangle_offset + base_index_triangle + j];
-
-                aabb3_from_triangle_by_index(triangle_aabb, 0, triangle_index, index_array, position_array);
-
-                // the tree stores bounds at float32 precision; validate at the same precision
-                // (round-to-nearest is exactly what Float32Array storage did on every build path)
-                aabb3_round_to_float32(triangle_aabb);
-
-                if (!child_aabb3.containsBox(triangle_aabb)) {
-                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates child bounds`);
-                }
-
-                if (!node_bounds.containsBox(triangle_aabb)) {
-                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates parent bounds`);
-                }
-            }
-
-
-        }
-
-        // queue intermediate children
-        let intermediate_index = 0;
-        for (let i = 0; i < 8; i++) {
-            if ((imask & (1 << i)) !== 0) {
-                // intermediate node
-                const child_bounds = new AABB3();
-                bvh8_get_node_child_bounds(child_bounds, 0, bvh, node, i);
-
-                stack.push(base_index_child + intermediate_index, child_bounds);
-                intermediate_index++;
-            }
-        }
-    }
-}
-
 /**
  * Validate a BVH8 against the geometry it was built for.
  *
@@ -162,5 +73,5 @@ export function bvh8_geometry_validate_indirect(bvh, index_array, position_array
     aabb3_round_to_float32(geometry_bounds);
 
     // check bounds
-    bvh8_geometry_validate_bounds_indirect(bvh, geometry_bounds, index_array, position_array);
+    bvh8_geometry_validate_bounds(bvh, geometry_bounds, index_array, position_array, bvh.primitives.data_uint32);
 }

package/src/core/cache/FrequencySketch.d.ts

@@ -56,7 +56,9 @@ export class FrequencySketch<T> {
     /**
      * Initializes and increases the capacity of this <tt>FrequencySketch</tt> instance, if necessary,
      * to ensure that it can accurately estimate the popularity of elements given the maximum size of
-     * the cache. This operation forgets all previous counts when resizing.
+     * the cache. This operation forgets all previous counts when resizing, so callers that care about
+     * the history — all of them — must size the sketch before they start counting rather than growing
+     * it as they go.
      *
      * @param {number} maximumSize the maximum size of the cache
      */

package/src/core/cache/FrequencySketch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrequencySketch.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/FrequencySketch.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,CAED;IACf;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IACb;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,4BAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,oBAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;OAOG;IACH,sBAFW,MAAM,QAwBhB;IAED;;OAEG;IACH,cAaC;CACJ"}
+{"version":3,"file":"FrequencySketch.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/FrequencySketch.js"],"names":[],"mappings":"AA0EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,CAED;IACf;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IACb;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,oBAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;OAOG;IACH,sBAFW,MAAM,QAwBhB;IAED;;OAEG;IACH,cAaC;CACJ"}

package/src/core/cache/FrequencySketch.js

@@ -27,8 +27,11 @@ const MAX_INT_32 = 2147483647;
 function spread(v) {
     let x = v;
 
-    x = ((x >>> 16) ^ x) * 0x45d9f3b;
-    x = ((x >>> 16) ^ x) * 0x45d9f3b;
+    //`Math.imul` and not `*`: both operands are ~2^31, and the double product lands around 2^62,
+    //nine orders past the exact-integer limit. The bits that get rounded away are the low ones,
+    //which are exactly the bits `indexOf` then masks off — see COR-002.
+    x = Math.imul((x >>> 16) ^ x, 0x45d9f3b);
+    x = Math.imul((x >>> 16) ^ x, 0x45d9f3b);
 
     return (x >>> 16) ^ x;
 }
@@ -41,7 +44,8 @@ function spread(v) {
  * @returns {number} the table index
  */
 function indexOf(item, i, tableMask) {
-    let hash = (item + SEED[i]) * SEED[i];
+    //Caffeine's original is `int` arithmetic that wraps at 32 bits; `Math.imul` is what wraps here.
+    let hash = Math.imul(item + SEED[i], SEED[i]);
     hash += (hash >>> 16);
 
     return hash & tableMask;
@@ -127,7 +131,9 @@ export class FrequencySketch {
     /**
      * Initializes and increases the capacity of this <tt>FrequencySketch</tt> instance, if necessary,
      * to ensure that it can accurately estimate the popularity of elements given the maximum size of
-     * the cache. This operation forgets all previous counts when resizing.
+     * the cache. This operation forgets all previous counts when resizing, so callers that care about
+     * the history — all of them — must size the sketch before they start counting rather than growing
+     * it as they go.
      *
      * @param {number} maximumSize the maximum size of the cache
      */

package/src/core/cache/wtinylfu/CacheWTinylfu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CacheWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheWTinylfu.js"],"names":[],"mappings":"AAiDA;IA0FI;;;;;;;;;;;OAWG;IACH;QAT4B,SAAS,GAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACyB,UAAU,GAAzC,CAAC,GAAG,KAAK,KAAK,MAAM;QACe,YAAY,GAA/C,CAAC,KAAK,OAAO,KAAK,MAAM;QACO,eAAe,kBAAhC,MAAM;QACiB,mBAAmB,6BAArC,OAAO;OAwDpC;IA3FD;;;OAGG;IACH,OAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,YAFU,MAAM,CAEU;IAsE1B;;;;OAIG;IACH,gBAGC;IAED;;;;OAIG;IACH,mBAcC;IACD;;;;OAIG;IACH,wBAsBC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,mCAEC;IAED;;;;;;;OAOG;IACH,wBAEC;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAUnB;IAED;;;OAGG;IACH,cASC;IAED;;;;;;OAMG;IACH,+BAUC;IAED;;;;OAIG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAIC;IAED;;;;;;;OAOG;IACH,8BAmBC;IAED;;;;;;;OAOG;IACH,0BAeC;IAED;;;;;;;OAOG;IACH,2BAwBC;IAED;;;;;;OAMG;IACH,sBAkCC;IAED;;;;OAIG;IACH,sBAGC;IAED;;;;;;OAMG;IACH,gBAQC;IAED;;;;;;;OAOG;IACH,gBASC;IAoBD;;;;OAIG;IACH,mBAOC;IAED;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;OAKG;IACH,8BAMC;IAED;;;;;;;OAOG;IACH,gCAcC;IAED;;;;OAIG;IACH,2BASC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;;OAKG;IACH,yBAmBC;IAED;;;;OAIG;IACH,kCAkBC;IAED;;;;OAIG;IACH,eAFa,QAAM,IAAI,CAWtB;IAID;;;;;OAKG;IACH,yBAFa,eAAe,GAAC,IAAI,CAKhC;IAED;;;OAGG;IACH,kBAFa;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAQ9D;;CACJ;uBA/vBoB,+BAA+B;gCARtB,sBAAsB"}
+{"version":3,"file":"CacheWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheWTinylfu.js"],"names":[],"mappings":"AA0DA;IA0FI;;;;;;;;;;;OAWG;IACH;QAT4B,SAAS,GAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACyB,UAAU,GAAzC,CAAC,GAAG,KAAK,KAAK,MAAM;QACe,YAAY,GAA/C,CAAC,KAAK,OAAO,KAAK,MAAM;QACO,eAAe,kBAAhC,MAAM;QACiB,mBAAmB,6BAArC,OAAO;OAqEpC;IAxGD;;;OAGG;IACH,OAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,YAFU,MAAM,CAEU;IAmF1B;;;;OAIG;IACH,gBAGC;IAED;;;;OAIG;IACH,mBAcC;IACD;;;;OAIG;IACH,wBAsBC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,mCAEC;IAED;;;;;;;OAOG;IACH,wBAEC;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAUnB;IAED;;;OAGG;IACH,cASC;IAED;;;;;;OAMG;IACH,+BAUC;IAED;;;;OAIG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAIC;IAED;;;;;;;OAOG;IACH,8BAmBC;IAED;;;;;;;OAOG;IACH,0BAeC;IAED;;;;;;;OAOG;IACH,2BAwBC;IAED;;;;;;OAMG;IACH,sBAkCC;IAED;;;;OAIG;IACH,sBAGC;IAED;;;;;;OAMG;IACH,gBAQC;IAED;;;;;;;OAOG;IACH,gBASC;IAoBD;;;;OAIG;IACH,mBAOC;IAED;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;OAKG;IACH,8BAMC;IAED;;;;;;;OAOG;IACH,gCAcC;IAED;;;;OAIG;IACH,2BASC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;;OAKG;IACH,yBAmBC;IAED;;;;OAIG;IACH,kCAkBC;IAED;;;;OAIG;IACH,eAFa,QAAM,IAAI,CAWtB;IAID;;;;;OAKG;IACH,yBAFa,eAAe,GAAC,IAAI,CAKhC;IAED;;;OAGG;IACH,kBAFa;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAQ9D;;CACJ;uBArxBoB,+BAA+B;gCARtB,sBAAsB"}