@woosh/meep-engine 3.28.0 → 3.30.0

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_live_count.d.ts

@@ -0,0 +1,22 @@
+/**
+ * How many wedges a mesh still has — how many vertices it would ship.
+ *
+ * Not `vertices.count()`, and the difference is the whole of what a wedge is for: a vertex whose
+ * corners shade two ways is two vertices to anything that carries a value per vertex, which is every
+ * meshlet, every vertex buffer and every renderer ever written. A caller sizing against that limit
+ * has to ask this rather than the pool.
+ *
+ * Counted off the per-vertex lists rather than from {@link BtWedgeSet#count}, because that one
+ * includes every id ever handed out and a collapse merges them away. Vertices the pool has released
+ * are skipped, so a sweep that removed faceless vertices without touching the wedge set is accounted
+ * for.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {BtWedgeSet} wedges
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_wedges_live_count(mesh: BinaryTopology, wedges: BtWedgeSet): number;
+//# sourceMappingURL=bt_wedges_live_count.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_live_count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_wedges_live_count.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_wedges_live_count.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gFALa,MAAM,CA4BlB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_live_count.js

@@ -0,0 +1,46 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * How many wedges a mesh still has — how many vertices it would ship.
+ *
+ * Not `vertices.count()`, and the difference is the whole of what a wedge is for: a vertex whose
+ * corners shade two ways is two vertices to anything that carries a value per vertex, which is every
+ * meshlet, every vertex buffer and every renderer ever written. A caller sizing against that limit
+ * has to ask this rather than the pool.
+ *
+ * Counted off the per-vertex lists rather than from {@link BtWedgeSet#count}, because that one
+ * includes every id ever handed out and a collapse merges them away. Vertices the pool has released
+ * are skipped, so a sweep that removed faceless vertices without touching the wedge set is accounted
+ * for.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {BtWedgeSet} wedges
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_wedges_live_count(mesh, wedges) {
+    const vertex_pool = mesh.vertices;
+
+    const first_of_vertex = wedges.first_of_vertex;
+    const next_of_wedge = wedges.next_of_wedge;
+
+    let count = 0;
+
+    for (let vertex = 0; vertex < vertex_pool.size; vertex++) {
+        if (!vertex_pool.is_allocated(vertex)) {
+            continue;
+        }
+
+        for (
+            let wedge = first_of_vertex[vertex];
+            wedge !== NULL_POINTER;
+            wedge = next_of_wedge[wedge]
+        ) {
+            count++;
+        }
+    }
+
+    return count;
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_per_vertex.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The wedge set of a mesh with no appearance seams: one wedge per vertex, and its id *is* the
+ * vertex id.
+ *
+ * The degenerate case, and worth having a name because it is what everything that does not carry
+ * appearance wants. A caller whose per-vertex arrays are indexed by vertex id can hand this to
+ * {@link bt_mesh_simplify_with_quadrics} and keep indexing them by vertex id, because here the two
+ * are the same number. Nothing requires wedge ids to be dense — only to be distinct — which is what
+ * lets that be true.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {BtWedgeSet}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_wedges_per_vertex(mesh: BinaryTopology): BtWedgeSet;
+import { BtWedgeSet } from "../BtWedgeSet.js";
+//# sourceMappingURL=bt_wedges_per_vertex.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_per_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_wedges_per_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_wedges_per_vertex.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,4DALa,UAAU,CAkCtB;2BA/C0B,kBAAkB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_wedges_per_vertex.js

@@ -0,0 +1,49 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { BtWedgeSet } from "../BtWedgeSet.js";
+
+/**
+ * The wedge set of a mesh with no appearance seams: one wedge per vertex, and its id *is* the
+ * vertex id.
+ *
+ * The degenerate case, and worth having a name because it is what everything that does not carry
+ * appearance wants. A caller whose per-vertex arrays are indexed by vertex id can hand this to
+ * {@link bt_mesh_simplify_with_quadrics} and keep indexing them by vertex id, because here the two
+ * are the same number. Nothing requires wedge ids to be dense — only to be distinct — which is what
+ * lets that be true.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {BtWedgeSet}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_wedges_per_vertex(mesh) {
+    const vertex_pool = mesh.vertices;
+    const loop_pool = mesh.loops;
+
+    const result = new BtWedgeSet();
+
+    result.count = vertex_pool.size;
+
+    result.parent = new Uint32Array(vertex_pool.size);
+    result.next_of_wedge = new Uint32Array(vertex_pool.size).fill(NULL_POINTER);
+    result.first_of_vertex = new Uint32Array(vertex_pool.size).fill(NULL_POINTER);
+
+    for (let vertex = 0; vertex < vertex_pool.size; vertex++) {
+        result.parent[vertex] = vertex;
+
+        if (vertex_pool.is_allocated(vertex)) {
+            result.first_of_vertex[vertex] = vertex;
+        }
+    }
+
+    result.of_loop = new Uint32Array(loop_pool.size).fill(NULL_POINTER);
+
+    for (let loop = 0; loop < loop_pool.size; loop++) {
+        if (loop_pool.is_allocated(loop)) {
+            result.of_loop[loop] = mesh.loop_read_vertex(loop);
+        }
+    }
+
+    return result;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * 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: BinaryTopology, survivor: number, victim: number, from: Float32Array | number[], to: Float32Array | number[], from_offset?: number, to_offset?: number): number;
+//# sourceMappingURL=bt_edge_collapse_fold_limit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_edge_collapse_fold_limit.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_collapse_fold_limit.js"],"names":[],"mappings":"AA4LA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,4EAZW,MAAM,UACN,MAAM,QACN,YAAY,GAAC,MAAM,EAAE,MACrB,YAAY,GAAC,MAAM,EAAE,gBACrB,MAAM,cACN,MAAM,GACJ,MAAM,CAsBlB"}

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;