@woosh/meep-engine 2.169.0 → 2.169.1

package/editor/process/symbolic/make3DSymbolicDisplay.js

@@ -7,7 +7,7 @@ import { SymbolicDisplayInternalAPI } from "./SymbolicDisplayInternalAPI.js";
 /**
  *
  * @param {Engine} engine
- * @param {function(components:[], api:{bind:function(Signal, function, thisArg:*), update: function, bindings:SignalBinding[]})} factory
+ * @param {(components: [], api: {bind: (signal: Signal, action: function, context: *) => void, update: function, bindings: SignalBinding[]}) => void} factory
  * @param {Class[]} components
  * @return {ComponentSymbolicDisplay}
  */

package/editor/view/ecs/EntityList.js

@@ -62,7 +62,7 @@ class EntityListView extends View {
     /**
      *
      * @param {Editor} editor
-     * @param { (function(entity:number, ecd:EntityComponentDataset, view:View):void)[]} decorators
+     * @param { ((entity: number, ecd: EntityComponentDataset, view: View) => void)[]} decorators
      */
     constructor({
                     editor,

package/editor/view/ecs/components/particles/ParticleLayerController.js

@@ -73,7 +73,7 @@ class ParticleLayerController extends GuiControl {
         /**
          *
          * @param {string} property
-         * @param {function(layer:ParticleLayer, value:*)} mutationCallback
+         * @param {(layer: ParticleLayer, value: *) => void} mutationCallback
          * @param {*} ops
          */
         function addControl(property, mutationCallback, ops) {

package/editor/view/makeEntityDecorators.js

@@ -10,7 +10,7 @@ import ImageView from "../../src/view/elements/image/ImageView.js";
 
 /**
  *
- * @return {(function(entity:number, ecd:EntityComponentDataset, view:View):void)[]}
+ * @return {((entity: number, ecd: EntityComponentDataset, view: View) => void)[]}
  */
 export function makeEntityDecorators() {
 

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.169.0",
+  "version": "2.169.1",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/REVIEW_2026_08_06.md

@@ -569,3 +569,42 @@ Measurement, since the original proposal asked for it: `Math.floor` and `x | 0`
 Round 2 closed 16 items. The CRITICALs listed as still open in §9 are unchanged by this round except for ECS-14 and BIN-2 — round 2 deliberately took the unambiguous work, and the open CRITICALs are open precisely because they are not.
 
 The three durable additions from this round are worth more than the individual fixes: the `hammersley` distinctness check, the `ArrayBufferLoader` settle-under-failure specs, and `Localization`'s first spec (which drives a real `AssetManager` through a real loader, the pattern the rest of the loader tests should follow).
+
+## 12. Review of the round-1 and round-2 commits
+
+A pass over all 34 commits, in `62047e542..a0e4b9dbc` plus the round-1 range. The point was to find defects in the remediation itself, so what follows leads with those.
+
+### 12.1 Verified rather than assumed
+
+- **Particle compaction** — the swap plan was brute-forced against a reference over every victim subset for arrays up to 12 elements: 8178 cases, 0 mismatches.
+- **Camera 0→1 and Path 2→3 upgraders** — executed end to end; see §12.3, which turned this into a standing harness.
+- **Both new upgraders are registered** in `GameBinarySerializationRegistry.js` (`3ecf5c16`, `8b8df83a`). A version bump without registration silently breaks every existing save, and that was the failure worth checking.
+- **`ServerAuthoritativeClient`** — `Uint32Map.get` does return −1 for absent; network ids come off a free list, so the watermark map is bounded by peak concurrent entities rather than leaking; and a recycled id inherits a watermark that is always behind the current server frame, so reuse cannot drop state.
+- **Physics hot paths** — `solve_constraints`, `convex_convex_manifold`, `raycast`, `ManifoldStore`, `quat3_multiply`: zero executable changes across the whole range, JSDoc only.
+- **`BiMap`** — the argument swap is names-only; identical behaviour for the same positional call.
+- **`Engine` lifecycle** — `Ticker.start` re-adds its lifecycle listeners, so `stop()`→`start()` is clean; the one consumer testing `graphics === undefined` also tests for null; and `start()` already returned a promise before it became `async`.
+- **The round-trip harness is not vacuous** — deleting a field's restoration from an adapter turns it red on exactly that adapter.
+
+### 12.2 Defects found in the remediation, and fixed
+
+- **`IndexedDBStorage.store` rejected up to three times for one failure.** `resolve`/`reject` there are the caller's own callbacks, not promise settle functions, and a failed write raises `error` on the request, bubbles to `error` on the transaction, then aborts it — with a listener on each. In-tree callers wrap the call in a promise, which hides it; `Storage` is published API, so an external consumer saw one lost save reported three times. Now it rejects on `abort` alone, which is the event that always fires for a transaction that will not commit, and it carries `transaction.error` as the reason. The storage classes had no specs at all; they have one now.
+- **The Lanczos `weight_sum === 0` fallback was unreachable.** Swept over every downscale ratio from 1 to 40 at 2 and 3 lobes, the weight sum was never zero, never negative, and never below 1. The NaN it claimed to prevent came from the *old* `if (weight <= 0) continue`, which discarded the negative lobes — and the rewrite had already removed that. Keeping the whole kernel makes the sum the integral of the kernel over the footprint, which stays near 1. Removed: it was precisely the defensive guard for a can't-happen condition this project rejects, and its comment described a failure the new code cannot produce.
+
+### 12.3 The gap that mattered most: upgraders were never executed
+
+`upgrader_chain_contract.spec.js` checks that a path from every historical version to the current one *exists*. That catches a missing upgrader, which is what it was built for. It does not catch an upgrader that is present and emits the wrong layout — and at load time that is the worse failure, because the deserializer then reads real bytes at wrong offsets instead of failing loudly. Its own docblock admitted this and left it outstanding.
+
+`upgrader_execution_contract.spec.js` closes it. Each covered upgrader gets a source buffer in the layout it reads, the chain runs to the current version through `executeBinaryClassUpgraderChain` — the same executor production uses — and the current adapter deserializes the result. The assertion that does the work is the byte count: the adapter must consume exactly what the chain produced.
+
+Two properties make it honest rather than decorative:
+
+- **It is a check of what an upgrader *writes*, not what it reads.** The golden describes the start version's layout, which is derived from the upgrader's own reads. The adapter that originally wrote that layout is gone, so there is nothing left to check the read side against, and the spec says so instead of implying otherwise.
+- **Coverage is enumerated, not assumed.** 9 of 23 upgraders have goldens; the other 14 are listed in `WITHOUT_GOLDEN`, and a new upgrader that appears in neither list fails the spec. Each entry is a save-format version nothing verifies can still be read.
+
+Mutation-verified in both directions: making an upgrader emit one extra field, and making it omit one, each turns its own case red.
+
+### 12.4 Left open, deliberately
+
+- **The Lanczos rewrite changed the filter shape** from radial (`sqrt(fx²+fy²)`) to separable (`L(x)·L(y)`). Separable is the correct Lanczos and it is cheaper — O(rx+ry) transcendental evaluations per output pixel instead of O(rx·ry) — but every downscaled texture now differs from before, and the commit framed it purely as a NaN fix. Recorded here rather than reverted; the old behaviour was not worth preserving.
+- **`sampler2d_scale_down_lanczos` throws "source is larger than destination"** when the condition, `source_width < d_w`, means the source is *smaller*. Pre-existing, and left alone rather than folded into an unrelated change.
+- **`IndexedDBStorage.remove` still reports success off the request** rather than the transaction commit — the same durability gap `store` had. Not touched here because it is a separate defect from the triple-reject this pass was fixing, and it deserves its own change.

package/src/core/IdPool.d.ts

@@ -29,9 +29,9 @@ declare class IdPool {
     isUsed(id: number): boolean;
     /**
      * Traverse all IDs currently in use
-     * @param {function(id:number)} visitor
+     * @param {(id: number) => void} visitor
      */
-    traverseUsed(visitor: any): void;
+    traverseUsed(visitor: (id: number) => void): void;
     /**
      *
      * @param {number} id

package/src/core/IdPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IdPool.d.ts","sourceRoot":"","sources":["../../../src/core/IdPool.js"],"names":[],"mappings":";AAGA;;;GAGG;AACH;IAOI;;;;OAIG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,OAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACL,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,iCASC;IAED;;;OAGG;IACH,YAFW,MAAM,QAIhB;IAED;;OAEG;IACH,cAEC;;CACJ"}
+{"version":3,"file":"IdPool.d.ts","sourceRoot":"","sources":["../../../src/core/IdPool.js"],"names":[],"mappings":";AAGA;;;GAGG;AACH;IAOI;;;;OAIG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,OAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACL,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,2BAFgB,MAAM,KAAK,IAAI,QAW9B;IAED;;;OAGG;IACH,YAFW,MAAM,QAIhB;IAED;;OAEG;IACH,cAEC;;CACJ"}

package/src/core/IdPool.js

@@ -58,7 +58,7 @@ class IdPool {
 
     /**
      * Traverse all IDs currently in use
-     * @param {function(id:number)} visitor
+     * @param {(id: number) => void} visitor
      */
     traverseUsed(visitor) {
         assert.isFunction(visitor, "visitor");

package/src/core/binary/32BitEncoder.d.ts

@@ -1,11 +1,10 @@
 /**
  * Builds an encoder/decoder to simplify process of reading/writing various parts of a 32 bit field
  * @param {number[]} bitCounts
- * @returns {{encode: function(...number):number, decode: function(value:number, result:number[]):void}}
+ * @returns {{encode: function(...number):number, decode: (value: number, result: number[]) => void}}
  */
 export function create32BitCodec(bitCounts: number[]): {
     encode: (...args: number[]) => number;
-    decode: (arg0: value) => number;
-    result: number[];
+    decode: (value: number, result: number[]) => void;
 };
 //# sourceMappingURL=32BitEncoder.d.ts.map

package/src/core/binary/32BitEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"32BitEncoder.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/32BitEncoder.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,4CAHW,MAAM,EAAE;sBACe,MAAM,OAAE,MAAM;6BAAyB,MAAM;YAAS,MAAM,EAAE;EA8D/F"}
+{"version":3,"file":"32BitEncoder.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/32BitEncoder.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,4CAHW,MAAM,EAAE;sBACe,MAAM,OAAE,MAAM;oBAAkB,MAAM,UAAU,MAAM,EAAE,KAAK,IAAI;EA8DlG"}

package/src/core/binary/32BitEncoder.js

@@ -4,7 +4,7 @@ import { assert } from "../assert.js";
 /**
  * Builds an encoder/decoder to simplify process of reading/writing various parts of a 32 bit field
  * @param {number[]} bitCounts
- * @returns {{encode: function(...number):number, decode: function(value:number, result:number[]):void}}
+ * @returns {{encode: function(...number):number, decode: (value: number, result: number[]) => void}}
  */
 export function create32BitCodec(bitCounts) {
     assert.isArray(bitCounts, 'bitCounts');

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

@@ -353,10 +353,10 @@ export class BVH {
     release_all(): void;
     /**
      *
-     * @param {function(node:number, tree:BVH):void} callback
+     * @param {(node: number, tree: BVH) => void} callback
      * @param {*} [ctx]
      */
-    traverse(callback: any, ctx?: any): void;
+    traverse(callback: (node: number, tree: BVH) => void, ctx?: any): void;
     /**
      *
      * @param {number[]} destination

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

@@ -1 +1 @@
-{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"AASA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAE/B;;;;;GAKG;AACH,+BAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEqB;AAiBrC;;;;;;;;GAQG;AACH;IAEI;;;;OAIG;IACH,sBAAuE;IAYvE;;;;;OAKG;IACH,kCAeC;IA/BD;;;;;OAKG;IACH,+BAEC;IAyBD;;;;OAIG;IACH,uBAAsD;IAUtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IApB9B;;;OAGG;IACH,iCAEC;IAgBD;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAUnB;;;OAGG;IACH,sBAEC;IAdD;;;OAGG;IACH,mBAEC;IAUD;;;;OAIG;IACH,mBAEC;IAUD;;;OAGG;IACH,+BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBA6BC;IAED;;OAEG;IACH,aAIC;IAED;;;;;;;OAOG;IACH,4BAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,iBAFa,MAAM,CAqDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAe/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAAM,QAsB1C;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAYlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAmBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAgBhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA0GhB;IAED;;;;;OAKG;IACH,wBAqBC;IAED;;;;OAIG;IACH,yBAmCC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;;;;;;OAWG;IACH,uBAoMC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,uBAwHC;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,WACN,MAAM,WACN,MAAM,QAWhB;IAED;;;;;;;OAOG;IACH,kCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAmBhB;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,yCA8BC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;IAGL;;;;OAIG;IACH,gBAFU,OAAO,CAEE;CAPlB"}
+{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"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"}

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

@@ -1296,7 +1296,7 @@ export class BVH {
 
     /**
      *
-     * @param {function(node:number, tree:BVH):void} callback
+     * @param {(node: number, tree: BVH) => void} callback
      * @param {*} [ctx]
      */
     traverse(callback, ctx) {

package/src/core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point_filtered.d.ts

@@ -15,9 +15,9 @@
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {function(userData:number):boolean} filter keep a leaf iff this returns true for its user data
+ * @param {(userData: number) => boolean} filter keep a leaf iff this returns true for its user data
  * @param {number} [max_distance=Infinity] how far to search
  * @returns {number} user data of the nearest passing leaf, or -1 if none qualifies
  */
-export function bvh_query_user_data_nearest_to_point_filtered(bvh: BVH, x: number, y: number, z: number, filter: any, max_distance?: number): number;
+export function bvh_query_user_data_nearest_to_point_filtered(bvh: BVH, x: number, y: number, z: number, filter: (userData: number) => boolean, max_distance?: number): number;
 //# sourceMappingURL=bvh_query_user_data_nearest_to_point_filtered.d.ts.map

package/src/core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point_filtered.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh_query_user_data_nearest_to_point_filtered.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point_filtered.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2EAPW,MAAM,KACN,MAAM,KACN,MAAM,8BAEN,MAAM,GACJ,MAAM,CA4DlB"}
+{"version":3,"file":"bvh_query_user_data_nearest_to_point_filtered.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point_filtered.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2EAPW,MAAM,KACN,MAAM,KACN,MAAM,qBACK,MAAM,KAAK,OAAO,iBAC7B,MAAM,GACJ,MAAM,CA4DlB"}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point_filtered.js

@@ -1,86 +1,86 @@
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_unsigned_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
-import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
-
-const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
-
-/**
- * Nearest leaf to a point whose user data PASSES `filter` — the branch-and-bound search of
- * {@link bvh_query_user_data_nearest_to_point}, except a leaf only becomes the new best when
- * `filter(userData)` returns true. Branches farther than the current best PASSING leaf are still pruned, so
- * `filter` runs only on leaves nearer than the best so far — typically a handful, not every leaf. Lets a
- * caller reject candidates by an external predicate the BVH itself can't express (e.g. line-of-sight from
- * the query point).
- *
- * Re-entrancy: this consumer keeps the shared traversal `pointer` live (advances the global pointer while
- * walking), so per the {@link SCRATCH_UINT32_TRAVERSAL_STACK} contract `filter` MAY itself run a nested
- * BVH walk (it pushes above this live frame and drains back). `filter` must not throw (a throw mid-walk
- * leaves the shared pointer elevated).
- *
- * @param {BVH} bvh
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {function(userData:number):boolean} filter keep a leaf iff this returns true for its user data
- * @param {number} [max_distance=Infinity] how far to search
- * @returns {number} user data of the nearest passing leaf, or -1 if none qualifies
- */
-export function bvh_query_user_data_nearest_to_point_filtered(bvh, x, y, z, filter, max_distance = Infinity) {
-    const root = bvh.root;
-
-    if (root === NULL_NODE) {
-        return -1;
-    }
-
-    const stack_top = stack.pointer++;
-
-    stack[stack_top] = root;
-
-    let best_user_data = -1;
-    let best_distance_sqr = max_distance * max_distance;
-
-    // bind data directly to avoid extra copies reading out AABBs
-    const float32 = bvh.__data_float32;
-    const uint32 = bvh.__data_uint32;
-
-    do {
-        stack.pointer--;
-
-        const node = stack[stack.pointer];
-
-        const address = node * ELEMENT_WORD_COUNT;
-
-        const distance_sqr = aabb3_unsigned_distance_sqr_to_point(
-            float32[address], float32[address + 1], float32[address + 2],
-            float32[address + 3], float32[address + 4], float32[address + 5],
-            x, y, z
-        );
-
-        if (distance_sqr >= best_distance_sqr) {
-            // node (or its whole subtree) can't beat the best passing leaf
-            continue;
-        }
-
-        const child_1 = uint32[address + COLUMN_CHILD_1];
-
-        if (child_1 !== NULL_NODE) {
-
-            // not a leaf — push children onto the traversal stack
-            stack[stack.pointer++] = child_1;
-            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
-
-        } else {
-
-            // leaf nearer than the current best — accept only if it passes the predicate
-            const user_data = bvh.node_get_user_data(node);
-
-            if (filter(user_data)) {
-                best_distance_sqr = distance_sqr;
-                best_user_data = user_data;
-            }
-
-        }
-    } while (stack.pointer > stack_top)
-
-    return best_user_data;
-}
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_unsigned_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ * Nearest leaf to a point whose user data PASSES `filter` — the branch-and-bound search of
+ * {@link bvh_query_user_data_nearest_to_point}, except a leaf only becomes the new best when
+ * `filter(userData)` returns true. Branches farther than the current best PASSING leaf are still pruned, so
+ * `filter` runs only on leaves nearer than the best so far — typically a handful, not every leaf. Lets a
+ * caller reject candidates by an external predicate the BVH itself can't express (e.g. line-of-sight from
+ * the query point).
+ *
+ * Re-entrancy: this consumer keeps the shared traversal `pointer` live (advances the global pointer while
+ * walking), so per the {@link SCRATCH_UINT32_TRAVERSAL_STACK} contract `filter` MAY itself run a nested
+ * BVH walk (it pushes above this live frame and drains back). `filter` must not throw (a throw mid-walk
+ * leaves the shared pointer elevated).
+ *
+ * @param {BVH} bvh
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {(userData: number) => boolean} filter keep a leaf iff this returns true for its user data
+ * @param {number} [max_distance=Infinity] how far to search
+ * @returns {number} user data of the nearest passing leaf, or -1 if none qualifies
+ */
+export function bvh_query_user_data_nearest_to_point_filtered(bvh, x, y, z, filter, max_distance = Infinity) {
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return -1;
+    }
+
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let best_user_data = -1;
+    let best_distance_sqr = max_distance * max_distance;
+
+    // bind data directly to avoid extra copies reading out AABBs
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
+        stack.pointer--;
+
+        const node = stack[stack.pointer];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        const distance_sqr = aabb3_unsigned_distance_sqr_to_point(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            x, y, z
+        );
+
+        if (distance_sqr >= best_distance_sqr) {
+            // node (or its whole subtree) can't beat the best passing leaf
+            continue;
+        }
+
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+
+            // not a leaf — push children onto the traversal stack
+            stack[stack.pointer++] = child_1;
+            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
+
+        } else {
+
+            // leaf nearer than the current best — accept only if it passes the predicate
+            const user_data = bvh.node_get_user_data(node);
+
+            if (filter(user_data)) {
+                best_distance_sqr = distance_sqr;
+                best_user_data = user_data;
+            }
+
+        }
+    } while (stack.pointer > stack_top)
+
+    return best_user_data;
+}

package/src/core/bvh2/traversal/aabb3_detailed_volume_intersection_callback_based.d.ts

@@ -14,8 +14,8 @@
  * @param {number[]} planes
  * @param {number} plane_count
  * @param {number} plane_mask
- * @param {function(x:number,y:number,z:number)} callback
+ * @param {(x: number, y: number, z: number) => void} callback
  * @param {*} [thisArg]
  */
-export function aabb3_detailed_volume_intersection_callback_based(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, plane_mask: number, planes: number[], plane_count: number, callback: any, thisArg?: any): void;
+export function aabb3_detailed_volume_intersection_callback_based(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, plane_mask: number, planes: number[], plane_count: number, callback: (x: number, y: number, z: number) => void, thisArg?: any): void;
 //# sourceMappingURL=aabb3_detailed_volume_intersection_callback_based.d.ts.map

package/src/core/bvh2/traversal/aabb3_detailed_volume_intersection_callback_based.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_detailed_volume_intersection_callback_based.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/traversal/aabb3_detailed_volume_intersection_callback_based.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sEAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,cAGN,MAAM,UAFN,MAAM,EAAE,eACR,MAAM,sCAsChB"}
+{"version":3,"file":"aabb3_detailed_volume_intersection_callback_based.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/traversal/aabb3_detailed_volume_intersection_callback_based.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sEAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,cAGN,MAAM,UAFN,MAAM,EAAE,eACR,MAAM,gBAEF,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,IAAI,uBAoCnD"}

package/src/core/bvh2/traversal/aabb3_detailed_volume_intersection_callback_based.js

@@ -23,7 +23,7 @@ const scratch_points_data = [];
  * @param {number[]} planes
  * @param {number} plane_count
  * @param {number} plane_mask
- * @param {function(x:number,y:number,z:number)} callback
+ * @param {(x: number, y: number, z: number) => void} callback
  * @param {*} [thisArg]
  */
 export function aabb3_detailed_volume_intersection_callback_based(

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

@@ -23,8 +23,8 @@ export class Cache<Key, Value> {
      * Note: setting {@link maxWeight} to 0 is pointless, as the cache will not be able to hold even a single element.
      *
      * @param {number} [maxWeight=Number.POSITIVE_INFINITY] capacity of the cache, measure in "weight"; The weight is computed by summing key and value weights.
-     * @param {function(key:Key):number} [keyWeigher= key=>0] function to compute weight of a key
-     * @param {function(value:Value):number} [valueWeigher= value=>1] function to compute weight of a value
+     * @param {(key: Key) => number} [keyWeigher= key=>0] function to compute weight of a key
+     * @param {(value: Value) => number} [valueWeigher= value=>1] function to compute weight of a value
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
      * @param {number} [capacity] initial capacity for the cache, helps prevent early resizing
@@ -200,11 +200,11 @@ export class Cache<Key, Value> {
     drop(): void;
     /**
      *
-     * @param {function(message:string, key:Key, value:Value)} callback
+     * @param {(message: string, key: Key, value: Value) => void} callback
      * @param {*} [thisArg]
      * @returns {boolean}
      */
-    validate(callback: any, thisArg?: any): boolean;
+    validate(callback: (message: string, key: Key, value: Value) => void, thisArg?: any): boolean;
     /**
      * Shortcut for "Map" class spec compliance
      * @readonly

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,eAA6B;IAE7B;;;OAGG;IACH,eAA6B;IAE7B;;;OAGG;IACH,WAAyB;IAG7B;;;;;OAKG;IACH,kBAqBC;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;6BApkB4B,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,eAA6B;IAE7B;;;OAGG;IACH,eAA6B;IAE7B;;;OAGG;IACH,WAAyB;IAG7B;;;;;OAKG;IACH,kBAqBC;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,6BAJqB,MAAM,OAAO,GAAG,SAAS,KAAK,KAAK,IAAI,kBAE/C,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA9FiB,OAAO,CA8FF;IAEtB;;;OAGG;IACH,4BAhLiB,OAAO,CAgLL;;CAlBlB;6BApkB4B,mBAAmB"}

package/src/core/cache/Cache.js

@@ -48,8 +48,8 @@ export class Cache {
      * Note: setting {@link maxWeight} to 0 is pointless, as the cache will not be able to hold even a single element.
      *
      * @param {number} [maxWeight=Number.POSITIVE_INFINITY] capacity of the cache, measure in "weight"; The weight is computed by summing key and value weights.
-     * @param {function(key:Key):number} [keyWeigher= key=>0] function to compute weight of a key
-     * @param {function(value:Value):number} [valueWeigher= value=>1] function to compute weight of a value
+     * @param {(key: Key) => number} [keyWeigher= key=>0] function to compute weight of a key
+     * @param {(value: Value) => number} [valueWeigher= value=>1] function to compute weight of a value
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
      * @param {number} [capacity] initial capacity for the cache, helps prevent early resizing
@@ -577,7 +577,7 @@ export class Cache {
 
     /**
      *
-     * @param {function(message:string, key:Key, value:Value)} callback
+     * @param {(message: string, key: Key, value: Value) => void} callback
      * @param {*} [thisArg]
      * @returns {boolean}
      */

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

@@ -18,7 +18,7 @@ export class LoadingCache<K, V> {
      * @param [keyEqualityFunction]
      * @param [capacity]
      * @param {number} [timeToLive] in seconds, default is 10 seconds
-     * @param {function(key:K):Promise<V>} load
+     * @param {(key: K) => Promise<V>} load
      * @param {boolean} [retryFailed]
      */
     constructor({ maxWeight, keyWeigher, valueWeigher, keyHashFunction, keyEqualityFunction, capacity, timeToLive, load, retryFailed }?: {

package/src/core/cache/LoadingCache.js

@@ -61,7 +61,7 @@ export class LoadingCache {
     #timeToLive = DEFAULT_TIME_TO_LIVE;
 
     /**
-     * @type {function(key:K):Promise<V>}
+     * @type {(key: K) => Promise<V>}
      */
     #load
 
@@ -85,7 +85,7 @@ export class LoadingCache {
      * @param [keyEqualityFunction]
      * @param [capacity]
      * @param {number} [timeToLive] in seconds, default is 10 seconds
-     * @param {function(key:K):Promise<V>} load
+     * @param {(key: K) => Promise<V>} load
      * @param {boolean} [retryFailed]
      */
     constructor({

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

@@ -5,8 +5,8 @@ export class CacheWTinylfu {
      * @param {number} [promotionThreshold=1] frequency an item must exceed to be promoted out of Trial (Probation)
      * @param {number} [capacityWindow=1] weight cap of the Window region (burst buffer)
      * @param {number} [capacityProtected=1] weight cap of the Protected region (VIP segment of Main)
-     * @param {function(key:Key):number} [keyWeigher= key=>0] function to compute weight of a key
-     * @param {function(value:Value):number} [valueWeigher= value=>1] function to compute weight of a value
+     * @param {(key: Key) => number} [keyWeigher= key=>0] function to compute weight of a key
+     * @param {(value: Value) => number} [valueWeigher= value=>1] function to compute weight of a value
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
      */

package/src/core/cache/wtinylfu/CacheWTinylfu.js

@@ -143,8 +143,8 @@ export class CacheWTinylfu {
      * @param {number} [promotionThreshold=1] frequency an item must exceed to be promoted out of Trial (Probation)
      * @param {number} [capacityWindow=1] weight cap of the Window region (burst buffer)
      * @param {number} [capacityProtected=1] weight cap of the Protected region (VIP segment of Main)
-     * @param {function(key:Key):number} [keyWeigher= key=>0] function to compute weight of a key
-     * @param {function(value:Value):number} [valueWeigher= value=>1] function to compute weight of a value
+     * @param {(key: Key) => number} [keyWeigher= key=>0] function to compute weight of a key
+     * @param {(value: Value) => number} [valueWeigher= value=>1] function to compute weight of a value
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
      */

package/src/core/collection/array/array_index_by_equality.d.ts

@@ -3,8 +3,8 @@
  * @template T
  * @param {T[]} array
  * @param {T} element
- * @param {function(a:T,b:T):boolean} equals
+ * @param {(a: T, b: T) => boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
-export function array_index_by_equality<T>(array: T[], element: T, equals: any): number;
+export function array_index_by_equality<T>(array: T[], element: T, equals: (a: T, b: T) => boolean): number;
 //# sourceMappingURL=array_index_by_equality.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"array_index_by_equality.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_index_by_equality.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,iFAFa,MAAM,CAclB"}
+{"version":3,"file":"array_index_by_equality.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_index_by_equality.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,2FAH2B,OAAO,GACrB,MAAM,CAclB"}

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

@@ -3,7 +3,7 @@
  * @template T
  * @param {T[]} array
  * @param {T} element
- * @param {function(a:T,b:T):boolean} equals
+ * @param {(a: T, b: T) => boolean} equals
  * @returns {number} index of first match or -1 if no matches found
  */
 export function array_index_by_equality(array, element, equals) {

package/src/core/collection/array/array_pick_best_element.d.ts

@@ -3,8 +3,8 @@
  * If multiple elements with the same highest score exist, the result will be first such encountered element
  * @template T
  * @param {T[]} array
- * @param {function(el:T, index:number):number} scoreFunction
+ * @param {(el: T, index: number) => number} scoreFunction
  * @returns {T|undefined}
  */
-export function array_pick_best_element<T>(array: T[], scoreFunction: any): T;
+export function array_pick_best_element<T>(array: T[], scoreFunction: (el: T, index: number) => number): T;
 //# sourceMappingURL=array_pick_best_element.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"array_pick_best_element.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_element.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8EAkCC"}
+{"version":3,"file":"array_pick_best_element.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_element.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,qFAH0B,MAAM,KAAK,MAAM,KAqC1C"}

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

@@ -5,7 +5,7 @@ import { assert } from "../../assert.js";
  * If multiple elements with the same highest score exist, the result will be first such encountered element
  * @template T
  * @param {T[]} array
- * @param {function(el:T, index:number):number} scoreFunction
+ * @param {(el: T, index: number) => number} scoreFunction
  * @returns {T|undefined}
  */
 export function array_pick_best_element(array, scoreFunction) {

package/src/core/collection/array/array_pick_best_elements.d.ts

@@ -1,8 +1,8 @@
 /**
  * @template T
  * @param {T[]} array
- * @param {function(el:T, index:number):number} scoreFunction
+ * @param {(el: T, index: number) => number} scoreFunction
  * @returns {T[]}
  */
-export function array_pick_best_elements<T>(array: T[], scoreFunction: any): T[];
+export function array_pick_best_elements<T>(array: T[], scoreFunction: (el: T, index: number) => number): T[];
 //# sourceMappingURL=array_pick_best_elements.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"array_pick_best_elements.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_elements.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,iFA0CC"}
+{"version":3,"file":"array_pick_best_elements.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_pick_best_elements.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,sFAH0B,MAAM,KAAK,MAAM,OA6C1C"}

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

@@ -3,7 +3,7 @@ import { assert } from "../../assert.js";
 /**
  * @template T
  * @param {T[]} array
- * @param {function(el:T, index:number):number} scoreFunction
+ * @param {(el: T, index: number) => number} scoreFunction
  * @returns {T[]}
  */
 export function array_pick_best_elements(array, scoreFunction) {