@woosh/meep-engine 3.29.0 → 3.30.0

package/src/format/image/avif/av1/util/round2.d.ts

@@ -7,8 +7,9 @@
  * guard is not cosmetic: `1 << -1` is `1 << 31` under JavaScript's shift-count masking, which would
  * silently produce garbage.
  *
- * `x` must fit in a signed 32-bit integer, which every intermediate the specification feeds to this
- * function does.
+ * `x + 2^(n-1)` must fit in a signed 32-bit integer — the rounding term is added before the shift, so
+ * the bound is slightly tighter than `x` itself. Most intermediates the specification feeds this do;
+ * the self-guided restoration box filter's do not, and use {@link round2_wide} instead.
  *
  * @param {number} x
  * @param {number} n number of bits to shift away, `>= 0`
@@ -19,4 +20,20 @@
  * @copyright Company Named Limited (c) 2026
  */
 export function round2(x: number, n: number): number;
+/**
+ * {@link round2} for operands that run past a signed 32-bit integer.
+ *
+ * `>>` applies ToInt32 to its left operand, so the shifted form silently wraps above 2^31 and comes
+ * back negative — the self-guided restoration box filter's `p * s` reaches 3.8e9 on an ordinary
+ * black/white edge, where `round2` returned -484 against an exact 3612. Every JavaScript number is
+ * already a double, so the product itself is exact to 2^53; only the shift needs replacing with a
+ * floor division, which is what the specification's Round2 says in the first place. Same shape as
+ * `round2_12` in the inverse transform, which hit this earlier.
+ *
+ * @param {number} x
+ * @param {number} n number of bits to shift away, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ */
+export function round2_wide(x: number, n: number): number;
 //# sourceMappingURL=round2.d.ts.map

package/src/format/image/avif/av1/util/round2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"round2.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/util/round2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0BARW,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB"}
+{"version":3,"file":"round2.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/util/round2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,0BARW,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;;GAcG;AACH,+BALW,MAAM,KACN,MAAM,GACJ,MAAM,CASlB"}

package/src/format/image/avif/av1/util/round2.js

@@ -1,27 +1,51 @@
-/**
- * `Round2( x, n )` from the AV1 specification: divide by `2^n` and round half up, rounding towards
- * negative infinity on the halfway case for negative inputs.
- *
- * The specification defines this with real division and a floor; JavaScript's `>>` is an arithmetic
- * shift, which is exactly that floor, so the integer form transliterates directly. The `n === 0`
- * guard is not cosmetic: `1 << -1` is `1 << 31` under JavaScript's shift-count masking, which would
- * silently produce garbage.
- *
- * `x` must fit in a signed 32-bit integer, which every intermediate the specification feeds to this
- * function does.
- *
- * @param {number} x
- * @param {number} n number of bits to shift away, `>= 0`
- * @returns {number}
- * @see AV1 spec 4.7 "Mathematical functions"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function round2(x, n) {
-    if (n === 0) {
-        return x;
-    }
-
-    return (x + (1 << (n - 1))) >> n;
-}
+/**
+ * `Round2( x, n )` from the AV1 specification: divide by `2^n` and round half up, rounding towards
+ * negative infinity on the halfway case for negative inputs.
+ *
+ * The specification defines this with real division and a floor; JavaScript's `>>` is an arithmetic
+ * shift, which is exactly that floor, so the integer form transliterates directly. The `n === 0`
+ * guard is not cosmetic: `1 << -1` is `1 << 31` under JavaScript's shift-count masking, which would
+ * silently produce garbage.
+ *
+ * `x + 2^(n-1)` must fit in a signed 32-bit integer — the rounding term is added before the shift, so
+ * the bound is slightly tighter than `x` itself. Most intermediates the specification feeds this do;
+ * the self-guided restoration box filter's do not, and use {@link round2_wide} instead.
+ *
+ * @param {number} x
+ * @param {number} n number of bits to shift away, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function round2(x, n) {
+    if (n === 0) {
+        return x;
+    }
+
+    return (x + (1 << (n - 1))) >> n;
+}
+
+/**
+ * {@link round2} for operands that run past a signed 32-bit integer.
+ *
+ * `>>` applies ToInt32 to its left operand, so the shifted form silently wraps above 2^31 and comes
+ * back negative — the self-guided restoration box filter's `p * s` reaches 3.8e9 on an ordinary
+ * black/white edge, where `round2` returned -484 against an exact 3612. Every JavaScript number is
+ * already a double, so the product itself is exact to 2^53; only the shift needs replacing with a
+ * floor division, which is what the specification's Round2 says in the first place. Same shape as
+ * `round2_12` in the inverse transform, which hit this earlier.
+ *
+ * @param {number} x
+ * @param {number} n number of bits to shift away, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ */
+export function round2_wide(x, n) {
+    if (n === 0) {
+        return x;
+    }
+
+    return Math.floor((x + 2 ** (n - 1)) / 2 ** n);
+}

package/src/format/image/avif/heif/parse_avif_file.js

@@ -170,6 +170,22 @@ function read_iloc(file, cursor) {
 
     check_count(item_count, "iloc");
 
+    /**
+     * What one extent record costs in the file. `uint_of_size(0)` returns 0 without consuming a
+     * byte, so with all three widths at zero an extent is free in the file and an `ItemExtent` in
+     * memory — 644 bytes asked for 6.5 million of them, and a full `item_count` asks for 4.3
+     * billion, which is an OOM. Every other width is self-limiting, because the cursor throws when
+     * it runs out; this one is not, so it is refused outright. An extent that carries neither an
+     * offset nor a length describes nothing anyway.
+     */
+    const extent_record_bytes = index_size + offset_size + length_size;
+
+    /**
+     * Across the whole box, not per item. `check_count` bounds each `extent_count` on its own, and
+     * nothing bounded the product — which is the other half of the same arithmetic.
+     */
+    let total_extent_count = 0;
+
     for (let i = 0; i < item_count; i++) {
         const id = version < 2 ? cursor.u16() : cursor.u32();
 
@@ -186,6 +202,14 @@ function read_iloc(file, cursor) {
 
         check_count(extent_count, "iloc extents");
 
+        if (extent_count > 0 && extent_record_bytes === 0) {
+            throw new Error(`iloc declares ${extent_count} extents of zero width, which cannot be represented`);
+        }
+
+        total_extent_count += extent_count;
+
+        check_count(total_extent_count, "iloc extents in total");
+
         for (let j = 0; j < extent_count; j++) {
             if (index_size > 0) {
                 cursor.uint_of_size(index_size);

package/src/shade/renderer/buffer/table/GPUTypedTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUTypedTable.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTable.js"],"names":[],"mappings":"AAwEA;;;GAGG;AACH;IAyKI;;;OAGG;IACH,wBAFW,uBAAuB,EASjC;IAlLD;;OAEG;IACH,YAFU,uBAAuB,CAEtB;IAEX;;;;OAIG;IACH,OAFU,IAAI,MAAM,EAAC,eAAe,CAAC,CAEnB;IAElB;;;;OAIG;IACH,uBAFU,YAAY,CAE6D;IAEnF;;;;;;;;;;;OAWG;IACH,4BAFU,YAAY,CAE6B;IAEnD;;;;;OAKG;IACH,qBAFU,YAAY,CAEsB;IAiF5C;;;;;OAKG;IACH,iBAFU,MAAM,CAEe;IAE/B;;;;OAIG;IACH,WAFU,MAAM,CAES;IAmBzB;;;;;;OAMG;IACH,oBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,kBAFU,cAAc,GAAC,SAAS,CAEjB;IAejB;;;;;OAKG;IACH,WAHW,CAAC,GACC,MAAM,CAQlB;IAED;;;;;;;OAOG;IACH,kBAJW,CAAC,UACD,eAAe,GACb,MAAM,CAQlB;IAED;;;;;OAKG;IACH,sBAFW,MAAM,QAsChB;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAUlB;IAsBD;;;;;;;;;;OAUG;IACH,cAuBC;IAmGD;;;;;;OAMG;IACH,mBAJW,MAAM,GACJ,CAAC,GAAC,SAAS,CA4BvB;IAgDD;;;OAGG;IACH,cAsBC;IA+BD;;;;OAIG;IACH,mBAHW,MAAM,SACN,CAAC,QAyEX;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,0BAJW,MAAM,SACN,CAAC,UACD,eAAe,QA4DzB;IAED;;;;;;;;;;;;;OAaG;IACH,yBALW,MAAM,eACN,MAAM,oBAEN,UAAU,QAqBpB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,yBANW,MAAM,eACN,MAAM,UACN,WAAW,GAAC,eAAe,kBAC3B,MAAM,gBACN,MAAM,QA+DhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,0BAJW,MAAM,SACN,CAAC,UACD,eAAe,QA6GzB;IA0KD;;;OAGG;IACH,8BASC;IAED;;;OAGG;IACH,2BAYC;IAED;;OAEG;IACH,oBAEC;IAED;;;;;;;;;;OAUG;IACH,+BAEC;IAED;;;;;;;;;;OAUG;IACH,mCAJW,WAAW,UACX,MAAM,GACL,MAAM,CAoBjB;IAED;;;;;;;;;;;;OAYG;IACH,kCAMC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAHW,MAAM,GACL,MAAM,CAKjB;IAED,mBAEC;;CACJ;sCAp1CY,OAAO,8BAA8B,EAAE,uBAAuB;6BAC9D,OAAO,qBAAqB,EAAE,cAAc;yBAC5C,OAAO,iCAAiC,EAAE,UAAU;8BACpD,OAAO,mCAAmC,EAAE,eAAe;gCAPxC,sBAAsB;6BAhBzB,yCAAyC;uBAC/C,mCAAmC"}
+{"version":3,"file":"GPUTypedTable.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTable.js"],"names":[],"mappings":"AAwEA;;;GAGG;AACH;IAyKI;;;OAGG;IACH,wBAFW,uBAAuB,EASjC;IAlLD;;OAEG;IACH,YAFU,uBAAuB,CAEtB;IAEX;;;;OAIG;IACH,OAFU,IAAI,MAAM,EAAC,eAAe,CAAC,CAEnB;IAElB;;;;OAIG;IACH,uBAFU,YAAY,CAE6D;IAEnF;;;;;;;;;;;OAWG;IACH,4BAFU,YAAY,CAE6B;IAEnD;;;;;OAKG;IACH,qBAFU,YAAY,CAEsB;IAiF5C;;;;;OAKG;IACH,iBAFU,MAAM,CAEe;IAE/B;;;;OAIG;IACH,WAFU,MAAM,CAES;IAmBzB;;;;;;OAMG;IACH,oBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,kBAFU,cAAc,GAAC,SAAS,CAEjB;IAejB;;;;;OAKG;IACH,WAHW,CAAC,GACC,MAAM,CAQlB;IAED;;;;;;;OAOG;IACH,kBAJW,CAAC,UACD,eAAe,GACb,MAAM,CAQlB;IAED;;;;;OAKG;IACH,sBAFW,MAAM,QAsChB;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAUlB;IAsBD;;;;;;;;;;OAUG;IACH,cAuBC;IAmGD;;;;;;OAMG;IACH,mBAJW,MAAM,GACJ,CAAC,GAAC,SAAS,CA0CvB;IAgDD;;;OAGG;IACH,cAsBC;IA+BD;;;;OAIG;IACH,mBAHW,MAAM,SACN,CAAC,QAyEX;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,0BAJW,MAAM,SACN,CAAC,UACD,eAAe,QA4DzB;IAED;;;;;;;;;;;;;OAaG;IACH,yBALW,MAAM,eACN,MAAM,oBAEN,UAAU,QAqBpB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,yBANW,MAAM,eACN,MAAM,UACN,WAAW,GAAC,eAAe,kBAC3B,MAAM,gBACN,MAAM,QA+DhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,0BAJW,MAAM,SACN,CAAC,UACD,eAAe,QA6GzB;IA0KD;;;OAGG;IACH,8BASC;IAED;;;OAGG;IACH,2BAYC;IAED;;OAEG;IACH,oBAEC;IAED;;;;;;;;;;OAUG;IACH,+BAEC;IAED;;;;;;;;;;OAUG;IACH,mCAJW,WAAW,UACX,MAAM,GACL,MAAM,CAoBjB;IAED;;;;;;;;;;;;OAYG;IACH,kCAMC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAHW,MAAM,GACL,MAAM,CAKjB;IAED,mBAEC;;CACJ;sCAl2CY,OAAO,8BAA8B,EAAE,uBAAuB;6BAC9D,OAAO,qBAAqB,EAAE,cAAc;yBAC5C,OAAO,iCAAiC,EAAE,UAAU;8BACpD,OAAO,mCAAmC,EAAE,eAAe;gCAPxC,sBAAsB;6BAhBzB,yCAAyC;uBAC/C,mCAAmC"}

package/src/shade/renderer/buffer/table/GPUTypedTable.js

@@ -519,6 +519,20 @@ export class GPUTypedTable {
      * @throws {Error} if the element is not CPU-resident and not in the upload buffer
      */
     get(element_index) {
+        if (!this.occupancy.get(element_index)) {
+            /**
+             * A freed row is not a record. {@link remove} zero-fills the shadow bytes and clears the
+             * bit but leaves the page allocated, so reading the bytes back gave a fully-formed
+             * record of zeros — against the `@returns {T|undefined}` one line above, which callers
+             * have been written to. Zero is a valid row index, so a caller walking a linked chain
+             * out of such a record walks to row 0 and back to row 0, forever.
+             *
+             * The occupancy bit is already the authority `#resolve` and `debug_table_read_all` read;
+             * the marshalling paths that deliberately ignore it do not come through here.
+             */
+            return undefined;
+        }
+
         const page_index = Math.floor(element_index / this.descriptor.elements_per_page);
         const page = this.pages.get(page_index);
 

package/src/shade/renderer/geometry/virtual/VIRTUAL_GEOMETRY_DESIGN.md

@@ -223,9 +223,7 @@ Distilled from the pixel-error musings
 Pinned:
 
 - **Error is an object-space distance from the *source* surface**, not a density heuristic
-  and not a sum of per-step deviations. It is measured before faceless vertices are cleaned
-  away, so that a patch consumed whole — which leaves nothing behind to be measured — still
-  costs what it cost. Vertex quadrics are built once from the source
+  and not a sum of per-step deviations. Vertex quadrics are built once from the source
   triangles and carried through the entire build: a survivor absorbs its victim's quadric at
   every collapse, at every round, so a vertex many rounds up still holds the planes of every
   source triangle folded into it, and evaluating that quadric at its current position
@@ -234,6 +232,51 @@ Pinned:
   `evaluate` is a sum of squared distances whose scale grows with the number of planes in the
   quadric, and its root is not a length. It remains a calibrated measure rather than a proven
   Hausdorff bound (blind to tangential drift), hence the sampled-Hausdorff gate in §3.
+- **It is read at the collapses, per endpoint, and kept as a running maximum** — not as one
+  sweep of the surviving vertices at the end of a pass. The weight that makes the number a
+  length is also a divisor that grows every time a vertex absorbs another, so a vertex that
+  destroyed a feature and then spent the rest of the pass swallowing surface it sits exactly
+  on has that feature divided by all of it. The dilution therefore deepens with the DAG, and
+  understates most at the coarse levels where the cut spends its budget: 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. Read at each collapse the same spike reads `0.65`–`0.71`
+  at every size. Reading the two endpoints apart rather than summed is the same argument one
+  collapse at a time — the sum's reading is the weighted mean of the two, which averages a
+  small victim's residual into a large survivor's untouched history.
+
+  Nothing is given up by no longer sweeping the survivors, and it is a domination rather than
+  a coincidence. What the sweep reads 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 the same point — so it can never exceed the larger of the two already taken
+  there. Every value the sweep could report is one this maximum has seen or beaten, and the
+  maximum holds the earlier and sharper readings besides. A patch consumed whole, which leaves
+  behind a faceless vertex the cleanup then sweeps away, is likewise read at the collapse that
+  consumed it.
+
+  Each pass therefore reports what *its own* collapses cost, and a caller carrying quadrics
+  across passes carries the maximum across them too (`vgeo_build_group_step` across its
+  attempts, and the child floor below across levels). A vertex that arrives already deviating
+  needs no re-reading: that reading is what the pass which placed it there already returned.
+
+  Superseded: measuring after the pass, "before faceless vertices are cleaned away, so that a
+  patch consumed whole still costs what it cost". The measurement point was right about the
+  faceless vertex and wrong about everything the sweep threw away to get there.
+- **A plane weighs the surface behind it, as a multiple of the mesh's mean triangle.** The
+  mean the error is read as has to be an average over the *surface*; over a plane count it is
+  an average over how the surface was cut, and a finely tessellated patch outvotes a coarse
+  one many times its size. Cutting one face in two along its own plane is the clean statement
+  of the defect — it adds no surface, and the metric heard the same plane twice. Weights are
+  ratios rather than areas because everything they are stated against is a ratio (the boundary
+  constraint is three *faces*; the attribute quadric summed with these weighs one per
+  triangle), and a slot holding square metres would make all of it depend on whether the asset
+  was authored in millimetres or kilometres. The reported error is a mean, which divides the
+  weights out again, so normalizing costs nothing there; it buys back every calibration.
+
+  This changes the quadric **matrix**, so it changes the placement solve and not only the
+  number — a behavioural change to simplification, landed on its own so it can be attributed.
+  `VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS` was calibrated against the diluted reading and is
+  **not** re-tuned here; it needs re-tuning against this one, separately.
+
 - **Composition across levels does not happen**, and that is the point of carrying quadrics.
   The measured value is already deviation from the source; a step takes `max(measured, max(e
   of child groups))`, where the floor exists only to impose monotonicity — the accumulated

package/src/shade/renderer/geometry/virtual/WEDGE_PLAN_2026_09_18.md

@@ -1,4 +1,94 @@
-# Wedges — plan, 2026-09-18
+# Wedges — plan, 2026-09-18 — **HALF OF IT REVERTED 2026-09-19**
+
+> **The partition stayed. The crease angle went.** This document was written as one idea and it is
+> two, and only one of them survived being measured in pixels.
+>
+> **What went: inferring a hard edge from an angle.** `VGEO_CREASE_ANGLE`, 45 degrees, applied
+> where the builder has to *synthesize* a normal because the source authored none. It made a
+> POSITION-only cube ship three normals at each corner instead of one that is 54.7 degrees wrong for
+> every face using it, which is a real improvement to look at. Measured against a true LOD 0
+> reference it bought nothing on any object tested, and on high-frequency relief it *cost*: the
+> attribute quadric's least-squares fit lands near the neighbourhood's mean normal, which is the
+> right filtered answer for a Lambertian surface, and bucketing each tile face on its own returns
+> that one face's normal exactly instead. It was also most of the price — on the pebble-scatter
+> geometry the wedge build cost +3.37% of asset bytes over pre-attribute with the threshold in and
+> +0.97% without it.
+>
+> **What stayed: carrying the shading frame a source actually authored.** `BtWedgeSet`,
+> `vgeo_mesh_wedges`, and the simplifier's wedge bookkeeping. The partition is decided by
+> `loop_data.record_equal()` — byte equality of what the source gave — so it needs no threshold and
+> makes no judgement about content. On a UE5 courtyard gate arch (188,180 triangles, authored
+> normals and UVs), taking it out costs, at **equal drawn cluster count**, mean luminance against
+> that build's own LOD 0:
+>
+> | ue_arch | τ=0.5 | τ=1 | τ=2 | τ=4 |
+> |---|---|---|---|---|
+> | without the partition | +1.18 | +6.50 | +6.91 | +8.82 |
+> | *same build, second page load* | −0.06 | +0.07 | +0.06 | +0.06 |
+>
+> That is 20–27% more error against a noise floor of 0.07, and it reproduces. At τ=0.5, 1 and 2 the
+> build without the partition is not even trading: it draws **more** clusters *and* errs more. Only
+> τ=4 is a real trade (−20% clusters for +27% error), and interpolated it sits on the same curve.
+>
+> **It is a normals result, not a UV one.** The playground binds one untextured grey
+> `StandardShadeMaterial` and samples no maps, so nothing in that table can come from texture
+> coordinates. Seams are carried by the same mechanism and that is worth having, but it is a
+> different question and it is not what was measured here.
+>
+> **And it helps where the frame is synthesized too**, now that the threshold is gone. Corners still
+> group, by connectivity rather than by angle: at a mesh boundary or a non-manifold fin there is no
+> second face to average with, so each side keeps its own normal instead of inventing a join the
+> mesh does not make. On the pebble scatter that costs +0.45% of bytes over having no partition at
+> all, and buys — again at equal drawn clusters, against pre-attribute —
+>
+> | mesh 1400 | τ=0.5 | τ=1 | τ=2 | τ=4 |
+> |---|---|---|---|---|
+> | no partition | +1.55 | +4.87 | +5.42 | +7.08 |
+> | partition, no threshold | +4.95 | **+4.03** | **−2.51** | **−5.30** |
+>
+> Pareto-dominant at τ=1, 2 and 4 — fewer clusters *and* less error — and at the two coarse cuts it
+> beats pre-attribute outright. The finest cut is worse, and that is the honest caveat.
+>
+> **The split is proved by byte identity, not only by pixels.** Built with the threshold removed,
+> the gate arch is byte-identical to the full wedge build (the whole win preserved, nothing else
+> changed), and a UE5 throne-room floor is byte-identical to a build with no wedge code at all.
+>
+> **What this does *not* claim.** Not that the N-dimensional attribute quadrics are themselves a
+> pixel win — measured the same way they are a wash-to-worse on three of five objects, and that
+> deserves its own investigation. Not that Zorah's normals are fine: on a POSITION-only source every
+> normal is synthesized by `vgeo_normalize_source`, area-weighted, after the weld, nothing pinned,
+> so a hard edge cannot exist at *any* level including the finest — that is the flat-looking tiled
+> surface, it is upstream of everything here, and the UE5 rebuild is what fixes it. And not that the
+> cut is free: on that floor, pre-attribute draws 80 clusters where both attribute builds draw 513
+> at the same τ, a 6x difference nobody asked for.
+>
+> **The pixel harness is the other thing worth keeping** (`container_diff.mjs`, scratchpad pattern).
+> Four ways it lied before it worked, each of which had already produced a confident wrong answer:
+>
+> 1. **TAA.** Two captures of one static camera differ by mean 4.0 with *not one pixel identical*.
+>    Pinning the jitter is necessary and insufficient — the resolve un-jitters against its own copy,
+>    so one run settles to 0.004 and an identical one plateaus at 0.153 forever. Average 16 frames.
+> 2. **Dilution.** The object covered 1–2% of the viewport, so every mean read 0.2–0.7 with p95 of
+>    exactly 0.0. Mask to lit pixels and print the coverage.
+> 3. **The stats panel**, which prints the file name and byte counts and so differs per build by
+>    construction — and the crop keeping it out was slicing through the object.
+> 4. **Cross-run image diffs are worthless.** The same build in two page loads, with identical
+>    `drawn` counts, differs by mean 15–17. Only a build's *own* LOD-0 curve is comparable.
+>
+> A whole scene has no reachable LOD 0 either: below about τ=0.25 the residency budget picks the cut
+> and at τ→0 the renderer stops producing frames, so single containers are the only honest reference.
+>
+> **Compare at equal drawn clusters, never at equal τ**, which is a request and not a price — the
+> wedge build drew 1,085 where pre-attribute drew 772 at the same number on the slider.
+>
+> **Choosing what to measure was half the work.** Three rounds of picking objects out of
+> `object_bounds` gave a pebble scatter, a bare tree and a set of beams, all nearly pure silhouette,
+> and the difference image is then an outline with black interiors — which says nothing about
+> shading, since attribute quadrics trade geometric accuracy for attribute accuracy. Manifest rows
+> are `(mesh, primitive)`; carry the primitive or you build a different object, as a row claiming
+> 289k triangles did when it built 2.04M. The UE5 rebuild's meshes have *names*, which is worth more
+> than any heuristic over bounds.
+
 
 `ATTRIBUTE_PLAN_2026_09_18.md` §7, taken up. That plan fixed *how a coarse vertex is given its
 shading values*; this one fixes the fact that a vertex can only hold **one set of them**, so every

package/src/shade/renderer/geometry/virtual/build/VGeoBuildOptions.d.ts

@@ -81,19 +81,6 @@ export class VGeoBuildOptions {
      * @type {number}
      */
     weld_ratio: number;
-    /**
-     * How far two triangles may turn across a shared edge before a **synthesized** normal is split
-     * there rather than averaged, in degrees. See {@link VGEO_CREASE_ANGLE}, which is where the
-     * default and the measurement behind it live.
-     *
-     * A build option rather than only a constant because it is the one number in this work that is a
-     * judgement about content rather than a consequence of arithmetic: a source of hard-surface
-     * props and a source of organic scans want different answers, and a conversion should be able to
-     * say which it has.
-     *
-     * @type {number}
-     */
-    crease_angle: number;
     /**
      * Decoded bytes per page, as a **hard cap**: no page of the asset exceeds it, and the container
      * says so with a feature bit a runtime can require (`VGEO_FORMAT.md` §11.14). That is what makes

package/src/shade/renderer/geometry/virtual/build/VGeoBuildOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoBuildOptions.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/VGeoBuildOptions.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH;IACI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,OAFU,MAAM,CAEW;IAE3B;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAFU,MAAM,CAEmB;IAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;;;;;;;OAWG;IACH,cAFU,MAAM,CAEiB;IAEjC;;;;;;;;;;;;;;OAcG;IACH,mBAFU,MAAM,CAE2B;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,yBAFU,MAAM,EAAE,CAEqD;IAEvE;;OAEG;IACH,eAFU,gBAAgB,CAEa;CAC1C;iCAjJgC,6BAA6B"}
+{"version":3,"file":"VGeoBuildOptions.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/VGeoBuildOptions.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IACI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,OAFU,MAAM,CAEW;IAE3B;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAFU,MAAM,CAEmB;IAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;;;;;;;;;;OAcG;IACH,mBAFU,MAAM,CAE2B;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,yBAFU,MAAM,EAAE,CAEqD;IAEvE;;OAEG;IACH,eAFU,gBAAgB,CAEa;CAC1C;iCAnIgC,6BAA6B"}

package/src/shade/renderer/geometry/virtual/build/VGeoBuildOptions.js

@@ -1,4 +1,3 @@
-import { VGEO_CREASE_ANGLE } from "./mesh/VGEO_CREASE_ANGLE.js";
 import { LZ4_LEVEL } from "../../../../../core/binary/lz4/LZ4_LEVEL.js";
 import { VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS } from "./mesh/VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS.js";
 import { VGEO_CODEC_DEFLATE } from "../format/frame/VGEO_CODEC_DEFLATE.js";
@@ -91,20 +90,6 @@ export class VGeoBuildOptions {
      */
     weld_ratio = 1e-5;
 
-    /**
-     * How far two triangles may turn across a shared edge before a **synthesized** normal is split
-     * there rather than averaged, in degrees. See {@link VGEO_CREASE_ANGLE}, which is where the
-     * default and the measurement behind it live.
-     *
-     * A build option rather than only a constant because it is the one number in this work that is a
-     * judgement about content rather than a consequence of arithmetic: a source of hard-surface
-     * props and a source of organic scans want different answers, and a conversion should be able to
-     * say which it has.
-     *
-     * @type {number}
-     */
-    crease_angle = VGEO_CREASE_ANGLE;
-
     /**
      * Decoded bytes per page, as a **hard cap**: no page of the asset exceeds it, and the container
      * says so with a feature bit a runtime can require (`VGEO_FORMAT.md` §11.14). That is what makes

package/src/shade/renderer/geometry/virtual/build/level/vgeo_build_group_step.js

@@ -248,11 +248,11 @@ export function vgeo_build_group_step(
     /**
      * Largest deviation any attempt measured, rather than the last one's.
      *
-     * A vertex left behind by a patch that was consumed whole is faceless, and the simplifier reads
-     * it before it sweeps it away precisely because it is the only thing still carrying the quadric
-     * of what used to be there. It is gone by the next attempt, so the next attempt cannot see what
-     * it cost. The surface only ever moves further from the source as this loop tightens, so the
-     * running maximum is what the step actually did.
+     * Each call reports what *its own* collapses cost ({@link bt_mesh_simplify_with_quadrics}), and
+     * the attempts below are one simplification continued rather than several, so no single call's
+     * answer is the step's. Carrying the maximum across them is what makes it one. The surface only
+     * ever moves further from the source as this loop tightens, so a maximum is also the whole of
+     * what is needed — no attempt can undo what an earlier one charged for.
      * @type {number}
      */
     let deviation = 0;

package/src/shade/renderer/geometry/virtual/build/mesh/VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS.d.ts

@@ -13,12 +13,22 @@
  * A collapse that would smear a crease is charged for it, in units of length, at exactly the rate
  * this names.
  *
- * ## How it was chosen
+ * ## How it was chosen — and why that needs doing again
  *
  * Swept from `1e-9` — the term effectively off — to `1/2`, measuring how far the shipped normal field
  * sits from the source's and what happened to `self_error`, which is the number the runtime's cut is
  * driven by.
  *
+ * **The `self_error` column below is a reading this metric no longer takes.** It was swept when the
+ * error was one post-hoc sweep of the surviving vertices, over quadrics that weighed a plane count —
+ * a mean that diluted with DAG depth and tracked tessellation rather than surface. Both are fixed
+ * (`VIRTUAL_GEOMETRY_DESIGN.md` §4), which moved the number the sweep was reading and changed the
+ * matrix that decides where a collapse puts the vertex, which is what this ratio trades against. The
+ * *shape* of the finding is unlikely to have moved — above `1/64` it was not a trade on smooth
+ * content by an order of magnitude — but the cliff's position is not known any more, and `1/1024`
+ * stands here because it was left deliberately untouched rather than because it has been re-measured
+ * against the metric that now ships. Re-sweeping it is its own work.
+ *
  * On a 31,874-triangle Zorah primitive, the content the defect was found on:
  *
  * ```

package/src/shade/renderer/geometry/virtual/build/mesh/VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,mDALU,MAAM,EAAE,CAOhB"}
+{"version":3,"file":"VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,mDALU,MAAM,EAAE,CAOhB"}

package/src/shade/renderer/geometry/virtual/build/mesh/VGEO_DEFAULT_ATTRIBUTE_WEIGHT_RATIOS.js

@@ -16,12 +16,22 @@ import { VGEO_ATTRIBUTES } from "../../format/attribute/VGEO_ATTRIBUTES.js";
  * A collapse that would smear a crease is charged for it, in units of length, at exactly the rate
  * this names.
  *
- * ## How it was chosen
+ * ## How it was chosen — and why that needs doing again
  *
  * Swept from `1e-9` — the term effectively off — to `1/2`, measuring how far the shipped normal field
  * sits from the source's and what happened to `self_error`, which is the number the runtime's cut is
  * driven by.
  *
+ * **The `self_error` column below is a reading this metric no longer takes.** It was swept when the
+ * error was one post-hoc sweep of the surviving vertices, over quadrics that weighed a plane count —
+ * a mean that diluted with DAG depth and tracked tessellation rather than surface. Both are fixed
+ * (`VIRTUAL_GEOMETRY_DESIGN.md` §4), which moved the number the sweep was reading and changed the
+ * matrix that decides where a collapse puts the vertex, which is what this ratio trades against. The
+ * *shape* of the finding is unlikely to have moved — above `1/64` it was not a trade on smooth
+ * content by an order of magnitude — but the cliff's position is not known any more, and `1/1024`
+ * stands here because it was left deliberately untouched rather than because it has been re-measured
+ * against the metric that now ships. Re-sweeping it is its own work.
+ *
  * On a 31,874-triangle Zorah primitive, the content the defect was found on:
  *
  * ```

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_compute_vertex_normals.d.ts

@@ -1,16 +1,26 @@
 /**
- * Area-weighted normals of a mesh, split at its creases, written into its normal channel.
+ * Area-weighted normals of a mesh, written into its normal channel, one per corner.
  *
  * The geometry a mesh actually has is the answer for that mesh: carrying a surviving vertex's
  * original normal through a dozen collapses shades a coarse level by whichever vertices happened to
  * win, which is visibly wrong.
  *
- * **Per corner group, not per vertex.** Averaging every face around a vertex is right for a surface
- * and wrong for a corner. Two faces sharing an edge belong to the same group when the surface turns
- * less than {@link VGEO_CREASE_ANGLE} across it; groups are the connected components that leaves,
- * and each gets its own area-weighted average. A vertex on a smooth surface has exactly one, and
- * this is then the pass it has always been. A box corner has three, and the eight vertices of a cube
- * stop carrying a normal that is ninety degrees wrong for every face using it.
+ * **It does not invent a crease.** An earlier version of this split a vertex wherever the surface
+ * turned more than a threshold, so that a synthesized cube got three normals at each corner instead
+ * of one that is ninety degrees wrong for every face using it. That is a real improvement to look
+ * at and it did not survive measurement: against a true LOD 0 reference in pixels it bought nothing
+ * on any object tested, and on high-frequency relief it *cost*, because the attribute quadric's
+ * least-squares fit lands near the neighbourhood's mean normal -- the right filtered answer for a
+ * Lambertian surface -- and bucketing each tile face on its own returns that one face's normal
+ * exactly instead. So the threshold is gone, and with it the one number in this work that was a
+ * judgement about content rather than a consequence of arithmetic.
+ *
+ * **Corners still group, by connectivity rather than by angle.** Two corners join when a manifold
+ * edge joins their faces, so a manifold vertex has exactly one group and this is the pass it has
+ * always been, arithmetic included. What the per-corner shape is *for* is the case this pass is not
+ * reached in at all: a source that authored its own shading frame, whose distinct corner values the
+ * weld would otherwise destroy. That is where wedges are worth their bytes, and it needs no
+ * threshold to decide anything.
  *
  * Area weighting falls out of the arithmetic rather than being applied: Newell's normal *is* the
  * face normal scaled by twice the area, so summing the raw face normals is the area-weighted sum.
@@ -36,10 +46,9 @@
  *     slot for every live corner by construction
  * @param {Set<number>} pinned vertex ids to leave exactly as they are; empty for a mesh nothing has
  *     locked yet
- * @param {number} [crease_angle] degrees; see {@link VGEO_CREASE_ANGLE}
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_compute_vertex_normals(mesh: VirtualGeometryMesh, pinned: Set<number>, crease_angle?: number): void;
+export function vgeo_compute_vertex_normals(mesh: VirtualGeometryMesh, pinned: Set<number>): void;
 //# sourceMappingURL=vgeo_compute_vertex_normals.d.ts.map

package/src/shade/renderer/geometry/virtual/build/mesh/vgeo_compute_vertex_normals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_compute_vertex_normals.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_compute_vertex_normals.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,+EAPW,IAAI,MAAM,CAAC,iBAEX,MAAM,QA4MhB"}
+{"version":3,"file":"vgeo_compute_vertex_normals.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_compute_vertex_normals.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,+EANW,IAAI,MAAM,CAAC,QA+LrB"}