@woosh/meep-engine 2.138.3 → 2.138.4

package/package.json

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

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

@@ -1,11 +1,19 @@
 /**
- * DO NOT USE, currently broken
+ * Build a binary radix tree over the given leaves and Morton codes.
+ *
  * @param {BVH} bvh
  * @param {number[]|Uint32Array} leaf_nodes
- * @param {number[]} sorted_morton_codes
+ *        Pre-allocated leaf node IDs, ordered to match `sorted_morton_codes`
+ *        (i.e. leaf_nodes[i]'s code is sorted_morton_codes[i]).
+ * @param {number[]|Uint32Array} sorted_morton_codes
+ *        Morton codes in non-decreasing order. May contain duplicates.
  * @param {number} leaf_count
- * @param {number[]} internal_nodes
- * @returns {number} new root
+ *        Number of leaves (must equal the length of `leaf_nodes` and
+ *        `sorted_morton_codes` that the function will actually look at).
+ * @param {number[]|Uint32Array} internal_nodes
+ *        Pre-allocated internal node IDs, of length at least `leaf_count - 1`.
+ *        Ignored when leaf_count < 2.
+ * @returns {number} The root node id, or NULL_NODE if leaf_count is 0.
  */
-export function ebvh_build_hierarchy_radix(bvh: BVH, leaf_nodes: number[] | Uint32Array, sorted_morton_codes: number[], leaf_count: number, internal_nodes: number[]): number;
+export function ebvh_build_hierarchy_radix(bvh: BVH, leaf_nodes: number[] | Uint32Array, sorted_morton_codes: number[] | Uint32Array, leaf_count: number, internal_nodes: number[] | Uint32Array): number;
 //# sourceMappingURL=ebvh_build_hierarchy_radix.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_hierarchy_radix.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy_radix.js"],"names":[],"mappings":"AA2MA;;;;;;;;GAQG;AACH,iEANW,MAAM,EAAE,GAAC,WAAW,uBACpB,MAAM,EAAE,cACR,MAAM,kBACN,MAAM,EAAE,GACN,MAAM,CAqElB"}
+{"version":3,"file":"ebvh_build_hierarchy_radix.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy_radix.js"],"names":[],"mappings":"AA4KA;;;;;;;;;;;;;;;;GAgBG;AACH,iEAbW,MAAM,EAAE,GAAC,WAAW,uBAGpB,MAAM,EAAE,GAAC,WAAW,cAEpB,MAAM,kBAGN,MAAM,EAAE,GAAC,WAAW,GAGlB,MAAM,CAiElB"}

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

@@ -1,280 +1,253 @@
-import { assert } from "../../assert.js";
-import { clamp } from "../../math/clamp.js";
-import { NULL_NODE } from "./BVH.js";
-import { ebvh_update_hierarchy_bounds } from "./ebvh_update_hierarchy_bounds.js";
-
-/**
- *
- * @see "Thinking Parallel, Part III: Tree Construction on the GPU", 2012 by Tero Karras
- *
- * @param {number[]|Uint32Array} sortedMortonCodes
- * @param {number} first
- * @param {number} last
- * @return {number}
- */
-function find_split(
-    sortedMortonCodes,
-    first,
-    last
-) {
-    // Identical Morton codes => split the range in the middle.
-
-    const firstCode = sortedMortonCodes[first];
-    const lastCode = sortedMortonCodes[last];
-
-    if (firstCode === lastCode) {
-        return (first + last) >>> 1;
-    }
-
-    // Calculate the number of highest bits that are the same
-    // for all objects, using the count-leading-zeros intrinsic.
-
-    const commonPrefix = Math.clz32(firstCode ^ lastCode);
-
-    // Use binary search to find where the next bit differs.
-    // Specifically, we are looking for the highest object that
-    // shares more than commonPrefix bits with the first one.
-
-    let split = first; // initial guess
-    let step = last - first;
-
-    do {
-        step = (step + 1) >>> 1; // exponential decrease
-        const newSplit = split + step; // proposed new position
-
-        if (newSplit < last) {
-            const splitCode = sortedMortonCodes[newSplit];
-            const splitPrefix = Math.clz32(firstCode ^ splitCode);
-            if (splitPrefix > commonPrefix) {
-                split = newSplit; // accept proposal
-            }
-        }
-    }
-    while (step > 1);
-
-    return split;
-}
-
-/**
- *
- * @param {number} indexA
- * @param {number} indexB
- * @param {number} elementCount
- * @param {number[]} mortonCodes
- * @return {number}
- * @see https://github.com/turanszkij/WickedEngine/blob/506749de321c2ab66fd33fbe41efb95afbbb7ff8/WickedEngine/shaders/bvh_hierarchyCS.hlsl#L28C1-L48C2
- */
-function GetLongestCommonPrefix(indexA, indexB, elementCount, mortonCodes) {
-    assert.isNonNegativeInteger(indexA, 'indexA');
-    assert.isNonNegativeInteger(indexB, 'indexB');
-
-    if (indexA >= elementCount || indexB >= elementCount) {
-        return -1;
-    } else {
-        const mortonCodeA = mortonCodes[indexA];
-        const mortonCodeB = mortonCodes[indexB];
-        if (mortonCodeA !== mortonCodeB) {
-            return Math.clz32(mortonCodeA ^ mortonCodeB);
-        } else {
-            // TODO: Technically this should be primitive ID
-            return Math.clz32(indexA ^ indexB) + 31;
-        }
-    }
-}
-
-/**
- * @see https://github.com/turanszkij/WickedEngine/blob/506749de321c2ab66fd33fbe41efb95afbbb7ff8/WickedEngine/shaders/bvh_hierarchyCS.hlsl#L28C1-L48C2
- * @param {number[]|Uint32Array} output
- * @param {number[]} sortedMortonCodes
- * @param {number} numTriangles
- * @param {number} idx
- */
-function determineRangeW(output, sortedMortonCodes, numTriangles, idx) {
-    if (idx === 0) {
-        // root
-        output[0] = 0;
-        output[1] = numTriangles - 1;
-        return;
-    }
-
-    let d = GetLongestCommonPrefix(idx, idx + 1, numTriangles, sortedMortonCodes) - GetLongestCommonPrefix(idx, idx - 1, numTriangles, sortedMortonCodes);
-    d = clamp(d, -1, 1);
-
-    let minPrefix = GetLongestCommonPrefix(idx, idx - d, numTriangles, sortedMortonCodes);
-
-    // TODO: Consider starting this at a higher number
-    let maxLength = 2;
-    while (GetLongestCommonPrefix(idx, idx + maxLength * d, numTriangles, sortedMortonCodes) > minPrefix) {
-        maxLength <<= 2;
-    }
-
-    let length = 0;
-    for (let t = maxLength >>> 1; t > 0; t >>>= 1) {
-        if (GetLongestCommonPrefix(idx, idx + (length + t) * d, numTriangles, sortedMortonCodes) > minPrefix) {
-            length = length + t;
-        }
-    }
-
-    let j = idx + length * d;
-
-    output[0] = Math.min(idx, j);
-    output[1] = Math.max(idx, j);
-
-}
-
-
-/**
- * @see https://github.com/mbartling/cuda-bvh/blob/7f2f98d9d29956c3559632e59104ba66f31f80b8/kernels/bvh.cu#L276C1-L352C2
- * @param {number[]|Uint32Array} output
- * @param {number[]} sortedMortonCodes
- * @param {number} numTriangles
- * @param {number} idx
- */
-function determineRange(output, sortedMortonCodes, numTriangles, idx) {
-
-    //determine the range of keys covered by each internal node (as well as its children)
-    //direction is found by looking at the neighboring keys ki-1 , ki , ki+1
-    //the index is either the beginning of the range or the end of the range
-    let direction = 0;
-    let common_prefix_with_left = 0;
-    let common_prefix_with_right = 0;
-
-    common_prefix_with_right = Math.clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx + 1]);
-
-    if (idx === 0) {
-        common_prefix_with_left = -1;
-    } else {
-        common_prefix_with_left = Math.clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx - 1]);
-
-    }
-
-    direction = ((common_prefix_with_right - common_prefix_with_left) > 0) ? 1 : -1;
-
-    let min_prefix_range = 0;
-
-    if (idx === 0) {
-        min_prefix_range = -1;
-
-    } else {
-        min_prefix_range = Math.clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx - direction]);
-    }
-
-    let lmax = 2;
-    let next_key = idx + lmax * direction;
-
-    while ((next_key >= 0) && (next_key < numTriangles) && (Math.clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[next_key]) > min_prefix_range)) {
-        lmax *= 2;
-        next_key = idx + lmax * direction;
-    }
-    //find the other end using binary search
-    let l = 0;
-
-    do {
-        lmax = (lmax + 1) >> 1; // exponential decrease
-        const new_val = idx + (l + lmax) * direction;
-
-        if (new_val >= 0 && new_val < numTriangles) {
-            const Code = sortedMortonCodes[new_val];
-            const Prefix = Math.clz32(sortedMortonCodes[idx] ^ Code);
-            if (Prefix > min_prefix_range) {
-                l = l + lmax;
-            }
-        }
-    } while (lmax > 1);
-
-    const j = idx + l * direction;
-
-    let left = 0;
-    let right = 0;
-
-    if (idx < j) {
-        left = idx;
-        right = j;
-    } else {
-        left = j;
-        right = idx;
-    }
-
-    // printf("idx : (%d) returning range (%d, %d) \n" , idx , left, right);
-
-    output[0] = left
-    output[1] = right;
-}
-
-/**
- * DO NOT USE, currently broken
- * @param {BVH} bvh
- * @param {number[]|Uint32Array} leaf_nodes
- * @param {number[]} sorted_morton_codes
- * @param {number} leaf_count
- * @param {number[]} internal_nodes
- * @returns {number} new root
- */
-export function ebvh_build_hierarchy_radix(
-    bvh,
-    leaf_nodes,
-    sorted_morton_codes,
-    leaf_count,
-    internal_nodes,
-) {
-    console.warn("IMPLEMENTATION IS INCOMPLETE, DO NOT USE")
-
-    assert.isNonNegativeInteger(leaf_count, 'leaf_count');
-
-    // Construct leaf nodes.
-    // Note: This step can be avoided by storing
-    // the tree in a slightly different way.
-
-    const range = new Uint32Array(2);
-
-    // Construct internal nodes.
-    const intermediate_node_count = leaf_count - 1;
-    for (let idx = 0; idx < intermediate_node_count; idx++) // in parallel
-    {
-        // Find out which range of objects the node corresponds to.
-        // (This is where the magic happens!)
-
-        determineRange(range, sorted_morton_codes, leaf_count, idx);
-
-        const first = range[0];
-        const last = range[1];
-
-        // Determine where to split the range.
-
-        const split = find_split(sorted_morton_codes, first, last);
-        assert.isNonNegativeInteger(split, 'split');
-
-        // Select childA.
-
-        let childA;
-        if (split === first) {
-            childA = leaf_nodes[split];
-        } else {
-            childA = internal_nodes[split];
-        }
-
-        // Select childB.
-
-        let childB;
-        if (split + 1 === last) {
-            childB = leaf_nodes[split + 1];
-        } else {
-            childB = internal_nodes[split + 1];
-        }
-
-        // Record parent-child relationships.
-        const parent = internal_nodes[idx];
-
-        bvh.node_assign_children_only(parent, childA, childB);
-    }
-
-    // Node 0 is the root.
-    const root = internal_nodes[0];
-
-    bvh.node_set_parent(root, NULL_NODE);
-
-    // update bounds
-    ebvh_update_hierarchy_bounds(bvh, root);
-
-    return root;
-}
+import { assert } from "../../assert.js";
+import { NULL_NODE } from "./BVH.js";
+
+/**
+ * Karras 2012 — "Maximizing Parallelism in the Construction of BVHs, Octrees, and k-d Trees".
+ *
+ * For a sorted array of N Morton codes, build a binary radix tree of N-1 internal
+ * nodes and N leaves. Each internal node corresponds to the longest common prefix
+ * of a contiguous range of Morton codes; its split point is where the first bit
+ * after that prefix flips from 0 to 1.
+ *
+ * The caller must pre-allocate:
+ *   - `leaf_count` leaf nodes in `bvh`, each with its AABB and user-data set;
+ *     their IDs are passed in `leaf_nodes`, sorted by `sorted_morton_codes`.
+ *   - `leaf_count - 1` internal nodes (when `leaf_count >= 2`); their IDs are
+ *     passed in `internal_nodes`, in arbitrary order.
+ *
+ * The returned root index is wired into the tree; internal-node bounds and
+ * heights are filled in by a bottom-up refit after structural construction.
+ *
+ * @see "Thinking Parallel, Part III: Tree Construction on the GPU", 2012 by Tero Karras
+ */
+
+/**
+ * Compute the position of the first bit where the codes at `first` and `last`
+ * differ in their longest-common-prefix sense — i.e. the split point for the
+ * range [first, last]. Returns an index `s` such that all codes in [first, s]
+ * share more leading bits with the firstCode than codes in [s+1, last] do.
+ *
+ * @param {number[]|Uint32Array} sortedMortonCodes
+ * @param {number} first
+ * @param {number} last
+ * @return {number}
+ */
+function find_split(sortedMortonCodes, first, last) {
+    const firstCode = sortedMortonCodes[first];
+    const lastCode = sortedMortonCodes[last];
+
+    // Identical Morton codes (multiple leaves at the same point): split the
+    // range in the middle so we still build a balanced subtree.
+    if (firstCode === lastCode) {
+        return (first + last) >>> 1;
+    }
+
+    // Number of highest bits that match between first and last.
+    const commonPrefix = Math.clz32(firstCode ^ lastCode);
+
+    // Binary search for the highest index that still shares more than
+    // `commonPrefix` bits with the firstCode.
+    let split = first;
+    let step = last - first;
+
+    do {
+        step = (step + 1) >>> 1;
+        const newSplit = split + step;
+
+        if (newSplit < last) {
+            const splitCode = sortedMortonCodes[newSplit];
+            const splitPrefix = Math.clz32(firstCode ^ splitCode);
+            if (splitPrefix > commonPrefix) {
+                split = newSplit;
+            }
+        }
+    } while (step > 1);
+
+    return split;
+}
+
+/**
+ * Determine the [first, last] code range covered by internal node `idx`.
+ *
+ * @see https://github.com/mbartling/cuda-bvh/blob/7f2f98d9d29956c3559632e59104ba66f31f80b8/kernels/bvh.cu#L276
+ * @param {number[]|Uint32Array} output 2-element output [first, last]
+ * @param {number[]|Uint32Array} sortedMortonCodes
+ * @param {number} leaf_count
+ * @param {number} idx
+ */
+function determineRange(output, sortedMortonCodes, leaf_count, idx) {
+    // For the root (idx === 0) the range is unambiguously [0, leaf_count - 1].
+    // We short-circuit so callers don't have to special-case it.
+    if (idx === 0) {
+        output[0] = 0;
+        output[1] = leaf_count - 1;
+        return;
+    }
+
+    const codeIdx = sortedMortonCodes[idx];
+    const prefixRight = Math.clz32(codeIdx ^ sortedMortonCodes[idx + 1]);
+    const prefixLeft  = Math.clz32(codeIdx ^ sortedMortonCodes[idx - 1]);
+
+    const direction = (prefixRight - prefixLeft) > 0 ? 1 : -1;
+
+    // Minimum prefix length we require to stay in this range — anything that
+    // shares fewer bits than this is "outside" the node's subtree.
+    const min_prefix_range = Math.clz32(codeIdx ^ sortedMortonCodes[idx - direction]);
+
+    // Expand maximum range with exponential growth, bounded by array.
+    let lmax = 2;
+    let next_key = idx + lmax * direction;
+
+    while (
+        next_key >= 0 &&
+        next_key < leaf_count &&
+        Math.clz32(codeIdx ^ sortedMortonCodes[next_key]) > min_prefix_range
+    ) {
+        lmax *= 2;
+        next_key = idx + lmax * direction;
+    }
+
+    // Binary-search for the actual length within [0, lmax].
+    let length = 0;
+    do {
+        lmax = (lmax + 1) >> 1;
+        const new_val = idx + (length + lmax) * direction;
+
+        if (new_val >= 0 && new_val < leaf_count) {
+            const prefix = Math.clz32(codeIdx ^ sortedMortonCodes[new_val]);
+            if (prefix > min_prefix_range) {
+                length += lmax;
+            }
+        }
+    } while (lmax > 1);
+
+    const j = idx + length * direction;
+
+    output[0] = Math.min(idx, j);
+    output[1] = Math.max(idx, j);
+}
+
+/**
+ * Bottom-up bounds and height refit for a radix-built tree.
+ *
+ * Walks the tree once in pre-order to collect every reachable node, then
+ * processes them in reverse — which is post-order for trees — combining
+ * each internal node's AABB from its children and updating its height.
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ */
+function refit_radix_tree(bvh, root) {
+    if (root === NULL_NODE) {
+        return;
+    }
+
+    const order = [];
+    const stack = [root];
+
+    while (stack.length > 0) {
+        const node = stack.pop();
+        order.push(node);
+
+        if (!bvh.node_is_leaf(node)) {
+            stack.push(bvh.node_get_child1(node));
+            stack.push(bvh.node_get_child2(node));
+        }
+    }
+
+    for (let i = order.length - 1; i >= 0; i--) {
+        const node = order[i];
+        if (bvh.node_is_leaf(node)) {
+            continue;
+        }
+        const c1 = bvh.node_get_child1(node);
+        const c2 = bvh.node_get_child2(node);
+        bvh.node_set_combined_aabb(node, c1, c2);
+        bvh.node_set_height(
+            node,
+            1 + Math.max(bvh.node_get_height(c1), bvh.node_get_height(c2))
+        );
+    }
+}
+
+/**
+ * Build a binary radix tree over the given leaves and Morton codes.
+ *
+ * @param {BVH} bvh
+ * @param {number[]|Uint32Array} leaf_nodes
+ *        Pre-allocated leaf node IDs, ordered to match `sorted_morton_codes`
+ *        (i.e. leaf_nodes[i]'s code is sorted_morton_codes[i]).
+ * @param {number[]|Uint32Array} sorted_morton_codes
+ *        Morton codes in non-decreasing order. May contain duplicates.
+ * @param {number} leaf_count
+ *        Number of leaves (must equal the length of `leaf_nodes` and
+ *        `sorted_morton_codes` that the function will actually look at).
+ * @param {number[]|Uint32Array} internal_nodes
+ *        Pre-allocated internal node IDs, of length at least `leaf_count - 1`.
+ *        Ignored when leaf_count < 2.
+ * @returns {number} The root node id, or NULL_NODE if leaf_count is 0.
+ */
+export function ebvh_build_hierarchy_radix(
+    bvh,
+    leaf_nodes,
+    sorted_morton_codes,
+    leaf_count,
+    internal_nodes
+) {
+    assert.isNonNegativeInteger(leaf_count, 'leaf_count');
+
+    // Empty input: nothing to build.
+    if (leaf_count === 0) {
+        return NULL_NODE;
+    }
+
+    // Single leaf is its own root; no internal node needed.
+    if (leaf_count === 1) {
+        const root = leaf_nodes[0];
+        bvh.node_set_parent(root, NULL_NODE);
+        return root;
+    }
+
+    // General case: build leaf_count - 1 internal nodes per Karras 2012.
+    const range = new Uint32Array(2);
+    const internal_node_count = leaf_count - 1;
+
+    for (let idx = 0; idx < internal_node_count; idx++) {
+        determineRange(range, sorted_morton_codes, leaf_count, idx);
+
+        const first = range[0];
+        const last = range[1];
+
+        const split = find_split(sorted_morton_codes, first, last);
+        assert.isNonNegativeInteger(split, 'split');
+
+        // child A: the [first, split] subrange's owner. If that subrange is a
+        // single element it's a leaf; otherwise it's the internal node at
+        // index `split` (Karras's convention: internal node k owns the range
+        // whose left boundary is at code-index k).
+        const childA = (split === first)
+            ? leaf_nodes[split]
+            : internal_nodes[split];
+
+        // child B: the [split+1, last] subrange's owner.
+        const childB = (split + 1 === last)
+            ? leaf_nodes[split + 1]
+            : internal_nodes[split + 1];
+
+        const parent = internal_nodes[idx];
+        bvh.node_assign_children_only(parent, childA, childB);
+    }
+
+    // Internal node 0 covers [0, leaf_count - 1] — the whole tree — and is
+    // therefore the root.
+    const root = internal_nodes[0];
+    bvh.node_set_parent(root, NULL_NODE);
+
+    // Walk back up to fill in correct AABBs and heights for every internal
+    // node. Heights set during construction by node_assign_children_only are
+    // stale because children may not have been built yet at parent-creation
+    // time.
+    refit_radix_tree(bvh, root);
+
+    return root;
+}

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

@@ -107,7 +107,7 @@ export function ebvh_update_hierarchy_bounds(bvh, root = bvh.root) {
 
         } else if (came_from_type === CAME_FROM_TYPE_PARENT) {
             const child1 = bvh.node_get_child1(node);
-            const child2 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
 
             if (child1 !== NULL_NODE) {
                 came_from_type = CAME_FROM_TYPE_PARENT;

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

@@ -1,6 +1,10 @@
 /**
- * UNTESTED, DO NOT USE.
- * Use {@link Cache} or {@link LoadingCache} instead
+ * NOT PRODUCTION READY. Work in progress, behaviour is incomplete and
+ * unverified — do not depend on it from product code, and do not add tests
+ * to lock in its current half-finished shape. Use {@link Cache} or
+ * {@link LoadingCache} for any real caching need until this class is
+ * finished and reviewed.
+ *
  * @template K,V
  */
 export class CacheV2<K, V> {

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

@@ -1 +1 @@
-{"version":3,"file":"CacheV2.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/CacheV2.js"],"names":[],"mappings":"AAkEA;;;;GAIG;AACH;IAKQ;;;;OAIG;IACH,iCAA2C;IAC3C;;;;OAIG;IACH,oCAA8C;IAE9C,6BAA6B;IAE7B,yBAAyB;IACzB,yBAAyB;IAG7B;;;OAGG;IACH,0BAHa,MAAM,CAKlB;IAED;;;OAGG;IACH,6CAEC;IAED,6BAEC;IAED,mCAEC;IAED,0CAEC;IAED;;;OAGG;IACH,8BAEC;IAED,kCAEC;IAED,oCAEC;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAyBhB;IAED;;;OAGG;IACH,qBAGC;IAED;;;;;;;;;OASG;IACH,sBAJW,MAAM,eACN,MAAM,GACJ,OAAO,CAmBnB;IAGD,0BAyBC;IAED,sBAEC;CACJ"}
+{"version":3,"file":"CacheV2.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/CacheV2.js"],"names":[],"mappings":"AAkEA;;;;;;;;GAQG;AACH;IAKQ;;;;OAIG;IACH,iCAA2C;IAC3C;;;;OAIG;IACH,oCAA8C;IAE9C,6BAA6B;IAE7B,yBAAyB;IACzB,yBAAyB;IAG7B;;;OAGG;IACH,0BAHa,MAAM,CAKlB;IAED;;;OAGG;IACH,6CAEC;IAED,6BAEC;IAED,mCAEC;IAED,0CAEC;IAED;;;OAGG;IACH,8BAEC;IAED,kCAEC;IAED,oCAEC;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAyBhB;IAED;;;OAGG;IACH,qBAGC;IAED;;;;;;;;;OASG;IACH,sBAJW,MAAM,eACN,MAAM,GACJ,OAAO,CAmBnB;IAGD,0BAyBC;IAED,sBAEC;CACJ"}

package/src/core/cache/CacheV2.js

@@ -65,8 +65,12 @@ class Node {
 }
 
 /**
- * UNTESTED, DO NOT USE.
- * Use {@link Cache} or {@link LoadingCache} instead
+ * NOT PRODUCTION READY. Work in progress, behaviour is incomplete and
+ * unverified — do not depend on it from product code, and do not add tests
+ * to lock in its current half-finished shape. Use {@link Cache} or
+ * {@link LoadingCache} for any real caching need until this class is
+ * finished and reviewed.
+ *
  * @template K,V
  */
 export class CacheV2 {

package/src/engine/graphics/ecs/light/LightSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/light/LightSystem.js"],"names":[],"mappings":"AAmQA;;;;;GAKG;AACH,2DAHW,MAAM,SACN,KAAK,QAwCf;;uBAxSsB,qBAAqB;sBAGtB,YAAY;AAOlC;IACI;;;;;OAKG;IACH,2CAsFC;IA1EG,kDAAsC;IAGtC,6DAEC;IAGD,eAAoB;IACpB,WAA2B;IAC3B,aAAwB;IAExB;;;;OAIG;IACH,mBAA0B;IAE1B;;;;OAIG;IACH,wBAA2B;IAE3B,gBAAkB;IAElB;;;;OAIG;IACH,kBAAoC;IAGpC;;;;OAIG;IACH,2BAA8B;IAC9B;;;;OAIG;IACH,iBAAoB;IAGpB;;;;OAIG;IACH,4BAAgD;IAqBpD,mCAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,QAkB/B;IAED;;;;OAIG;IACH,4BAHW,KAAK,UACL,MAAM,QAMhB;IAED,2CAOC;IAED,4CASC;IAGD,4CAOC;IAED;;;;;OAKG;IACH,wCAmCC;IAED;;;;;;OAMG;IACH,sCAwBC;CACJ;sCA3PqC,8CAA8C;0BAC1D,qCAAqC;4CAFnB,uDAAuD"}
+{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/light/LightSystem.js"],"names":[],"mappings":"AAuQA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,2DANW,YAAY,SACZ,WAAW,oBACX,MAAM,QAmEhB;;uBAvVsB,qBAAqB;sBAEtB,YAAY;AAQlC;IACI;;;;;OAKG;IACH,2CAsFC;IA1EG,kDAAsC;IAGtC,6DAEC;IAGD,eAAoB;IACpB,WAA2B;IAC3B,aAAwB;IAExB;;;;OAIG;IACH,mBAA0B;IAE1B;;;;OAIG;IACH,wBAA2B;IAE3B,gBAAkB;IAElB;;;;OAIG;IACH,kBAAoC;IAGpC;;;;OAIG;IACH,2BAA8B;IAC9B;;;;OAIG;IACH,iBAAoB;IAGpB;;;;OAIG;IACH,4BAAgD;IAqBpD,mCAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,QAkB/B;IAED;;;;OAIG;IACH,4BAHW,KAAK,UACL,MAAM,QAMhB;IAED,2CAOC;IAED,4CASC;IAGD,4CAOC;IAED;;;;;OAKG;IACH,wCAmCC;IAED;;;;;;OAMG;IACH,sCAwBC;CACJ;sCA3PqC,8CAA8C;0BAC1D,qCAAqC;4CAFnB,uDAAuD"}