@woosh/meep-engine 3.28.0 → 3.30.0

package/src/core/geom/3d/quadric/quadric_attribute_sub.js

@@ -0,0 +1,35 @@
+import { QUADRIC3_SIZE } from "./QUADRIC3_SIZE.js";
+
+/**
+ * Subtract one attribute quadric from another, elementwise — the inverse of
+ * {@link quadric_attribute_add}.
+ *
+ * What it is for is the same thing {@link quadric3_sub} is for: recovering what a pass *added* to a
+ * quadric, when two passes started from the same one. Two group steps sharing a pinned boundary
+ * vertex each begin from that vertex's quadric and each fold their own victims onto it, so the two
+ * results overlap by exactly the quadric they both began with; adding them whole would count the
+ * source under that vertex twice.
+ *
+ * The difference of two quadrics is not itself a sum of anything, and its weight can come out
+ * negative. Nothing here objects — a gain is meant to be added back to the quadric it was measured
+ * against, not evaluated on its own.
+ *
+ * @param {number[]|Float32Array|Float64Array} out `quadric_attribute_size(components)` elements from
+ *     `out_offset`; may alias either input
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} a
+ * @param {number} a_offset
+ * @param {ArrayLike<number>} b subtracted from `a`
+ * @param {number} b_offset
+ * @param {number} components number of scalar channels
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric_attribute_sub(out, out_offset, a, a_offset, b, b_offset, components) {
+    const size = QUADRIC3_SIZE + components * 4;
+
+    for (let i = 0; i < size; i++) {
+        out[out_offset + i] = a[a_offset + i] - b[b_offset + i];
+    }
+}

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

@@ -107,6 +107,21 @@ export class BinaryDataBlock {
      * @param {number} source_id element id in `source`
      */
     copy_record(id: number, source: BinaryDataBlock, source_id: number): void;
+    /**
+     * Do two records hold the same bytes?
+     *
+     * Bytes, not values, and that is the point: this is the test a *wedge* is defined by — a set of
+     * corners at one vertex that shade identically — and identity has to be exact for the grouping
+     * to be an equivalence relation. A tolerance is not transitive, so grouping by one would depend
+     * on the order the corners were visited in, and two runs over the same mesh could disagree.
+     *
+     * Every byte of the record, so a block gaining a layer needs nothing here.
+     *
+     * @param {number} a element id in this block
+     * @param {number} b element id in this block
+     * @returns {boolean}
+     */
+    record_equal(a: number, b: number): boolean;
     /**
      * Take on another block's layers and contents.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"BinaryDataBlock.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/struct/binary/BinaryDataBlock.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAwCI;;OAEG;IACH,kBAFW,iBAAiB,EAM3B;IAED;;;OAGG;IACH,0BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;OAEG;IACH,0BAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAJW,cAAc,cACd,MAAM,GACJ,eAAe,CAa3B;IAED;;;OAGG;IACH,0BAFW,MAAM,QAUhB;IAED;;;OAGG;IACH,sBAEC;IAED;;OAEG;IACH,aAQC;IAED;;;;;;;;OAQG;IACH,QAHW,MAAM,KACN,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAJW,MAAM,UACN,eAAe,aACf,MAAM,QAchB;IAED;;;;;;;;OAQG;IACH,YAFW,eAAe,QAyBzB;IA8CL;;;;OAIG;IACH,4BAFU,OAAO,CAE0B;;CAP1C;6BAlTY,OAAO,8CAA8C,EAAE,cAAc;gCACrE,OAAO,wBAAwB,EAAE,iBAAiB;gCAJ/B,sBAAsB"}
+{"version":3,"file":"BinaryDataBlock.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/struct/binary/BinaryDataBlock.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAwCI;;OAEG;IACH,kBAFW,iBAAiB,EAM3B;IAED;;;OAGG;IACH,0BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;OAEG;IACH,0BAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAJW,cAAc,cACd,MAAM,GACJ,eAAe,CAa3B;IAED;;;OAGG;IACH,0BAFW,MAAM,QAUhB;IAED;;;OAGG;IACH,sBAEC;IAED;;OAEG;IACH,aAQC;IAED;;;;;;;;OAQG;IACH,QAHW,MAAM,KACN,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAJW,MAAM,UACN,eAAe,aACf,MAAM,QAchB;IAED;;;;;;;;;;;;;OAaG;IACH,gBAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAqBnB;IAED;;;;;;;;OAQG;IACH,YAFW,eAAe,QAyBzB;IA8CL;;;;OAIG;IACH,4BAFU,OAAO,CAE0B;;CAP1C;6BArVY,OAAO,8CAA8C,EAAE,cAAc;gCACrE,OAAO,wBAAwB,EAAE,iBAAiB;gCAJ/B,sBAAsB"}

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

@@ -233,6 +233,41 @@ export class BinaryDataBlock {
         );
     }
 
+    /**
+     * Do two records hold the same bytes?
+     *
+     * Bytes, not values, and that is the point: this is the test a *wedge* is defined by — a set of
+     * corners at one vertex that shade identically — and identity has to be exact for the grouping
+     * to be an equivalence relation. A tolerance is not transitive, so grouping by one would depend
+     * on the order the corners were visited in, and two runs over the same mesh could disagree.
+     *
+     * Every byte of the record, so a block gaining a layer needs nothing here.
+     *
+     * @param {number} a element id in this block
+     * @param {number} b element id in this block
+     * @returns {boolean}
+     */
+    record_equal(a, b) {
+        if (a === b) {
+            return true;
+        }
+
+        const record_size = this.#record_size;
+
+        const from_a = a * record_size;
+        const from_b = b * record_size;
+
+        const data = this.#data_uint8;
+
+        for (let offset = 0; offset < record_size; offset++) {
+            if (data[from_a + offset] !== data[from_b + offset]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Take on another block's layers and contents.
      *

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

@@ -0,0 +1,93 @@
+/**
+ * Which corners of a mesh shade as one.
+ *
+ * A **wedge** is a set of loops at one vertex that carry the same appearance. A vertex has one
+ * position and the topology says so; it does not have one *appearance*, and a hard edge or a texture
+ * seam is exactly a vertex whose corners disagree. This is the structure that lets them.
+ *
+ * Three things, and the split between them is the whole design:
+ *
+ * - **{@link of_loop} is never written after construction.** A collapse re-points a victim's loops
+ *   onto the survivor and leaves the loops themselves alone, so a corner's wedge id travels with it
+ *   for free. Nothing has to find a corner in order to move it.
+ * - **{@link parent} is a union-find**, and merging two wedges is a union. That is what makes the
+ *   previous point affordable: the ids a loop holds go stale, {@link find} resolves them, and no
+ *   pass over the loop pool is ever needed to keep them true.
+ * - **{@link first_of_vertex} and {@link next_of_wedge} are one intrusive list per vertex**, which
+ *   is what a collapse iterates. Two typed arrays rather than an array of arrays per vertex: a
+ *   frontier holds every vertex of a level, and on smooth geometry every one of those lists has
+ *   exactly one entry.
+ *
+ * Wedge ids need not be dense and need not agree with vertex ids. {@link bt_wedges_per_vertex}
+ * builds the degenerate set where they are vertex ids — one wedge per vertex, which is a mesh with
+ * no seams and is what every caller that does not care about appearance wants.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BtWedgeSet {
+    /**
+     * The wedge each loop belongs to, indexed by loop id. Read through {@link find}, never trusted
+     * raw: a merge leaves it naming a wedge that is no longer a root.
+     * @type {Uint32Array}
+     */
+    of_loop: Uint32Array;
+    /**
+     * Union-find over wedge ids. A root is its own parent.
+     * @type {Uint32Array}
+     */
+    parent: Uint32Array;
+    /**
+     * Head of each vertex's wedge list, or `NULL_POINTER` for a vertex with no corners.
+     * @type {Uint32Array}
+     */
+    first_of_vertex: Uint32Array;
+    /**
+     * Next wedge at the same vertex, or `NULL_POINTER`.
+     * @type {Uint32Array}
+     */
+    next_of_wedge: Uint32Array;
+    /**
+     * How many wedge ids exist, live and merged-away together.
+     * @type {number}
+     */
+    count: number;
+    /**
+     * The root of the wedge `wedge` has been merged into, or itself.
+     *
+     * Path-halving rather than full compression: it is one write per step instead of a second walk,
+     * and it gives the same near-constant amortized bound. This runs once per corner of every
+     * candidate the heap scores, which is several times per edge per round.
+     *
+     * @param {number} wedge
+     * @returns {number}
+     */
+    find(wedge: number): number;
+    /**
+     * Make `other` part of `wedge`.
+     *
+     * Directed on purpose, where a union-find would normally pick the taller tree: the caller is
+     * merging a victim's wedge into a survivor's, and which id survives decides which vertex's list
+     * the result is on. Correctness beats the tree height, and the depth this trades away is what
+     * {@link find}'s path halving pays back.
+     *
+     * @param {number} wedge the root that survives
+     * @param {number} other the root that does not
+     * @returns {boolean} `false` when they were already one wedge and nothing was done
+     */
+    merge(wedge: number, other: number): boolean;
+    /**
+     * Put `wedge` at the head of `vertex`'s list. It must be a root and must not be on any list.
+     *
+     * @param {number} wedge
+     * @param {number} vertex
+     */
+    attach(wedge: number, vertex: number): void;
+    /**
+     * Drop every wedge `vertex` holds, without touching the wedges themselves.
+     *
+     * @param {number} vertex
+     */
+    detach_all(vertex: number): void;
+}
+//# sourceMappingURL=BtWedgeSet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BtWedgeSet.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/struct/binary/BtWedgeSet.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IACI;;;;OAIG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;OAGG;IACH,QAFU,WAAW,CAEO;IAE5B;;;OAGG;IACH,iBAFU,WAAW,CAEgB;IAErC;;;OAGG;IACH,eAFU,WAAW,CAEc;IAEnC;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;OASG;IACH,YAHW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;;;;;;;OAWG;IACH,aAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,cAHW,MAAM,UACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;CACJ"}

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

@@ -0,0 +1,128 @@
+import { NULL_POINTER } from "./BinaryTopology.js";
+
+/**
+ * Which corners of a mesh shade as one.
+ *
+ * A **wedge** is a set of loops at one vertex that carry the same appearance. A vertex has one
+ * position and the topology says so; it does not have one *appearance*, and a hard edge or a texture
+ * seam is exactly a vertex whose corners disagree. This is the structure that lets them.
+ *
+ * Three things, and the split between them is the whole design:
+ *
+ * - **{@link of_loop} is never written after construction.** A collapse re-points a victim's loops
+ *   onto the survivor and leaves the loops themselves alone, so a corner's wedge id travels with it
+ *   for free. Nothing has to find a corner in order to move it.
+ * - **{@link parent} is a union-find**, and merging two wedges is a union. That is what makes the
+ *   previous point affordable: the ids a loop holds go stale, {@link find} resolves them, and no
+ *   pass over the loop pool is ever needed to keep them true.
+ * - **{@link first_of_vertex} and {@link next_of_wedge} are one intrusive list per vertex**, which
+ *   is what a collapse iterates. Two typed arrays rather than an array of arrays per vertex: a
+ *   frontier holds every vertex of a level, and on smooth geometry every one of those lists has
+ *   exactly one entry.
+ *
+ * Wedge ids need not be dense and need not agree with vertex ids. {@link bt_wedges_per_vertex}
+ * builds the degenerate set where they are vertex ids — one wedge per vertex, which is a mesh with
+ * no seams and is what every caller that does not care about appearance wants.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BtWedgeSet {
+    /**
+     * The wedge each loop belongs to, indexed by loop id. Read through {@link find}, never trusted
+     * raw: a merge leaves it naming a wedge that is no longer a root.
+     * @type {Uint32Array}
+     */
+    of_loop = new Uint32Array(0);
+
+    /**
+     * Union-find over wedge ids. A root is its own parent.
+     * @type {Uint32Array}
+     */
+    parent = new Uint32Array(0);
+
+    /**
+     * Head of each vertex's wedge list, or `NULL_POINTER` for a vertex with no corners.
+     * @type {Uint32Array}
+     */
+    first_of_vertex = new Uint32Array(0);
+
+    /**
+     * Next wedge at the same vertex, or `NULL_POINTER`.
+     * @type {Uint32Array}
+     */
+    next_of_wedge = new Uint32Array(0);
+
+    /**
+     * How many wedge ids exist, live and merged-away together.
+     * @type {number}
+     */
+    count = 0;
+
+    /**
+     * The root of the wedge `wedge` has been merged into, or itself.
+     *
+     * Path-halving rather than full compression: it is one write per step instead of a second walk,
+     * and it gives the same near-constant amortized bound. This runs once per corner of every
+     * candidate the heap scores, which is several times per edge per round.
+     *
+     * @param {number} wedge
+     * @returns {number}
+     */
+    find(wedge) {
+        const parent = this.parent;
+
+        let root = wedge;
+
+        while (parent[root] !== root) {
+            parent[root] = parent[parent[root]];
+
+            root = parent[root];
+        }
+
+        return root;
+    }
+
+    /**
+     * Make `other` part of `wedge`.
+     *
+     * Directed on purpose, where a union-find would normally pick the taller tree: the caller is
+     * merging a victim's wedge into a survivor's, and which id survives decides which vertex's list
+     * the result is on. Correctness beats the tree height, and the depth this trades away is what
+     * {@link find}'s path halving pays back.
+     *
+     * @param {number} wedge the root that survives
+     * @param {number} other the root that does not
+     * @returns {boolean} `false` when they were already one wedge and nothing was done
+     */
+    merge(wedge, other) {
+        if (wedge === other) {
+            return false;
+        }
+
+        this.parent[other] = wedge;
+
+        return true;
+    }
+
+    /**
+     * Put `wedge` at the head of `vertex`'s list. It must be a root and must not be on any list.
+     *
+     * @param {number} wedge
+     * @param {number} vertex
+     */
+    attach(wedge, vertex) {
+        this.next_of_wedge[wedge] = this.first_of_vertex[vertex];
+
+        this.first_of_vertex[vertex] = wedge;
+    }
+
+    /**
+     * Drop every wedge `vertex` holds, without touching the wedges themselves.
+     *
+     * @param {number} vertex
+     */
+    detach_all(vertex) {
+        this.first_of_vertex[vertex] = NULL_POINTER;
+    }
+}

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

@@ -5,6 +5,26 @@
  * vertices; the corresponding quadric is then accumulated onto each of those
  * three vertices' Quadric3. Non-triangular faces are skipped.
  *
+ * **Each plane weighs the surface standing behind it, not one.** What a vertex reports is the mean
+ * over its planes ({@link Quadric3#distance}), and a mean over a count is a statement about how the
+ * surface was *cut* rather than about the surface: cutting one face in two along its own plane adds
+ * no surface and the metric hears the same plane twice, so a finely tessellated patch outvotes a
+ * coarse one many times its size. Weighing each plane by its triangle's area is what makes the mean
+ * an average over the surface, and it is what makes an in-plane subdivision — which says nothing new
+ * — change nothing.
+ *
+ * The weights are **areas as a multiple of this mesh's own mean triangle**, not areas. A ratio is
+ * what every other number here is stated against: {@link BOUNDARY_WEIGHT} is three *faces*, and the
+ * attribute quadric a virtual-geometry build sums with these weighs one per triangle and says so
+ * ({@link quadric_attribute_set_from_triangle}) — both of which are answers to "how much is a face
+ * worth", and neither survives the slot becoming square metres. It costs nothing that matters: a
+ * mean divides the weights out again, so what a vertex reports is identical either way, and
+ * {@link quadric3_optimize} is scale-invariant, so placement is too.
+ *
+ * A triangle with no area is skipped entirely rather than weighed at zero. It has no plane —
+ * {@link tri3_compute_normal} hands it an arbitrary direction — so it neither contributes one nor
+ * counts towards the mean it would otherwise drag down.
+ *
  * @param {BinaryTopology} mesh
  * @returns {Quadric3[]} Array indexed by vertex ID. Entries for unallocated
  *     vertex slots are `undefined`.

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_compute_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;GAUG;AACH,uEAHa,QAAQ,EAAE,CA2EtB;yBA5GwB,iCAAiC"}
+{"version":3,"file":"bt_mesh_compute_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAHa,QAAQ,EAAE,CAgHtB;yBA1KwB,iCAAiC"}

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

@@ -1,6 +1,7 @@
 import { quadric3_set_from_plane_through_point } from "../../../../quadric/quadric3_set_from_plane_through_point.js";
 import { assert } from "../../../../../../assert.js";
 import { v3_dot } from "../../../../../vec3/v3_dot.js";
+import { tri3_area } from "../../../../triangle/tri3_area.js";
 import { tri3_compute_normal } from "../../../../triangle/tri3_compute_normal.js";
 import { Quadric3 } from "../../../../quadric/Quadric3.js";
 import { NULL_POINTER } from "../BinaryTopology.js";
@@ -12,7 +13,7 @@ const scratch_normal = new Float32Array(3);
 const boundary_quadric = new Quadric3();
 
 /**
- * How much a boundary constraint plane weighs against one face plane.
+ * How much a boundary constraint plane weighs against one face plane **of the same area**.
  *
  * Three, measured. A face-plane quadric alone says nothing about a vertex sliding *within* the
  * surface, which is exactly what an open edge does when it erodes, so without this term a boundary
@@ -22,6 +23,11 @@ const boundary_quadric = new Quadric3();
  * roughly the displacement itself, while leaving the boundary free enough to erode at all — which
  * it must, or a mesh made of open shells has no coarse form and no root.
  *
+ * It is a ratio against a face, so it is applied on top of the face's own area weight rather than
+ * instead of it. Three flat is a number of square metres, which is not a ratio at all: the same
+ * border would weigh a millionth of its fan on a model authored in millimetres and a million times
+ * it on one authored in kilometres, and the measurement above would hold for neither.
+ *
  * @readonly
  * @type {number}
  */
@@ -34,6 +40,26 @@ const BOUNDARY_WEIGHT = 3;
  * vertices; the corresponding quadric is then accumulated onto each of those
  * three vertices' Quadric3. Non-triangular faces are skipped.
  *
+ * **Each plane weighs the surface standing behind it, not one.** What a vertex reports is the mean
+ * over its planes ({@link Quadric3#distance}), and a mean over a count is a statement about how the
+ * surface was *cut* rather than about the surface: cutting one face in two along its own plane adds
+ * no surface and the metric hears the same plane twice, so a finely tessellated patch outvotes a
+ * coarse one many times its size. Weighing each plane by its triangle's area is what makes the mean
+ * an average over the surface, and it is what makes an in-plane subdivision — which says nothing new
+ * — change nothing.
+ *
+ * The weights are **areas as a multiple of this mesh's own mean triangle**, not areas. A ratio is
+ * what every other number here is stated against: {@link BOUNDARY_WEIGHT} is three *faces*, and the
+ * attribute quadric a virtual-geometry build sums with these weighs one per triangle and says so
+ * ({@link quadric_attribute_set_from_triangle}) — both of which are answers to "how much is a face
+ * worth", and neither survives the slot becoming square metres. It costs nothing that matters: a
+ * mean divides the weights out again, so what a vertex reports is identical either way, and
+ * {@link quadric3_optimize} is scale-invariant, so placement is too.
+ *
+ * A triangle with no area is skipped entirely rather than weighed at zero. It has no plane —
+ * {@link tri3_compute_normal} hands it an arbitrary direction — so it neither contributes one nor
+ * counts towards the mean it would otherwise drag down.
+ *
  * @param {BinaryTopology} mesh
  * @returns {Quadric3[]} Array indexed by vertex ID. Entries for unallocated
  *     vertex slots are `undefined`.
@@ -58,6 +84,11 @@ export function bt_mesh_compute_vertex_quadrics(mesh) {
 
     const q = new Quadric3();
 
+    // The mesh's own scale, for the normalization below. Accumulated as the faces go by rather than
+    // swept for beforehand, since the loop below already has every area it needs.
+    let total_area = 0;
+    let triangle_count = 0;
+
     for (let f = 0; f < face_count; f++) {
         if (!face_pool.is_allocated(f)) {
             continue;
@@ -85,6 +116,19 @@ export function bt_mesh_compute_vertex_quadrics(mesh) {
         mesh.vertex_read_coordinate(scratch_coord_b, 0, vb);
         mesh.vertex_read_coordinate(scratch_coord_c, 0, vc);
 
+        const area = tri3_area(
+            scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2],
+            scratch_coord_b[0], scratch_coord_b[1], scratch_coord_b[2],
+            scratch_coord_c[0], scratch_coord_c[1], scratch_coord_c[2]
+        );
+
+        if (area === 0) {
+            continue;
+        }
+
+        total_area += area;
+        triangle_count++;
+
         tri3_compute_normal(
             scratch_normal, 0,
             scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2],
@@ -102,11 +146,30 @@ export function bt_mesh_compute_vertex_quadrics(mesh) {
             scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2]
         );
 
+        // Weight and matrix together, which is what {@link quadric3_scale} is for: the plane counts
+        // for its area in the sum *and* declares that it does, so the mean stays a length.
+        q.multiplyScalar(area);
+
         quadratics[va].add(q);
         quadratics[vb].add(q);
         quadratics[vc].add(q);
 
-        add_boundary_constraints(mesh, quadratics, f, nx, ny, nz);
+        add_boundary_constraints(mesh, quadratics, f, nx, ny, nz, area);
+    }
+
+    if (triangle_count > 0) {
+        // Areas into multiples of the mean triangle. One pass at the end rather than a pass for the
+        // mean before the accumulation: scaling is linear and uniform, so dividing every quadric
+        // here is dividing every plane's weight there.
+        const of_a_mean_triangle = triangle_count / total_area;
+
+        for (let v = 0; v < vertex_count; v++) {
+            const quadric = quadratics[v];
+
+            if (quadric !== undefined) {
+                quadric.multiplyScalar(of_a_mean_triangle);
+            }
+        }
     }
 
     return quadratics;
@@ -170,8 +233,10 @@ function count_edge_faces(mesh, edge) {
  * @param {number} nx face normal, unit
  * @param {number} ny
  * @param {number} nz
+ * @param {number} area of the face, which the constraint carries so that it stays
+ *     {@link BOUNDARY_WEIGHT} times a face rather than a fixed number of square metres
  */
-function add_boundary_constraints(mesh, quadratics, face, nx, ny, nz) {
+function add_boundary_constraints(mesh, quadratics, face, nx, ny, nz, area) {
     const first = mesh.face_read_loop(face);
 
     let loop = first;
@@ -217,7 +282,7 @@ function add_boundary_constraints(mesh, quadratics, face, nx, ny, nz) {
             scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2]
         );
 
-        boundary_quadric.multiplyScalar(BOUNDARY_WEIGHT);
+        boundary_quadric.multiplyScalar(BOUNDARY_WEIGHT * area);
 
         quadratics[v1].add(boundary_quadric);
         quadratics[v2].add(boundary_quadric);

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

@@ -0,0 +1,38 @@
+/**
+ * One attribute quadric per wedge, accumulated from every allocated triangle.
+ *
+ * The companion of {@link bt_mesh_compute_vertex_quadrics}, and deliberately its *companion* rather
+ * than an extension of it: that one stays the pure geometric quadric, which is what lets the error a
+ * caller reports stay an object-space length no matter what this one does to the placement
+ * (`VIRTUAL_GEOMETRY_DESIGN.md` §3). Solve in the higher-dimensional metric, evaluate in the 3-D one.
+ *
+ * The attribute values arrive as a flat array indexed by **wedge** id — `components` scalars each,
+ * whatever they happen to mean. This pass does not know and does not need to: a channel is a number
+ * per corner that varies affinely over a triangle, and a normal, a texture coordinate and a colour
+ * are all that.
+ *
+ * Per wedge rather than per vertex because a vertex has one position and not one appearance, and per
+ * wedge rather than per *corner* because a single corner's quadric would only ever hold its own
+ * triangle — a field fitted from one triangle is exact and says nothing. The history is what a
+ * quadric is for, and the history belongs to the set of corners that share a value.
+ * {@link bt_wedges_per_vertex} is the set for a mesh with no seams, where a wedge id *is* a vertex
+ * id and this is per vertex again.
+ *
+ * Non-triangular faces are skipped, as they are in the geometric pass. So are slivers, by
+ * {@link quadric_attribute_set_from_triangle}'s own test — a gradient that divides by twice the area
+ * would otherwise outweigh every honest triangle around it.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {ArrayLike<number>} values `wedges.count * components` scalars, indexed by wedge id
+ * @param {number} components number of scalar channels
+ * @param {ArrayLike<number>} weights one per channel, mapping it into units of length
+ * @param {BtWedgeSet} wedges which corners of each vertex shade as one
+ * @returns {Float64Array} `wedges.count * quadric_attribute_size(components)` elements, indexed by
+ *     wedge id; a slot no triangle used holds a quadric of zero weight, which
+ *     {@link quadric_attribute_solve} refuses rather than answering from
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_compute_wedge_attribute_quadrics(mesh: BinaryTopology, values: ArrayLike<number>, components: number, weights: ArrayLike<number>, wedges: BtWedgeSet): Float64Array;
+//# sourceMappingURL=bt_mesh_compute_wedge_attribute_quadrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_compute_wedge_attribute_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_wedge_attribute_quadrics.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uFAXW,UAAU,MAAM,CAAC,cACjB,MAAM,WACN,UAAU,MAAM,CAAC,uBAEf,YAAY,CAmExB"}

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

@@ -0,0 +1,113 @@
+import { assert } from "../../../../../../assert.js";
+import {
+    quadric_attribute_add
+} from "../../../../quadric/quadric_attribute_add.js";
+import {
+    quadric_attribute_set_from_triangle
+} from "../../../../quadric/quadric_attribute_set_from_triangle.js";
+import { quadric_attribute_size } from "../../../../quadric/quadric_attribute_size.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * One triangle's contribution, before it is accumulated onto each of its corners.
+ * @type {Float64Array}
+ */
+let scratch_quadric = new Float64Array(0);
+
+/**
+ * One attribute quadric per wedge, accumulated from every allocated triangle.
+ *
+ * The companion of {@link bt_mesh_compute_vertex_quadrics}, and deliberately its *companion* rather
+ * than an extension of it: that one stays the pure geometric quadric, which is what lets the error a
+ * caller reports stay an object-space length no matter what this one does to the placement
+ * (`VIRTUAL_GEOMETRY_DESIGN.md` §3). Solve in the higher-dimensional metric, evaluate in the 3-D one.
+ *
+ * The attribute values arrive as a flat array indexed by **wedge** id — `components` scalars each,
+ * whatever they happen to mean. This pass does not know and does not need to: a channel is a number
+ * per corner that varies affinely over a triangle, and a normal, a texture coordinate and a colour
+ * are all that.
+ *
+ * Per wedge rather than per vertex because a vertex has one position and not one appearance, and per
+ * wedge rather than per *corner* because a single corner's quadric would only ever hold its own
+ * triangle — a field fitted from one triangle is exact and says nothing. The history is what a
+ * quadric is for, and the history belongs to the set of corners that share a value.
+ * {@link bt_wedges_per_vertex} is the set for a mesh with no seams, where a wedge id *is* a vertex
+ * id and this is per vertex again.
+ *
+ * Non-triangular faces are skipped, as they are in the geometric pass. So are slivers, by
+ * {@link quadric_attribute_set_from_triangle}'s own test — a gradient that divides by twice the area
+ * would otherwise outweigh every honest triangle around it.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {ArrayLike<number>} values `wedges.count * components` scalars, indexed by wedge id
+ * @param {number} components number of scalar channels
+ * @param {ArrayLike<number>} weights one per channel, mapping it into units of length
+ * @param {BtWedgeSet} wedges which corners of each vertex shade as one
+ * @returns {Float64Array} `wedges.count * quadric_attribute_size(components)` elements, indexed by
+ *     wedge id; a slot no triangle used holds a quadric of zero weight, which
+ *     {@link quadric_attribute_solve} refuses rather than answering from
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_compute_wedge_attribute_quadrics(mesh, values, components, weights, wedges) {
+    assert.equal(mesh.isBinaryTopology, true, 'mesh.isBinaryTopology !== true');
+    assert.isPositiveInteger(components, 'components');
+
+    const size = quadric_attribute_size(components);
+
+    if (scratch_quadric.length < size) {
+        scratch_quadric = new Float64Array(size);
+    }
+
+    const result = new Float64Array(wedges.count * size);
+
+    const face_pool = mesh.faces;
+
+    const coordinate = new Float32Array(9);
+
+    for (let face = 0; face < face_pool.size; face++) {
+        if (!face_pool.is_allocated(face)) {
+            continue;
+        }
+
+        const la = mesh.face_read_loop(face);
+
+        if (la === NULL_POINTER) {
+            continue;
+        }
+
+        const lb = mesh.loop_read_next(la);
+        const lc = mesh.loop_read_next(lb);
+
+        if (mesh.loop_read_next(lc) !== la) {
+            continue;
+        }
+
+        mesh.vertex_read_coordinate(coordinate, 0, mesh.loop_read_vertex(la));
+        mesh.vertex_read_coordinate(coordinate, 3, mesh.loop_read_vertex(lb));
+        mesh.vertex_read_coordinate(coordinate, 6, mesh.loop_read_vertex(lc));
+
+        const wa = wedges.find(wedges.of_loop[la]);
+        const wb = wedges.find(wedges.of_loop[lb]);
+        const wc = wedges.find(wedges.of_loop[lc]);
+
+        const built = quadric_attribute_set_from_triangle(
+            scratch_quadric, 0, components, weights,
+            coordinate[0], coordinate[1], coordinate[2],
+            coordinate[3], coordinate[4], coordinate[5],
+            coordinate[6], coordinate[7], coordinate[8],
+            values, wa * components, wb * components, wc * components
+        );
+
+        if (!built) {
+            continue;
+        }
+
+        quadric_attribute_add(result, wa * size, result, wa * size, scratch_quadric, 0, components);
+        quadric_attribute_add(result, wb * size, result, wb * size, scratch_quadric, 0, components);
+        quadric_attribute_add(result, wc * size, result, wc * size, scratch_quadric, 0, components);
+    }
+
+    return result;
+}