@woosh/meep-engine 3.28.0 → 3.30.0

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

@@ -1,7 +1,15 @@
 import { assert } from "../../../../../../assert.js";
 import { Uint32Heap } from "../../../../../../collection/heap/Uint32Heap.js";
 import { Quadric3 } from "../../../../quadric/Quadric3.js";
+import { QUADRIC3_SIZE } from "../../../../quadric/QUADRIC3_SIZE.js";
+import { quadric3_add } from "../../../../quadric/quadric3_add.js";
+import { quadric3_evaluate } from "../../../../quadric/quadric3_evaluate.js";
+import { quadric_attribute_add } from "../../../../quadric/quadric_attribute_add.js";
+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 { 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";
 import { bt_loop_kill } from "./bt_loop_kill.js";
 import { bt_mesh_compute_vertex_quadrics } from "./bt_mesh_compute_vertex_quadrics.js";
@@ -17,6 +25,73 @@ const scratch_coord_a = new Float32Array(3);
 const scratch_coord_b = new Float32Array(3);
 const scratch_target = new Float32Array(3);
 const scratch_combined_q = new Quadric3();
+const scratch_anchor = new Float32Array(3);
+const scratch_candidate = new Float32Array(3);
+const scratch_placement = new Float32Array(3);
+
+/**
+ * How much of the way to the fold limit a constrained placement is allowed to travel.
+ *
+ * The limit itself is where a surviving triangle reaches *zero* area, which is refused along with an
+ * outright flip and for the same reason: a zero-area triangle has no normal, so the quadrics built
+ * from it afterwards are meaningless and every later collapse around it is priced off nothing. So
+ * stopping short of the limit is a statement about the mesh rather than about arithmetic.
+ *
+ * Half, because the feasible interval along the segment is `[0, limit)` and its midpoint is the
+ * placement furthest from both ends of it — from the anchor, which is the placement this was trying
+ * to improve on, and from the degeneracy. Nothing is given up by stopping there: swept against 0.9
+ * and 0.99 over Zorah's 479k-triangle `mesh0[0]`, all three build the *same* 34 levels to the *same*
+ * root error of `1.0445e+3`, and differ only in cluster count, by 0.3% and in no particular
+ * direction (11,511 / 11,498 / 11,532). The choice is free on everything that was measured, so it
+ * goes to the end that cannot produce a sliver.
+ * @type {number}
+ */
+const FOLD_LIMIT_TRAVEL = 0.5;
+
+/**
+ * The pair's summed attribute quadric, and its reduction. Grown to whatever channel count the
+ * current call carries and reused across every candidate it scores — `evaluate_edge_collapse` runs
+ * once per heap insert and again for every neighbour of every collapse, and an allocation there is
+ * an allocation per edge per round.
+ * @type {Float64Array}
+ */
+let scratch_attribute_sum = new Float64Array(0);
+
+/**
+ * @type {Float64Array}
+ */
+const scratch_attribute_reduced = new Float64Array(QUADRIC3_SIZE);
+
+/**
+ * One wedge group's reduction, on its way into the sum over groups.
+ * @type {Float64Array}
+ */
+const scratch_group_reduced = new Float64Array(QUADRIC3_SIZE);
+
+/**
+ * The wedges of a candidate's two endpoints, the survivor's first, and the local union-find that
+ * groups them. Only the multi-wedge path touches these, which on smooth geometry is never.
+ * @type {Uint32Array}
+ */
+let scratch_wedge_ids = new Uint32Array(0);
+
+/**
+ * @type {Uint32Array}
+ */
+let scratch_wedge_group = new Uint32Array(0);
+
+/**
+ * The corners of the faces a collapse would destroy, as `(at a, at b)` pairs. Two on a manifold
+ * edge, which is why it starts small and grows.
+ * @type {Uint32Array}
+ */
+let scratch_dying_loops = new Uint32Array(8);
+
+/**
+ * The fitted attribute record, on its way onto the survivor.
+ * @type {Float64Array}
+ */
+let scratch_attribute_values = new Float64Array(0);
 
 /**
  * Count the number of still-live faces attached to an edge via its radial loop cycle.
@@ -52,6 +127,143 @@ function count_edge_faces(mesh, edge_id) {
     return count;
 }
 
+/**
+ * What a collapse of this pair costs with its surviving vertex at `(x, y, z)`.
+ *
+ * The two geometric quadrics say how far the placement is from the surface the pair was cut out of;
+ * the reduced attribute quadric, when there is one, says what the channels still cost once each has
+ * been given its best value there — in units of length, because the weights put them there.
+ *
+ * It is exactly the function the placement minimizes — quadric evaluation is linear in the quadric,
+ * so the sum `optimize` was handed evaluates to the sum of the two terms below — which is why
+ * constraining the placement can only ever raise this, never lower it. Read at the placement
+ * actually chosen, so the queue's order is a statement about the collapses that will happen rather
+ * than about ones that will not.
+ *
+ * @param {Quadric3} q1
+ * @param {Quadric3} q2
+ * @param {boolean} has_attributes whether {@link scratch_attribute_reduced} holds this pair's
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+function placement_cost(q1, q2, has_attributes, x, y, z) {
+    // Cost can drift slightly negative for near-zero values due to fp noise.
+    const geometric = Math.abs(q1.evaluate(x, y, z) + q2.evaluate(x, y, z));
+
+    if (!has_attributes) {
+        return geometric;
+    }
+
+    return geometric + Math.abs(quadric3_evaluate(scratch_attribute_reduced, 0, x, y, z));
+}
+
+/**
+ * Move `out_target` to the cheapest placement near it that turns no surviving triangle over, or
+ * report that the pair has none.
+ *
+ * **A placement that folds is not an impossible collapse, and this is where the two stop being
+ * conflated.** What the quadric hands back is the unconstrained minimum of a convex cost. Keeping
+ * every surviving triangle facing the way it did is a *constraint* on that minimum — a linear one,
+ * as {@link bt_edge_collapse_fold_limit} derives, so the placements that satisfy it are a convex set
+ * and the constrained minimum is the thing this should be choosing. Testing the unconstrained
+ * answer and abandoning the collapse when it fails is the classic way of getting that wrong, and it
+ * is expensive: measured over one 479k-triangle Zorah primitive, 12% to 15% of every candidate
+ * collapse scored was discarded that way — and it is not a tail, it is the whole build, which is how
+ * a level of the DAG that could still have been halved came to be reported as having no coarser
+ * form at all.
+ *
+ * The constrained minimum lies on the boundary whenever the unconstrained one is outside, and the
+ * boundary is reached along a segment: the cost is convex with its minimum at `out_target`, so along
+ * a segment ending there it falls monotonically, and the best placement on that segment is simply
+ * the furthest one the fold limit allows. That makes this exact in one dimension rather than a
+ * search — what is heuristic is only the choice of where to measure *from*.
+ *
+ * Three anchors, and they are the three points the surface already passes through: either endpoint,
+ * or the middle of the edge. An anchor that folds on its own is no anchor and is skipped; when all
+ * three do, the pair really has nothing this can offer and the collapse is refused.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v1
+ * @param {number} v2
+ * @param {Quadric3} q1
+ * @param {Quadric3} q2
+ * @param {boolean} has_attributes
+ * @param {Float32Array|number[]} out_target the wanted placement, replaced by the chosen one
+ * @returns {boolean} `false` when every anchor folds, and the collapse has no placement at all
+ */
+function constrain_placement(mesh, v1, v2, q1, q2, has_attributes, out_target) {
+    if (!bt_edge_collapse_would_fold(mesh, v1, v2, out_target)) {
+        return true;
+    }
+
+    mesh.vertex_read_coordinate(scratch_coord_a, 0, v1);
+    mesh.vertex_read_coordinate(scratch_coord_b, 0, v2);
+
+    // Tracked separately rather than read off `best`, which cannot say the difference between "no
+    // anchor held" and "one did, at a price that overflowed" — a quadric carrying the planes of a
+    // few hundred thousand source triangles is not far off it.
+    let placed = false;
+
+    let best = Number.POSITIVE_INFINITY;
+
+    for (let anchor = 0; anchor < 3; anchor++) {
+        if (anchor === 0) {
+            scratch_anchor.set(scratch_coord_a);
+        } else if (anchor === 1) {
+            scratch_anchor.set(scratch_coord_b);
+        } else {
+            scratch_anchor[0] = (scratch_coord_a[0] + scratch_coord_b[0]) * 0.5;
+            scratch_anchor[1] = (scratch_coord_a[1] + scratch_coord_b[1]) * 0.5;
+            scratch_anchor[2] = (scratch_coord_a[2] + scratch_coord_b[2]) * 0.5;
+        }
+
+        const limit = bt_edge_collapse_fold_limit(mesh, v1, v2, scratch_anchor, out_target);
+
+        if (limit < 0) {
+            continue;
+        }
+
+        const travel = limit * FOLD_LIMIT_TRAVEL;
+
+        scratch_candidate[0] = scratch_anchor[0] + (out_target[0] - scratch_anchor[0]) * travel;
+        scratch_candidate[1] = scratch_anchor[1] + (out_target[1] - scratch_anchor[1]) * travel;
+        scratch_candidate[2] = scratch_anchor[2] + (out_target[2] - scratch_anchor[2]) * travel;
+
+        if (bt_edge_collapse_would_fold(mesh, v1, v2, scratch_candidate)) {
+            /*
+             The limit is exact in real arithmetic and this is not real arithmetic: a fan whose
+             triangles are already slivers can put the crossing and the anchor within a few ulps of
+             each other, and half of nothing is still nothing. The anchor is feasible by
+             construction, so fall back to it rather than to a search for how much less to travel.
+            */
+            scratch_candidate.set(scratch_anchor);
+        }
+
+        const cost = placement_cost(
+            q1, q2, has_attributes,
+            scratch_candidate[0], scratch_candidate[1], scratch_candidate[2]
+        );
+
+        if (!placed || cost < best) {
+            placed = true;
+            best = cost;
+            scratch_placement.set(scratch_candidate);
+        }
+    }
+
+    if (!placed) {
+        return false;
+    }
+
+    out_target[0] = scratch_placement[0];
+    out_target[1] = scratch_placement[1];
+    out_target[2] = scratch_placement[2];
+
+    return true;
+}
+
 /**
  * Evaluate a potential edge collapse: choose the optimal surviving vertex position
  * and return the quadric-based cost. Returns Infinity if the edge cannot be collapsed.
@@ -60,10 +272,17 @@ function count_edge_faces(mesh, edge_id) {
  * @param {number} edge_id
  * @param {Quadric3[]} quadratics
  * @param {Set<number>} restricted_vertices
+ * @param {{values: Float64Array, components: number, quadrics: Float64Array, weights: Float64Array}|null}
+ *     attributes the channels the collapse carries, or `null` to carry none
+ * @param {BtWedgeSet|null} wedges which corners of each vertex shade as one
  * @param {Float32Array|number[]} out_target Target position is written here.
- * @returns {number}
+ * @returns {number} the price at the placement written, which is the placement the collapse would
+ *     actually use — so the queue this feeds is ordered on what the collapses cost rather than on
+ *     what they would have cost somewhere they are not allowed to go
  */
-function evaluate_edge_collapse(mesh, edge_id, quadratics, restricted_vertices, out_target) {
+function evaluate_edge_collapse(
+    mesh, edge_id, quadratics, restricted_vertices, attributes, wedges, out_target
+) {
     const v1 = mesh.edge_read_vertex1(edge_id);
     const v2 = mesh.edge_read_vertex2(edge_id);
 
@@ -89,6 +308,12 @@ function evaluate_edge_collapse(mesh, edge_id, quadratics, restricted_vertices,
         return Number.POSITIVE_INFINITY;
     }
 
+    const has_attributes = attributes !== null;
+
+    if (has_attributes) {
+        reduce_pair_attributes(mesh, v1, v2, attributes, wedges, scratch_attribute_reduced);
+    }
+
     if (v1_restricted) {
         mesh.vertex_read_coordinate(out_target, 0, v1);
     } else if (v2_restricted) {
@@ -97,6 +322,22 @@ function evaluate_edge_collapse(mesh, edge_id, quadratics, restricted_vertices,
         scratch_combined_q.copy(q1);
         scratch_combined_q.add(q2);
 
+        if (has_attributes) {
+            /*
+             The channels decide where the vertex goes, and this is where they do it. `A` and `b` of
+             the reduced attribute quadric are what is left of them after the exact solve for their
+             own values, so a collapse across a crease or a texture seam is pulled away from the
+             placement that would smear it.
+
+             Only `optimize` reads this sum. Its weight slot is now a plane count plus a triangle
+             count, which is not a quantity, and nothing downstream takes a distance from it -- the
+             cost below is the two pure geometric quadrics, evaluated separately.
+             */
+            quadric3_add(
+                scratch_combined_q, 0, scratch_combined_q, 0, scratch_attribute_reduced, 0
+            );
+        }
+
         if (!scratch_combined_q.optimize(out_target)) {
             // Singular combined tensor: fall back to the midpoint
             mesh.vertex_read_coordinate(scratch_coord_a, 0, v1);
@@ -108,25 +349,45 @@ function evaluate_edge_collapse(mesh, edge_id, quadratics, restricted_vertices,
         }
     }
 
-    const tx = out_target[0];
-    const ty = out_target[1];
-    const tz = out_target[2];
+    if (v1_restricted || v2_restricted) {
+        /*
+         A pin takes the placement with it, so there is no segment to slide along and a fold here is
+         final. Refused with the price rather than by the caller, so the queue never holds an edge
+         whose cost describes a collapse that will not be performed.
+        */
+        if (bt_edge_collapse_would_fold(mesh, v1, v2, out_target)) {
+            return Number.POSITIVE_INFINITY;
+        }
+    } else if (!constrain_placement(mesh, v1, v2, q1, q2, has_attributes, out_target)) {
+        return Number.POSITIVE_INFINITY;
+    }
 
-    // Cost can drift slightly negative for near-zero values due to fp noise.
-    return Math.abs(q1.evaluate(tx, ty, tz) + q2.evaluate(tx, ty, tz));
+    return placement_cost(
+        q1, q2, has_attributes, out_target[0], out_target[1], out_target[2]
+    );
 }
 
 /**
  * Re-score every edge in the disk cycle of `survivor` that is currently in the heap.
  * Edges that were never inserted (e.g. both endpoints restricted) are left untouched.
  *
+ * Left untouched including the ones that were left out because they had no placement at the time,
+ * which is a real limit and a deliberate one: an edge is excluded when *both* its fans leave it
+ * nowhere to go, and a collapse one edge away is unlikely to change that. Re-admitting them here was
+ * built and measured — it moved a 479k-triangle Zorah primitive from 34 levels to 33, and cost 60%
+ * of the build time to do it.
+ *
  * @param {BinaryTopology} mesh
  * @param {number} survivor
  * @param {Quadric3[]} quadratics
  * @param {Set<number>} restricted_vertices
+ * @param {{values: Float64Array, components: number, quadrics: Float64Array, weights: Float64Array}|null} attributes
+ * @param {BtWedgeSet|null} wedges
  * @param {Uint32Heap} heap
  */
-function update_neighbor_costs(mesh, survivor, quadratics, restricted_vertices, heap) {
+function update_neighbor_costs(
+    mesh, survivor, quadratics, restricted_vertices, attributes, wedges, heap
+) {
     let curr_e = mesh.vertex_read_edge(survivor);
 
     if (curr_e === NULL_POINTER) {
@@ -148,7 +409,10 @@ function update_neighbor_costs(mesh, survivor, quadratics, restricted_vertices,
         const idx = heap.find_index_by_id(curr_e);
 
         if (idx !== -1) {
-            const cost = evaluate_edge_collapse(mesh, curr_e, quadratics, restricted_vertices, scratch_target);
+            const cost = evaluate_edge_collapse(
+                mesh, curr_e, quadratics, restricted_vertices, attributes, wedges, scratch_target
+            );
+
             heap.__update_score_by_index(idx, cost);
         }
 
@@ -156,6 +420,504 @@ function update_neighbor_costs(mesh, survivor, quadratics, restricted_vertices,
     } while (curr_e !== start_e && curr_e !== NULL_POINTER);
 }
 
+/**
+ * The corners of every face a collapse of `(a, b)` would destroy, as pairs — the corner at `a`
+ * followed by the corner at `b` — written into {@link scratch_dying_loops}.
+ *
+ * **The faces a collapse destroys are not only the ones on the edge it names.** They are the ones
+ * holding *both* endpoints: the edge's own, the ones on any parallel edge {@link bt_edge_kill_parallels}
+ * clears first, and the ones {@link bt_vertex_fuse_duplicate_edges} finds degenerate afterwards. That
+ * is {@link collapse_kills_protected_face}'s contract, written down there and true here for the same
+ * reason — and a triangle holding both endpoints has an edge between them, so walking the disk cycle
+ * for edges to `b` finds all of them.
+ *
+ * Walking one radial cycle instead would miss the parallel edges, and a wedge whose only dying face
+ * is on one of those would be adopted by the survivor rather than merged into it: two corner groups
+ * that are one piece of surface, left as two, which is a crease where the mesh has none.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} a
+ * @param {number} b
+ * @returns {number} how many pairs were written
+ */
+function collect_dying_faces(mesh, a, b) {
+    let count = 0;
+
+    let edge = mesh.vertex_read_edge(a);
+
+    if (edge === NULL_POINTER) {
+        return 0;
+    }
+
+    const start_edge = edge;
+    const face_pool = mesh.faces;
+
+    do {
+        const at_v1 = mesh.edge_read_vertex1(edge) === a;
+
+        const other = at_v1 ? mesh.edge_read_vertex2(edge) : mesh.edge_read_vertex1(edge);
+
+        if (other === b) {
+            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 next_loop = mesh.loop_read_next(loop);
+
+                    const at_a = mesh.loop_read_vertex(loop) === a ? loop : next_loop;
+
+                    if (scratch_dying_loops.length < (count + 1) * 2) {
+                        const grown = new Uint32Array(Math.max(8, (count + 1) * 4));
+
+                        grown.set(scratch_dying_loops);
+
+                        scratch_dying_loops = grown;
+                    }
+
+                    scratch_dying_loops[count * 2] = at_a;
+                    scratch_dying_loops[count * 2 + 1] = at_a === loop ? next_loop : loop;
+
+                    count++;
+                }
+
+                loop = mesh.loop_read_radial_next(loop);
+
+                if (loop === first_loop) {
+                    break;
+                }
+            }
+        }
+
+        edge = at_v1 ? mesh.edge_read_v1_disk_next(edge) : mesh.edge_read_v2_disk_next(edge);
+    } while (edge !== start_edge && edge !== NULL_POINTER);
+
+    return count;
+}
+
+/**
+ * Which wedges of a collapse's two endpoints would become one, and the reduced attribute quadric
+ * that follows from it.
+ *
+ * **A live face is what says two corners shade as one.** Each face on the edge holds one corner at
+ * each endpoint, and that face is about to die into the survivor — so whatever those two corners
+ * were, they are one corner's worth of surface afterwards. Everything else the two vertices carry
+ * stays apart. That rule needs no tolerance and no comparison of values, which matters: two
+ * neighbours on a smoothly curved surface have genuinely different normals, so a rule that merged
+ * only equal values would invent a crease at every collapse a sphere has.
+ *
+ * Each resulting group is reduced separately and the reductions summed, because each group solves
+ * for its own value ({@link quadric_attribute_reduce} is the substitution of that solve). Summing
+ * the quadrics first and reducing once would be the claim that all of them share one value, which
+ * is the thing a seam denies.
+ *
+ * **A collapse with no face to destroy is a fuse of two points, not a simplification of a surface**,
+ * and it is treated as one group. Nothing survives to hold the corners apart, and the alternative
+ * leaves the victim's accumulated history on a wedge that may have no corners left to carry it. Rare,
+ * and measured rather than assumed: 6 of 6,195 collapses over a 12,288-triangle sphere's whole DAG.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v1
+ * @param {number} v2
+ * @param {{values: Float64Array, components: number, quadrics: Float64Array, weights: Float64Array}} attributes
+ * @param {BtWedgeSet} wedges
+ * @param {Float64Array} out `QUADRIC3_SIZE` elements, overwritten
+ */
+function reduce_pair_attributes(mesh, v1, v2, attributes, wedges, out) {
+    const components = attributes.components;
+    const size = quadric_attribute_size(components);
+
+    const quadrics = attributes.quadrics;
+
+    const first_1 = wedges.first_of_vertex[v1];
+    const first_2 = wedges.first_of_vertex[v2];
+
+    /*
+     One wedge each, which is every vertex of a mesh with no seams and the overwhelming majority of
+     one that has them. They can only end up in the same group, so the answer is the sum of the two
+     reduced once -- exactly the arithmetic this had before wedges existed, kept on the path that
+     runs once per edge per round.
+     */
+    if (
+        first_1 !== NULL_POINTER && wedges.next_of_wedge[first_1] === NULL_POINTER
+        && first_2 !== NULL_POINTER && wedges.next_of_wedge[first_2] === NULL_POINTER
+    ) {
+        quadric_attribute_add(
+            scratch_attribute_sum, 0,
+            quadrics, first_1 * size, quadrics, first_2 * size,
+            components
+        );
+
+        quadric_attribute_reduce(out, 0, scratch_attribute_sum, 0, components);
+
+        return;
+    }
+
+    let count = 0;
+
+    for (let w = first_1; w !== NULL_POINTER; w = wedges.next_of_wedge[w]) {
+        count++;
+    }
+
+    for (let w = first_2; w !== NULL_POINTER; w = wedges.next_of_wedge[w]) {
+        count++;
+    }
+
+    if (scratch_wedge_ids.length < count) {
+        scratch_wedge_ids = new Uint32Array(count);
+        scratch_wedge_group = new Uint32Array(count);
+    }
+
+    let n = 0;
+
+    for (let w = first_1; w !== NULL_POINTER; w = wedges.next_of_wedge[w]) {
+        scratch_wedge_ids[n] = w;
+        scratch_wedge_group[n] = n;
+        n++;
+    }
+
+    const first_count = n;
+
+    for (let w = first_2; w !== NULL_POINTER; w = wedges.next_of_wedge[w]) {
+        scratch_wedge_ids[n] = w;
+        scratch_wedge_group[n] = n;
+        n++;
+    }
+
+    const dying = collect_dying_faces(mesh, v1, v2);
+
+    for (let pair = 0; pair < dying; pair++) {
+        local_union(
+            local_index(wedges.find(wedges.of_loop[scratch_dying_loops[pair * 2]]), n),
+            local_index(wedges.find(wedges.of_loop[scratch_dying_loops[pair * 2 + 1]]), n)
+        );
+    }
+
+    if (dying === 0 && first_count > 0) {
+        /*
+         Whatever the second vertex holds joins the first's first wedge, and the first's *other*
+         wedges are left alone -- which is exactly what {@link carry_wedges} does when the edge has no
+         face, and the two have to agree or the price of a collapse is not the price of the collapse
+         that happens. (Which of the pair survives is decided after this runs, so a swapped pair
+         scores the mirror of what it will do; the shape of the partition is the same either way and
+         this is a heuristic over 0.1% of collapses.)
+         */
+        for (let i = first_count; i < n; i++) {
+            local_union(0, i);
+        }
+    }
+
+    out.fill(0, 0, QUADRIC3_SIZE);
+
+    for (let group = 0; group < n; group++) {
+        if (local_find(group) !== group) {
+            continue;
+        }
+
+        let members = 0;
+
+        for (let i = 0; i < n; i++) {
+            if (local_find(i) !== group) {
+                continue;
+            }
+
+            const from = scratch_wedge_ids[i] * size;
+
+            if (members === 0) {
+                for (let element = 0; element < size; element++) {
+                    scratch_attribute_sum[element] = quadrics[from + element];
+                }
+            } else {
+                quadric_attribute_add(
+                    scratch_attribute_sum, 0, scratch_attribute_sum, 0, quadrics, from, components
+                );
+            }
+
+            members++;
+        }
+
+        quadric_attribute_reduce(scratch_group_reduced, 0, scratch_attribute_sum, 0, components);
+
+        quadric3_add(out, 0, out, 0, scratch_group_reduced, 0);
+    }
+}
+
+/**
+ * Where a wedge id sits in {@link scratch_wedge_ids}, or `-1`.
+ *
+ * A scan rather than a map: it is over the wedges of two vertices, which is two on a crease and one
+ * on everything else.
+ *
+ * @param {number} wedge
+ * @param {number} count
+ * @returns {number}
+ */
+function local_index(wedge, count) {
+    for (let i = 0; i < count; i++) {
+        if (scratch_wedge_ids[i] === wedge) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+/**
+ * @param {number} index
+ * @returns {number}
+ */
+function local_find(index) {
+    let root = index;
+
+    while (scratch_wedge_group[root] !== root) {
+        root = scratch_wedge_group[root];
+    }
+
+    return root;
+}
+
+/**
+ * @param {number} a index into {@link scratch_wedge_ids}, or `-1` for a wedge not among them
+ * @param {number} b
+ */
+function local_union(a, b) {
+    if (a < 0 || b < 0) {
+        return;
+    }
+
+    const root_a = local_find(a);
+    const root_b = local_find(b);
+
+    if (root_a !== root_b) {
+        scratch_wedge_group[root_b] = root_a;
+    }
+}
+
+/**
+ * Move the survivor's attribute record onto the value the pair between them stands for, when there
+ * is no field to fit one from.
+ *
+ * The fallback, not the rule. A vertex whose every incident triangle was a sliver -- or which has
+ * none left at all -- has an attribute quadric of no weight, and a quadric of no weight has no field
+ * to evaluate. Blending is what is left, and it is a reasonable answer rather than a good one: it is
+ * confined to the values that went in, where a fit is not, and it says nothing about where the
+ * vertex ended up.
+ *
+ * Blended by accumulated quadric weight, which is how much source surface each endpoint speaks for:
+ * a vertex that a dozen collapses have folded into already represents a dozen vertices' worth of the
+ * original, and taking half its word against a vertex that represents one would let whichever side
+ * of a merge happened to be shorter of history pull the value across.
+ *
+ * Two endpoints that have accumulated nothing have no claim over one another, and split it.
+ *
+ * @param {Float64Array} values indexed by wedge id, `components` elements each
+ * @param {number} components
+ * @param {number} survivor wedge
+ * @param {number} victim wedge
+ * @param {number} survivor_weight
+ * @param {number} victim_weight
+ */
+function blend_attributes(values, components, survivor, victim, survivor_weight, victim_weight) {
+    const total = survivor_weight + victim_weight;
+
+    const survivor_share = total > 0 ? survivor_weight / total : 0.5;
+    const victim_share = 1 - survivor_share;
+
+    const survivor_base = survivor * components;
+    const victim_base = victim * components;
+
+    for (let component = 0; component < components; component++) {
+        values[survivor_base + component] =
+            values[survivor_base + component] * survivor_share
+            + values[victim_base + component] * victim_share;
+    }
+}
+
+/**
+ * Merge the pair's wedges, and — where there are values riding along — decide what the survivor
+ * carries and give it the victim's accumulated fields.
+ *
+ * **The merge happens whether or not anything is being carried.** A wedge set is a statement about
+ * which corners of the result belong together, and a set that stops tracking collapses is a set
+ * whose ids go stale: the victim's loops arrive at the survivor still naming the victim's wedge, and
+ * every consumer downstream reads a seam where there is none. Measured, because it got past a
+ * byte-identity gate and was caught by an unrelated assertion instead: a round over a mesh with no
+ * channels at all cut clusters of 132 vertices against a ceiling of 128.
+ *
+ * Once per **wedge**, because a vertex has one position and not one appearance. The survivor comes
+ * out of this holding its own wedges, whichever of the victim's merged into them, and whichever of
+ * the victim's did not — those simply move, still carrying what they always did.
+ * {@link reduce_pair_attributes} is the rule for which is which, and it is the same walk.
+ *
+ * Every wedge that ends up on the survivor is fitted afresh, not only the merged ones: the vertex
+ * moved, and a field is evaluated *at a position*.
+ *
+ * A merged wedge's quadric absorbs its partner's first, so the fit it is then asked for is over
+ * *everything* the pair has ever stood for — which is what makes the answer a deviation from the
+ * source rather than from the step before it, exactly as the geometric quadric's is.
+ *
+ * Then the value: the position it is being moved to, plugged into the field those accumulated
+ * triangles describe. Where there is no field — a wedge every one of whose triangles was a sliver,
+ * or which has no triangles left — {@link blend_attributes} is the fallback, applied at the merge so
+ * that a wedge with nothing to fit from still ends up between the two values rather than on one of
+ * them. A successful fit overwrites it. (Two victim wedges merging into one survivor wedge, which
+ * takes a non-manifold edge, blend the second against the first's result; it is a fallback inside a
+ * fallback and it is confined to the values that went in either way.)
+ *
+ * **A restricted survivor is given the victim's fields and none of its values.** Its position does
+ * not move, but the fit at that unchanged position would still come out different, because `W`, `G`
+ * and `D` under it have grown. That would break the one thing pinning is for: a vertex two groups
+ * share must carry byte-identical values in both. It keeps the quadric so that a *later* step, one
+ * that is free to move it, fits from the whole history rather than from the fragment it started
+ * with. A wedge it *adopts* is a wedge the other group never had, carrying corners that are this
+ * group's alone, so it is no exception to that.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {BtWedgeSet} wedges
+ * @param {{values: Float64Array, components: number, quadrics: Float64Array, weights: Float64Array}|null} attributes
+ * @param {number} survivor
+ * @param {number} victim
+ * @param {boolean} survivor_restricted
+ * @param {number} survivor_weight geometric quadric weight, for the fallback
+ * @param {number} victim_weight
+ * @param {Float32Array|number[]} target where the survivor is being moved to
+ */
+function carry_wedges(
+    mesh, wedges, attributes, survivor, victim, survivor_restricted,
+    survivor_weight, victim_weight, target
+) {
+    const dying = collect_dying_faces(mesh, survivor, victim);
+
+    for (let pair = 0; pair < dying; pair++) {
+        absorb_wedge(
+            wedges, attributes,
+            wedges.find(wedges.of_loop[scratch_dying_loops[pair * 2]]),
+            wedges.find(wedges.of_loop[scratch_dying_loops[pair * 2 + 1]]),
+            survivor_restricted, survivor_weight, victim_weight
+        );
+    }
+
+    if (dying === 0 && wedges.first_of_vertex[survivor] !== NULL_POINTER) {
+        // A fuse of two points rather than a simplification of a surface; see
+        // {@link reduce_pair_attributes}, whose cost model this has to agree with.
+        const into = wedges.find(wedges.first_of_vertex[survivor]);
+
+        for (
+            let wedge = wedges.first_of_vertex[victim];
+            wedge !== NULL_POINTER;
+            wedge = wedges.next_of_wedge[wedge]
+        ) {
+            absorb_wedge(
+                wedges, attributes, into, wedges.find(wedge),
+                survivor_restricted, survivor_weight, victim_weight
+            );
+        }
+    }
+
+    // The survivor's own list, less whatever merged into something else, then the victim's on top of
+    // it. The loops themselves are not touched: a corner's wedge id goes stale and `find` resolves
+    // it, which is the whole reason nothing has to go looking for a corner in order to move it.
+    relist_wedges(wedges, survivor, survivor);
+    relist_wedges(wedges, victim, survivor);
+
+    if (survivor_restricted || attributes === null) {
+        return;
+    }
+
+    const components = attributes.components;
+
+    for (
+        let wedge = wedges.first_of_vertex[survivor];
+        wedge !== NULL_POINTER;
+        wedge = wedges.next_of_wedge[wedge]
+    ) {
+        const fitted = quadric_attribute_solve(
+            scratch_attribute_values, 0,
+            attributes.quadrics, wedge * quadric_attribute_size(components), components,
+            attributes.weights,
+            target[0], target[1], target[2]
+        );
+
+        if (fitted) {
+            attributes.values.set(
+                scratch_attribute_values.subarray(0, components), wedge * components
+            );
+        }
+    }
+}
+
+/**
+ * Make `other` part of `wedge`: its accumulated field, and — for the case where there turns out to
+ * be no field to fit from — its value.
+ *
+ * @param {BtWedgeSet} wedges
+ * @param {{values: Float64Array, components: number, quadrics: Float64Array, weights: Float64Array}|null} attributes
+ * @param {number} wedge root that survives, the survivor's
+ * @param {number} other root that does not, the victim's
+ * @param {boolean} survivor_restricted
+ * @param {number} survivor_weight
+ * @param {number} victim_weight
+ */
+function absorb_wedge(
+    wedges, attributes, wedge, other, survivor_restricted, survivor_weight, victim_weight
+) {
+    if (!wedges.merge(wedge, other)) {
+        // Already one wedge. A manifold edge's two faces name the same pair twice, which is the
+        // common case rather than an oddity, so this is the guard that keeps a quadric from being
+        // counted into itself.
+        return;
+    }
+
+    if (attributes === null) {
+        return;
+    }
+
+    const components = attributes.components;
+    const size = quadric_attribute_size(components);
+
+    quadric_attribute_add(
+        attributes.quadrics, wedge * size,
+        attributes.quadrics, wedge * size,
+        attributes.quadrics, other * size,
+        components
+    );
+
+    if (!survivor_restricted) {
+        blend_attributes(
+            attributes.values, components, wedge, other, survivor_weight, victim_weight
+        );
+    }
+}
+
+/**
+ * Move every wedge of `from` onto `to`, dropping the ones that are no longer their own root.
+ *
+ * `from === to` is a compaction in place, which is what the survivor needs: its own wedges can have
+ * merged into each other, through a victim wedge that touched both.
+ *
+ * @param {BtWedgeSet} wedges
+ * @param {number} from vertex
+ * @param {number} to vertex
+ */
+function relist_wedges(wedges, from, to) {
+    let wedge = wedges.first_of_vertex[from];
+
+    wedges.detach_all(from);
+
+    while (wedge !== NULL_POINTER) {
+        const next = wedges.next_of_wedge[wedge];
+
+        if (wedges.find(wedge) === wedge) {
+            wedges.attach(wedge, to);
+        }
+
+        wedge = next;
+    }
+}
+
 /**
  * Would collapsing this edge destroy a face the caller asked to keep?
  *
@@ -228,9 +990,24 @@ function collapse_kills_protected_face(mesh, edge_id, protected_faces) {
  * removed. If the target cannot be reached (e.g. too many restricted vertices),
  * simplification stops early without failing.
  *
- * A collapse that would turn a surviving triangle inside out is refused however cheap the quadric
- * says it is ({@link bt_edge_collapse_would_fold}) -- the quadric cannot see a fold, because a flat
- * region scores zero for every placement in its plane.
+ * No collapse ever turns a surviving triangle inside out, and the quadric cannot help with that: it
+ * cannot see a fold at all, because a flat region scores zero for every placement in its plane. So
+ * the placement is *constrained* rather than merely checked. Where the quadric's own answer folds,
+ * the collapse is re-placed at the best point that does not — see {@link constrain_placement}, and
+ * {@link bt_edge_collapse_fold_limit} for why that point can be found exactly instead of hunted for.
+ * A collapse is refused only when the pair has no such placement anywhere, which is a statement
+ * about the geometry rather than about the quadric's preference.
+ *
+ * Every edge is priced at the placement it would actually use, including the constrained ones, and
+ * the queue is ordered on that. It is the expensive way round — the constraint costs a walk of both
+ * the pair's fans, and pricing happens once per edge at the start and again for every neighbour of
+ * every collapse, which measures at 1.4x to 2.5x the build time of the alternative. The alternative
+ * is to order on the unconstrained price, which is a genuine lower bound ({@link placement_cost}),
+ * and settle only on the way out of the queue. That was built and measured, and it is not here: the
+ * greedy order it produces is approximate, and on a pinwheel whose whole rim is pinned it stopped at
+ * 28 faces against a target of 21 — which is precisely the shape a vgeo group step hands this, since
+ * such a step pins its entire outer boundary. A cheaper order that cannot finish a pinned
+ * simplification is no bargain.
  *
  * **Topology is not preserved**, and cannot be here. The other standard guard, the *link condition*
  * ({@link bt_edge_collapse_breaks_link_condition}), refuses collapses that weld together two parts
@@ -246,21 +1023,36 @@ 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, over every
- * vertex, of that vertex's accumulated quadric evaluated where the vertex ended up, normalized by
- * the quadric's weight. Because a survivor inherits its victim's quadric, this measures deviation
- * from the mesh as it stood when the call began — not merely from the step before.
+ * 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.
  *
- * It is taken *before* faceless vertices are cleaned away, and that is not an implementation detail.
- * A patch that is consumed entirely leaves a vertex behind that belongs to no face; that vertex is
- * the only thing still holding the quadric of everything that used to be there, and reading the mesh
- * after cleanup would find no trace of it. A soup of separate triangles simplifies by *deleting*
- * them, and measuring survivors alone reports the deletion of ninety per cent of a model as costing
- * nothing at all.
+ * **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.
  *
- * A caller that needs deviation from something *older* than this call's input — a mesh several
- * simplification passes back — supplies its own quadrics through
- * {@link bt_mesh_simplify_with_quadrics} and keeps them across passes.
+ * 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.
  *
  * `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
@@ -316,7 +1108,48 @@ export function bt_mesh_simplify(
  * @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.
+ * `attributes` is per-vertex data that travels *through* the collapse rather than being re-derived
+ * from the result. Whatever a merged vertex is to carry has to be decided here, from the values
+ * being merged: the mesh a collapse leaves behind is a different surface, and a value read off it
+ * afterwards describes that one rather than the one the caller started with.
+ *
+ * It is carried per **wedge** — a set of corners at one vertex that shade as one — so a hard edge
+ * or a texture seam survives a collapse instead of being averaged away. Which of the pair's wedges
+ * become one is decided by the faces the collapse destroys, in {@link reduce_pair_attributes}; a
+ * mesh with no seams has one wedge per vertex, every collapse merges the pair, and all of this is
+ * the arithmetic it always was.
+ *
+ * It is **fitted**, not inherited and not averaged. Each channel varies affinely over a triangle, so
+ * every triangle a wedge has ever absorbed says what that channel should be at any position; the
+ * survivor takes the value that best explains all of them at once, at the position it is being moved
+ * to ({@link quadric_attribute_solve}). Those same accumulated fields also reach the *placement* and
+ * the cost, through {@link quadric_attribute_reduce} -- so a collapse that would smear a crease or a
+ * texture seam is both moved away from it and priced for it. A vertex with no field to fit from
+ * falls back to a weighted blend, and a **restricted** survivor is left exactly as it is, for the
+ * same reason its position is.
+ *
+ * The values themselves mean nothing here. A caller whose record holds a direction or a flag rather
+ * than a quantity has to say so afterwards, over the array this leaves behind.
+ *
+ * What the call **returns** is still the pure geometric quadric's answer, evaluated at wherever the
+ * higher-dimensional metric put each vertex. Solving in one metric and reporting in the other is
+ * what keeps the number an object-space length (`VIRTUAL_GEOMETRY_DESIGN.md` §3).
+ *
  * @param {Quadric3[]} quadratics indexed by vertex id, one per allocated vertex; mutated in place
+ * @param {{values: Float64Array, components: number, quadrics: Float64Array, weights: Float64Array}|null} [attributes]
+ *     per-wedge records to carry through the collapses, with the attribute quadrics that fit them
+ *     ({@link bt_mesh_compute_wedge_attribute_quadrics}) and the per-channel weights those were
+ *     built with. `values` and `quadrics` are indexed by **wedge id**;
+ *     {@link bt_wedges_per_vertex} is the set where that is the vertex id. `null` to carry nothing,
+ *     which is what every caller but the virtual-geometry builder does. {@link bt_mesh_simplify_by_error}
+ *     is not among them at all — it is a separate implementation with its own cost function, and so
+ *     is untouched by any of this, which matters because it simplifies to a *tolerance* that an
+ *     attribute term would quietly move.
+ * @param {BtWedgeSet|null} [wedges] which corners of each vertex shade as one, **mutated in place**
+ *     as the collapses merge them. Required when `attributes` is given, and useful without it: a
+ *     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
  */
 export function bt_mesh_simplify_with_quadrics(
@@ -324,7 +1157,9 @@ export function bt_mesh_simplify_with_quadrics(
     target_face_count,
     restricted_vertices,
     protected_faces,
-    quadratics
+    quadratics,
+    attributes = null,
+    wedges = null
 ) {
     assert.defined(mesh, 'mesh');
     assert.notNull(mesh, 'mesh');
@@ -341,10 +1176,34 @@ export function bt_mesh_simplify_with_quadrics(
     // Tracked from here on rather than re-counted, so progress costs nothing per iteration.
     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.
+     * @type {number}
+     */
+    let deviation = 0;
+
     if (current_face_count <= target_face_count) {
         return 0;
     }
 
+    if (attributes !== null) {
+        assert.notNull(wedges, 'wedges, which carrying attributes requires');
+
+        const size = quadric_attribute_size(attributes.components);
+
+        // Grown, never shrunk: a build is thousands of calls over the same handful of channel
+        // counts, and every one of them would otherwise allocate.
+        if (scratch_attribute_sum.length < size) {
+            scratch_attribute_sum = new Float64Array(size);
+        }
+
+        if (scratch_attribute_values.length < attributes.components) {
+            scratch_attribute_values = new Float64Array(attributes.components);
+        }
+    }
+
     const edge_pool = mesh.edges;
     const heap = new Uint32Heap(edge_pool.size);
 
@@ -357,7 +1216,9 @@ export function bt_mesh_simplify_with_quadrics(
             continue;
         }
 
-        const cost = evaluate_edge_collapse(mesh, e, quadratics, restricted_vertices, scratch_target);
+        const cost = evaluate_edge_collapse(
+            mesh, e, quadratics, restricted_vertices, attributes, wedges, scratch_target
+        );
 
         if (cost === Number.POSITIVE_INFINITY) {
             continue;
@@ -407,20 +1268,24 @@ export function bt_mesh_simplify_with_quadrics(
             continue;
         }
 
-        const cost = evaluate_edge_collapse(mesh, edge_id, quadratics, restricted_vertices, scratch_target);
+        const cost = evaluate_edge_collapse(
+            mesh, edge_id, quadratics, restricted_vertices, attributes, wedges, scratch_target
+        );
 
         if (cost === Number.POSITIVE_INFINITY) {
             continue;
         }
 
-        // `evaluate_edge_collapse` has just written the placement into `scratch_target`, which is
-        // what this needs and why it is tested here rather than beside the link condition above.
-        // Quadric cost is blind to the fold: a flat region scores zero for every placement in its
-        // plane, so nothing in the price stops a one-ring that is not star-shaped about the target
-        // from turning inside out.
-        if (bt_edge_collapse_would_fold(mesh, v1, v2, scratch_target)) {
-            continue;
-        }
+        /*
+         An invariant now, not a filter. `evaluate_edge_collapse` has just written the placement
+         into `scratch_target`, and it returns a finite price only for a placement it has itself
+         confirmed folds nothing -- so a fold reaching this point is this file being wrong, which is
+         what an assertion is for and what a `continue` would have hidden.
+        */
+        assert.notOk(
+            bt_edge_collapse_would_fold(mesh, v1, v2, scratch_target),
+            'the placement a finite collapse price was quoted for must not fold'
+        );
 
         const face_deaths = count_edge_faces(mesh, edge_id);
 
@@ -433,6 +1298,32 @@ export function bt_mesh_simplify_with_quadrics(
         const pre_survivor = mesh.edge_read_vertex1(edge_id);
         const pre_victim = mesh.edge_read_vertex2(edge_id);
 
+        const target_x = scratch_target[0];
+        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)
+        );
+
+        // Before the accumulation below, which is what makes the blend fallback weigh the two
+        // endpoints' own histories rather than the survivor's already carrying the victim's. And
+        // before the topology mutates, which is what lets the faces about to die say which corners
+        // shade as one.
+        if (wedges !== null) {
+            carry_wedges(
+                mesh, wedges, attributes, pre_survivor, pre_victim,
+                restricted_vertices.has(pre_survivor),
+                quadratics[pre_survivor].weight,
+                quadratics[pre_victim].weight,
+                scratch_target
+            );
+        }
+
         // Accumulate victim's quadric onto the survivor before the topology mutates.
         quadratics[pre_survivor].add(quadratics[pre_victim]);
         quadratics[pre_victim] = null;
@@ -453,14 +1344,11 @@ export function bt_mesh_simplify_with_quadrics(
         // are still intact.
         current_face_count -= bt_vertex_fuse_duplicate_edges(mesh, survivor);
 
-        update_neighbor_costs(mesh, survivor, quadratics, restricted_vertices, heap);
+        update_neighbor_costs(
+            mesh, survivor, quadratics, restricted_vertices, attributes, wedges, heap
+        );
     }
 
-    // Measured here, before the cleanup below, because a vertex left behind by a patch that was
-    // consumed whole is faceless and about to be removed — and it is the only thing still carrying
-    // the quadric of the geometry that used to be there.
-    const deviation = measure_deviation(mesh, quadratics);
-
     // Drop any loose loops/edges/verts produced during collapses, preserving
     // restricted vertices even if they ended up isolated.
     cleanup_faceless_preserving_restricted(mesh, restricted_vertices);
@@ -468,33 +1356,6 @@ export function bt_mesh_simplify_with_quadrics(
     return deviation;
 }
 
-/**
- * The largest distance any vertex now sits from the surface its quadric remembers.
- *
- * @param {BinaryTopology} mesh
- * @param {Quadric3[]} quadratics
- * @returns {number}
- */
-function measure_deviation(mesh, quadratics) {
-    const vertex_pool = mesh.vertices;
-
-    let result = 0;
-
-    for (let v = 0; v < vertex_pool.size; v++) {
-        if (!vertex_pool.is_allocated(v) || quadratics[v] === null || quadratics[v] === undefined) {
-            continue;
-        }
-
-        mesh.vertex_read_coordinate(scratch_coord_a, 0, v);
-
-        result = Math.max(
-            result, quadratics[v].distance(scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2])
-        );
-    }
-
-    return result;
-}
-
 /**
  * Variant of bt_mesh_cleanup_faceless_references that never releases a restricted
  * vertex even when it has no remaining edges.