@woosh/meep-engine 3.30.0 → 3.31.0

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

@@ -39,36 +39,50 @@
  * At the end of the call the mesh is cleaned up so that no dangling loops, edges,
  * or vertices remain in the topology.
  *
- * The return value is the **object-space distance** the surface moved: the largest reading taken at
- * any collapse the call performed, a collapse being read by evaluating *each* of its two endpoints'
- * accumulated quadrics at the placement the survivor is about to take, each normalized by its own
- * weight. Because a survivor inherits its victim's quadric, every such reading is a deviation from
- * the mesh as it stood when the call began — not merely from the step before.
- *
- * **At the collapses, and per endpoint, and both of those are what keep it from diluting.** The
- * weight is what makes the value a length ({@link Quadric3#distance}) and it is also a divisor that
- * grows every time a vertex absorbs another. A vertex that flattens a spike and then spends the rest
- * of the call swallowing the plane around it ends up standing mostly for planes it sits exactly on,
- * and a single reading taken at the end divides the spike it destroyed by all of them — measured on
- * a unit spike at the centre of a pinned grid, the same spike came back at 0.64 on a 7-vertex grid
- * and at 0.040 on a 33-vertex one, which is the reported error falling as the surface grows.
- * Reading at every collapse catches the spike while the quadric is still mostly about it. Reading
- * the two endpoints apart rather than summed stops a small victim's residual being averaged into a
- * large survivor's untouched history, which is that same dilution one collapse at a time.
- *
- * Nothing is given up by no longer scanning the survivors, and it is a domination rather than a
- * coincidence. What the scan would read off a survivor is its *merged* quadric at the placement its
- * last collapse chose — and a merged quadric's reading is the weight-weighted mean of its two parts'
- * readings at that same point, so it can never exceed the larger of the two this already took there.
- * Every value the scan could report is therefore one this maximum has seen or beaten, and the
- * maximum holds the earlier and sharper readings besides. A patch consumed entirely, which leaves
- * behind a faceless vertex that the cleanup then sweeps, is read at the collapse that consumed it
- * instead of in the window between the last collapse and the sweep.
- *
- * So what comes back is what *this call's* collapses cost. A caller carrying quadrics across calls
- * through {@link bt_mesh_simplify_with_quadrics} carries the maximum across them too — and the
- * deviation a vertex arrives already carrying is, by construction, a reading that the call which
- * placed it there has already returned.
+ * The return value is an **upper bound, in object-space distance, on how far the surface moved** —
+ * not an estimate of it. That distinction is the whole job: the runtime divides this number by the
+ * camera distance and calls the result pixels of error, so wherever it reads low the cut draws a
+ * cluster it should have refined and nothing downstream can tell.
+ *
+ * **It is carried per vertex and composed by the triangle inequality.** Each vertex holds a bound on
+ * how far it now sits from the surface the caller started from, zero at the source. A collapse
+ * charges what it moved the *surface*, on top of whatever the pair already carried:
+ *
+ * ```
+ * bound[survivor] = max( bound[v1], bound[v2] ) + max over the pair's former positions
+ *                                                of their distance to the survivor's one-ring
+ * ```
+ *
+ * **The increment is not how far the vertices went, and that distinction is the whole of it.** A
+ * vertex sliding within its own plane moves and the surface does not, and flat geometry is mostly
+ * that — charging the movement makes a flat wall refine forever, which is the one thing the
+ * refinement metric is not allowed to do (`VIRTUAL_GEOMETRY_DESIGN.md` §4, the flat-wall test that
+ * density heuristics were rejected on). Measured: charging movement reported `15.9` where the
+ * surface had moved `0.98`, and `41.6` on the same shape with a larger plane around it — the old
+ * dilution's mirror image, growing with surface that never moved. Charging the distance from each
+ * former position to the geometry now standing in its place is zero for the sliding case by
+ * construction, because the former position is still *on* that geometry.
+ *
+ * Where the one-ring is empty the patch was consumed whole, there is no surface left to measure
+ * against, and the movement is the only evidence there is.
+ *
+ * **Why not the quadric, which is right there and tighter.** Because it is a mean and a mean is
+ * never a bound. The quadric's reading at a placement is the weighted average of the squared
+ * distances to every plane the vertex stands for, so a vertex that destroyed one feature and stands
+ * for a thousand planes it sits exactly on reports the feature divided by all of them. That is not a
+ * tuning error and no amount of choosing *when* to read fixes it — measured against the distance the
+ * surface actually moved, sampled at the source vertices, the quadric reading came back at 0.34 of
+ * it on a closed pyramid, 0.58 on an octahedron and 0.62 on a spike standing off a plane. The
+ * quadric still decides **where** the vertex goes, which is what it is good at; it no longer decides
+ * what that cost.
+ *
+ * The price is looseness, and it is real: the bound accumulates the movement of every collapse a
+ * vertex has been through rather than measuring the result against the source. It is the trade the
+ * metric has to make to be usable as a threshold.
+ *
+ * A caller that simplifies in several passes hands its own `bounds` array and keeps it across them,
+ * which is what makes the accumulation mean anything; each call then returns the largest bound any
+ * of *its own* collapses produced.
  *
  * `protected_faces` names faces that must still be there when the call returns. Pinning vertices
  * does not by itself protect the *edges* between them: a collapse elsewhere in the fan can take away
@@ -81,7 +95,8 @@
  * @param {number} target_face_count Desired face count after simplification.
  * @param {Set<number>} [restricted_vertices] Vertices that must not move or be removed.
  * @param {Set<number>} [protected_faces] Faces that must not be removed.
- * @returns {number} object-space distance the surface moved, `0` when no collapse was performed
+ * @returns {number} an upper bound on the object-space distance the surface moved, `0` when no
+ *     collapse was performed
  */
 export function bt_mesh_simplify(mesh: BinaryTopology, target_face_count: number, restricted_vertices?: Set<number>, protected_faces?: Set<number>): number;
 /**
@@ -143,13 +158,19 @@ export function bt_mesh_simplify(mesh: BinaryTopology, target_face_count: number
  *     caller that carries no values may still care which corners of the result belong together, and
  *     a set that is not maintained is a set whose ids go stale — corners of one vertex would resolve
  *     to different wedges and every consumer downstream would see a seam that is not there.
- * @returns {number} object-space distance the surface moved, `0` when no collapse was performed
+ * @param {Float64Array} [bounds] how far each vertex already sits from the surface the caller is
+ *     measuring against, indexed by vertex id and **mutated in place**. Omitted, every vertex starts
+ *     on it and the answer is this call's own movement; supplied and kept across calls, the answer
+ *     accumulates from wherever the caller first started measuring — the same thing `quadratics`
+ *     does for the placement.
+ * @returns {number} an upper bound on the object-space distance the surface moved, `0` when no
+ *     collapse was performed
  */
 export function bt_mesh_simplify_with_quadrics(mesh: BinaryTopology, target_face_count: number, restricted_vertices: Set<number>, protected_faces: Set<number>, quadratics: Quadric3[], attributes?: {
     values: Float64Array;
     components: number;
     quadrics: Float64Array;
     weights: Float64Array;
-} | null, wedges?: BtWedgeSet | null): number;
+} | null, wedges?: BtWedgeSet | null, bounds?: Float64Array): number;
 import { Quadric3 } from "../../../../quadric/Quadric3.js";
 //# sourceMappingURL=bt_mesh_simplify.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AAw9BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,0EALW,MAAM,wBACN,IAAI,MAAM,CAAC,oBACX,IAAI,MAAM,CAAC,GACT,MAAM,CAwBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wFA/CW,MAAM,uBACN,IAAI,MAAM,CAAC,mBACX,IAAI,MAAM,CAAC,cA4BX,QAAQ,EAAE,eACV;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAC,GAAC,IAAI,WAS9F,aAAW,IAAI,GAKb,MAAM,CA4MlB;yBA10CwB,iCAAiC"}
+{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AAikCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,0EANW,MAAM,wBACN,IAAI,MAAM,CAAC,oBACX,IAAI,MAAM,CAAC,GACT,MAAM,CAyBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wFArDW,MAAM,uBACN,IAAI,MAAM,CAAC,mBACX,IAAI,MAAM,CAAC,cA4BX,QAAQ,EAAE,eACV;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAC,GAAC,IAAI,WAS9F,aAAW,IAAI,WAKf,YAAY,GAKV,MAAM,CAgPlB;yBA1+CwB,iCAAiC"}

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

@@ -1,5 +1,6 @@
+import { bt_edge_count_faces } from "../query/bt_edge_count_faces.js";
 import { assert } from "../../../../../../assert.js";
-import { Uint32Heap } from "../../../../../../collection/heap/Uint32Heap.js";
+import { IndexedFloatMinHeap } from "../../../../../../collection/heap/IndexedFloatMinHeap.js";
 import { Quadric3 } from "../../../../quadric/Quadric3.js";
 import { QUADRIC3_SIZE } from "../../../../quadric/QUADRIC3_SIZE.js";
 import { quadric3_add } from "../../../../quadric/quadric3_add.js";
@@ -8,6 +9,7 @@ import { quadric_attribute_add } from "../../../../quadric/quadric_attribute_add
 import { quadric_attribute_reduce } from "../../../../quadric/quadric_attribute_reduce.js";
 import { quadric_attribute_size } from "../../../../quadric/quadric_attribute_size.js";
 import { quadric_attribute_solve } from "../../../../quadric/quadric_attribute_solve.js";
+import { tri3_closest_point } from "../../../../triangle/tri3_closest_point.js";
 import { NULL_POINTER } from "../BinaryTopology.js";
 import { bt_edge_collapse_fold_limit } from "../query/bt_edge_collapse_fold_limit.js";
 import { bt_edge_collapse_would_fold } from "../query/bt_edge_collapse_would_fold.js";
@@ -28,6 +30,33 @@ const scratch_combined_q = new Quadric3();
 const scratch_anchor = new Float32Array(3);
 const scratch_candidate = new Float32Array(3);
 const scratch_placement = new Float32Array(3);
+const scratch_old_survivor = new Float32Array(3);
+const scratch_old_victim = new Float32Array(3);
+const scratch_fan_a = new Float32Array(3);
+const scratch_fan_b = new Float32Array(3);
+const scratch_fan_c = new Float32Array(3);
+const scratch_closest = new Float64Array(3);
+
+/**
+ * How near a point has to be to a triangle before it counts as sitting *on* it, as a fraction of the
+ * coordinates involved.
+ *
+ * Vertex coordinates are stored as `float32`, so twenty-four bits of mantissa is all the mesh can
+ * say about where its own surface is, and {@link tri3_closest_point} spends a few of them on the two
+ * divisions its barycentric solve takes. Below that, a reported distance is not a measurement of the
+ * geometry, it is a measurement of the storage — and it cannot be allowed through, because a flat
+ * surface has to report **exactly** zero. Not nearly zero: the cut has an explicit zero-error case
+ * (`project((s, 0)) === 0`), and the camera-inside-sphere rule that sends a cluster to `+Infinity`
+ * is conditioned on `r_e > 0`. A flat cluster carrying `1.6e-14` takes the second path and becomes
+ * undrawable at close range, which is the exact bug that convention exists to prevent.
+ *
+ * `2^-20` rather than `2^-24`, leaving the four bits the solve can lose. On a ten-unit mesh that is
+ * a distance of about `1e-5`, some three orders below anything a pixel threshold can see.
+ *
+ * @readonly
+ * @type {number}
+ */
+const ON_THE_SURFACE = 2 ** -20;
 
 /**
  * How much of the way to the fold limit a constrained placement is allowed to travel.
@@ -94,39 +123,115 @@ let scratch_dying_loops = new Uint32Array(8);
 let scratch_attribute_values = new Float64Array(0);
 
 /**
- * Count the number of still-live faces attached to an edge via its radial loop cycle.
- * Orphan loops (whose face was already killed by a prior collapse) are skipped so
- * that callers tracking running face totals don't double-decrement.
+ * How far `point` sits from the surface still attached to `vertex` — the closest point on any
+ * triangle in its one-ring.
+ *
+ * Every face is visited twice, once per incident edge, and that is left alone: deduplicating means a
+ * set per collapse, and a one-ring is a dozen triangles.
  *
  * @param {BinaryTopology} mesh
- * @param {number} edge_id
- * @returns {number}
+ * @param {number} vertex
+ * @param {ArrayLike<number>} point
+ * @returns {number} the distance, or `-1` where the vertex has no surface left at all
  */
-function count_edge_faces(mesh, edge_id) {
-    const l0 = mesh.edge_read_loop(edge_id);
+function distance_to_vertex_fan(mesh, vertex, point) {
+    let edge = mesh.vertex_read_edge(vertex);
 
-    if (l0 === NULL_POINTER) {
-        return 0;
+    if (edge === NULL_POINTER) {
+        return -1;
     }
 
     const face_pool = mesh.faces;
 
-    let count = 0;
-    let l = l0;
+    const start_edge = edge;
+
+    let nearest_sqr = Number.POSITIVE_INFINITY;
+
+    // What the coordinates in play are worth, for {@link ON_THE_SURFACE} below. Float32 loses
+    // precision in proportion to magnitude, so the threshold has to be stated against the geometry
+    // rather than as a distance.
+    let scale_sqr = point[0] * point[0] + point[1] * point[1] + point[2] * point[2];
 
     do {
-        const f = mesh.loop_read_face(l);
+        const first_loop = mesh.edge_read_loop(edge);
+
+        let loop = first_loop;
+
+        while (loop !== NULL_POINTER) {
+            const face = mesh.loop_read_face(loop);
+
+            if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
+                const la = mesh.face_read_loop(face);
+                const lb = mesh.loop_read_next(la);
+                const lc = mesh.loop_read_next(lb);
+
+                if (mesh.loop_read_next(lc) === la) {
+                    mesh.vertex_read_coordinate(scratch_fan_a, 0, mesh.loop_read_vertex(la));
+                    mesh.vertex_read_coordinate(scratch_fan_b, 0, mesh.loop_read_vertex(lb));
+                    mesh.vertex_read_coordinate(scratch_fan_c, 0, mesh.loop_read_vertex(lc));
+
+                    scale_sqr = Math.max(
+                        scale_sqr,
+                        scratch_fan_a[0] * scratch_fan_a[0]
+                            + scratch_fan_a[1] * scratch_fan_a[1]
+                            + scratch_fan_a[2] * scratch_fan_a[2],
+                        scratch_fan_b[0] * scratch_fan_b[0]
+                            + scratch_fan_b[1] * scratch_fan_b[1]
+                            + scratch_fan_b[2] * scratch_fan_b[2],
+                        scratch_fan_c[0] * scratch_fan_c[0]
+                            + scratch_fan_c[1] * scratch_fan_c[1]
+                            + scratch_fan_c[2] * scratch_fan_c[2]
+                    );
+
+                    nearest_sqr = Math.min(nearest_sqr, tri3_closest_point(
+                        scratch_closest, 0,
+                        point[0], point[1], point[2],
+                        scratch_fan_a[0], scratch_fan_a[1], scratch_fan_a[2],
+                        scratch_fan_b[0], scratch_fan_b[1], scratch_fan_b[2],
+                        scratch_fan_c[0], scratch_fan_c[1], scratch_fan_c[2]
+                    ));
+                }
+            }
 
-        if (f !== NULL_POINTER && face_pool.is_allocated(f)) {
-            count++;
+            loop = mesh.loop_read_radial_next(loop);
+
+            if (loop === first_loop) {
+                break;
+            }
         }
 
-        l = mesh.loop_read_radial_next(l);
-    } while (l !== l0 && l !== NULL_POINTER);
+        edge = mesh.edge_read_vertex1(edge) === vertex
+            ? mesh.edge_read_v1_disk_next(edge)
+            : mesh.edge_read_v2_disk_next(edge);
+    } while (edge !== start_edge && edge !== NULL_POINTER);
+
+    if (nearest_sqr === Number.POSITIVE_INFINITY) {
+        return -1;
+    }
 
-    return count;
+    if (nearest_sqr <= scale_sqr * ON_THE_SURFACE * ON_THE_SURFACE) {
+        return 0;
+    }
+
+    return Math.sqrt(nearest_sqr);
 }
 
+/**
+ * Distance from the point `from` holds to `(x, y, z)`.
+ *
+ * @param {ArrayLike<number>} from
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+function distance_from(from, x, y, z) {
+    const dx = x - from[0];
+    const dy = y - from[1];
+    const dz = z - from[2];
+
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
 /**
  * What a collapse of this pair costs with its surviving vertex at `(x, y, z)`.
  *
@@ -383,7 +488,7 @@ function evaluate_edge_collapse(
  * @param {Set<number>} restricted_vertices
  * @param {{values: Float64Array, components: number, quadrics: Float64Array, weights: Float64Array}|null} attributes
  * @param {BtWedgeSet|null} wedges
- * @param {Uint32Heap} heap
+ * @param {IndexedFloatMinHeap} heap
  */
 function update_neighbor_costs(
     mesh, survivor, quadratics, restricted_vertices, attributes, wedges, heap
@@ -406,14 +511,14 @@ function update_neighbor_costs(
             next_e = mesh.edge_read_v2_disk_next(curr_e);
         }
 
-        const idx = heap.find_index_by_id(curr_e);
-
-        if (idx !== -1) {
+        // `contains` asserts the id against the queue's own index length, which is the check the
+        // keyed lookup actually needs -- a collapse only ever kills edges, so it cannot fail.
+        if (heap.contains(curr_e)) {
             const cost = evaluate_edge_collapse(
                 mesh, curr_e, quadratics, restricted_vertices, attributes, wedges, scratch_target
             );
 
-            heap.__update_score_by_index(idx, cost);
+            heap.update(curr_e, cost);
         }
 
         curr_e = next_e;
@@ -1023,36 +1128,50 @@ function collapse_kills_protected_face(mesh, edge_id, protected_faces) {
  * At the end of the call the mesh is cleaned up so that no dangling loops, edges,
  * or vertices remain in the topology.
  *
- * The return value is the **object-space distance** the surface moved: the largest reading taken at
- * any collapse the call performed, a collapse being read by evaluating *each* of its two endpoints'
- * accumulated quadrics at the placement the survivor is about to take, each normalized by its own
- * weight. Because a survivor inherits its victim's quadric, every such reading is a deviation from
- * the mesh as it stood when the call began — not merely from the step before.
- *
- * **At the collapses, and per endpoint, and both of those are what keep it from diluting.** The
- * weight is what makes the value a length ({@link Quadric3#distance}) and it is also a divisor that
- * grows every time a vertex absorbs another. A vertex that flattens a spike and then spends the rest
- * of the call swallowing the plane around it ends up standing mostly for planes it sits exactly on,
- * and a single reading taken at the end divides the spike it destroyed by all of them — measured on
- * a unit spike at the centre of a pinned grid, the same spike came back at 0.64 on a 7-vertex grid
- * and at 0.040 on a 33-vertex one, which is the reported error falling as the surface grows.
- * Reading at every collapse catches the spike while the quadric is still mostly about it. Reading
- * the two endpoints apart rather than summed stops a small victim's residual being averaged into a
- * large survivor's untouched history, which is that same dilution one collapse at a time.
- *
- * Nothing is given up by no longer scanning the survivors, and it is a domination rather than a
- * coincidence. What the scan would read off a survivor is its *merged* quadric at the placement its
- * last collapse chose — and a merged quadric's reading is the weight-weighted mean of its two parts'
- * readings at that same point, so it can never exceed the larger of the two this already took there.
- * Every value the scan could report is therefore one this maximum has seen or beaten, and the
- * maximum holds the earlier and sharper readings besides. A patch consumed entirely, which leaves
- * behind a faceless vertex that the cleanup then sweeps, is read at the collapse that consumed it
- * instead of in the window between the last collapse and the sweep.
- *
- * So what comes back is what *this call's* collapses cost. A caller carrying quadrics across calls
- * through {@link bt_mesh_simplify_with_quadrics} carries the maximum across them too — and the
- * deviation a vertex arrives already carrying is, by construction, a reading that the call which
- * placed it there has already returned.
+ * The return value is an **upper bound, in object-space distance, on how far the surface moved** —
+ * not an estimate of it. That distinction is the whole job: the runtime divides this number by the
+ * camera distance and calls the result pixels of error, so wherever it reads low the cut draws a
+ * cluster it should have refined and nothing downstream can tell.
+ *
+ * **It is carried per vertex and composed by the triangle inequality.** Each vertex holds a bound on
+ * how far it now sits from the surface the caller started from, zero at the source. A collapse
+ * charges what it moved the *surface*, on top of whatever the pair already carried:
+ *
+ * ```
+ * bound[survivor] = max( bound[v1], bound[v2] ) + max over the pair's former positions
+ *                                                of their distance to the survivor's one-ring
+ * ```
+ *
+ * **The increment is not how far the vertices went, and that distinction is the whole of it.** A
+ * vertex sliding within its own plane moves and the surface does not, and flat geometry is mostly
+ * that — charging the movement makes a flat wall refine forever, which is the one thing the
+ * refinement metric is not allowed to do (`VIRTUAL_GEOMETRY_DESIGN.md` §4, the flat-wall test that
+ * density heuristics were rejected on). Measured: charging movement reported `15.9` where the
+ * surface had moved `0.98`, and `41.6` on the same shape with a larger plane around it — the old
+ * dilution's mirror image, growing with surface that never moved. Charging the distance from each
+ * former position to the geometry now standing in its place is zero for the sliding case by
+ * construction, because the former position is still *on* that geometry.
+ *
+ * Where the one-ring is empty the patch was consumed whole, there is no surface left to measure
+ * against, and the movement is the only evidence there is.
+ *
+ * **Why not the quadric, which is right there and tighter.** Because it is a mean and a mean is
+ * never a bound. The quadric's reading at a placement is the weighted average of the squared
+ * distances to every plane the vertex stands for, so a vertex that destroyed one feature and stands
+ * for a thousand planes it sits exactly on reports the feature divided by all of them. That is not a
+ * tuning error and no amount of choosing *when* to read fixes it — measured against the distance the
+ * surface actually moved, sampled at the source vertices, the quadric reading came back at 0.34 of
+ * it on a closed pyramid, 0.58 on an octahedron and 0.62 on a spike standing off a plane. The
+ * quadric still decides **where** the vertex goes, which is what it is good at; it no longer decides
+ * what that cost.
+ *
+ * The price is looseness, and it is real: the bound accumulates the movement of every collapse a
+ * vertex has been through rather than measuring the result against the source. It is the trade the
+ * metric has to make to be usable as a threshold.
+ *
+ * A caller that simplifies in several passes hands its own `bounds` array and keeps it across them,
+ * which is what makes the accumulation mean anything; each call then returns the largest bound any
+ * of *its own* collapses produced.
  *
  * `protected_faces` names faces that must still be there when the call returns. Pinning vertices
  * does not by itself protect the *edges* between them: a collapse elsewhere in the fan can take away
@@ -1065,7 +1184,8 @@ function collapse_kills_protected_face(mesh, edge_id, protected_faces) {
  * @param {number} target_face_count Desired face count after simplification.
  * @param {Set<number>} [restricted_vertices] Vertices that must not move or be removed.
  * @param {Set<number>} [protected_faces] Faces that must not be removed.
- * @returns {number} object-space distance the surface moved, `0` when no collapse was performed
+ * @returns {number} an upper bound on the object-space distance the surface moved, `0` when no
+ *     collapse was performed
  */
 export function bt_mesh_simplify(
     mesh,
@@ -1150,7 +1270,13 @@ export function bt_mesh_simplify(
  *     caller that carries no values may still care which corners of the result belong together, and
  *     a set that is not maintained is a set whose ids go stale — corners of one vertex would resolve
  *     to different wedges and every consumer downstream would see a seam that is not there.
- * @returns {number} object-space distance the surface moved, `0` when no collapse was performed
+ * @param {Float64Array} [bounds] how far each vertex already sits from the surface the caller is
+ *     measuring against, indexed by vertex id and **mutated in place**. Omitted, every vertex starts
+ *     on it and the answer is this call's own movement; supplied and kept across calls, the answer
+ *     accumulates from wherever the caller first started measuring — the same thing `quadratics`
+ *     does for the placement.
+ * @returns {number} an upper bound on the object-space distance the surface moved, `0` when no
+ *     collapse was performed
  */
 export function bt_mesh_simplify_with_quadrics(
     mesh,
@@ -1159,7 +1285,8 @@ export function bt_mesh_simplify_with_quadrics(
     protected_faces,
     quadratics,
     attributes = null,
-    wedges = null
+    wedges = null,
+    bounds = null
 ) {
     assert.defined(mesh, 'mesh');
     assert.notNull(mesh, 'mesh');
@@ -1177,13 +1304,21 @@ export function bt_mesh_simplify_with_quadrics(
     let current_face_count = face_pool.count();
 
     /**
-     * The largest object-space distance any collapse so far has put the surface from the one the
-     * quadrics remember. See {@link bt_mesh_simplify} for why it is a running maximum over the
-     * collapses rather than one sweep of the survivors at the end.
+     * The largest bound any collapse so far has produced. See {@link bt_mesh_simplify} for why it is
+     * a bound carried per vertex rather than a reading taken off the quadric.
      * @type {number}
      */
     let deviation = 0;
 
+    /**
+     * Zero for every vertex when the caller is not keeping its own: with nothing carried in, the
+     * surface being measured against is the one this call was handed.
+     * @type {Float64Array}
+     */
+    const deviation_bounds = bounds === null
+        ? new Float64Array(mesh.vertices.size)
+        : bounds;
+
     if (current_face_count <= target_face_count) {
         return 0;
     }
@@ -1205,7 +1340,10 @@ export function bt_mesh_simplify_with_quadrics(
     }
 
     const edge_pool = mesh.edges;
-    const heap = new Uint32Heap(edge_pool.size);
+    // Slot capacity as well as id capacity: the heap holds at most one entry per edge, and the
+    // default would start at 64 slots and grow through the initial fill. This is the allocation
+    // `new Uint32Heap(edge_pool.size)` made before the queue changed.
+    const heap = new IndexedFloatMinHeap(edge_pool.size, edge_pool.size);
 
     for (let e = 0; e < edge_pool.size; e++) {
         if (!edge_pool.is_allocated(e)) {
@@ -1234,7 +1372,7 @@ export function bt_mesh_simplify_with_quadrics(
     let iterations = 0;
 
     while (
-        !heap.is_empty()
+        heap.size !== 0
         && current_face_count > target_face_count
         && iterations < max_iterations
     ) {
@@ -1287,7 +1425,7 @@ export function bt_mesh_simplify_with_quadrics(
             'the placement a finite collapse price was quoted for must not fold'
         );
 
-        const face_deaths = count_edge_faces(mesh, edge_id);
+        const face_deaths = bt_edge_count_faces(mesh, edge_id);
 
         // bt_edge_collapse keeps v1 as the survivor. If v2 is the pinned endpoint,
         // swap the edge's slots so the pinned vertex ends up in the v1 position.
@@ -1302,12 +1440,15 @@ export function bt_mesh_simplify_with_quadrics(
         const target_y = scratch_target[1];
         const target_z = scratch_target[2];
 
-        // Priced before the accumulation below, which is the merge that would dilute it, and each
-        // endpoint against its own weight for the same reason.
-        deviation = Math.max(
-            deviation,
-            quadratics[pre_survivor].distance(target_x, target_y, target_z),
-            quadratics[pre_victim].distance(target_x, target_y, target_z)
+        /*
+         Where the surface is about to stop being, kept because nothing in the mesh will say so
+         afterwards. What it cost is measured below, once there is something to measure against.
+        */
+        mesh.vertex_read_coordinate(scratch_old_survivor, 0, pre_survivor);
+        mesh.vertex_read_coordinate(scratch_old_victim, 0, pre_victim);
+
+        const carried_base = Math.max(
+            deviation_bounds[pre_survivor], deviation_bounds[pre_victim]
         );
 
         // Before the accumulation below, which is what makes the blend fallback weigh the two
@@ -1344,6 +1485,26 @@ export function bt_mesh_simplify_with_quadrics(
         // are still intact.
         current_face_count -= bt_vertex_fuse_duplicate_edges(mesh, survivor);
 
+        // What the collapse cost the surface — see {@link bt_mesh_simplify}. Measured here rather
+        // than before, because the geometry it is measured against is the one the collapse just
+        // produced, and after the fuse rather than before, because a degenerate left in the fan
+        // would be the nearest thing in it.
+        const from_survivor = distance_to_vertex_fan(mesh, survivor, scratch_old_survivor);
+        const from_victim = distance_to_vertex_fan(mesh, survivor, scratch_old_victim);
+
+        const increment = Math.max(
+            from_survivor < 0
+                ? distance_from(scratch_old_survivor, target_x, target_y, target_z)
+                : from_survivor,
+            from_victim < 0
+                ? distance_from(scratch_old_victim, target_x, target_y, target_z)
+                : from_victim
+        );
+
+        deviation_bounds[survivor] = carried_base + increment;
+
+        deviation = Math.max(deviation, deviation_bounds[survivor]);
+
         update_neighbor_costs(
             mesh, survivor, quadratics, restricted_vertices, attributes, wedges, heap
         );

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

@@ -1 +1 @@
-{"version":3,"file":"bt_edge_kill_parallels.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_kill_parallels.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wEAHW,MAAM,GACJ,MAAM,CAyElB"}
+{"version":3,"file":"bt_edge_kill_parallels.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_kill_parallels.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,wEAHW,MAAM,GACJ,MAAM,CA6DlB"}

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

@@ -1,6 +1,7 @@
 import { assert } from "../../../../../../../assert.js";
 import { NULL_POINTER } from "../../BinaryTopology.js";
 import { bt_edge_kill } from "./bt_edge_kill.js";
+import { bt_edge_count_faces } from "../../query/bt_edge_count_faces.js";
 
 /**
  * Kill every edge that shares both endpoints with `keep_edge`, leaving `keep_edge`
@@ -59,8 +60,6 @@ export function bt_edge_kill_parallels(mesh, keep_edge) {
     } while (curr_e !== start_e && curr_e !== NULL_POINTER);
 
     const edge_pool = mesh.edges;
-    const face_pool = mesh.faces;
-
     let faces_killed = 0;
 
     for (let i = 0; i < victims.length; i++) {
@@ -71,19 +70,9 @@ export function bt_edge_kill_parallels(mesh, keep_edge) {
         }
 
         // Count still-allocated faces in this edge's radial loop cycle before
-        // bt_edge_kill drops them. Orphan loops (face already dead) are skipped.
-        const l0 = mesh.edge_read_loop(e);
-
-        if (l0 !== NULL_POINTER) {
-            let l = l0;
-            do {
-                const f = mesh.loop_read_face(l);
-                if (f !== NULL_POINTER && face_pool.is_allocated(f)) {
-                    faces_killed++;
-                }
-                l = mesh.loop_read_radial_next(l);
-            } while (l !== l0 && l !== NULL_POINTER);
-        }
+        // bt_edge_kill drops them. Orphan loops (face already dead) are skipped, which is what
+        // bt_edge_count_faces does.
+        faces_killed += bt_edge_count_faces(mesh, e);
 
         bt_edge_kill(mesh, e);
     }

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_split_pinched_vertices.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_mesh_split_pinched_vertices.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,sEAFa,MAAM,CAsLlB"}
+{"version":3,"file":"bt_mesh_split_pinched_vertices.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_mesh_split_pinched_vertices.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,sEAFa,MAAM,CAkMlB"}