@woosh/meep-engine 3.30.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/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/clipboard/obtainClipBoard.d.ts

@@ -1,5 +1,9 @@
 /**
  * Resolves the platform clipboard, verifying read/write permissions are granted when necessary.
+ *
+ * Rejects when there is no clipboard. Callers such as {@link safeClipboardReadText} key their
+ * fallback off that rejection, so this must never resolve with a missing clipboard.
+ *
  * @returns {Promise<Clipboard>}
  */
 export function obtainClipBoard(): Promise<Clipboard>;

package/src/core/clipboard/obtainClipBoard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"obtainClipBoard.d.ts","sourceRoot":"","sources":["../../../../src/core/clipboard/obtainClipBoard.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,mCAFa,QAAQ,SAAS,CAAC,CA0B9B"}
+{"version":3,"file":"obtainClipBoard.d.ts","sourceRoot":"","sources":["../../../../src/core/clipboard/obtainClipBoard.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,mCAFa,QAAQ,SAAS,CAAC,CA2C9B"}

package/src/core/clipboard/obtainClipBoard.js

@@ -1,29 +1,50 @@
 /**
  * Resolves the platform clipboard, verifying read/write permissions are granted when necessary.
+ *
+ * Rejects when there is no clipboard. Callers such as {@link safeClipboardReadText} key their
+ * fallback off that rejection, so this must never resolve with a missing clipboard.
+ *
  * @returns {Promise<Clipboard>}
  */
 export async function obtainClipBoard() {
     const navigator = globalThis.navigator;
 
-    if (navigator.clipboard === undefined) {
+    const clipboard = navigator.clipboard;
+
+    if (clipboard === undefined) {
+        throw new Error("Clipboard is not available on this platform");
+    }
+
+    const permissions = navigator.permissions;
+
+    if (permissions !== undefined) {
         const queries = [{
             name: "clipboard-read"
         }, {
             name: "clipboard-write"
         }];
 
-        const permission_queries = queries.map(q => navigator.permissions.query(q));
+        for (let i = 0; i < queries.length; i++) {
+            const query = queries[i];
 
-        const statuses = await Promise.all(permission_queries);
+            let permissionStatus;
 
-        for (let i = 0; i < statuses.length; i++) {
-            const permissionStatus = statuses[i];
+            try {
+                permissionStatus = await permissions.query(query);
+            } catch (e) {
+                // Not every engine knows these permission names - Firefox throws for
+                // "clipboard-read". An unknown name is not a denial, so carry on and let the
+                // clipboard API itself decide.
+                continue;
+            }
 
-            if (permissionStatus.state !== "granted") {
-                throw new Error(`Permission for query not granted (actual state = ${permissionStatus.state}). Query:${JSON.stringify(queries[i])}`)
+            // "prompt" is not a refusal either; the clipboard call raises the browser's own prompt.
+            // Only an explicit denial is worth failing early for.
+            if (permissionStatus.state === "denied") {
+                throw new Error(`Permission for query not granted (actual state = ${permissionStatus.state}). Query:${JSON.stringify(query)}`)
             }
         }
     }
 
-    return navigator.clipboard;
+    return clipboard;
 }

package/src/core/clipboard/safeClipboardReadText.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safeClipboardReadText.d.ts","sourceRoot":"","sources":["../../../../src/core/clipboard/safeClipboardReadText.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,yCAFa,QAAQ,MAAM,CAAC,CAkD3B"}
+{"version":3,"file":"safeClipboardReadText.d.ts","sourceRoot":"","sources":["../../../../src/core/clipboard/safeClipboardReadText.js"],"names":[],"mappings":"AAqEA;;;GAGG;AACH,yCAFa,QAAQ,MAAM,CAAC,CAkB3B"}