@woosh/meep-engine 2.155.0 → 2.157.0

package/src/core/bvh8/bvh8_get_node_child_bounds.js

@@ -0,0 +1,53 @@
+import { assert } from "../assert.js";
+import { reinterpret_uint32_as_float32 } from "../binary/reinterpret_uint32_as_float32.js";
+import { aabb3_array_set } from "../geom/3d/aabb/aabb3_array_set.js";
+
+const scratch_f32 = new Float32Array(6);
+
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {number} child
+ */
+export function bvh8_get_node_child_bounds(out, out_offset, bvh, node, child) {
+    assert.isNonNegativeInteger(node, 'node');
+    assert.isNonNegativeInteger(child, 'child');
+
+    bvh.node_get_p(node, scratch_f32);
+
+    const p_x = scratch_f32[0];
+    const p_y = scratch_f32[1];
+    const p_z = scratch_f32[2];
+
+    // read out exponent
+    bvh.node_get_e(node, scratch_f32);
+
+    const e_x = scratch_f32[0];
+    const e_y = scratch_f32[1];
+    const e_z = scratch_f32[2];
+
+    const scale_x = reinterpret_uint32_as_float32(e_x << 23);
+    const scale_y = reinterpret_uint32_as_float32(e_y << 23);
+    const scale_z = reinterpret_uint32_as_float32(e_z << 23);
+
+    bvh.node_get_quantized_min(node, child, scratch_f32);
+
+    const q_low_x = scratch_f32[0];
+    const q_low_y = scratch_f32[1];
+    const q_low_z = scratch_f32[2];
+
+    bvh.node_get_quantized_max(node, child, scratch_f32);
+
+    const q_high_x = scratch_f32[0];
+    const q_high_y = scratch_f32[1];
+    const q_high_z = scratch_f32[2];
+
+    aabb3_array_set(
+        out, out_offset,
+        q_low_x * scale_x + p_x, q_low_y * scale_y + p_y, q_low_z * scale_z + p_z,
+        q_high_x * scale_x + p_x, q_high_y * scale_y + p_y, q_high_z * scale_z + p_z
+    );
+}

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

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {number} child
+ * @returns {number}
+ */
+export function bvh8_node_child_surface_area(bvh: BVH8, node: number, child: number): number;
+//# sourceMappingURL=bvh8_node_child_surface_area.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_node_child_surface_area.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_node_child_surface_area.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,8DAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAMlB"}

package/src/core/bvh8/bvh8_node_child_surface_area.js

@@ -0,0 +1,18 @@
+import { aabb3_compute_surface_area } from "../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { bvh8_get_node_child_bounds } from "./bvh8_get_node_child_bounds.js";
+
+const scratch_f32 = new Float32Array(6);
+
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {number} child
+ * @returns {number}
+ */
+export function bvh8_node_child_surface_area(bvh, node, child) {
+    bvh8_get_node_child_bounds(scratch_f32, 0, bvh, node, child);
+
+    return aabb3_compute_surface_area(...scratch_f32);
+}
+

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

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @returns {number} number of triangles under this node
+ */
+export function bvh8_node_count_triangles(bvh: BVH8, node: number): number;
+//# sourceMappingURL=bvh8_node_count_triangles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_node_count_triangles.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_node_count_triangles.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2DAHW,MAAM,GACJ,MAAM,CAqBlB"}

package/src/core/bvh8/bvh8_node_count_triangles.js

@@ -0,0 +1,28 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @returns {number} number of triangles under this node
+ */
+export function bvh8_node_count_triangles(bvh, node) {
+    let result = 0;
+
+    const imask = bvh.node_get_imask(node);
+
+    for (let i = 0; i < 8; i++) {
+        if ((imask & (1 << i)) !== 0) {
+            // intermediate node
+            continue;
+        }
+
+        const meta = bvh.node_get_meta(node, i);
+
+        const triangles = bitCount(meta & 0b11100000);
+
+        result += triangles;
+    }
+
+    return result;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * We compute surface area heuristic (SAH) over the entire (sub-)tree
+ * @param {BVH8} bvh
+ * @param {number} [root]
+ * @returns {number} Lower = better
+ */
+export function bvh8_quality(bvh: BVH8, root?: number): number;
+//# sourceMappingURL=bvh8_quality.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_quality.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_quality.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,+CAHW,MAAM,GACJ,MAAM,CA+DlB"}

package/src/core/bvh8/bvh8_quality.js

@@ -0,0 +1,73 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+import { aabb3_compute_surface_area } from "../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { bvh8_get_node_bounds } from "./bvh8_get_node_bounds.js";
+import { bvh8_node_child_surface_area } from "./bvh8_node_child_surface_area.js";
+
+/**
+ * We compute surface area heuristic (SAH) over the entire (sub-)tree
+ * @param {BVH8} bvh
+ * @param {number} [root]
+ * @returns {number} Lower = better
+ */
+export function bvh8_quality(bvh, root = 0) {
+    const stack = [root];
+    let node_count = 0;
+
+    // cost of traversing an intermediate node
+    const COST_INTERMEDIATE = 1.2;
+    // cost of traversing a leaf node
+    const COST_LEAF = 0.1;
+    // cost of performing ray/triangle test
+    const COST_TRIANGLE = 1;
+
+    const root_bounds = new Float32Array(6);
+    bvh8_get_node_bounds(root_bounds, 0, bvh, root);
+    const root_area = aabb3_compute_surface_area(...root_bounds);
+
+    if (root_area === 0) {
+        return 1;
+    }
+
+    let sum_area_node = 0;
+    let sum_triangle_cost = 0;
+    let sum_area_leaf = 0;
+
+    while (stack.length > 0) {
+        const node = stack.pop();
+
+        node_count++;
+
+        const imask = bvh.node_get_imask(node);
+
+        const offset = bvh.node_get_base_index_child(node);
+
+        let child_count = 0;
+        for (let i = 0; i < 8; i++) {
+
+            const child_area = bvh8_node_child_surface_area(bvh, node, i);
+
+            if ((imask & (1 << i)) !== 0) {
+                // intermediate
+                sum_area_node += child_area;
+
+                stack.push(offset + child_count);
+                child_count++;
+            } else {
+
+                const meta = bvh.node_get_meta(node, i);
+
+                if (meta === 0) {
+                    // empty
+                    continue;
+                }
+
+                const triangle_count = bitCount(meta & 0b11100000);
+
+                sum_triangle_cost += (child_area * triangle_count)
+                sum_area_leaf += child_area;
+            }
+        }
+    }
+
+    return (COST_INTERMEDIATE * sum_area_node + COST_LEAF * sum_area_leaf + COST_TRIANGLE * sum_triangle_cost) / root_area;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Validate structural invariants of a BVH8, independent of any geometry:
+ *
+ * - every internal slot (imask bit set) stores exactly `(24 + slot) | 0b00100000` in its meta
+ * - every leaf slot stores a triangle offset ≤ 23 (≥ 24 would be misread as an internal slot)
+ *   and a unary triangle count mask (0b001, 0b011 or 0b111)
+ * - internal child blocks lie within the node pool
+ * - every allocated node is reachable from the root exactly once
+ *
+ * Throws an Error describing the first violation found.
+ *
+ * @param {BVH8} bvh
+ */
+export function bvh8_validate_structure(bvh: BVH8): void;
+//# sourceMappingURL=bvh8_validate_structure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_validate_structure.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_validate_structure.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,yDAuEC"}

package/src/core/bvh8/bvh8_validate_structure.js

@@ -0,0 +1,87 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+
+/**
+ * Validate structural invariants of a BVH8, independent of any geometry:
+ *
+ * - every internal slot (imask bit set) stores exactly `(24 + slot) | 0b00100000` in its meta
+ * - every leaf slot stores a triangle offset ≤ 23 (≥ 24 would be misread as an internal slot)
+ *   and a unary triangle count mask (0b001, 0b011 or 0b111)
+ * - internal child blocks lie within the node pool
+ * - every allocated node is reachable from the root exactly once
+ *
+ * Throws an Error describing the first violation found.
+ *
+ * @param {BVH8} bvh
+ */
+export function bvh8_validate_structure(bvh) {
+    const node_count = bvh.nodes.size;
+
+    if (node_count === 0) {
+        // empty tree
+        return;
+    }
+
+    const visited = new Uint8Array(node_count);
+    let visited_count = 0;
+
+    const stack = [0];
+
+    while (stack.length > 0) {
+        const node = stack.pop();
+
+        if (node >= node_count) {
+            throw new Error(`node index ${node} is out of range [0, ${node_count})`);
+        }
+
+        if (visited[node] !== 0) {
+            throw new Error(`node ${node} is reachable more than once`);
+        }
+
+        visited[node] = 1;
+        visited_count++;
+
+        const imask = bvh.node_get_imask(node);
+        const base_index_child = bvh.node_get_base_index_child(node);
+
+        const internal_count = bitCount(imask);
+
+        if (internal_count > 0 && base_index_child + internal_count > node_count) {
+            throw new Error(`node ${node}: child block [${base_index_child}, ${base_index_child + internal_count}) exceeds node pool size ${node_count}`);
+        }
+
+        let intermediate_count = 0;
+
+        for (let i = 0; i < 8; i++) {
+            const meta = bvh.node_get_meta(node, i);
+
+            if ((imask & (1 << i)) !== 0) {
+                // internal slot
+                const expected = (24 + i) | 0b00100000;
+
+                if (meta !== expected) {
+                    throw new Error(`node ${node} slot ${i}: internal slot meta is ${meta}, expected ${expected}`);
+                }
+
+                stack.push(base_index_child + intermediate_count);
+                intermediate_count++;
+
+            } else if (meta !== 0) {
+                // leaf slot
+                const triangle_offset = meta & 0b11111;
+                const unary_count = (meta >> 5) & 0b111;
+
+                if (triangle_offset > 23) {
+                    throw new Error(`node ${node} slot ${i}: leaf triangle offset ${triangle_offset} > 23 collides with the internal slot encoding`);
+                }
+
+                if (unary_count !== 0b001 && unary_count !== 0b011 && unary_count !== 0b111) {
+                    throw new Error(`node ${node} slot ${i}: triangle count mask ${unary_count.toString(2)} is not unary`);
+                }
+            }
+        }
+    }
+
+    if (visited_count !== node_count) {
+        throw new Error(`${node_count - visited_count} allocated node(s) are not reachable from the root`);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAgBI;;;;;;;;;;OAUG;IACH,sGARW,MAAM,EA2FhB;IAzDG;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,gBAAmB;IACnB;;;;OAIG;IACH,eAAkB;IAGlB;;;;OAIG;IACH,aAIE;IAEF;;;;OAIG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,OAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEF;IAG7B;;;;;OAKG;IACH,kBAyBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,2BAeC;IAED,wBAEC;IAED;;;;OAIG;IACH,wBAaC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAkBnB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QAwEf;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;;;OAIG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,wCAFa,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA9FiB,OAAO,CA8FF;IAEtB;;;OAGG;IACH,4BAhLiB,OAAO,CAgLL;;CAlBlB;mBAtkBkB,4BAA4B;6BAKlB,mBAAmB"}
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAgBI;;;;;;;;;;OAUG;IACH,sGARW,MAAM,EA2FhB;IAzDG;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,gBAAmB;IACnB;;;;OAIG;IACH,eAAkB;IAGlB;;;;OAIG;IACH,aAIE;IAEF;;;;OAIG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,OAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEF;IAG7B;;;;;OAKG;IACH,kBAyBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,2BAeC;IAED,wBAEC;IAED;;;;OAIG;IACH,wBAaC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAkBnB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QA+Ef;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;;;OAIG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,wCAFa,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA9FiB,OAAO,CA8FF;IAEtB;;;OAGG;IACH,4BAhLiB,OAAO,CAgLL;;CAlBlB;mBA7kBkB,4BAA4B;6BAKlB,mBAAmB"}

package/src/core/cache/Cache.js

@@ -417,6 +417,13 @@ export class Cache {
 
             // element inserted again, promote it to the front of the access queue
             this.__promote(element);
+
+            // Replacing a key's value with a heavier one can push total weight over capacity; trim back down.
+            // The element was just promoted to the front (most-recently-used), so evictUntilWeight (which evicts
+            // from the LRU tail) won't evict it unless it alone exceeds maxWeight.
+            if (this.#weight > this.#maxWeight && element.weight <= this.#maxWeight) {
+                this.evictUntilWeight(this.#maxWeight);
+            }
         }
 
         this.onSet.send2(key, value);

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":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CAclB;IAED;;;;;;;OAOG;IACH,sBAFW,MAAM,QAoBhB;IAED;;;;;;OAMG;IACH,eAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAgBnB;IAED;;OAEG;IACH,cAaC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,MAAM,CASlB;CACJ"}
+{"version":3,"file":"FrequencySketch.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/FrequencySketch.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CAclB;IAED;;;;;;;OAOG;IACH,sBAFW,MAAM,QAwBhB;IAED;;;;;;OAMG;IACH,eAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAgBnB;IAED;;OAEG;IACH,cAaC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,MAAM,CASlB;CACJ"}

package/src/core/cache/FrequencySketch.js

@@ -152,10 +152,14 @@ export class FrequencySketch {
         const index2 = this.indexOf(hash, 2);
         const index3 = this.indexOf(hash, 3);
 
-        const added = this.incrementAt(index0, start)
-            || this.incrementAt(index1, start + 1)
-            || this.incrementAt(index2, start + 2)
-            || this.incrementAt(index3, start + 3);
+        // Evaluate all four counters unconditionally; `||` would short-circuit and skip the remaining
+        // increments as soon as the first one returned true, so only one of the four counters would ever advance.
+        const added0 = this.incrementAt(index0, start);
+        const added1 = this.incrementAt(index1, start + 1);
+        const added2 = this.incrementAt(index2, start + 2);
+        const added3 = this.incrementAt(index3, start + 3);
+
+        const added = added0 || added1 || added2 || added3;
 
         if (added && (++this.size === this.sampleSize)) {
             this.reset();

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

@@ -0,0 +1,6 @@
+/**
+ * Resolves the platform clipboard, verifying read/write permissions are granted when necessary.
+ * @returns {Promise<Clipboard>}
+ */
+export function obtainClipBoard(): Promise<Clipboard>;
+//# sourceMappingURL=obtainClipBoard.d.ts.map

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

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

package/src/core/clipboard/obtainClipBoard.js

@@ -0,0 +1,29 @@
+/**
+ * Resolves the platform clipboard, verifying read/write permissions are granted when necessary.
+ * @returns {Promise<Clipboard>}
+ */
+export async function obtainClipBoard() {
+    const navigator = globalThis.navigator;
+
+    if (navigator.clipboard === undefined) {
+        const queries = [{
+            name: "clipboard-read"
+        }, {
+            name: "clipboard-write"
+        }];
+
+        const permission_queries = queries.map(q => navigator.permissions.query(q));
+
+        const statuses = await Promise.all(permission_queries);
+
+        for (let i = 0; i < statuses.length; i++) {
+            const permissionStatus = statuses[i];
+
+            if (permissionStatus.state !== "granted") {
+                throw new Error(`Permission for query not granted (actual state = ${permissionStatus.state}). Query:${JSON.stringify(queries[i])}`)
+            }
+        }
+    }
+
+    return navigator.clipboard;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Reads text from the clipboard, falling back to a file picker prompt when no clipboard is available.
+ * @returns {Promise<string>}
+ */
+export function safeClipboardReadText(): Promise<string>;
+//# sourceMappingURL=safeClipboardReadText.d.ts.map

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

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

package/src/core/clipboard/safeClipboardReadText.js

@@ -0,0 +1,55 @@
+import { obtainClipBoard } from "./obtainClipBoard.js";
+
+/**
+ * Reads text from the clipboard, falling back to a file picker prompt when no clipboard is available.
+ * @returns {Promise<string>}
+ */
+export async function safeClipboardReadText() {
+
+    return obtainClipBoard().then(() => {
+
+        const navigator = globalThis.navigator;
+        return navigator.clipboard.readText();
+    }, () => {
+        // clipboard not available
+        console.log(`No clipboard available, using a prompt instead`);
+
+        function clickElem(elem) {
+            // Thx user1601638 on Stack Overflow (6/6/2018 - https://stackoverflow.com/questions/13405129/javascript-create-and-save-file )
+            var eventMouse = document.createEvent("MouseEvents")
+            eventMouse.initMouseEvent("click", true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null)
+            elem.dispatchEvent(eventMouse)
+        }
+
+        function openFile(func) {
+            const fileInput = document.createElement("input");
+
+            const readFile = function (e) {
+                var file = e.target.files[0];
+                if (!file) {
+                    return;
+                }
+                var reader = new FileReader();
+                reader.onload = function (e) {
+                    var contents = e.target.result;
+                    fileInput.func(contents)
+                    document.body.removeChild(fileInput)
+                }
+                reader.readAsText(file)
+            }
+            fileInput.type = 'file'
+            fileInput.style.display = 'none'
+            fileInput.onchange = readFile
+            fileInput.func = func
+            document.body.appendChild(fileInput)
+            clickElem(fileInput)
+        }
+
+        return new Promise((resolve, reject) => {
+            openFile(resolve);
+        });
+
+
+    });
+
+}

package/src/core/clipboard/safeClipboardWriteText.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Writes text to the clipboard, falling back to a file download when no clipboard is available.
+ * @param {string} text
+ * @param {string} [data_name]
+ * @returns {Promise<void>}
+ */
+export function safeClipboardWriteText(text: string, data_name?: string): Promise<void>;
+//# sourceMappingURL=safeClipboardWriteText.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"safeClipboardWriteText.d.ts","sourceRoot":"","sources":["../../../../src/core/clipboard/safeClipboardWriteText.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6CAJW,MAAM,cACN,MAAM,GACJ,QAAQ,IAAI,CAAC,CAezB"}

package/src/core/clipboard/safeClipboardWriteText.js

@@ -0,0 +1,23 @@
+import { obtainClipBoard } from "./obtainClipBoard.js";
+import { downloadAsFile } from "../binary/downloadAsFile.js";
+
+/**
+ * Writes text to the clipboard, falling back to a file download when no clipboard is available.
+ * @param {string} text
+ * @param {string} [data_name]
+ * @returns {Promise<void>}
+ */
+export async function safeClipboardWriteText(text, data_name = "data") {
+
+    return obtainClipBoard().then(
+        () => {
+            const navigator = globalThis.navigator;
+            return navigator.clipboard.writeText(text);
+        },
+        () => {
+            // no clipboard available
+            console.log(`No clipboard available, downloading instead`);
+            downloadAsFile(text, `${data_name}.json`);
+        }
+    );
+}

package/src/core/collection/Uint32MinHeap.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Binary min-heap of uint32 values backed by a flat `Uint32Array`.
+ *
+ * Built for deterministic id-recycling free lists: {@link pop} always
+ * returns the SMALLEST stored value, so two pools given the same
+ * allocate/free sequence reuse identical ids regardless of how the calls
+ * interleaved — the property the physics `BodyStorage` / `ManifoldStore`
+ * free lists are built on (each previously carried a byte-identical
+ * private copy of this heap). Values are expected unique (they are slot
+ * ids); duplicates are not rejected but make pop order between the
+ * duplicates unspecified.
+ *
+ * Grows by doubling on push; never shrinks. Not a hot-path structure —
+ * pushes/pops happen at allocate/release time, not per-iteration.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Uint32MinHeap {
+    /**
+     * @param {number} [initial_capacity]
+     */
+    constructor(initial_capacity?: number);
+    /**
+     * @private
+     * @type {Uint32Array}
+     */
+    private __data;
+    /**
+     * @private
+     * @type {number}
+     */
+    private __count;
+    /**
+     * Number of stored values.
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * Remove every value. Capacity is retained.
+     */
+    clear(): void;
+    /**
+     * Insert a value.
+     * @param {number} v
+     */
+    push(v: number): void;
+    /**
+     * Remove and return the smallest value. Caller guarantees non-empty
+     * (the free-list usage always checks `size` first); popping an empty
+     * heap returns stale storage.
+     * @returns {number}
+     */
+    pop(): number;
+}
+//# sourceMappingURL=Uint32MinHeap.d.ts.map

package/src/core/collection/Uint32MinHeap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint32MinHeap.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/Uint32MinHeap.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;OAEG;IACH,+BAFW,MAAM,EAchB;IAXG;;;OAGG;IACH,eAA4D;IAE5D;;;OAGG;IACH,gBAAgB;IAGpB;;;OAGG;IACH,mBAEC;IAED;;OAEG;IACH,cAEC;IAED;;;OAGG;IACH,QAFW,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,OAFa,MAAM,CAuBlB;CACJ"}