@woosh/meep-engine 2.155.0 → 2.157.0

package/src/core/collection/Uint32MinHeap.js

@@ -0,0 +1,109 @@
+/**
+ * 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 = 16) {
+        /**
+         * @private
+         * @type {Uint32Array}
+         */
+        this.__data = new Uint32Array(Math.max(1, initial_capacity));
+
+        /**
+         * @private
+         * @type {number}
+         */
+        this.__count = 0;
+    }
+
+    /**
+     * Number of stored values.
+     * @returns {number}
+     */
+    get size() {
+        return this.__count;
+    }
+
+    /**
+     * Remove every value. Capacity is retained.
+     */
+    clear() {
+        this.__count = 0;
+    }
+
+    /**
+     * Insert a value.
+     * @param {number} v
+     */
+    push(v) {
+        let heap = this.__data;
+        if (this.__count === heap.length) {
+            const next = new Uint32Array(heap.length << 1);
+            next.set(heap);
+            this.__data = next;
+            heap = next;
+        }
+
+        let i = this.__count++;
+        heap[i] = v;
+        while (i > 0) {
+            const parent = (i - 1) >>> 1;
+            if (heap[parent] > heap[i]) {
+                const tmp = heap[parent];
+                heap[parent] = heap[i];
+                heap[i] = tmp;
+                i = parent;
+            } else {
+                break;
+            }
+        }
+    }
+
+    /**
+     * 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() {
+        const heap = this.__data;
+        const result = heap[0];
+        const new_count = --this.__count;
+        if (new_count > 0) {
+            heap[0] = heap[new_count];
+            let i = 0;
+            for (;;) {
+                const l = (i << 1) + 1;
+                const r = l + 1;
+                let smallest = i;
+                if (l < new_count && heap[l] < heap[smallest]) smallest = l;
+                if (r < new_count && heap[r] < heap[smallest]) smallest = r;
+                if (smallest === i) break;
+                const tmp = heap[i];
+                heap[i] = heap[smallest];
+                heap[smallest] = tmp;
+                i = smallest;
+            }
+        }
+        return result;
+    }
+}

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

@@ -19,7 +19,7 @@ export function array_quick_sort_by_lookup_map(
         return;
     }
 
-    const stack_frame = start.pointer;
+    const stack_frame = stack.pointer;
     let stackPointer = stack_frame;
 
     let i, j;

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

@@ -1 +1 @@
-{"version":3,"file":"array_set_diff_sorting.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_set_diff_sorting.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;;;;EAsDC"}
+{"version":3,"file":"array_set_diff_sorting.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_set_diff_sorting.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;;;;EAyDC"}

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

@@ -44,11 +44,14 @@ export function array_set_diff_sorting(a, b, compare) {
                 uniqueB.splice(j, 1);
 
                 i--;
-                j--;
 
                 length_a--;
                 length_b--;
 
+                // exactly one A and one B element are consumed per match; stop matching this A element so a
+                // single A cannot pair with multiple equal B elements (which corrupted the diff on duplicates)
+                break;
+
             } else if (diff > 0) {
                 cursor_j++;
             } else {

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

@@ -1 +1 @@
-{"version":3,"file":"array_shuffle.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_shuffle.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,+CAJsB,MAAM,uBAEjB,MAAM,QAYhB"}
+{"version":3,"file":"array_shuffle.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_shuffle.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,+CAJsB,MAAM,uBAEjB,MAAM,QAehB"}

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

@@ -1,27 +1,30 @@
-import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
-import { array_swap_one } from "./array_swap_one.js";
-
-/**
- * Randomly re-orders items in-place using Fisher–Yates.
- *
- * Pass `length` when shuffling a prefix of a larger buffer (e.g. a scratch
- * typed array sized for a worst-case but containing only a smaller active
- * range). Elements beyond `length` are untouched. Default is `array.length`,
- * which gives the natural "shuffle the whole thing" behaviour.
- *
- * @template T
- * @param {function():number} random random number generator; can use Math.random. Must return a value between 0 and 1
- * @param {T[]|TypedArray} array what to shuffle (mutated in place)
- * @param {number} [length] how many leading entries of `array` to shuffle; defaults to `array.length`
- */
-export function array_shuffle(random, array, length = array.length) {
-    for (let source_index = 0; source_index < length; ++source_index) {
-        const target_index = randomIntegerBetween(random, 0, length - (source_index + 1));
-
-        if (target_index === source_index) {
-            continue;
-        }
-
-        array_swap_one(array, source_index, target_index);
-    }
-}
+import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
+import { array_swap_one } from "./array_swap_one.js";
+
+/**
+ * Randomly re-orders items in-place using Fisher–Yates.
+ *
+ * Pass `length` when shuffling a prefix of a larger buffer (e.g. a scratch
+ * typed array sized for a worst-case but containing only a smaller active
+ * range). Elements beyond `length` are untouched. Default is `array.length`,
+ * which gives the natural "shuffle the whole thing" behaviour.
+ *
+ * @template T
+ * @param {function():number} random random number generator; can use Math.random. Must return a value between 0 and 1
+ * @param {T[]|TypedArray} array what to shuffle (mutated in place)
+ * @param {number} [length] how many leading entries of `array` to shuffle; defaults to `array.length`
+ */
+export function array_shuffle(random, array, length = array.length) {
+    for (let source_index = 0; source_index < length; ++source_index) {
+        // Fisher-Yates: swap each position with a uniformly-chosen index in the remaining suffix
+        // [source_index, length - 1]. The previous range [0, length - source_index - 1] sampled the wrong
+        // window and collapsed toward 0 as the loop advanced, producing a heavily biased ordering.
+        const target_index = randomIntegerBetween(random, source_index, length - 1);
+
+        if (target_index === source_index) {
+            continue;
+        }
+
+        array_swap_one(array, source_index, target_index);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"binarySearchLowIndex.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/binarySearchLowIndex.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qGALyB,MAAM,aACpB,MAAM,aACN,MAAM,GACL,MAAM,CA0BjB"}
+{"version":3,"file":"binarySearchLowIndex.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/binarySearchLowIndex.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qGALyB,MAAM,aACpB,MAAM,aACN,MAAM,GACL,MAAM,CA2BjB"}

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

@@ -9,7 +9,8 @@
  */
 export function binarySearchLowIndex(array, el, compareFunction, minIndex = 0, maxIndex = array.length - 1) {
 
-    let result = 0;
+    // index of the largest element <= el (the "low"/floor index), or -1 if el is below every element
+    let result = -1;
 
     while (minIndex <= maxIndex) {
 
@@ -18,12 +19,12 @@ export function binarySearchLowIndex(array, el, compareFunction, minIndex = 0, m
         const cmp = compareFunction(el, array[pivotIndex]);
 
         if (cmp > 0) {
+            // pivot is <= el so far; record it and keep searching to the right for a closer one
+            result = pivotIndex;
             minIndex = pivotIndex + 1;
         } else if (cmp < 0) {
             maxIndex = pivotIndex - 1;
-            result = maxIndex;
         } else {
-            //set low boundary for next step based on assumption that upper bound is higher than lower bound
             result = pivotIndex;
             break;
         }

package/src/core/collection/array/typed/array_buffer_hash.js

@@ -20,7 +20,7 @@ export function array_buffer_hash(buffer, offset, length) {
             0,
             length >>> 2
         );
-    } else if ((alignment_mask & 2) === 0) {
+    } else if ((alignment_mask & 1) === 0) {
         // 2-byte alignment
         return uint16_array_hash(
             new Uint16Array(buffer, offset, length >>> 1),

package/src/core/collection/array/typed/is_typed_array_equals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is_typed_array_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/is_typed_array_equals.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,yCAJW,UAAU,GAAC,WAAW,KACtB,UAAU,GAAC,WAAW,GACpB,OAAO,CAmFnB"}
+{"version":3,"file":"is_typed_array_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/is_typed_array_equals.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,yCAJW,UAAU,GAAC,WAAW,KACtB,UAAU,GAAC,WAAW,GACpB,OAAO,CA6FnB"}

package/src/core/collection/array/typed/is_typed_array_equals.js

@@ -69,8 +69,17 @@ export function is_typed_array_equals(a, b) {
 
     const alignment = largest_common_alignment_uint32(a_offset, b_offset, byte_length);
 
+    // Float arrays must NOT be widened to integers for comparison: reinterpreting float bits as integers
+    // changes equality semantics (e.g. distinct NaN bit patterns, +0 vs -0) and makes the result depend on the
+    // element width. Only Float16Array (2 bytes) can reach the widening branches below; guard all float types.
+    const is_float =
+        (typeof Float16Array !== "undefined" && a_constructor === Float16Array)
+        || a_constructor === Float32Array
+        || a_constructor === Float64Array;
+
     if (
-        bytes_per_element < 4
+        !is_float
+        && bytes_per_element < 4
         && alignment === 4
     ) {
 
@@ -79,7 +88,8 @@ export function is_typed_array_equals(a, b) {
         b_proxy = new Uint32Array(b_buffer, b_offset, byte_length >>> 2);
 
     } else if (
-        bytes_per_element < 2
+        !is_float
+        && bytes_per_element < 2
         && alignment === 2
     ) {
 

package/src/core/collection/heap/BinaryHeap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;;;;;;GASG;AACH;IAaI;;;;OAIG;IACH,qCAUC;IA3BD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IAWP;;;OAGG;IACH,8BAFuB,MAAM,CAEU;IAI3C;;;OAGG;IACH,iBAkCC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAWnB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}
+{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;;;;;;GASG;AACH;IAaI;;;;OAIG;IACH,qCAUC;IA3BD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IAWP;;;OAGG;IACH,8BAFuB,MAAM,CAEU;IAI3C;;;OAGG;IACH,iBAkCC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAehB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAanB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}

package/src/core/collection/heap/BinaryHeap.js

@@ -213,10 +213,18 @@ class BinaryHeap {
      * @param {number} i
      */
     deleteByIndex(i) {
+        // Move the last element into the hole and re-establish the heap invariant, rather than splicing
+        // (splice shifts every following element and destroys the heap ordering).
+        this.length--;
 
-        this.data.splice(i, 1);
+        const last = this.data.pop();
 
-        this.length--;
+        if (i < this.length) {
+            this.data[i] = last;
+            // the moved element may need to sink or rise; at most one of these does any work
+            this.bubbleDown(i);
+            this.bubbleUp(i);
+        }
     }
 
     /**
@@ -265,6 +273,8 @@ class BinaryHeap {
             return false;
         }
 
+        // the score may have increased or decreased; re-heapify in both directions (only one does work)
+        this.bubbleUp(index);
         this.bubbleDown(index);
         return true;
     }

package/src/core/collection/list/FilteredListProjection.js

@@ -1,4 +1,4 @@
-import { frameThrottle } from "../../../engine/graphics/FrameThrottle.js";
+import { frameThrottle } from "../../function/frameThrottle.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
 import { array_set_diff } from "../array/array_set_diff.js";
 import List from "./List.js";

package/src/core/collection/queue/Deque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Deque.js"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH;IAgCI;;;OAGG;IACH,uBAFW,MAAM,EAUhB;IA4FD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,SAFa,IAAI,CAiBhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAalB;IA6BD;;;;;;;OAOG;IACH,UAHW,CAAC,GACC,OAAO,CAqBnB;IA4BD;;;;OAIG;IACH,OAHW,CAAC,GACC,OAAO,CAInB;IAED;;;OAGG;IACH,YAFW,CAAC,QAOX;IAED;;;OAGG;IACH,eAFa,CAAC,GAAC,SAAS,CAQvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,IAAI,CAOhB;IAED;;;OAGG;IACH,cAFa,CAAC,CASb;IAGD;;;OAGG;IACH,WAFa,CAAC,GAAC,SAAS,CAKvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,CAAC,GAAC,SAAS,CAmBvB;IAED;;;;;OAKG;IACH,iBAJW,CAAC,EAAE,kBACH,MAAM,GACJ,CAAC,EAAE,CAUf;IAoBL;;OAEG;IACH,gBAAoB;IACpB;;OAEG;IACH,uBAAoB;IACpB;;OAEG;IACH,eAAmB;IAEnB;;OAEG;IACH,iBA1GiB,IAAI,CA0GF;IAlCf;;;OAGG;IACH,qBAFa,UAAU,CAAC,EAAC,IAAI,CAAC,CAS7B;;CACJ"}
+{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Deque.js"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH;IAgCI;;;OAGG;IACH,uBAFW,MAAM,EAUhB;IA4FD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,SAFa,IAAI,CAiBhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAalB;IA+BD;;;;;;;OAOG;IACH,UAHW,CAAC,GACC,OAAO,CAqBnB;IA4BD;;;;OAIG;IACH,OAHW,CAAC,GACC,OAAO,CAInB;IAED;;;OAGG;IACH,YAFW,CAAC,QAOX;IAED;;;OAGG;IACH,eAFa,CAAC,GAAC,SAAS,CAQvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,IAAI,CAOhB;IAED;;;OAGG;IACH,cAFa,CAAC,CASb;IAGD;;;OAGG;IACH,WAFa,CAAC,GAAC,SAAS,CAKvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,CAAC,GAAC,SAAS,CAmBvB;IAED;;;;;OAKG;IACH,iBAJW,CAAC,EAAE,kBACH,MAAM,GACJ,CAAC,EAAE,CAUf;IAoBL;;OAEG;IACH,gBAAoB;IACpB;;OAEG;IACH,uBAAoB;IACpB;;OAEG;IACH,eAAmB;IAEnB;;OAEG;IACH,iBA1GiB,IAAI,CA0GF;IAlCf;;;OAGG;IACH,qBAFa,UAAU,CAAC,EAAC,IAAI,CAAC,CAS7B;;CACJ"}

package/src/core/collection/queue/Deque.js

@@ -216,23 +216,25 @@ export class Deque {
      * @private
      */
     #remove_internal_shift_backward(current) {
-        let cursor = current;
-
         // shift towards head, this has a better data access pattern than shifting the other way as we're going through the data in forward sequence
 
-        const tail = this.#tail;
+        // Bound the shift by the true last occupied index, NOT by #tail. When the deque is full, #head === #tail,
+        // so #tail is the head slot rather than a free past-the-end marker; using it would walk the cursor all the
+        // way around the ring and corrupt the head element.
+        const last = this.#circular_previous_position(this.#tail);
+
+        let cursor = current;
 
-        while (cursor !== tail) {
+        while (cursor !== last) {
             const next = this.#circular_next_position(cursor);
             this.#data[cursor] = this.#data[next];
             cursor = next;
         }
 
-        this.#tail = this.#circular_previous_position(tail);
-
-
         // fill in slot of last moved element
-        this.#data[cursor] = undefined;
+        this.#data[last] = undefined;
+
+        this.#tail = last;
 
         this.#reset_status(false);
     }

package/src/core/collection/table/RowFirstTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH;IACI;;;;;OAKG;IACH,oDAHW,OAAO,EAsDjB;IAzCG;;;OAGG;IACH,wBAAgB;IAEhB;;;OAGG;IACH,MAFU,WAAW,CAE4D;IAEjF;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,UAFU,QAAQ,CAEqB;IAEvC;;;OAGG;IACH,IAFU;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAOxB;IAKL;;;;;;OAMG;IACH,uDAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA+BlB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAgDhB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,gBACN,MAAM,SACN,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,gBACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,kBAHW,MAAM,aACN,MAAM,QAyBhB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,kBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,eAHW,MAAO,MAAM,CAAC,GACZ,MAAM,CAYlB;IAED;;;;OAIG;IACH,eAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,QAwBhB;IAGD;;;;;OAKG;IACH,eAJW,MAAM,WACN,MAAM,EAAE,GACN,MAAM,EAAE,CAUpB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,EAAE,QAUlB;IAED;;;;;;OAMG;IACH,gBAFW,MAAM,QAgBhB;IAED;;OAEG;IACH,qBA4BC;IAED;;OAEG;IACH,cAIC;IAED;;;;OAIG;IACH,cAFa,MAAM,EAAE,EAAE,CAetB;IAED;;;OAGG;IACH,uBAIC;IAED;;;;OAIG;IACH,YAFW,aAAa,QAmBvB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAwCnB;CACJ;mBApmBkB,+BAA+B"}
+{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH;IACI;;;;;OAKG;IACH,oDAHW,OAAO,EAsDjB;IAzCG;;;OAGG;IACH,wBAAgB;IAEhB;;;OAGG;IACH,MAFU,WAAW,CAE4D;IAEjF;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,UAFU,QAAQ,CAEqB;IAEvC;;;OAGG;IACH,IAFU;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAOxB;IAKL;;;;;;OAMG;IACH,uDAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA+BlB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAgDhB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,gBACN,MAAM,SACN,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,yBAJW,MAAM,gBACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,kBAHW,MAAM,aACN,MAAM,QAyBhB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,kBAFY,MAAM,CAYjB;IAED;;;;OAIG;IACH,eAHW,MAAO,MAAM,CAAC,GACZ,MAAM,CAYlB;IAED;;;;OAIG;IACH,eAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,QAwBhB;IAGD;;;;;OAKG;IACH,eAJW,MAAM,WACN,MAAM,EAAE,GACN,MAAM,EAAE,CAUpB;IAED;;;;OAIG;IACH,gBAHW,MAAM,UACN,MAAM,EAAE,QAUlB;IAED;;;;;;OAMG;IACH,gBAFW,MAAM,QAgBhB;IAED;;OAEG;IACH,qBA4BC;IAED;;OAEG;IACH,cAIC;IAED;;;;OAIG;IACH,cAFa,MAAM,EAAE,EAAE,CAetB;IAED;;;OAGG;IACH,uBAIC;IAED;;;;OAIG;IACH,YAFW,aAAa,QAqBvB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAwCnB;CACJ;mBAtmBkB,+BAA+B"}

package/src/core/collection/table/RowFirstTable.js

@@ -559,9 +559,11 @@ export class RowFirstTable {
 
         const record_count = other.length;
 
-        this.resize(record_count);
+        // Set length BEFORE resizing: resize() copies `this.length` records from the old buffer, so leaving the
+        // old (larger) length in place while shrinking would read past the new, smaller buffer and throw.
+        this.length = record_count;
 
-        this.length = other.length;
+        this.resize(record_count);
 
         // copy data
         const data_byte_count = other.spec.bytesPerRecord * record_count;

package/src/core/collection/table/RowFirstTableSpec.js

@@ -255,7 +255,7 @@ export class RowFirstTableSpec {
      * @param {EndianType} [endianType]
      * @returns {RowFirstTableSpec}
      */
-    static get(types, endianType = EndianType.BigEndian) {
+    static get(types, endianType = EndianType.LittleEndian) {
         assert.isArray(types, 'types');
         assert.enum(endianType, EndianType, 'endianType');
 
@@ -268,7 +268,7 @@ export class RowFirstTableSpec {
             return cachedValue;
         }
 
-        const newValue = Object.freeze(new RowFirstTableSpec(types));
+        const newValue = Object.freeze(new RowFirstTableSpec(types, endianType));
         SPEC_CACHE.put(hash, newValue);
 
         return newValue;

package/src/{engine/physics/island → core/collection/union-find}/union_find.d.ts

@@ -4,8 +4,10 @@
  *
  * Design choices:
  *  - **Path halving** rather than full path compression. Halving rewires
- *    `parent[x]` to `parent[parent[x]]` as it walks, which is `O(α(n))`
- *    amortised (same as full compression) but has a simpler control flow and
+ *    `parent[x]` to `parent[parent[x]]` as it walks. WITHOUT union-by-rank
+ *    (deliberately omitted — see below) this is Θ(log n) amortised, not the
+ *    textbook O(α(n)) (that bound needs halving AND rank together); log n of
+ *    a per-island body count is negligible. Halving has simpler control flow and
  *    is deterministic regardless of call order. Full compression's iterative
  *    second pass would observe a different mutation pattern depending on
  *    which subtree was queried first — fine for correctness, awkward for
@@ -18,9 +20,10 @@
  *    union-by-rank but path halving keeps the amortised cost the same in
  *    practice for the body counts we care about (≤ millions).
  *
- * Used by {@link IslandBuilder} to partition awake bodies + contact pairs
- * into connected components (islands) so the solver can iterate each
- * independently and so whole islands can sleep atomically.
+ * Primary consumer: the physics engine's `IslandBuilder`, which partitions
+ * awake bodies + contact pairs into connected components (islands) so the
+ * solver can iterate each independently and so whole islands can sleep
+ * atomically.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/core/collection/union-find/union_find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union_find.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/union-find/union_find.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;GAIG;AACH,gCAHW,WAAW,KACX,MAAM,QAIhB;AAED;;;;;;GAMG;AACH,gCAJW,WAAW,KACX,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;GAOG;AACH,iCALW,WAAW,KACX,MAAM,KACN,MAAM,GACJ,MAAM,CAalB"}

package/src/{engine/physics/island → core/collection/union-find}/union_find.js

@@ -4,8 +4,10 @@
  *
  * Design choices:
  *  - **Path halving** rather than full path compression. Halving rewires
- *    `parent[x]` to `parent[parent[x]]` as it walks, which is `O(α(n))`
- *    amortised (same as full compression) but has a simpler control flow and
+ *    `parent[x]` to `parent[parent[x]]` as it walks. WITHOUT union-by-rank
+ *    (deliberately omitted — see below) this is Θ(log n) amortised, not the
+ *    textbook O(α(n)) (that bound needs halving AND rank together); log n of
+ *    a per-island body count is negligible. Halving has simpler control flow and
  *    is deterministic regardless of call order. Full compression's iterative
  *    second pass would observe a different mutation pattern depending on
  *    which subtree was queried first — fine for correctness, awkward for
@@ -18,9 +20,10 @@
  *    union-by-rank but path halving keeps the amortised cost the same in
  *    practice for the body counts we care about (≤ millions).
  *
- * Used by {@link IslandBuilder} to partition awake bodies + contact pairs
- * into connected components (islands) so the solver can iterate each
- * independently and so whole islands can sleep atomically.
+ * Primary consumer: the physics engine's `IslandBuilder`, which partitions
+ * awake bodies + contact pairs into connected components (islands) so the
+ * solver can iterate each independently and so whole islands can sleep
+ * atomically.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/core/color/operations/color_lerp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"color_lerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/operations/color_lerp.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,oCALW,KAAK,WACL,KAAK,KACL,MAAM,GACJ,KAAK,CAsBjB;sBApCqB,aAAa"}
+{"version":3,"file":"color_lerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/operations/color_lerp.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,oCALW,KAAK,WACL,KAAK,KACL,MAAM,GACJ,KAAK,CA6BjB;sBA3CqB,aAAa"}

package/src/core/color/operations/color_lerp.js

@@ -29,9 +29,16 @@ export function color_lerp(color_0, color_1, t) {
 
     const _t = clamp01(t);
 
-    for (let i = 0; i < 3; i++) {
-        hsv_2[i] = lerp(hsv_0[i], hsv_1[i], _t);
-    }
+    // Hue is circular (wraps at 1.0), so it must be interpolated along the shortest arc rather than linearly,
+    // otherwise the blend takes the long way around and passes through the wrong hues. Saturation and value
+    // are linear. JS `%` can return negative values, so the wrap math is guarded explicitly.
+    const h0 = hsv_0[0];
+    const h1 = hsv_1[0];
+    const hue_delta = ((h1 - h0) % 1 + 1.5) % 1 - 0.5; // signed shortest-arc delta in (-0.5, 0.5]
+
+    hsv_2[0] = ((h0 + hue_delta * _t) % 1 + 1) % 1;
+    hsv_2[1] = lerp(hsv_0[1], hsv_1[1], _t);
+    hsv_2[2] = lerp(hsv_0[2], hsv_1[2], _t);
 
     okhsv_to_linear_srgb(r, ...hsv_2);
     r.a = lerp(color_0.a, color_1.a, _t);

package/src/core/color/rgb2uint32.js

@@ -10,7 +10,7 @@ import { rgb2uint24 } from "./rgb2uint24.js";
  * @returns {number}
  */
 export function rgb2uint32(r, g, b, a) {
-    const partial = rgb2uint24(r, b, g);
+    const partial = rgb2uint24(r, g, b);
 
     const _a = float_to_uint8(a);
 

package/src/core/color/rgbe9995_to_rgb.js

@@ -11,7 +11,7 @@ export function rgbe9995_to_rgb(out, out_offset, rgbe) {
     const r = rgbe & 0x1ff;
     const g = (rgbe >> 9) & 0x1ff;
     const b = (rgbe >> 18) & 0x1ff;
-    const e = (rgbe >> 27);
+    const e = (rgbe >>> 27);
 
     const scale = Math.pow(2.0, e - 15.0 - 9.0);
 

package/src/core/dom/isImageBitmap.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Guards against cases where ImageBitmap doesn't exist
+ * @param {*} image
+ * @return {boolean}
+ */
+export function isImageBitmap(image: any): boolean;
+//# sourceMappingURL=isImageBitmap.d.ts.map

package/src/core/dom/isImageBitmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isImageBitmap.d.ts","sourceRoot":"","sources":["../../../../src/core/dom/isImageBitmap.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,2CAFY,OAAO,CAQlB"}

package/src/core/dom/isImageBitmap.js

@@ -0,0 +1,12 @@
+/**
+ * Guards against cases where ImageBitmap doesn't exist
+ * @param {*} image
+ * @return {boolean}
+ */
+export function isImageBitmap(image) {
+    /**
+     * check that browser/environment has the class at all to avoid potential exceptions
+     * Required for Safari below version 15.6
+     */
+    return typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap;
+}

package/src/core/function/frameThrottle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wraps a function in {@link window.requestAnimationFrame}
+ * @param {function} original
+ * @param {*} [thisArg]
+ * @returns {function} proxy which will call the original at most once per frame
+ */
+export function frameThrottle(original: Function, thisArg?: any): Function;
+//# sourceMappingURL=frameThrottle.d.ts.map

package/src/core/function/frameThrottle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameThrottle.d.ts","sourceRoot":"","sources":["../../../../src/core/function/frameThrottle.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,2EAgBC"}

package/src/core/function/frameThrottle.js

@@ -0,0 +1,23 @@
+/**
+ * Wraps a function in {@link window.requestAnimationFrame}
+ * @param {function} original
+ * @param {*} [thisArg]
+ * @returns {function} proxy which will call the original at most once per frame
+ */
+export function frameThrottle(original, thisArg) {
+    let pending = false;
+
+    function wrap() {
+        pending = false;
+        original.call(thisArg);
+    }
+
+    function proxy() {
+        if (!pending) {
+            pending = true;
+            requestAnimationFrame(wrap);
+        }
+    }
+
+    return proxy;
+}

package/src/core/function/objectsEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"objectsEqual.d.ts","sourceRoot":"","sources":["../../../../src/core/function/objectsEqual.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,8CAFa,OAAO,CASnB"}
+{"version":3,"file":"objectsEqual.d.ts","sourceRoot":"","sources":["../../../../src/core/function/objectsEqual.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,8CAFa,OAAO,CAUnB"}

package/src/core/function/objectsEqual.js

@@ -7,7 +7,8 @@
 export function objectsEqual(a, b) {
     return a === b
         || (
-            typeof a === "object" //guard against null and undefined values
+            typeof a === "object" // guard against undefined values
+            && a !== null // typeof null === "object", so null must be excluded explicitly
             && typeof a.equals === "function" // check for equals method
             && a.equals(b)
         );

package/src/core/geom/2d/aabb/AABB2.d.ts.map

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