@woosh/meep-engine 3.29.0 → 3.30.0

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_collapse_fold_limit.js

@@ -0,0 +1,228 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * How far along a segment an edge collapse may place its surviving vertex before one of the
+ * triangles it keeps turns over.
+ *
+ * **It is one walk and not a search, because the fold test is linear in the placement.** A surviving
+ * triangle keeps two of its corners, `b` and `c`, exactly where they were, so with the third at `p`
+ * its area vector is
+ *
+ *     N(p) = (b - p) x (c - p) = b x c + p x (b - c)
+ *
+ * which is affine in `p`. "Still facing the way it did", `N(before) . N(p) > 0`, is therefore a
+ * linear inequality; the placements that fold nothing are an intersection of open half-spaces, which
+ * is convex; and along a segment `p(t) = from + t (to - from)` the test collapses to an affine
+ * function of the single parameter `t`. Two evaluations give the exact crossing rather than
+ * approaching it -- with `d0` at `from` and `d1` at `to`, the triangle reaches zero area at
+ * `t = d0 / (d0 - d1)` -- and the smallest crossing over both fans is the answer.
+ *
+ * The walk is {@link bt_edge_collapse_would_fold}'s, which is the same question asked at one point
+ * instead of two, and that function is now this one.
+ *
+ * **What it is for.** A quadric names the placement that best fits the surface and cannot see a fold
+ * at all: on a flat region every placement in the plane scores zero, so nothing in the price stops a
+ * one-ring that is not star-shaped about the target from turning inside out. A caller that tests its
+ * preferred placement and abandons the collapse when it folds has treated a bad *placement* as an
+ * impossible *operation*, and those are different things -- measured over one Zorah primitive, 15%
+ * of all candidate collapses were discarded that way, and the simplifier then reported itself
+ * finished with a mesh it could still have halved. Sliding back toward a placement the surface
+ * already passes through is what turns that refusal into an answer, and this is what says how far
+ * back to slide.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+const scratch_moved = new Float32Array(3);
+const scratch_b = new Float32Array(3);
+const scratch_c = new Float32Array(3);
+const scratch_before = new Float32Array(3);
+const scratch_at_from = new Float32Array(3);
+const scratch_at_to = new Float32Array(3);
+
+/**
+ * Unnormalised triangle normal `(b - a) x (c - a)`, written into `out`.
+ *
+ * Deliberately not `v3_compute_triangle_normal`: this needs the raw cross product, because a
+ * vanishing magnitude is what says the result is a zero-area sliver and the `dot <= 0` test below is
+ * what rejects it. Normalising discards that magnitude, and that function answers `(0, 1, 0)` for a
+ * degenerate triangle -- which would let a collapse-to-sliver walk straight past the guard.
+ *
+ * @param {Float32Array} out
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ */
+function triangle_cross(out, ax, ay, az, bx, by, bz, cx, cy, cz) {
+    const ux = bx - ax;
+    const uy = by - ay;
+    const uz = bz - az;
+
+    const vx = cx - ax;
+    const vy = cy - ay;
+    const vz = cz - az;
+
+    out[0] = uy * vz - uz * vy;
+    out[1] = uz * vx - ux * vz;
+    out[2] = ux * vy - uy * vx;
+}
+
+/**
+ * The limit over one endpoint's fan.
+ *
+ * Faces that also hold `other` are skipped: those are the collapse's own faces and they die with it.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} moved the vertex whose position changes
+ * @param {number} other the collapse's other endpoint
+ * @param {Float32Array|number[]} from
+ * @param {number} from_offset
+ * @param {Float32Array|number[]} to
+ * @param {number} to_offset
+ * @returns {number} as {@link bt_edge_collapse_fold_limit}, over this fan alone
+ */
+function fan_fold_limit(mesh, moved, other, from, from_offset, to, to_offset) {
+    mesh.vertex_read_coordinate(scratch_moved, 0, moved);
+
+    const face_pool = mesh.faces;
+
+    let edge = mesh.vertex_read_edge(moved);
+
+    if (edge === NULL_POINTER) {
+        return 1;
+    }
+
+    const start_edge = edge;
+
+    let limit = 1;
+
+    do {
+        const first_loop = mesh.edge_read_loop(edge);
+
+        if (first_loop !== NULL_POINTER) {
+            let loop = first_loop;
+
+            do {
+                // each face of the fan is reached exactly once, via the loop anchored at `moved`
+                if (mesh.loop_read_vertex(loop) === moved) {
+                    const face = mesh.loop_read_face(loop);
+
+                    if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
+                        const loop_b = mesh.loop_read_next(loop);
+                        const loop_c = mesh.loop_read_next(loop_b);
+
+                        // triangles only; a larger polygon has no single normal to compare
+                        if (mesh.loop_read_next(loop_c) === loop) {
+                            const b = mesh.loop_read_vertex(loop_b);
+                            const c = mesh.loop_read_vertex(loop_c);
+
+                            if (b !== other && c !== other) {
+                                mesh.vertex_read_coordinate(scratch_b, 0, b);
+                                mesh.vertex_read_coordinate(scratch_c, 0, c);
+
+                                triangle_cross(
+                                    scratch_before,
+                                    scratch_moved[0], scratch_moved[1], scratch_moved[2],
+                                    scratch_b[0], scratch_b[1], scratch_b[2],
+                                    scratch_c[0], scratch_c[1], scratch_c[2]
+                                );
+                                triangle_cross(
+                                    scratch_at_from,
+                                    from[from_offset], from[from_offset + 1], from[from_offset + 2],
+                                    scratch_b[0], scratch_b[1], scratch_b[2],
+                                    scratch_c[0], scratch_c[1], scratch_c[2]
+                                );
+                                triangle_cross(
+                                    scratch_at_to,
+                                    to[to_offset], to[to_offset + 1], to[to_offset + 2],
+                                    scratch_b[0], scratch_b[1], scratch_b[2],
+                                    scratch_c[0], scratch_c[1], scratch_c[2]
+                                );
+
+                                const d0 = scratch_before[0] * scratch_at_from[0]
+                                    + scratch_before[1] * scratch_at_from[1]
+                                    + scratch_before[2] * scratch_at_from[2];
+
+                                if (d0 <= 0) {
+                                    // `from` is not a placement at all, so there is no segment left
+                                    // to measure and nothing further to learn from this fan.
+                                    return -1;
+                                }
+
+                                const d1 = scratch_before[0] * scratch_at_to[0]
+                                    + scratch_before[1] * scratch_at_to[1]
+                                    + scratch_before[2] * scratch_at_to[2];
+
+                                if (d1 <= 0) {
+                                    // Affine in `t` and positive at `0`, so it has exactly one root
+                                    // on the segment and `d0 - d1` cannot vanish.
+                                    const crossing = d0 / (d0 - d1);
+
+                                    if (crossing < limit) {
+                                        limit = crossing;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                loop = mesh.loop_read_radial_next(loop);
+            } while (loop !== first_loop && loop !== NULL_POINTER);
+        }
+
+        edge = (mesh.edge_read_vertex1(edge) === moved)
+            ? mesh.edge_read_v1_disk_next(edge)
+            : mesh.edge_read_v2_disk_next(edge);
+    } while (edge !== start_edge && edge !== NULL_POINTER);
+
+    return limit;
+}
+
+/**
+ * How far from `from` toward `to` may a collapse of `survivor`-`victim` place the surviving vertex
+ * and still turn no surviving triangle over?
+ *
+ * Both fans are walked, because both endpoints move: the victim onto the placement by definition,
+ * and the survivor too wherever the caller puts it somewhere other than where it already sits. The
+ * union of the two is the set of faces the collapse reshapes, which is what makes the answer
+ * symmetric in the two endpoints -- a caller that has not yet settled which of them survives can
+ * rely on that.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} survivor the endpoint that stays allocated
+ * @param {number} victim the endpoint that is removed
+ * @param {Float32Array|number[]} from the placement to measure from, at `t = 0`
+ * @param {Float32Array|number[]} to the placement wanted, at `t = 1`
+ * @param {number} [from_offset]
+ * @param {number} [to_offset]
+ * @returns {number} where the first surviving triangle reaches **zero** area, so the placements that
+ *     fold nothing are `t` in `[0, limit)` -- open at the top, since zero area is refused along with
+ *     a flip, and a caller therefore takes a fraction of this rather than this. `1` when nothing on
+ *     the segment folds, and `-1` when `from` itself does, which is the one answer no amount of
+ *     sliding recovers from.
+ */
+export function bt_edge_collapse_fold_limit(
+    mesh, survivor, victim, from, to, from_offset = 0, to_offset = 0
+) {
+    const on_victim = fan_fold_limit(mesh, victim, survivor, from, from_offset, to, to_offset);
+
+    if (on_victim < 0) {
+        return -1;
+    }
+
+    const on_survivor = fan_fold_limit(mesh, survivor, victim, from, from_offset, to, to_offset);
+
+    if (on_survivor < 0) {
+        return -1;
+    }
+
+    return Math.min(on_victim, on_survivor);
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_collapse_would_fold.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Triangle-inversion rejection for an edge collapse: would any triangle that survives it come out
+ * facing the other way?
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
 /**
  * Would collapsing `survivor`-`victim` onto `target` turn any surviving triangle inside out?
  *
@@ -17,6 +24,12 @@
  * worse rather than better — a pinned endpoint takes the placement with it, and the surviving
  * vertex lands on the pin rather than anywhere the geometry chose.
  *
+ * **A `true` here is not a reason to abandon the collapse**, and a caller free to choose the
+ * placement should not treat it as one. The set of placements that fold nothing is convex, so a
+ * caller holding one placement it likes and one that works can slide between them and find the
+ * best point that does — {@link bt_edge_collapse_fold_limit} is that question, this is the same
+ * walk asking it at a single point, and this function is a call to that one.
+ *
  * @param {BinaryTopology} mesh
  * @param {number} survivor the endpoint that stays allocated
  * @param {number} victim the endpoint that is removed

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_collapse_would_fold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_edge_collapse_would_fold.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_collapse_would_fold.js"],"names":[],"mappings":"AAuIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4EANW,MAAM,UACN,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,kBACrB,MAAM,GACJ,OAAO,CAKnB"}
+{"version":3,"file":"bt_edge_collapse_would_fold.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_collapse_would_fold.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,4EANW,MAAM,UACN,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,kBACrB,MAAM,GACJ,OAAO,CAMnB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_edge_collapse_would_fold.js

@@ -1,4 +1,4 @@
-import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_edge_collapse_fold_limit } from "./bt_edge_collapse_fold_limit.js";
 
 /**
  * Triangle-inversion rejection for an edge collapse: would any triangle that survives it come out
@@ -8,131 +8,6 @@ import { NULL_POINTER } from "../BinaryTopology.js";
  * @copyright Company Named Limited (c) 2026
  */
 
-const scratch_moved = new Float32Array(3);
-const scratch_b = new Float32Array(3);
-const scratch_c = new Float32Array(3);
-const scratch_before = new Float32Array(3);
-const scratch_after = new Float32Array(3);
-
-/**
- * Unnormalised triangle normal `(b - a) x (c - a)`, written into `out`.
- *
- * Deliberately not `v3_compute_triangle_normal`: this needs the raw cross product, because a
- * vanishing magnitude is what says the result is a zero-area sliver and the `dot <= 0` test below is
- * what rejects it. Normalising discards that magnitude, and that function answers `(0, 1, 0)` for a
- * degenerate triangle — which would let a collapse-to-sliver walk straight past the guard.
- *
- * @param {Float32Array} out
- * @param {number} ax
- * @param {number} ay
- * @param {number} az
- * @param {number} bx
- * @param {number} by
- * @param {number} bz
- * @param {number} cx
- * @param {number} cy
- * @param {number} cz
- */
-function triangle_cross(out, ax, ay, az, bx, by, bz, cx, cy, cz) {
-    const ux = bx - ax;
-    const uy = by - ay;
-    const uz = bz - az;
-
-    const vx = cx - ax;
-    const vy = cy - ay;
-    const vz = cz - az;
-
-    out[0] = uy * vz - uz * vy;
-    out[1] = uz * vx - ux * vz;
-    out[2] = ux * vy - uy * vx;
-}
-
-/**
- * Does moving `moved` to `target` reverse any triangle in its fan?
- *
- * Faces that also hold `other` are skipped: those are the collapse's own faces and they die with it.
- *
- * @param {BinaryTopology} mesh
- * @param {number} moved the vertex whose position changes
- * @param {number} other the collapse's other endpoint
- * @param {Float32Array|number[]} target
- * @param {number} target_offset
- * @returns {boolean}
- */
-function fan_would_fold(mesh, moved, other, target, target_offset) {
-    mesh.vertex_read_coordinate(scratch_moved, 0, moved);
-
-    const face_pool = mesh.faces;
-
-    let edge = mesh.vertex_read_edge(moved);
-
-    if (edge === NULL_POINTER) {
-        return false;
-    }
-
-    const start_edge = edge;
-
-    do {
-        const first_loop = mesh.edge_read_loop(edge);
-
-        if (first_loop !== NULL_POINTER) {
-            let loop = first_loop;
-
-            do {
-                // each face of the fan is reached exactly once, via the loop anchored at `moved`
-                if (mesh.loop_read_vertex(loop) === moved) {
-                    const face = mesh.loop_read_face(loop);
-
-                    if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
-                        const loop_b = mesh.loop_read_next(loop);
-                        const loop_c = mesh.loop_read_next(loop_b);
-
-                        // triangles only; a larger polygon has no single normal to compare
-                        if (mesh.loop_read_next(loop_c) === loop) {
-                            const b = mesh.loop_read_vertex(loop_b);
-                            const c = mesh.loop_read_vertex(loop_c);
-
-                            if (b !== other && c !== other) {
-                                mesh.vertex_read_coordinate(scratch_b, 0, b);
-                                mesh.vertex_read_coordinate(scratch_c, 0, c);
-
-                                triangle_cross(
-                                    scratch_before,
-                                    scratch_moved[0], scratch_moved[1], scratch_moved[2],
-                                    scratch_b[0], scratch_b[1], scratch_b[2],
-                                    scratch_c[0], scratch_c[1], scratch_c[2]
-                                );
-                                triangle_cross(
-                                    scratch_after,
-                                    target[target_offset], target[target_offset + 1], target[target_offset + 2],
-                                    scratch_b[0], scratch_b[1], scratch_b[2],
-                                    scratch_c[0], scratch_c[1], scratch_c[2]
-                                );
-
-                                const dot = scratch_before[0] * scratch_after[0]
-                                    + scratch_before[1] * scratch_after[1]
-                                    + scratch_before[2] * scratch_after[2];
-
-                                if (dot <= 0) {
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-                }
-
-                loop = mesh.loop_read_radial_next(loop);
-            } while (loop !== first_loop && loop !== NULL_POINTER);
-        }
-
-        edge = (mesh.edge_read_vertex1(edge) === moved)
-            ? mesh.edge_read_v1_disk_next(edge)
-            : mesh.edge_read_v2_disk_next(edge);
-    } while (edge !== start_edge && edge !== NULL_POINTER);
-
-    return false;
-}
-
 /**
  * Would collapsing `survivor`-`victim` onto `target` turn any surviving triangle inside out?
  *
@@ -152,6 +27,12 @@ function fan_would_fold(mesh, moved, other, target, target_offset) {
  * worse rather than better — a pinned endpoint takes the placement with it, and the surviving
  * vertex lands on the pin rather than anywhere the geometry chose.
  *
+ * **A `true` here is not a reason to abandon the collapse**, and a caller free to choose the
+ * placement should not treat it as one. The set of placements that fold nothing is convex, so a
+ * caller holding one placement it likes and one that works can slide between them and find the
+ * best point that does — {@link bt_edge_collapse_fold_limit} is that question, this is the same
+ * walk asking it at a single point, and this function is a call to that one.
+ *
  * @param {BinaryTopology} mesh
  * @param {number} survivor the endpoint that stays allocated
  * @param {number} victim the endpoint that is removed
@@ -160,6 +41,7 @@ function fan_would_fold(mesh, moved, other, target, target_offset) {
  * @returns {boolean}
  */
 export function bt_edge_collapse_would_fold(mesh, survivor, victim, target, target_offset = 0) {
-    return fan_would_fold(mesh, victim, survivor, target, target_offset)
-        || fan_would_fold(mesh, survivor, victim, target, target_offset);
+    return bt_edge_collapse_fold_limit(
+        mesh, survivor, victim, target, target, target_offset, target_offset
+    ) < 0;
 }

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_build_face_bvh.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,6EAwDC"}
+{"version":3,"file":"bt_mesh_build_face_bvh.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,6EAkEC"}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js

@@ -15,12 +15,22 @@ export function bt_mesh_build_face_bvh(bvh, mesh) {
     // clear out the BVH
     bvh.release_all();
 
-    // NOTE: we assume there are no holes in the allocation, data must be packed
     const face_count = mesh.faces.size;
 
     const vertex_position = new Float32Array(3);
 
     for (let face_id = 0; face_id < face_count; face_id++) {
+        /**
+         * The face pool can have holes: `bt_face_kill` leaves the slot unallocated with its loop
+         * pointer at NULL_POINTER, and reading a loop at that address is off the end of the
+         * DataView. The navmesh pipeline compacts only inside three conditional branches, so "the
+         * caller hands us a packed mesh" was a precondition no caller could honour. The sibling
+         * builder, `bt_mesh_build_surface_triangle_bvh`, skips them the same way.
+         */
+        if (!mesh.faces.is_allocated(face_id)) {
+            continue;
+        }
+
         let bounds_x0 = Infinity;
         let bounds_y0 = Infinity;
         let bounds_z0 = Infinity;

package/src/core/graph/mn_graph_collapse_weighted_edge.js

@@ -62,12 +62,12 @@ export function mn_graph_collapse_weighted_edge(
             heap.delete(b_edge);
         }
 
-        const heap_index = heap.data.indexOf(target_edge);
-
-        if (heap_index !== -1) {
-            // updated edge is in the heap, re-score
-            heap.bubbleDown(heap_index);
-        }
+        // The merge above raises the survivor's weight, and the heap is keyed on `-weight`, so the
+        // survivor's score *falls* and it has to move up. `bubbleDown` alone, which is what this
+        // used to do, is a no-op for an element that has sunk below its parent — the heaviest edge
+        // then sits stranded under a lighter one and the coarsener stops collapsing in weight
+        // order. `updateElementScore` goes both ways, and does not need the heap's private `data`.
+        heap.updateElementScore(target_edge);
 
     }
 

package/src/core/math/lookup/ParameterLookupTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParameterLookupTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/ParameterLookupTable.js"],"names":[],"mappings":"AAWA;IAibI;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,EAAE,cACR,MAAM,EAAE,wBAQlB;IAED;;;;OAIG;IACH,8CAFa,oBAAoB,CA0BhC;IA5bD;;;;OAIG;IACH,uBAHW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,MAFU,MAAM,EAAE,GAAC,YAAY,CAErB;IAEV;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,CAEhB;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,cAA4C;IAUxC;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAI5B;;;OAGG;IACH,WAFW,yBAAyB,QAInC;IAED;;;OAGG;IACH,aAFW,yBAAyB,GAAC,MAAM,QAI1C;IAED;;;;OAIG;IACH,WAHW,yBAAyB,GACvB,OAAO,CAInB;IAED,yBAEC;IAED,0BAGC;IAED;;;;MAMC;IAED;;;;OAIG;IACH,2CA2CC;IAED;;;OAGG;IACH,6CAkCC;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA0D5C;IAED,gCAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,cAC7C,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA4B5C;IAED;;;;OAIG;IACH,mBAHW,MAAM,SACN,MAAM,EAAE,QAqClB;IAED;;OAEG;IACH,0BAkBC;IAED,eAgBC;IAED;;;;OAIG;IACH,cAHW,oBAAoB,GAClB,OAAO,CAenB;IAED,oBAwCC;IAgDL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;0CAheyC,gCAAgC"}
+{"version":3,"file":"ParameterLookupTable.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/ParameterLookupTable.js"],"names":[],"mappings":"AAWA;IAsbI;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,EAAE,cACR,MAAM,EAAE,wBAQlB;IAED;;;;OAIG;IACH,8CAFa,oBAAoB,CA0BhC;IAjcD;;;;OAIG;IACH,uBAHW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,MAFU,MAAM,EAAE,GAAC,YAAY,CAErB;IAEV;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,CAEhB;IAEf;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,cAA4C;IAUxC;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAI5B;;;OAGG;IACH,WAFW,yBAAyB,QAInC;IAED;;;OAGG;IACH,aAFW,yBAAyB,GAAC,MAAM,QAI1C;IAED;;;;OAIG;IACH,WAHW,yBAAyB,GACvB,OAAO,CAInB;IAED,yBAEC;IAED,0BAGC;IAED;;;;MAMC;IAED;;;;OAIG;IACH,2CAgDC;IAED;;;OAGG;IACH,6CAkCC;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA0D5C;IAED,gCAUC;IAED;;;;OAIG;IACH,cAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,cAC7C,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA4B5C;IAED;;;;OAIG;IACH,mBAHW,MAAM,SACN,MAAM,EAAE,QAqClB;IAED;;OAEG;IACH,0BAkBC;IAED,eAgBC;IAED;;;;OAIG;IACH,cAHW,oBAAoB,GAClB,OAAO,CAenB;IAED,oBAwCC;IAgDL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;0CAreyC,gCAAgC"}

package/src/core/math/lookup/ParameterLookupTable.js

@@ -107,15 +107,20 @@ export class ParameterLookupTable {
     toBinaryBuffer(buffer) {
         const itemCount = this.positions.length;
 
-        const itemCountBitSize = Math.log2(itemCount);
-
         let itemCountByteSize;
 
-        if (itemCountBitSize <= 8) {
+        /**
+         * Sized from the value and not from `Math.log2(itemCount)`: the bits needed to hold `n` are
+         * `ceil(log2(n + 1))`, so a log2 test is off by exactly one representable value at each
+         * boundary. 256 read as "8 bits, fits a byte" and `setUint8` then wrote `256 % 256 === 0`,
+         * which left the reader allocating nothing and stopping the cursor an entire payload short
+         * of where the writer left it.
+         */
+        if (itemCount < 256) {
             itemCountByteSize = 1;
-        } else if (itemCountBitSize <= 16) {
+        } else if (itemCount < 65536) {
             itemCountByteSize = 2;
-        } else if (itemCountBitSize <= 32) {
+        } else if (itemCount < 4294967296) {
             itemCountByteSize = 4;
         } else {
             throw new Error(`Item count is too high`);

package/src/core/math/noise/sdnoise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAmDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAkIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CA+OlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA+RlB"}
+{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAsDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAmIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CAgPlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgSlB"}

package/src/core/math/noise/sdnoise.js

@@ -196,7 +196,10 @@ function grad4(result, hash) {
  * @returns {number}
  */
 export function sdnoise1(derivatives, x) {
-    const i0 = x | 0;
+    //Math.floor, not `| 0`: `| 0` truncates toward zero, which names the cell above a negative
+    //point rather than the one containing it, and tears the field along every negative cell boundary.
+    //Gustavson's reference uses FASTFLOOR here for exactly this reason.
+    const i0 = Math.floor(x);
     const i1 = i0 + 1;
 
     const x0 = x - i0;
@@ -275,8 +278,9 @@ export function sdnoise2(derivatives, x, y) {
     const xs = x + s;
     const ys = y + s;
 
-    let ii, i = xs | 0;
-    let jj, j = ys | 0;
+    //see sdnoise1 on why this is Math.floor and not `| 0`
+    let ii, i = Math.floor(xs);
+    let jj, j = Math.floor(ys);
 
     const t = (i + j) * G2;
     const X0 = i - t; /* Unskew the cell origin back to (x,y) space */
@@ -426,9 +430,10 @@ export function sdnoise3(derivatives, x, y, z) {
     const ys = y + s;
     const zs = z + s;
 
-    const i = xs | 0;
-    const j = ys | 0;
-    const k = zs | 0;
+    //see sdnoise1 on why this is Math.floor and not `| 0`
+    const i = Math.floor(xs);
+    const j = Math.floor(ys);
+    const k = Math.floor(zs);
 
     const t = (i + j + k) * G3;
 
@@ -683,10 +688,11 @@ export function sdnoise4(derivatives, x, y, z, w) {
     const zs = z + s;
     const ws = w + s;
 
-    let ii, i = xs | 0;
-    let jj, j = ys | 0;
-    let kk, k = zs | 0;
-    let ll, l = ws | 0;
+    //see sdnoise1 on why this is Math.floor and not `| 0`
+    let ii, i = Math.floor(xs);
+    let jj, j = Math.floor(ys);
+    let kk, k = Math.floor(zs);
+    let ll, l = Math.floor(ws);
 
     const t = (i + j + k + l) * G4; // Factor for 4D unskewing
     const X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space

package/src/core/model/object/ImmutableObjectPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImmutableObjectPool.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/ImmutableObjectPool.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IA+BI;;;OAaC;IA3CD;;;OAGG;IACH,wBAAwB;IACxB;;;OAGG;IACH,MAFU,QAAQ,GAAG,EAAE,aAAa,GAAG,EAAC,KAAK,CAAC,EAAE,CAAC,CAE5B;IAErB;;;;OAIG;IACH,gBAAe;IACf;;;;OAIG;IACH,eAAc;IAEd;;;OAGG;IACH,MAFU,MAAM,CAEP;IAIL;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gBAFU,MAAM,CAEoB;IAGxC,qBAuBC;IAED;;;;;OAKG;IACH,yBAUC;IAED;;;OAGG;IACH,cAIC;IAED;;;;OAIG;IACH,wBAkBC;IAED,mCA2CC;CACJ;wBA9KuB,iCAAiC;6BAD5B,6BAA6B"}
+{"version":3,"file":"ImmutableObjectPool.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/ImmutableObjectPool.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IA+BI;;;OAaC;IA3CD;;;OAGG;IACH,wBAAwB;IACxB;;;OAGG;IACH,MAFU,QAAQ,GAAG,EAAE,aAAa,GAAG,EAAC,KAAK,CAAC,EAAE,CAAC,CAE5B;IAErB;;;;OAIG;IACH,gBAAe;IACf;;;;OAIG;IACH,eAAc;IAEd;;;OAGG;IACH,MAFU,MAAM,CAEP;IAIL;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gBAFU,MAAM,CAEoB;IAGxC,qBAuBC;IAED;;;;;OAKG;IACH,yBAUC;IAED;;;OAGG;IACH,cAIC;IAED;;;;OAIG;IACH,wBAkBC;IAED,mCAqDC;CACJ;wBAxLuB,iCAAiC;6BAD5B,6BAA6B"}

package/src/core/model/object/ImmutableObjectPool.js

@@ -131,14 +131,9 @@ export class ImmutableObjectPool {
 
     add(key, value) {
 
-        let elements = this.data.get(key);
-
-        if (elements === undefined) {
-            // no elements for this key, create container
-            elements = [];
-            this.data.set(key, elements);
+        const existing_elements = this.data.get(key);
 
-        } else if (elements.length >= this.perKeyCapacity) {
+        if (existing_elements !== undefined && existing_elements.length >= this.perKeyCapacity) {
             // reached capacity for this key, discard element
             return false;
         }
@@ -149,6 +144,21 @@ export class ImmutableObjectPool {
             this.__removeElement(this.__first);
         }
 
+        /**
+         * Resolved after the eviction, never before. When the victim is the last element under this
+         * same key, `__removeElement` deletes the bucket out of the map — a reference taken before
+         * that points at an array nothing can reach any more, and the element pushed into it is
+         * counted in `size` and linked into the eviction list but invisible to `get`, which then
+         * makes `clear` throw when it walks the list onto it.
+         */
+        let elements = this.data.get(key);
+
+        if (elements === undefined) {
+            // no elements for this key, create container
+            elements = [];
+            this.data.set(key, elements);
+        }
+
         const cache_element = new CacheElement();
 
         cache_element.value = value;

package/src/core/process/executor/ConcurrentExecutor.d.ts

@@ -85,11 +85,7 @@ declare class ConcurrentExecutor {
      * @returns {boolean}
      */
     contains(task: Task): boolean;
-    /**
-     * kicks the scheduler into action, this is an internal method and should not be called from outside
-     * @private
-     */
-    private prod;
+    prod(): void;
     join(callback: any): void;
     #private;
 }

package/src/core/process/executor/ConcurrentExecutor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConcurrentExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/executor/ConcurrentExecutor.js"],"names":[],"mappings":";mBAQa,OAAO,iBAAiB,EAAE,IAAI;wBAC9B,OAAO,sBAAsB,EAAE,OAAO;AAYnD;;GAEG;AACH;IAaI;;;;;OAKG;IACH,wBAJW,MAAM,aACN,MAAM,EAwChB;IApCG;;;OAGG;IACH,WAFU,MAAM,CAEU;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAES;IAEzB;;;OAGG;IACH,YAFU,IAAI,EAAE,CAEI;IAEpB;;;;MAIC;IAED,cAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,GAAC,gBAAgB,CAES;IAG9C;;;OAGG;IACH,oBAFW,SAAS,QAqEnB;IAED;;;OAGG;IACH,mBAFW,SAAS,QAenB;IAED;;;;OAIG;IACH,iBAHW,IAAI,GACH,OAAO,CAwBlB;IAED;;;OAGG;IACH,UAFW,IAAI,QAKd;IAED;;;OAGG;IACH,eAFW,IAAI,EAAE,QAMhB;IAED;;;;OAIG;IACH,kBAkCC;IAED;;OAEG;IACH,qBAyCC;IAED;;;;OAIG;IACH,eAHW,IAAI,GACF,OAAO,CAYnB;IAwLD;;;OAGG;IACH,aAQC;IAED,0BAMC;;CACJ;;;;mBAhhBkB,+BAA+B;wBAohBxC,MAAM"}
+{"version":3,"file":"ConcurrentExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/executor/ConcurrentExecutor.js"],"names":[],"mappings":";mBASa,OAAO,iBAAiB,EAAE,IAAI;wBAC9B,OAAO,sBAAsB,EAAE,OAAO;AAYnD;;GAEG;AACH;IAaI;;;;;OAKG;IACH,wBAJW,MAAM,aACN,MAAM,EAwChB;IApCG;;;OAGG;IACH,WAFU,MAAM,CAEU;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAES;IAEzB;;;OAGG;IACH,YAFU,IAAI,EAAE,CAEI;IAEpB;;;;MAIC;IAED,cAAiB;IAEjB;;;OAGG;IACH,QAFU,MAAM,GAAC,gBAAgB,CAES;IAG9C;;;OAGG;IACH,oBAFW,SAAS,QAqEnB;IAED;;;OAGG;IACH,mBAFW,SAAS,QAenB;IAED;;;;OAIG;IACH,iBAHW,IAAI,GACH,OAAO,CAwBlB;IAED;;;OAGG;IACH,UAFW,IAAI,QAKd;IAED;;;OAGG;IACH,eAFW,IAAI,EAAE,QAMhB;IAED;;;;OAIG;IACH,kBAkCC;IAED;;OAEG;IACH,qBAgDC;IAED;;;;OAIG;IACH,eAHW,IAAI,GACF,OAAO,CAYnB;IA8QD,aAYC;IAED,0BAMC;;CACJ;;;;mBA9mBkB,+BAA+B;wBAknBxC,MAAM"}