@woosh/meep-engine 3.29.0 → 3.30.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.29.0",
+  "version": "3.30.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/binary/BinaryBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BinaryBuffer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"BinaryBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BinaryBuffer.js"],"names":[],"mappings":"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"}

package/src/core/binary/BinaryBuffer.js

@@ -974,8 +974,20 @@ export class BinaryBuffer {
      * @param {number} value must be an unsigned integer
      */
     writeUintVar(value) {
-        assert.isNonNegativeInteger(value, 'value');
-        assert.ok(value <= MAX_SAFE_UINT_VAR, `value=[${value}] exceeds maximum safe limit[=${MAX_SAFE_UINT_VAR}]`);
+        /**
+         * Deliberately an ordinary throw and not an `assert.*`: the accumulator below uses a signed
+         * `>>=`, so a value at or above 2^31 coerces to a negative int32 and `-1 >> 7 === -1` spins
+         * the loop forever, writing 0x80 until the heap gives out. The consumer strips asserts, so a
+         * strippable guard is no guard at all in the build that ships. `MAX_SAFE_UINT_VAR` is 2^31-1,
+         * which is also the ceiling {@link #readUintVar} can reconstruct, so this is the format's
+         * own limit rather than a conservative one.
+         *
+         * `(value | 0) !== value` catches non-integers, NaN and anything outside int32 in one test;
+         * `value < 0` takes the negative half of that range.
+         */
+        if ((value | 0) !== value || value < 0) {
+            throw new RangeError(`value=[${value}] must be an integer in [0, ${MAX_SAFE_UINT_VAR}]`);
+        }
 
         let first = true;
         let _v = value;

package/src/core/bvh2/bvh3/BVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"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"}

package/src/core/bvh2/bvh3/BVH.js

@@ -1176,7 +1176,20 @@ export class BVH {
         }
 
         if (best_rotation === 0) {
-            return iA; // no beneficial rotation
+            /**
+             * No swap reduces the surface area. That is the ordinary case for a well-shaped subtree,
+             * but it is also what happens when the candidate boxes are identical or one contains the
+             * other: every rotation then changes the area by exactly zero, `imp > best_improvement`
+             * is false four times over, and nothing moves. Left there, each new leaf inserted into
+             * such a cluster goes one level deeper than the last and the subtree becomes a linked
+             * list — 1,500 leaves sharing one AABB gave depth 1,531 rather than ~11, which is 1,500
+             * box tests on every query that reaches them and an O(N^2) insert.
+             *
+             * The height-AVL rotation is the tie-break. It is itself a no-op unless the subtree is
+             * out of balance by more than one level, so a subtree the SAH pass is already happy with
+             * is left exactly as it was.
+             */
+            return this.balance_height(iA);
         }
 
         // Apply the chosen rotation: re-wire one child↔grandchild pair, then

package/src/core/cache/FrequencySketch.d.ts

@@ -56,7 +56,9 @@ export class FrequencySketch<T> {
     /**
      * Initializes and increases the capacity of this <tt>FrequencySketch</tt> instance, if necessary,
      * to ensure that it can accurately estimate the popularity of elements given the maximum size of
-     * the cache. This operation forgets all previous counts when resizing.
+     * the cache. This operation forgets all previous counts when resizing, so callers that care about
+     * the history — all of them — must size the sketch before they start counting rather than growing
+     * it as they go.
      *
      * @param {number} maximumSize the maximum size of the cache
      */

package/src/core/cache/FrequencySketch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrequencySketch.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/FrequencySketch.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,CAED;IACf;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IACb;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,4BAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,oBAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;OAOG;IACH,sBAFW,MAAM,QAwBhB;IAED;;OAEG;IACH,cAaC;CACJ"}
+{"version":3,"file":"FrequencySketch.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/FrequencySketch.js"],"names":[],"mappings":"AA0EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,CAED;IACf;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IACb;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,oBAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;OAOG;IACH,sBAFW,MAAM,QAwBhB;IAED;;OAEG;IACH,cAaC;CACJ"}

package/src/core/cache/FrequencySketch.js

@@ -27,8 +27,11 @@ const MAX_INT_32 = 2147483647;
 function spread(v) {
     let x = v;
 
-    x = ((x >>> 16) ^ x) * 0x45d9f3b;
-    x = ((x >>> 16) ^ x) * 0x45d9f3b;
+    //`Math.imul` and not `*`: both operands are ~2^31, and the double product lands around 2^62,
+    //nine orders past the exact-integer limit. The bits that get rounded away are the low ones,
+    //which are exactly the bits `indexOf` then masks off — see COR-002.
+    x = Math.imul((x >>> 16) ^ x, 0x45d9f3b);
+    x = Math.imul((x >>> 16) ^ x, 0x45d9f3b);
 
     return (x >>> 16) ^ x;
 }
@@ -41,7 +44,8 @@ function spread(v) {
  * @returns {number} the table index
  */
 function indexOf(item, i, tableMask) {
-    let hash = (item + SEED[i]) * SEED[i];
+    //Caffeine's original is `int` arithmetic that wraps at 32 bits; `Math.imul` is what wraps here.
+    let hash = Math.imul(item + SEED[i], SEED[i]);
     hash += (hash >>> 16);
 
     return hash & tableMask;
@@ -127,7 +131,9 @@ export class FrequencySketch {
     /**
      * Initializes and increases the capacity of this <tt>FrequencySketch</tt> instance, if necessary,
      * to ensure that it can accurately estimate the popularity of elements given the maximum size of
-     * the cache. This operation forgets all previous counts when resizing.
+     * the cache. This operation forgets all previous counts when resizing, so callers that care about
+     * the history — all of them — must size the sketch before they start counting rather than growing
+     * it as they go.
      *
      * @param {number} maximumSize the maximum size of the cache
      */

package/src/core/cache/wtinylfu/CacheWTinylfu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CacheWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheWTinylfu.js"],"names":[],"mappings":"AAiDA;IA0FI;;;;;;;;;;;OAWG;IACH;QAT4B,SAAS,GAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACyB,UAAU,GAAzC,CAAC,GAAG,KAAK,KAAK,MAAM;QACe,YAAY,GAA/C,CAAC,KAAK,OAAO,KAAK,MAAM;QACO,eAAe,kBAAhC,MAAM;QACiB,mBAAmB,6BAArC,OAAO;OAwDpC;IA3FD;;;OAGG;IACH,OAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,YAFU,MAAM,CAEU;IAsE1B;;;;OAIG;IACH,gBAGC;IAED;;;;OAIG;IACH,mBAcC;IACD;;;;OAIG;IACH,wBAsBC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,mCAEC;IAED;;;;;;;OAOG;IACH,wBAEC;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAUnB;IAED;;;OAGG;IACH,cASC;IAED;;;;;;OAMG;IACH,+BAUC;IAED;;;;OAIG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAIC;IAED;;;;;;;OAOG;IACH,8BAmBC;IAED;;;;;;;OAOG;IACH,0BAeC;IAED;;;;;;;OAOG;IACH,2BAwBC;IAED;;;;;;OAMG;IACH,sBAkCC;IAED;;;;OAIG;IACH,sBAGC;IAED;;;;;;OAMG;IACH,gBAQC;IAED;;;;;;;OAOG;IACH,gBASC;IAoBD;;;;OAIG;IACH,mBAOC;IAED;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;OAKG;IACH,8BAMC;IAED;;;;;;;OAOG;IACH,gCAcC;IAED;;;;OAIG;IACH,2BASC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;;OAKG;IACH,yBAmBC;IAED;;;;OAIG;IACH,kCAkBC;IAED;;;;OAIG;IACH,eAFa,QAAM,IAAI,CAWtB;IAID;;;;;OAKG;IACH,yBAFa,eAAe,GAAC,IAAI,CAKhC;IAED;;;OAGG;IACH,kBAFa;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAQ9D;;CACJ;uBA/vBoB,+BAA+B;gCARtB,sBAAsB"}
+{"version":3,"file":"CacheWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheWTinylfu.js"],"names":[],"mappings":"AA0DA;IA0FI;;;;;;;;;;;OAWG;IACH;QAT4B,SAAS,GAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACyB,UAAU,GAAzC,CAAC,GAAG,KAAK,KAAK,MAAM;QACe,YAAY,GAA/C,CAAC,KAAK,OAAO,KAAK,MAAM;QACO,eAAe,kBAAhC,MAAM;QACiB,mBAAmB,6BAArC,OAAO;OAqEpC;IAxGD;;;OAGG;IACH,OAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,YAFU,MAAM,CAEU;IAmF1B;;;;OAIG;IACH,gBAGC;IAED;;;;OAIG;IACH,mBAcC;IACD;;;;OAIG;IACH,wBAsBC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,mCAEC;IAED;;;;;;;OAOG;IACH,wBAEC;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAUnB;IAED;;;OAGG;IACH,cASC;IAED;;;;;;OAMG;IACH,+BAUC;IAED;;;;OAIG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAIC;IAED;;;;;;;OAOG;IACH,8BAmBC;IAED;;;;;;;OAOG;IACH,0BAeC;IAED;;;;;;;OAOG;IACH,2BAwBC;IAED;;;;;;OAMG;IACH,sBAkCC;IAED;;;;OAIG;IACH,sBAGC;IAED;;;;;;OAMG;IACH,gBAQC;IAED;;;;;;;OAOG;IACH,gBASC;IAoBD;;;;OAIG;IACH,mBAOC;IAED;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;OAKG;IACH,8BAMC;IAED;;;;;;;OAOG;IACH,gCAcC;IAED;;;;OAIG;IACH,2BASC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;;OAKG;IACH,yBAmBC;IAED;;;;OAIG;IACH,kCAkBC;IAED;;;;OAIG;IACH,eAFa,QAAM,IAAI,CAWtB;IAID;;;;;OAKG;IACH,yBAFa,eAAe,GAAC,IAAI,CAKhC;IAED;;;OAGG;IACH,kBAFa;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAQ9D;;CACJ;uBArxBoB,+BAA+B;gCARtB,sBAAsB"}

package/src/core/cache/wtinylfu/CacheWTinylfu.js

@@ -39,6 +39,7 @@ import {invokeObjectEquals} from "../../model/object/invokeObjectEquals.js";
 import {HashMap} from "../../collection/map/HashMap.js";
 import {mainCapacity, exceedsMainWeight, cannotFitMain, winsAdmissionDuel, shouldPromoteToProtected, classifyAdmission, AdmissionRoute} from "./wtinylfuDecisions.js";
 import {Signal} from "../../events/signal/Signal.js";
+import {min2} from "../../math/min2.js";
 
 /**
  * Cap on the reuse pool of evicted element objects. Under churn the pool hovers near 1 (one evict per
@@ -47,6 +48,14 @@ import {Signal} from "../../events/signal/Signal.js";
  */
 const ELEMENT_POOL_MAX = 256;
 
+/**
+ * Ceiling on the up-front {@link FrequencySketch} size, in counter slots. The sketch costs 4 bytes a
+ * slot, so this is 4 KiB; `maxWeight` is a weight budget and defaults to infinity, so it cannot be
+ * used to size the table unclamped.
+ * @type {number}
+ */
+const SKETCH_SEED_LIMIT = 1024;
+
 export class CacheWTinylfu {
 
     /**
@@ -201,8 +210,21 @@ export class CacheWTinylfu {
             keyEqualityFunction
         });
 
-        // The sketch is sized dynamically to the live element count in __admit; seed a minimal table.
-        this.#sketch.ensureCapacity(0);
+        /**
+         * Size the sketch up front, from the cache's own budget, rather than letting `__admit` grow
+         * it one admission at a time. `ensureCapacity` drops every count it holds when it grows, so
+         * growing alongside the cache wipes the access history at each power-of-two boundary —
+         * exactly while the cache is filling, which is when the admission duel first starts running.
+         * The effect is that a long-resident hot key reads back as frequency 0 and loses its duel to
+         * whichever one-shot newcomer was admitted most recently.
+         *
+         * `maxWeight` is a weight budget, not an element count, and defaults to infinity, so it is
+         * only an element ceiling under the default unit weigher. It is clamped here so a
+         * byte-weighted cache does not allocate a table sized in its byte budget; a cache whose live
+         * set exceeds the clamp still grows (and still loses its early history once), which is a
+         * transient at that scale rather than the whole warm-up.
+         */
+        this.#sketch.ensureCapacity(Math.ceil(min2(maxWeight, SKETCH_SEED_LIMIT)));
     }
 
     /**

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_simplify.d.ts

@@ -6,9 +6,24 @@
  * 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
@@ -24,21 +39,36 @@
  * 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.
- *
- * 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.
- *
- * 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.
+ * 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.
  *
  * `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

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":"AA4yBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;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,CA2LlB;yBA/mCwB,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":"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"}