@woosh/meep-engine 3.29.0 → 3.31.0

package/src/core/collection/list/list_apply_ordered_diff.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Bring a {@link List} into line with `desired` by removing and inserting only what differs — so that
+ * a view observing the list's `added`/`removed` signals redraws only what moved.
+ *
+ * Five steps: diff the two as multisets, remove everything the list has and `desired` does not, then
+ * take the additions in reverse order of their position in `desired` and insert each one directly
+ * after the nearest element before it in `desired` that the list already holds. Working back to front
+ * is what makes the positions stable — an insertion never shifts an element a later insertion is
+ * measuring against.
+ *
+ * **Surviving elements are not reordered.** This is a diff-and-place, not an assignment: an element
+ * present in both keeps the position it already had, and only the additions are placed. So a list of
+ * `[1, 2, 3, 4]` against a desired `[4, 5, 1]` becomes `[1, 4, 5]`, not `[4, 5, 1]`. That is the point
+ * of the operation for a view — reordering survivors would cost the redraw the diff exists to avoid.
+ *
+ * One `equals` governs all three questions the walk asks: what is common, what to remove, and where an
+ * addition's predecessor is. It defaults to {@link objectsEqual}, which is the rule
+ * {@link List#removeOneOf} applies, so the diff choosing what to remove agrees with the removal doing
+ * it. `invokeObjectEquals` does not agree — it calls `a.equals(b)` unconditionally, and so throws on a
+ * list of primitives.
+ *
+ * This walk was written out twice, in `List#patch` and `FilteredListProjection#apply`, with three
+ * different equality rules between the two copies — including a predecessor lookup by identity that
+ * sent an addition to the front of the list whenever its predecessor was an `equals`-but-not-identical
+ * twin. The sort in both copies also called `indexOf` from inside the comparator, an O(n^2 log n) that
+ * the position map below removes.
+ *
+ * @template T
+ * @param {List<T>} list the list to bring into line, modified in place
+ * @param {T[]} desired the entries it should hold, in the order additions should be placed by
+ * @param {(a: T, b: T) => boolean} [equals] how to decide two entries are the same entry
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function list_apply_ordered_diff<T>(list: List<T>, desired: T[], equals?: (a: T, b: T) => boolean): void;
+//# sourceMappingURL=list_apply_ordered_diff.d.ts.map

package/src/core/collection/list/list_apply_ordered_diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list_apply_ordered_diff.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/list_apply_ordered_diff.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iGAL2B,OAAO,QAoDjC"}

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

@@ -0,0 +1,87 @@
+import { objectsEqual } from "../../function/objectsEqual.js";
+import { array_index_by_equality } from "../array/array_index_by_equality.js";
+import { array_set_diff } from "../array/array_set_diff.js";
+
+/**
+ * Bring a {@link List} into line with `desired` by removing and inserting only what differs — so that
+ * a view observing the list's `added`/`removed` signals redraws only what moved.
+ *
+ * Five steps: diff the two as multisets, remove everything the list has and `desired` does not, then
+ * take the additions in reverse order of their position in `desired` and insert each one directly
+ * after the nearest element before it in `desired` that the list already holds. Working back to front
+ * is what makes the positions stable — an insertion never shifts an element a later insertion is
+ * measuring against.
+ *
+ * **Surviving elements are not reordered.** This is a diff-and-place, not an assignment: an element
+ * present in both keeps the position it already had, and only the additions are placed. So a list of
+ * `[1, 2, 3, 4]` against a desired `[4, 5, 1]` becomes `[1, 4, 5]`, not `[4, 5, 1]`. That is the point
+ * of the operation for a view — reordering survivors would cost the redraw the diff exists to avoid.
+ *
+ * One `equals` governs all three questions the walk asks: what is common, what to remove, and where an
+ * addition's predecessor is. It defaults to {@link objectsEqual}, which is the rule
+ * {@link List#removeOneOf} applies, so the diff choosing what to remove agrees with the removal doing
+ * it. `invokeObjectEquals` does not agree — it calls `a.equals(b)` unconditionally, and so throws on a
+ * list of primitives.
+ *
+ * This walk was written out twice, in `List#patch` and `FilteredListProjection#apply`, with three
+ * different equality rules between the two copies — including a predecessor lookup by identity that
+ * sent an addition to the front of the list whenever its predecessor was an `equals`-but-not-identical
+ * twin. The sort in both copies also called `indexOf` from inside the comparator, an O(n^2 log n) that
+ * the position map below removes.
+ *
+ * @template T
+ * @param {List<T>} list the list to bring into line, modified in place
+ * @param {T[]} desired the entries it should hold, in the order additions should be placed by
+ * @param {(a: T, b: T) => boolean} [equals] how to decide two entries are the same entry
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function list_apply_ordered_diff(list, desired, equals = objectsEqual) {
+    const diff = array_set_diff(list.asArray(), desired, equals);
+
+    const removals = diff.uniqueA;
+
+    const removal_count = removals.length;
+
+    for (let i = 0; i < removal_count; i++) {
+        list.removeOneOf(removals[i]);
+    }
+
+    const additions = diff.uniqueB;
+
+    const addition_count = additions.length;
+
+    if (addition_count === 0) {
+        return;
+    }
+
+    // first position of each entry in `desired`, which is what `indexOf` would answer, taken once
+    // instead of once per comparison
+    const position = new Map();
+
+    for (let i = desired.length - 1; i >= 0; i--) {
+        position.set(desired[i], i);
+    }
+
+    additions.sort((a, b) => position.get(b) - position.get(a));
+
+    for (let i = 0; i < addition_count; i++) {
+        const item = additions[i];
+
+        const desired_index = position.get(item);
+
+        let insertion_index = 0;
+
+        for (let j = desired_index - 1; j >= 0; j--) {
+            const predecessor = array_index_by_equality(list.asArray(), desired[j], equals);
+
+            if (predecessor !== -1) {
+                insertion_index = predecessor + 1;
+                break;
+            }
+        }
+
+        list.insert(insertion_index, item);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"BiMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/BiMap.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IAEI;;;OAGG;IACH,SAFU,IAAI,CAAC,EAAE,CAAC,CAAC,CAEC;IACpB;;;OAGG;IACH,UAFU,IAAI,CAAC,EAAE,CAAC,CAAC,CAEE;IAGrB;;;;;;;;OAQG;IACH,WAHW,CAAC,OACD,CAAC,QAKX;IAED;;;;;OAKG;IACH,qBAHW,CAAC,GACC,OAAO,CAanB;IAED;;;;;OAKG;IACH,iBAHW,CAAC,GACC,OAAO,CAanB;IAED;;OAEG;IACH,mBAEC;IAED,cAGC;IAED;;;;OAIG;IACH,qBAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,uBAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAGL,2BAAmB;IACnB,oCAAmB;CAHlB"}
+{"version":3,"file":"BiMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/BiMap.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IAEI;;;OAGG;IACH,SAFU,IAAI,CAAC,EAAE,CAAC,CAAC,CAEC;IACpB;;;OAGG;IACH,UAFU,IAAI,CAAC,EAAE,CAAC,CAAC,CAEE;IAGrB;;;;;;;;OAQG;IACH,WAHW,CAAC,OACD,CAAC,QAgBX;IAED;;;;;OAKG;IACH,qBAHW,CAAC,GACC,OAAO,CAcnB;IAED;;;;;OAKG;IACH,iBAHW,CAAC,GACC,OAAO,CAcnB;IAED;;OAEG;IACH,mBAEC;IAED,cAGC;IAED;;;;OAIG;IACH,qBAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,uBAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAGL,2BAAmB;IACnB,oCAAmB;CAHlB"}

package/src/core/collection/map/BiMap.js

@@ -26,6 +26,17 @@ export class BiMap {
      * @param {K} key
      */
     add(value, key) {
+        // The two maps are the same state held twice. Writing a pair that displaces an existing
+        // binding in either direction has to retract the other half, or the displaced partner
+        // stays resolvable forever and the two maps disagree about `size`.
+        if (this.forward.has(key)) {
+            this.backward.delete(this.forward.get(key));
+        }
+
+        if (this.backward.has(value)) {
+            this.forward.delete(this.backward.get(value));
+        }
+
         this.forward.set(key, value);
         this.backward.set(value, key);
     }
@@ -37,12 +48,13 @@ export class BiMap {
      * @returns {boolean} whether a pair was removed
      */
     deleteByValue(value) {
-        const key = this.backward.get(value);
-
-        if (key === undefined) {
+        // `has`, not `=== undefined` - `undefined` is a legal key
+        if (!this.backward.has(value)) {
             return false;
         }
 
+        const key = this.backward.get(value);
+
         this.backward.delete(value);
         this.forward.delete(key);
 
@@ -56,12 +68,13 @@ export class BiMap {
      * @returns {boolean} whether a pair was removed
      */
     deleteByKey(key) {
-        const value = this.forward.get(key);
-
-        if (value === undefined) {
+        // `has`, not `=== undefined` - `undefined` is a legal value
+        if (!this.forward.has(key)) {
             return false;
         }
 
+        const value = this.forward.get(key);
+
         this.forward.delete(key);
         this.backward.delete(value);
 

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

@@ -1 +1 @@
-{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AA+GA;;;;;;;;;GASG;AACH;IAsFI;;;;;;OAMG;IACH;QALwC,eAAe,UAAnC,CAAC,KAAE,MAAM;QACc,mBAAmB,UAA1C,CAAC,QAAC,CAAC,KAAE,OAAO;QACJ,QAAQ,GAAzB,MAAM;QACW,UAAU,GAA3B,MAAM;OAmChB;IA7HD;;;;;OAKG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAyB;IAEzB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,oBAAgB;IAEhB;;;;OAIG;IACH,kCAA8B;IAE9B;;;;OAIG;IACH,iCAA6B;IAE7B;;;;OAIG;IACH,qCAAiC;IAEjC;;;;OAIG;IACH,yBAAqB;IAErB;;;;OAIG;IACH,sBAAoC;IAEpC;;;;OAIG;IACH,kBAAc;IAwBV;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2CD;;;;;OAKG;IACH,0BAUC;IAsGD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QA+DX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAgBZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAaZ;IAwBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,uBAJW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,kBAEzC,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBA0DC;IAmBD,2CA0BC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,WAFa,SAAS,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAM3B;IAED;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IA1DD,yDA2BC;;CAgCJ"}
+{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AA+GA;;;;;;;;;GASG;AACH;IAsFI;;;;;;OAMG;IACH;QALwC,eAAe,UAAnC,CAAC,KAAE,MAAM;QACc,mBAAmB,UAA1C,CAAC,QAAC,CAAC,KAAE,OAAO;QACJ,QAAQ,GAAzB,MAAM;QACW,UAAU,GAA3B,MAAM;OAmChB;IA7HD;;;;;OAKG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAyB;IAEzB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,oBAAgB;IAEhB;;;;OAIG;IACH,kCAA8B;IAE9B;;;;OAIG;IACH,iCAA6B;IAE7B;;;;OAIG;IACH,qCAAiC;IAEjC;;;;OAIG;IACH,yBAAqB;IAErB;;;;OAIG;IACH,sBAAoC;IAEpC;;;;OAIG;IACH,kBAAc;IAwBV;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2CD;;;;;OAKG;IACH,0BAUC;IAsGD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QAmEX;IAyCD;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAUvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAgBZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAaZ;IAwBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CAgDnB;IAED;;;;;OAKG;IACH,uBAJW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,kBAEzC,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBA0DC;IAmBD,2CA0BC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cAiCC;IA+BD;;;OAGG;IACH,WAFa,SAAS,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAM3B;IAED;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IA1DD,yDA2BC;;CAgCJ"}

package/src/core/collection/map/HashMap.js

@@ -488,14 +488,21 @@ export class HashMap {
         }
 
         this.__size++;
+
+        // only reached when a new entry was allocated - overwriting an existing key returns above
+        // and is not a structural change
+        this.__version++;
     }
 
     /**
+     * Probe for the entry holding `key`. The probe is the only thing that knows whether a bin is
+     * occupied, so occupancy is returned rather than re-derived from the payload - a key can
+     * legitimately map to `undefined`.
      *
      * @param {K} key
-     * @returns {V|undefined}
+     * @returns {HashMapEntry<K,V>|null} null if the key is not in the map
      */
-    get(key) {
+    #find_entry(key) {
         const raw_hash = this.#build_key_hash(key);
 
         let bin_index = this.compute_bin_index(raw_hash);
@@ -511,12 +518,12 @@ export class HashMap {
 
                 if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
-                    return entry.value;
+                    return entry;
                 }
 
             } else if (bin === BIN_RESERVED_VALUE_EMPTY) {
                 // bin is empty
-                return undefined;
+                return null;
             }
 
             // perform secondary hashing
@@ -526,6 +533,21 @@ export class HashMap {
 
     }
 
+    /**
+     *
+     * @param {K} key
+     * @returns {V|undefined}
+     */
+    get(key) {
+        const entry = this.#find_entry(key);
+
+        if (entry === null) {
+            return undefined;
+        }
+
+        return entry.value;
+    }
+
     /**
      * If key exists in the map - returns stored value, if it doesn't - invokes `compute` function and stores produced value in the map; then returns that value
      *
@@ -538,10 +560,10 @@ export class HashMap {
     getOrCompute(key, compute, compute_context) {
         assert.isFunction(compute, 'compute');
 
-        const existing = this.get(key);
+        const existing = this.#find_entry(key);
 
-        if (existing !== undefined) {
-            return existing;
+        if (existing !== null) {
+            return existing.value;
         }
 
         const value = compute.call(compute_context, key);
@@ -558,10 +580,10 @@ export class HashMap {
      * @return {V}
      */
     getOrSet(key, value) {
-        const existing = this.get(key);
+        const existing = this.#find_entry(key);
 
-        if (existing !== undefined) {
-            return existing;
+        if (existing !== null) {
+            return existing.value;
         }
 
         // TODO we can do this more efficiently, no need to hash twice
@@ -627,6 +649,7 @@ export class HashMap {
                     bins[bin_index] = BIN_RESERVED_VALUE_DELETED;
 
                     this.__size--;
+                    this.__version++;
 
                     this.#update_range_for_deleted(entry_index);
 
@@ -800,7 +823,7 @@ export class HashMap {
      * @returns {boolean}
      */
     has(key) {
-        return this.get(key) !== undefined;
+        return this.#find_entry(key) !== null;
     }
 
     /**
@@ -808,6 +831,10 @@ export class HashMap {
      */
     clear() {
 
+        if (this.__size > 0) {
+            this.__version++;
+        }
+
         // clear out all
         const bins = this.__bins;
         const count = this.__bin_count;

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

@@ -66,9 +66,9 @@ export class Deque<T> {
     addLast(e: T): void;
     /**
      * Remove an element from the end of the queue
-     * @returns {T}
+     * @returns {T|undefined} undefined if the queue is empty
      */
-    removeLast(): T;
+    removeLast(): T | undefined;
     /**
      * Peek an element from the end of the queue without removing it
      * @returns {T|undefined}

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;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"}
+{"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,CAcvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACC,IAAI,CAOhB;IAED;;;OAGG;IACH,cAFa,CAAC,GAAC,SAAS,CAcvB;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,iBA/GiB,IAAI,CA+GF;IAlCf;;;OAGG;IACH,qBAFa,UAAU,CAAC,EAAC,IAAI,CAAC,CAS7B;;CACJ"}

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

@@ -319,6 +319,12 @@ export class Deque {
      * @returns {T|undefined}
      */
     removeFirst() {
+        if (this.#status === STATUS_EMPTY) {
+            // advancing #head past #tail would make #reset_status read the deque as NORMAL,
+            // turning it into a ring full of `capacity - 1` phantom `undefined` elements
+            return undefined;
+        }
+
         const element = this.#data[this.#head];
         this.#data[this.#head] = undefined;
         this.#head = this.#circular_next_position(this.#head);
@@ -348,9 +354,14 @@ export class Deque {
 
     /**
      * Remove an element from the end of the queue
-     * @returns {T}
+     * @returns {T|undefined} undefined if the queue is empty
      */
     removeLast() {
+        if (this.#status === STATUS_EMPTY) {
+            // see removeFirst
+            return undefined;
+        }
+
         const last = this.#circular_previous_position(this.#tail);
         const element = this.#data[last];
         this.#data[last] = undefined;

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":"AAmCA;;;;;;;;GAQG;AACH;IAOI;;;;;OAKG;IACH,kBAJW,iBAAiB,iBACjB,OAAO,EA+CjB;IAxDD;;;OAGG;IACH,QAFU,MAAM,CAEL;IAkBP;;;OAGG;IACH,MAFU,iBAAiB,CAEX;IAEhB;;;OAGG;IACH,MAFU,WAAW,CAE4D;IAEjF;;;OAGG;IACH,UAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,UAFU,QAAQ,CAEqB;IAEvC;;;OAGG;IACH,IAFU;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAOxB;IAIL;;;;;;OAMG;IACH,0DAMC;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,iBACN,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAO,MAAM,CAAC,QAAM,QAIvD;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;gCAnmBY,OAAO,wBAAwB,EAAE,iBAAiB;mBAN5C,+BAA+B"}
+{"version":3,"file":"RowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/RowFirstTable.js"],"names":[],"mappings":"AAmCA;;;;;;;;GAQG;AACH;IAOI;;;;;OAKG;IACH,kBAJW,iBAAiB,iBACjB,OAAO,EA+CjB;IAxDD;;;OAGG;IACH,QAFU,MAAM,CAEL;IAkBP;;;OAGG;IACH,MAFU,iBAAiB,CAEX;IAEhB;;;OAGG;IACH,MAFU,WAAW,CAE4D;IAEjF;;;OAGG;IACH,UAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,UAFU,QAAQ,CAEqB;IAEvC;;;OAGG;IACH,IAFU;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAOxB;IAIL;;;;;;OAMG;IACH,0DAMC;IAED;;;OAGG;IACH,QAFa,MAAM,CA4ClB;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,iBACN,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAO,MAAM,CAAC,QAAM,QAIvD;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;gCAhnBY,OAAO,wBAAwB,EAAE,iBAAiB;mBAN5C,+BAA+B"}

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

@@ -123,10 +123,17 @@ export class RowFirstTable {
      */
     hash() {
 
-        const byteLength = this.data.byteLength;
+        // `equals` compares exactly `length * bytesPerRecord` bytes, so the hash has to read the
+        // same window. Seeding from `data.byteLength` and tapping the whole buffer brought in the
+        // spare capacity and the rows `removeRows` leaves physically present past `length`, so two
+        // tables that compare equal could hash differently.
+        const length = this.length;
+
+        const byteLength = length * this.spec.bytesPerRecord;
+
         const dataView = this.dataView;
 
-        let result = byteLength;
+        let result = length;
 
 
         const uint32_length = byteLength >> 2;
@@ -149,6 +156,12 @@ export class RowFirstTable {
             result = ((result << 5) - result) + uint32;
         }
 
+        // trailing bytes that do not make up a whole uint32, so a table shorter than 4 bytes
+        // still hashes its contents rather than just its length
+        for (let i = uint32_length << 2; i < byteLength; i++) {
+            result = ((result << 5) - result) + dataView.getUint8(i);
+        }
+
         return result;
     }
 

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

@@ -1 +1 @@
-{"version":3,"file":"serializeRowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/serializeRowFirstTable.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,yFAmBC"}
+{"version":3,"file":"serializeRowFirstTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/table/serializeRowFirstTable.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,yFAkBC"}

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

@@ -1,4 +1,4 @@
-import { DataTypeIndices } from "../../binary/type/DataTypeIndices.js";
+import { dataTypeIndex } from "../../binary/type/DataTypeIndices.js";
 
 /**
  *
@@ -11,8 +11,7 @@ function serializeRowFirstTable(buffer, table) {
     //write types
     buffer.writeUint16(spec.types.length);
     spec.types.forEach(function (type) {
-        const typeIndex = DataTypeIndices[type];
-        buffer.writeUint8(typeIndex);
+        buffer.writeUint8(dataTypeIndex(type));
     });
 
     //write record length

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;;;;;;;;;;;;;;;;GAgBG;AACH,oCAPW,KAAK,WACL,KAAK,KACL,MAAM,GACJ,KAAK,CA+BjB;sBApDqB,aAAa"}
+{"version":3,"file":"color_lerp.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/operations/color_lerp.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;GAgBG;AACH,oCAPW,KAAK,WACL,KAAK,KACL,MAAM,GACJ,KAAK,CAoDjB;sBA1EqB,aAAa"}

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

@@ -1,56 +1,78 @@
-import { assert } from "../../assert.js";
-import { clamp01 } from "../../math/clamp01.js";
-import { lerp } from "../../math/lerp.js";
-import { Color } from "../Color.js";
-import { linear_srgb_to_okhsv } from "../oklab/linear_srgb_to_okhsv.js";
-import { okhsv_to_linear_srgb } from "../oklab/okhsv_to_linear_srgb.js";
-
-const hsv_0 = [0, 0, 0];
-const hsv_1 = [0, 0, 0];
-const hsv_2 = [0, 0, 0];
-
-/**
- * Performs linear interpolation of two colors in perceptual color space,
- * Useful for palette generation and other use cases where perceptual likeness is important.
- *
- * Interpolates in OkHSV, taking the shortest arc around the hue circle. That is not the same operation as
- * {@link Color#lerpColors}, which interpolates the raw channels — the two differ substantially at mid-`t`,
- * and between two hues the per-channel version passes through a desaturated middle while this one does not.
- * Reach for this when the intermediate colours are meant to be looked at, and for `lerpColors` when the
- * colour is a vector being blended alongside other vectors.
- *
- * @param {Color} color_0 **linear** sRGB
- * @param {Color} color_1 **linear** sRGB
- * @param {number} t
- * @returns {Color}
- *
- * @see Color#lerpColors for the per-channel alternative
- */
-export function color_lerp(color_0, color_1, t) {
-    assert.defined(color_0, 'color_0');
-    assert.defined(color_1, 'color_1');
-    assert.isNumber(t, 't');
-
-    const r = new Color();
-
-    linear_srgb_to_okhsv(hsv_0, color_0.r, color_0.g, color_0.b);
-    linear_srgb_to_okhsv(hsv_1, color_1.r, color_1.g, color_1.b);
-
-    const _t = clamp01(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);
-
-    return r;
+import { assert } from "../../assert.js";
+import { clamp01 } from "../../math/clamp01.js";
+import { lerp } from "../../math/lerp.js";
+import { Color } from "../Color.js";
+import { linear_srgb_to_okhsv } from "../oklab/linear_srgb_to_okhsv.js";
+import { okhsv_to_linear_srgb } from "../oklab/okhsv_to_linear_srgb.js";
+
+const hsv_0 = [0, 0, 0];
+const hsv_1 = [0, 0, 0];
+const hsv_2 = [0, 0, 0];
+const rgb_out = [0, 0, 0];
+
+/**
+ * Performs linear interpolation of two colors in perceptual color space,
+ * Useful for palette generation and other use cases where perceptual likeness is important.
+ *
+ * Interpolates in OkHSV, taking the shortest arc around the hue circle. That is not the same operation as
+ * {@link Color#lerpColors}, which interpolates the raw channels — the two differ substantially at mid-`t`,
+ * and between two hues the per-channel version passes through a desaturated middle while this one does not.
+ * Reach for this when the intermediate colours are meant to be looked at, and for `lerpColors` when the
+ * colour is a vector being blended alongside other vectors.
+ *
+ * @param {Color} color_0 **linear** sRGB
+ * @param {Color} color_1 **linear** sRGB
+ * @param {number} t
+ * @returns {Color}
+ *
+ * @see Color#lerpColors for the per-channel alternative
+ */
+export function color_lerp(color_0, color_1, t) {
+    assert.defined(color_0, 'color_0');
+    assert.defined(color_1, 'color_1');
+    assert.isNumber(t, 't');
+
+    const r = new Color();
+
+    const _t = clamp01(t);
+
+    // The OkHSV round trip is not an identity - it overshoots by ~1e-7 - so at the endpoints go
+    // straight to a copy rather than through the conversion, which would otherwise return a colour
+    // that is neither equal to the endpoint nor in gamut.
+    if (_t === 0) {
+        r.copy(color_0);
+
+        return r;
+    } else if (_t === 1) {
+        r.copy(color_1);
+
+        return r;
+    }
+
+    linear_srgb_to_okhsv(hsv_0, color_0.r, color_0.g, color_0.b);
+    linear_srgb_to_okhsv(hsv_1, color_1.r, color_1.g, color_1.b);
+
+    // 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(rgb_out, hsv_2[0], hsv_2[1], hsv_2[2]);
+
+    // The round trip overshoots by ~1e-7, so clamp the way color_scale_okhsv_channel does - an
+    // out-of-gamut channel reaches float_to_uint8 and Color.toUint32 as a value that is not a byte.
+    r.set(
+        clamp01(rgb_out[0]),
+        clamp01(rgb_out[1]),
+        clamp01(rgb_out[2]),
+        lerp(color_0.a, color_1.a, _t)
+    );
+
+    return r;
 }

package/src/core/color/sRGB/linear_to_sRGB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linear_to_sRGB.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/sRGB/linear_to_sRGB.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,kDAHW,MAAM,GACL,MAAM,CAQjB;AAED;;;;;;GAMG;AACH,uCALW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,SACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,QAahB"}
+{"version":3,"file":"linear_to_sRGB.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/sRGB/linear_to_sRGB.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,kDAHW,MAAM,GACL,MAAM,CAQjB;AAED;;;;;;GAMG;AACH,uCALW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,SACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,QAahB"}

package/src/core/color/sRGB/linear_to_sRGB.js

@@ -1,3 +1,5 @@
+import { SRGB_OETF_EXPONENT } from "../REC709_PRIMARIES.js";
+
 /**
  * On the two spellings of the sRGB token.
  *
@@ -14,7 +16,7 @@ export function convert_channel_linear_to_sRGB(c) {
     if (c < 0.0031308) {
         return c * 12.92;
     } else {
-        return 1.055 * (Math.pow(c, 0.4166666666666667)) - 0.055;
+        return 1.055 * (Math.pow(c, SRGB_OETF_EXPONENT)) - 0.055;
     }
 }
 

package/src/core/debug/matchers/AllOf.d.ts

@@ -4,10 +4,11 @@ export class AllOf extends BaseMatcher {
      * @param {Matcher[]} matchers
      */
     constructor(matchers: Matcher<any>[]);
-    matches(item: any, mismatch_description: any): boolean;
+    matches(item: any, mismatch_description?: NullDescription): boolean;
     describeTo(description: any): void;
     #private;
 }
 import { BaseMatcher } from "../BaseMatcher.js";
+import { NullDescription } from "../NullDescription.js";
 import { Matcher } from "../Matcher.js";
 //# sourceMappingURL=AllOf.d.ts.map

package/src/core/debug/matchers/AllOf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AllOf.d.ts","sourceRoot":"","sources":["../../../../../src/core/debug/matchers/AllOf.js"],"names":[],"mappings":"AAIA;IAMI;;;OAGG;IACH,sBAFW,cAAS,EAMnB;IAED,uDAYC;IAED,mCAEC;;CACJ;4BArC2B,mBAAmB;wBACvB,eAAe"}
+{"version":3,"file":"AllOf.d.ts","sourceRoot":"","sources":["../../../../../src/core/debug/matchers/AllOf.js"],"names":[],"mappings":"AAIA;IAMI;;;OAGG;IACH,sBAFW,cAAS,EAMnB;IAED,oEAYC;IAED,mCAEC;;CACJ;4BArC2B,mBAAmB;gCAEf,uBAAuB;wBAD/B,eAAe"}

package/src/core/debug/matchers/AllOf.js

@@ -18,7 +18,7 @@ export class AllOf extends BaseMatcher {
         this.#matchers = matchers;
     }
 
-    matches(item, mismatch_description) {
+    matches(item, mismatch_description = NullDescription.INSTANCE) {
         for (const matcher of this.#matchers) {
             if (!matcher.matches(item, NullDescription.INSTANCE)) {
 

package/src/core/debug/matchers/AnyOf.d.ts

@@ -4,10 +4,11 @@ export class AnyOf extends BaseMatcher {
      * @param {Matcher[]} matchers
      */
     constructor(matchers: Matcher<any>[]);
-    matches(item: any, mismatch_description: any): boolean;
+    matches(item: any, mismatch_description?: NullDescription): boolean;
     describeTo(description: any): void;
     #private;
 }
 import { BaseMatcher } from "../BaseMatcher.js";
+import { NullDescription } from "../NullDescription.js";
 import { Matcher } from "../Matcher.js";
 //# sourceMappingURL=AnyOf.d.ts.map

package/src/core/debug/matchers/AnyOf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnyOf.d.ts","sourceRoot":"","sources":["../../../../../src/core/debug/matchers/AnyOf.js"],"names":[],"mappings":"AAIA;IAMI;;;OAGG;IACH,sBAFW,cAAS,EAMnB;IAED,uDAQC;IAED,mCAEC;;CACJ;4BA/B2B,mBAAmB;wBAFvB,eAAe"}
+{"version":3,"file":"AnyOf.d.ts","sourceRoot":"","sources":["../../../../../src/core/debug/matchers/AnyOf.js"],"names":[],"mappings":"AAIA;IAMI;;;OAGG;IACH,sBAFW,cAAS,EAMnB;IAED,oEAQC;IAED,mCAEC;;CACJ;4BA/B2B,mBAAmB;gCADf,uBAAuB;wBAD/B,eAAe"}