@woosh/meep-engine 3.30.0 → 3.31.0

package/src/shade/renderer/geometry/virtual/build/level/VGeoGroupStep.d.ts

@@ -35,6 +35,14 @@ export class VGeoGroupStep {
      * @type {Map<number, Quadric3>}
      */
     quadrics: Map<number, Quadric3>;
+    /**
+     * `frontier vertex id -> that vertex's deviation bound after this step`, for every vertex that
+     * survived it. Held for the same reason {@link quadrics} is — a step is speculative until the
+     * round accepts it — and folded back by `max` rather than by gains, since a bound composes that
+     * way.
+     * @type {Map<number, number>}
+     */
+    bounds: Map<number, number>;
     /**
      * Every attribute quadric this step's collapses left behind, indexed by the **wedge's** id
      * *within the step's own submesh* at a stride of `quadric_attribute_size(components)`.

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoGroupStep.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/VGeoGroupStep.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IACI;;;OAGG;IACH,gBAFU,wBAAwB,CAEd;IAEpB;;OAEG;IACH,iBAFU,wBAAwB,CAEb;IAErB;;;;OAIG;IACH,iBAFU,gBAAgB,EAAE,CAEP;IAErB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,UAFU,IAAI,MAAM,WAAW,CAEV;IAErB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oBAFU,YAAY,CAEmB;IAEzC;;;;OAIG;IACH,4BAFU,WAAW,CAE2B;IAEhD;;;;OAIG;IACH,aAFU,IAAI,MAAM,CAAC,CAEG;IAExB;;;OAGG;IACH,QAFU,YAAY,CAEO;CAChC"}
+{"version":3,"file":"VGeoGroupStep.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/VGeoGroupStep.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IACI;;;OAGG;IACH,gBAFU,wBAAwB,CAEd;IAEpB;;OAEG;IACH,iBAFU,wBAAwB,CAEb;IAErB;;;;OAIG;IACH,iBAFU,gBAAgB,EAAE,CAEP;IAErB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,UAFU,IAAI,MAAM,WAAW,CAEV;IAErB;;;;;;OAMG;IACH,QAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAEV;IAEnB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oBAFU,YAAY,CAEmB;IAEzC;;;;OAIG;IACH,4BAFU,WAAW,CAE2B;IAEhD;;;;OAIG;IACH,aAFU,IAAI,MAAM,CAAC,CAEG;IAExB;;;OAGG;IACH,QAFU,YAAY,CAEO;CAChC"}

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

@@ -40,6 +40,15 @@ export class VGeoGroupStep {
      */
     quadrics = new Map();
 
+    /**
+     * `frontier vertex id -> that vertex's deviation bound after this step`, for every vertex that
+     * survived it. Held for the same reason {@link quadrics} is — a step is speculative until the
+     * round accepts it — and folded back by `max` rather than by gains, since a bound composes that
+     * way.
+     * @type {Map<number, number>}
+     */
+    bounds = new Map();
+
     /**
      * Every attribute quadric this step's collapses left behind, indexed by the **wedge's** id
      * *within the step's own submesh* at a stride of `quadric_attribute_size(components)`.

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

@@ -1 +1 @@
-{"version":3,"file":"vgeo_build_group_step.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_build_group_step.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;;;GAcG;AACH,8EAXW,MAAM,EAAE,iBACR,UAAU,eACV,MAAM,SACN,MAAM,8BAEJ,aAAa,GAAC,SAAS,CAidnC;8BArgB6B,oBAAoB"}
+{"version":3,"file":"vgeo_build_group_step.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_build_group_step.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;;;GAcG;AACH,8EAXW,MAAM,EAAE,iBACR,UAAU,eACV,MAAM,SACN,MAAM,8BAEJ,aAAa,GAAC,SAAS,CA0dnC;8BA9gB6B,oBAAoB"}

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

@@ -127,9 +127,17 @@ export function vgeo_build_group_step(
      */
     const quadrics = new Array(source_vertex_id_count);
 
+    /**
+     * What each of them already stands away from the source, cloned for the same reason.
+     * @type {Float64Array}
+     */
+    const bounds = new Float64Array(source_vertex_id_count);
+
     for (let i = 0; i < source_vertex_id_count; i++) {
         const source = submesh_source_vertex_ids[i];
+
         quadrics[i] = frontier.quadrics[source].clone();
+        bounds[i] = frontier.bounds[source];
     }
 
     /*
@@ -272,7 +280,7 @@ export function vgeo_build_group_step(
     function reduce_to(target_face_count) {
         deviation = Math.max(deviation, bt_mesh_simplify_with_quadrics(
             topology, target_face_count, locked, protected_faces, quadrics, attributes,
-            submesh.wedges
+            submesh.wedges, bounds
         ));
 
         assert.equal(
@@ -472,6 +480,7 @@ export function vgeo_build_group_step(
     submesh.source_vertex_ids.forEach((source, local) => {
         if (quadrics[local] !== null) {
             step.quadrics.set(source, quadrics[local]);
+            step.bounds.set(source, bounds[local]);
         }
     });
 

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

@@ -1 +1 @@
-{"version":3,"file":"vgeo_build_leaf_frontier.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_build_leaf_frontier.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;GAYG;AACH,wFATW,YAAY,GAIV,YAAY,CAgFxB;6BA1F4B,mBAAmB"}
+{"version":3,"file":"vgeo_build_leaf_frontier.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_build_leaf_frontier.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;GAYG;AACH,wFATW,YAAY,GAIV,YAAY,CAoFxB;6BA9F4B,mBAAmB"}

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

@@ -65,6 +65,10 @@ export function vgeo_build_leaf_frontier(
     // round inherits these and adds to them, which is the whole point.
     frontier.quadrics = bt_mesh_compute_vertex_quadrics(mesh.topology);
 
+    // And every vertex starts on the surface it came from, which is what makes the bound carried
+    // above them a distance from the *source* rather than from the round below.
+    frontier.bounds = new Float64Array(mesh.topology.vertices.size);
+
     /*
      And the same for the shading channels, which is what lets a vertex twelve rounds up be given the
      value the *source's* field has where it now sits, rather than one read off whatever the collapses

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

@@ -1 +1 @@
-{"version":3,"file":"vgeo_build_levels.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_build_levels.js"],"names":[],"mappings":"AAoEA;;;;;;;GAOG;AACH,4GAHW,YAAY,GACV,SAAS,EAAE,CAyOvB;0BA3SyB,gBAAgB"}
+{"version":3,"file":"vgeo_build_levels.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_build_levels.js"],"names":[],"mappings":"AAoEA;;;;;;;GAOG;AACH,4GAHW,YAAY,GACV,SAAS,EAAE,CAqPvB;0BAvTyB,gBAAgB"}

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

@@ -217,6 +217,10 @@ export function vgeo_build_levels(mesh, options, attribute_weights) {
         // source planes under that vertex twice and inflate every error above it.
         const updated = frontier.quadrics.slice();
 
+        // By max, not by gains: see VGeoFrontier#bounds for why a bound composes that way and a
+        // quadric does not.
+        const updated_bounds = frontier.bounds.slice();
+
         const attribute_stride = frontier.attribute_layout.components > 0
             ? quadric_attribute_size(frontier.attribute_layout.components)
             : 0;
@@ -239,6 +243,10 @@ export function vgeo_build_levels(mesh, options, attribute_weights) {
 
             }
 
+            for (const [vertex, bound] of step.bounds) {
+                updated_bounds[vertex] = Math.max(updated_bounds[vertex], bound);
+            }
+
             step.attribute_source_wedge_ids.forEach((wedge, local) => {
                 // `live_wedges` is what says the wedge survived the step; the attribute buffer is
                 // handed over whole and has an entry for every slot the submesh ever had. A wedge
@@ -268,6 +276,10 @@ export function vgeo_build_levels(mesh, options, attribute_weights) {
             stitched.source_vertex_ids, (source) => updated[source]
         );
 
+        frontier.bounds = Float64Array.from(
+            stitched.source_vertex_ids, (source) => updated_bounds[source]
+        );
+
         frontier.attribute_layout = attribute_layout;
         frontier.attribute_weights = resolved_attribute_weights;
         frontier.wedges = stitched.wedges;

package/src/shade/renderer/geometry/virtual/format/read/VGeoContainerReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoContainerReader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/read/VGeoContainerReader.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA8PI;;;;;;;;OAQG;IACH,oBANW,cAAc,YACd,eAAe,GACb,QAAQ,mBAAmB,CAAC,CAUxC;IAhJD;;;OAGG;IACH,oBAHW,cAAc,YACd,eAAe,EAOzB;IArID;;OAEG;IACH,QAFU,mBAAmB,CAEV;IAEnB;;;;OAIG;IACH,WAFU,aAAa,GAAC,SAAS,CAEX;IA6HtB;;OAEG;IACH,2DAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;;;;OAaG;IACH,6BAEC;IAED;;OAEG;IACH,iCAEC;IAED;;;;;;;;;OASG;IACH,2CAEC;IAED;;;;;OAKG;IACH,yBAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;;;;;;;;;;;OAYG;IACH,6CAEC;IAED;;;;;;;;;OASG;IACH,gDAEC;IAED;;;;OAIG;IACH,kBAFa,iBAAiB,QAAQ,CAAC,CAItC;IA0FD;;;;;;;;OAQG;IACH,iBAHW,MAAM,GACJ,QAAQ,GAAC,SAAS,CAI9B;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,iCAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAUnB;IAoOD;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,8BAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;OAGG;IACH,cAFa,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAI9C;IAED;;;;;;;;;;;;OAYG;IACH,8BAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;;;;;;;OAYG;IACH,oBAPW,MAAM,gBACN,MAAM,cACN,MAAM,GACJ,QAAQ,QAAQ,CAAC,CAoC7B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;;OAGG;IACH,cAFa,MAAM,CAYlB;IA8CD;;;;;;;;;OASG;IACH,YAHW,QAAQ,GACN,QAAQ,CAqBpB;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAMhB;IACD;;;;;OAKG;IACH,mBAHW,YAAY,GACV,QAAQ,QAAQ,CAAC,CAI7B;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,qBANW,YAAY,EAAE,UACd,MAAM,WAEN,WAAW,GACT,QAAQ,QAAQ,EAAE,CAAC,CA+D/B;IAED;;;;;;;;;;OAUG;IACH,kBAHW,MAAM,GACJ,OAAO,CAsDnB;IAED;;;;OAIG;IACH,aAFa,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,kBAFa,QAAQ,aAAa,CAAC,CAkBlC;IAED;;;;;;;;OAQG;IACH,uCAHoB,MAAM,QAAE,MAAM,KAAG,IAAI,GAC5B,QAAQ,IAAI,CAAC,CAMzB;IAED;;;;;;;;;OASG;IACH,YAFa,QAAQ,UAAU,EAAE,CAAC,CAYjC;IAiCD;;;;;;;;;OASG;IACH,gBAFa,MAAM,CAQlB;;CA6BJ;6BAxvCY,OAAO,qBAAqB,EAAE,cAAc;kCAC5C,OAAO,0BAA0B,EAAE,mBAAmB;yBACtD,OAAO,kBAAkB,EAAE,UAAU;4BACrC,OAAO,oBAAoB,EAAE,aAAa;uBAC1C,OAAO,eAAe,EAAE,QAAQ;2BAChC,OAAO,mBAAmB,EAAE,YAAY;gCAXrB,sBAAsB"}
+{"version":3,"file":"VGeoContainerReader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/format/read/VGeoContainerReader.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA8PI;;;;;;;;OAQG;IACH,oBANW,cAAc,YACd,eAAe,GACb,QAAQ,mBAAmB,CAAC,CAUxC;IAhJD;;;OAGG;IACH,oBAHW,cAAc,YACd,eAAe,EAOzB;IArID;;OAEG;IACH,QAFU,mBAAmB,CAEV;IAEnB;;;;OAIG;IACH,WAFU,aAAa,GAAC,SAAS,CAEX;IA6HtB;;OAEG;IACH,2DAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;;;;OAaG;IACH,6BAEC;IAED;;OAEG;IACH,iCAEC;IAED;;;;;;;;;OASG;IACH,2CAEC;IAED;;;;;OAKG;IACH,yBAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;;;;;;;;;;;OAYG;IACH,6CAEC;IAED;;;;;;;;;OASG;IACH,gDAEC;IAED;;;;OAIG;IACH,kBAFa,iBAAiB,QAAQ,CAAC,CAItC;IA0FD;;;;;;;;OAQG;IACH,iBAHW,MAAM,GACJ,QAAQ,GAAC,SAAS,CAI9B;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,iCAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAUnB;IA6OD;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,8BAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;OAGG;IACH,cAFa,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAI9C;IAED;;;;;;;;;;;;OAYG;IACH,8BAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;;;;;;;OAYG;IACH,oBAPW,MAAM,gBACN,MAAM,cACN,MAAM,GACJ,QAAQ,QAAQ,CAAC,CAoC7B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;;OAGG;IACH,cAFa,MAAM,CAYlB;IA8CD;;;;;;;;;OASG;IACH,YAHW,QAAQ,GACN,QAAQ,CAqBpB;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAMhB;IACD;;;;;OAKG;IACH,mBAHW,YAAY,GACV,QAAQ,QAAQ,CAAC,CAI7B;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,qBANW,YAAY,EAAE,UACd,MAAM,WAEN,WAAW,GACT,QAAQ,QAAQ,EAAE,CAAC,CA+D/B;IAED;;;;;;;;;;OAUG;IACH,kBAHW,MAAM,GACJ,OAAO,CAsDnB;IAED;;;;OAIG;IACH,aAFa,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,kBAFa,QAAQ,aAAa,CAAC,CAkBlC;IAED;;;;;;;;OAQG;IACH,uCAHoB,MAAM,QAAE,MAAM,KAAG,IAAI,GAC5B,QAAQ,IAAI,CAAC,CAMzB;IAED;;;;;;;;;OASG;IACH,YAFa,QAAQ,UAAU,EAAE,CAAC,CAYjC;IAiCD;;;;;;;;;OASG;IACH,gBAFa,MAAM,CAQlB;;CA6BJ;6BAjwCY,OAAO,qBAAqB,EAAE,cAAc;kCAC5C,OAAO,0BAA0B,EAAE,mBAAmB;yBACtD,OAAO,kBAAkB,EAAE,UAAU;4BACrC,OAAO,oBAAoB,EAAE,aAAa;uBAC1C,OAAO,eAAe,EAAE,QAAQ;2BAChC,OAAO,mBAAmB,EAAE,YAAY;gCAXrB,sBAAsB"}

package/src/shade/renderer/geometry/virtual/format/read/VGeoContainerReader.js

@@ -677,7 +677,16 @@ export class VGeoContainerReader {
             return page.index;
         }
 
-        if (child_ref >= page.child_page_index.length) {
+        /*
+         Negated rather than written the obvious way round, so a non-number fails CLOSED.
+
+         `child_ref` is a Uint16Array read, which is `undefined` for an index past its end, and
+         `undefined >= n` is false — so the obvious form let an out-of-range cluster through to
+         `child_page_index[undefined]` and answered `undefined`, which the caller then compared
+         against 0 and held a reference for. A malformed page is refused in `vgeo_read_page` now,
+         and this is the second line of the same defence.
+        */
+        if (!(child_ref < page.child_page_index.length)) {
             return -1;
         }
 

package/src/shade/renderer/geometry/virtual/format/read/vgeo_read_page.js

@@ -510,6 +510,27 @@ function read_cluster_table(page, format_version) {
         const first = page.group_cluster_first[group];
         const members = page.group_cluster_count[group];
 
+        /*
+         A group's slice has to be inside the cluster table it names into.
+
+         This loop used to write `group_of_cluster[first + i]` for whatever the group record said,
+         and a typed array discards an out-of-range index without a sound — so a page whose group
+         claims eight clusters when the header says four decoded cleanly and left the reader holding
+         cluster indices past the end of every per-cluster array. `child_ref[cluster]` is then
+         `undefined`, which is not a number and therefore fails every comparison the residency
+         guards with, and an `undefined` page index reaches the pending-reference index as a key
+         nothing can ever release.
+
+         Refused here, with the extent of the table itself, rather than guarded at each of the
+         places a bad index can surface.
+        */
+        if (first + members > count) {
+            throw new Error(
+                `page ${page.index}: group ${group} claims clusters [${first}, ${first + members}),`
+                + ` past the ${count} the page has`
+            );
+        }
+
         for (let i = 0; i < members; i++) {
             page.group_of_cluster[first + i] = group;
         }

package/src/shade/renderer/geometry/virtual/format/vgeo_write_container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_write_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_write_container.js"],"names":[],"mappings":"AAkdA;;;;;;;;GAQG;AACH,4CANW,qBAAqB,8BAGnB,QAAQ,YAAY,CAAC,CAmOjC;6BA1rB4B,4CAA4C"}
+{"version":3,"file":"vgeo_write_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_write_container.js"],"names":[],"mappings":"AAkfA;;;;;;;;GAQG;AACH,4CANW,qBAAqB,8BAGnB,QAAQ,YAAY,CAAC,CAmOjC;6BA1tB4B,4CAA4C"}

package/src/shade/renderer/geometry/virtual/format/vgeo_write_container.js

@@ -404,7 +404,39 @@ function build_page_blob(page, child_pages, parents) {
                 buffer.writeUint16(VGEO_NO_CHILD);
                 buffer.writeUint16(VGEO_NO_GROUP);
             } else {
-                buffer.writeUint16(child_ref_of_page.get(cluster.child_group.page.index));
+                /*
+                 A child group inside this page is named by VGEO_SAME_PAGE, exactly as a parent
+                 inside it is twelve lines up — `collect_child_pages` deliberately leaves the page
+                 out of its own child table, so there is no ref for it to have.
+
+                 This used to call `child_ref_of_page.get(...)` unguarded for every child, and an
+                 undefined handed to `writeUint16` becomes 0 by way of ToUint16(NaN) — a perfectly
+                 well-formed reference to an unrelated page, over which the file's checksums then
+                 compute happily. The reader's SAME_PAGE branch has always been there; nothing could
+                 produce the value that reaches it.
+
+                 Unreachable with today's assembler, which opens one page per level and so never
+                 puts a cluster's child group in its own page. It is one line of `open_page` away
+                 from being reachable, and `vgeo_write_container` is a public entry point that
+                 specs already drive directly.
+                */
+                const child_page = cluster.child_group.page;
+
+                if (child_page === page) {
+                    buffer.writeUint16(VGEO_SAME_PAGE);
+                } else {
+                    const child_ref = child_ref_of_page.get(child_page.index);
+
+                    if (child_ref === undefined) {
+                        throw new Error(
+                            `page ${page.index}: a cluster's child group is in page ${child_page.index},`
+                            + ` which is not in this page's child table`
+                        );
+                    }
+
+                    buffer.writeUint16(child_ref);
+                }
+
                 buffer.writeUint16(cluster.child_group.index_in_page);
             }
 

package/src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoPageFetcher.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IA0EI;;;;;;OAMG;IACH;QAL4B,YAAY,GAA7B,MAAM;QACuB,WAAW,SAA5B,MAAM;OAS5B;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;;;OAOG;IACH,cAPW,mBAAmB,cACnB,MAAM,gBACN,MAAM,cACN,MAAM,WACN,WAAW,GACT,QAAQ,QAAQ,CAAC,CAc7B;IAED;;;;;;OAMG;IACH,eAHW,mBAAmB,GACjB,MAAM,CAuBlB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAiBhB;;CAiLJ;kCA5YY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ"}
+{"version":3,"file":"VGeoPageFetcher.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IA0EI;;;;;;OAMG;IACH;QAL4B,YAAY,GAA7B,MAAM;QACuB,WAAW,SAA5B,MAAM;OAS5B;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;;;OAOG;IACH,cAPW,mBAAmB,cACnB,MAAM,gBACN,MAAM,cACN,MAAM,WACN,WAAW,GACT,QAAQ,QAAQ,CAAC,CAc7B;IAED;;;;;;OAMG;IACH,eAHW,mBAAmB,GACjB,MAAM,CAkClB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAoBhB;;CAgOJ;kCAzcY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ"}

package/src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js

@@ -189,7 +189,18 @@ export class VGeoPageFetcher {
 
             this.#pending.delete(id);
 
-            this.#workers[entry.worker].postMessage({ cancel: id });
+            /*
+             An in-process fetch has no worker to tell; it has an AbortController, which is what
+             carries the cancellation down to the source read. It used to have neither, because it
+             was never registered here at all — and the fetcher the residency builds for itself has
+             worker_count 0, so on the default path every fetch is in-process and this loop had
+             nothing to walk. abort() returned having cancelled zero fetches and said so.
+            */
+            if (entry.worker === -1) {
+                entry.controller.abort();
+            } else {
+                this.#workers[entry.worker].postMessage({ cancel: id });
+            }
 
             entry.reject(new VGeoFetchError('the fetch was cancelled', false, 'cancelled'));
 
@@ -209,6 +220,9 @@ export class VGeoPageFetcher {
      */
     destroy() {
         for (const entry of this.#pending.values()) {
+            // the in-process ones are still reading; terminating a worker is what stops the others
+            entry.controller?.abort();
+
             entry.reject(new VGeoFetchError('the fetcher was destroyed', false, 'destroyed'));
         }
 
@@ -397,6 +411,53 @@ export class VGeoPageFetcher {
 
         this.#in_process_fetch_count++;
 
-        return core.fetch(page_index, frame_offset, fetch_size, signal);
+        /*
+         Registered in #pending exactly as a worker fetch is, so cancel() reaches both paths through
+         one mechanism.
+
+         This used to return core.fetch(...) and record nothing, which made cancel() and abort() no-ops
+         on the path that is always taken: VGeoResidency builds `new VGeoPageFetcher()` when the host
+         passes none, and that defaults worker_count to 0. Each fetch ran to completion, resolved
+         after the geometry it was for had gone, and kept fetches_in_flight elevated against the
+         `>= max_concurrent_fetches * 2` throttle for the next reading.
+
+         The controller is the fetcher's own, and a caller's signal — nobody passes one today — is
+         chained onto it so there is still one thing to abort.
+        */
+        const controller = new AbortController();
+
+        if (signal !== undefined) {
+            if (signal.aborted) {
+                controller.abort();
+            } else {
+                signal.addEventListener('abort', () => controller.abort(), { once: true });
+            }
+        }
+
+        const id = this.#next_id++;
+
+        const settle = (entry_action) => (value) => {
+            const entry = this.#pending.get(id);
+
+            if (entry === undefined) {
+                // cancel() or destroy() already settled this promise
+                return;
+            }
+
+            this.#pending.delete(id);
+
+            entry_action(entry, value);
+        };
+
+        const promise = new Promise((resolve, reject) => {
+            this.#pending.set(id, { resolve, reject, reader, worker: -1, controller, fetch_size });
+        });
+
+        core.fetch(page_index, frame_offset, fetch_size, controller.signal).then(
+            settle((entry, page) => entry.resolve(page)),
+            settle((entry, error) => entry.reject(error)),
+        );
+
+        return promise;
     }
 }

package/src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.d.ts

@@ -53,6 +53,23 @@ export class VGeoViewCut {
      * @returns {number}
      */
     get frontier_word_count(): number;
+    /**
+     * Zero the frontier, so what is in it is where THIS cut ended.
+     *
+     * The buffer is created once and outlives every frame, and nothing else ever writes zeros into
+     * it — so without this the bits are the union over every cut since it was made. The traverse
+     * shader's own comment says "where this cut ENDED", and that is false from frame two: the
+     * reseed pass seeds and claims from this set, and a union over all time is strictly more work
+     * than the root descent it is meant to replace. Worse, page rows are recycled, so a bit left
+     * behind by a page that has since been evicted defeats the eviction-count invalidation that
+     * pass relies on.
+     *
+     * Through the queue rather than an encoder: a writeBuffer issued before a submit happens before
+     * it, and the cut's commands are submitted after the graph that calls this is built.
+     *
+     * @returns {void}
+     */
+    clear_frontier(): void;
     /**
      * Size the frontier to the tier it will name rows of.
      *

package/src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoViewCut.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAwCI;;;;OAIG;IACH;QAH8B,MAAM;QACR,KAAK,GAAtB,MAAM;OAehB;IAED;;;;OAIG;IACH,+BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAHW,MAAM,GACJ,IAAI,CAkBhB;IAED;;;;;;;OAOG;IACH;QAJ2B,aAAa,EAA7B,MAAM;QACU,KAAK,EAArB,MAAM;QACJ,IAAI,CAShB;IAED;;;;;;;;;;;OAWG;IACH;QAJ8C,OAAO,EAA1C,yBAAyB;QACP,OAAO,GAAzB,OAAO;QACL,IAAI,CA8BhB;IAED,gBAIC;;CACJ;wCAlNY,OAAO,gCAAgC,EAAE,yBAAyB"}
+{"version":3,"file":"VGeoViewCut.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js"],"names":[],"mappings":"AAgBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAwCI;;;;OAIG;IACH;QAH8B,MAAM;QACR,KAAK,GAAtB,MAAM;OAehB;IAED;;;;OAIG;IACH,+BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAFa,IAAI,CAchB;IAED;;;;;;;;;;OAUG;IACH,mCAHW,MAAM,GACJ,IAAI,CAkBhB;IAED;;;;;;;OAOG;IACH;QAJ2B,aAAa,EAA7B,MAAM;QACU,KAAK,EAArB,MAAM;QACJ,IAAI,CAShB;IAED;;;;;;;;;;;OAWG;IACH;QAJ8C,OAAO,EAA1C,yBAAyB;QACP,OAAO,GAAzB,OAAO;QACL,IAAI,CA8BhB;IAED,gBAIC;;CACJ;wCAhPY,OAAO,gCAAgC,EAAE,yBAAyB"}

package/src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js

@@ -5,6 +5,15 @@ import { VGEO_CUT_PARAMS_STRUCT } from "./cut/VGEO_CUT_PARAMS_STRUCT.js";
 import { vgeo_frontier_words } from "./vgeo_frontier_words.js";
 import { write_gpu_typed_buffer } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
 
+/**
+ * Zeros to write over a frontier with, grown to the largest one any view has asked for. A frontier
+ * is a few hundred bytes — 128 words covers a million page rows — so one shared buffer costs less
+ * than the allocation per frame per view it replaces.
+ *
+ * @type {Uint8Array}
+ */
+let ZEROES = new Uint8Array(0);
+
 /**
  * @typedef {import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime} GPUVirtualGeometryRuntime
  */
@@ -123,6 +132,36 @@ export class VGeoViewCut {
         return this.#frontier_word_count;
     }
 
+    /**
+     * Zero the frontier, so what is in it is where THIS cut ended.
+     *
+     * The buffer is created once and outlives every frame, and nothing else ever writes zeros into
+     * it — so without this the bits are the union over every cut since it was made. The traverse
+     * shader's own comment says "where this cut ENDED", and that is false from frame two: the
+     * reseed pass seeds and claims from this set, and a union over all time is strictly more work
+     * than the root descent it is meant to replace. Worse, page rows are recycled, so a bit left
+     * behind by a page that has since been evicted defeats the eviction-count invalidation that
+     * pass relies on.
+     *
+     * Through the queue rather than an encoder: a writeBuffer issued before a submit happens before
+     * it, and the cut's commands are submitted after the graph that calls this is built.
+     *
+     * @returns {void}
+     */
+    clear_frontier() {
+        const frontier = this.#frontier;
+
+        if (frontier === undefined) {
+            return;
+        }
+
+        if (ZEROES.byteLength < frontier.size) {
+            ZEROES = new Uint8Array(frontier.size);
+        }
+
+        this.#device.queue.writeBuffer(frontier, 0, ZEROES, 0, frontier.size);
+    }
+
     /**
      * Size the frontier to the tier it will name rows of.
      *

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_vgeo_expand_instances_to_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAX+B,KAAK;IACT,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACkB,IAAI;IACO,OAAO;IACb,MAAM;IACjC,MAAM,CAsSlB"}
+{"version":3,"file":"graph_vgeo_expand_instances_to_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAX+B,KAAK;IACT,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACkB,IAAI;IACO,OAAO;IACb,MAAM;IACjC,MAAM,CA6SlB"}

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js

@@ -110,6 +110,13 @@ export function graph_vgeo_expand_instances_to_meshlets({
     */
     view_cut.resize_frontier(pool.page_row_capacity);
 
+    /*
+     And zeroed, every frame, because the frontier is a statement about the cut that is about to
+     run. The buffer outlives the frame and nothing else clears it, so what was in it was the union
+     over every cut since it was created — see VGeoViewCut#clear_frontier.
+    */
+    view_cut.clear_frontier();
+
     view_cut.write_params({ runtime });
 
     // ----- collect: which of these instances are virtual, and where is the camera in each one -----

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick4_sh3_color_decode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_decode.js"],"names":[],"mappings":"AAEA,sDAkCC;AAGD,oEAyCE;0BAhFwB,6CAA6C"}
+{"version":3,"file":"chunk_brick4_sh3_color_decode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_decode.js"],"names":[],"mappings":"AAuBA,sDAkCC;AAGD,oEAyCE;0BArGwB,6CAA6C"}

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_decode.js

@@ -1,9 +1,30 @@
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
 
+/*
+ * The v1 brick4 SH3 probe encoding: nine RGB coefficients as fourteen f16 pairs.
+ *
+ * **Superseded by `../v2`, which is what the live bake and load run.** v2 packs a probe into seven
+ * words (rgbe9995 DC plus `sh3_compress`), and `BRICK4_PROBE_ENCODED_SIZE` is 7 — so v1's fourteen-word
+ * layout contradicts the shipped size and cannot be swapped in. Nothing imports `encoding/v1`. It is kept
+ * because `@woosh/meep-engine` publishes raw `src`, so an unreferenced export is public surface.
+ *
+ * Every WGSL function here carries a `_v1` suffix, and the scaled pair a `_v1_scaled` one. They did not:
+ * the two encode chunks in this directory both declared `fn brick4_sh3_color_encode_to_storage` with
+ * *incompatible* layouts — one steals slot 0.x for a shared scale factor and shifts every coefficient by
+ * half a word, the other packs straight through — and the plain encode/decode pair collided with v2's
+ * functions of the same names. The `2` that distinguished them lived on the JS export, so at an import
+ * site the collision was invisible: pulling both into one shader is a redefinition error, and pulling one
+ * and pairing it with the wrong decoder shifts every coefficient by half a word, which reads as
+ * plausible-but-wrong indirect lighting.
+ *
+ * The JS export names are unchanged, since those are the published surface.
+ */
+
+
 export const chunk_brick4_sh3_color_decode = CodeChunk.from(
     //language=WGSL
     `
-fn brick4_sh3_color_decode(packed: array<u32, 14>) -> array<vec3<f32>, 9> {
+fn brick4_sh3_color_decode_v1(packed: array<u32, 14>) -> array<vec3<f32>, 9> {
     var sh: array<vec3<f32>, 9>;
 
     let v0 = unpack2x16float(packed[0]);
@@ -40,7 +61,7 @@ fn brick4_sh3_color_decode(packed: array<u32, 14>) -> array<vec3<f32>, 9> {
 export const chunk_brick4_sh3_color_decode_from_storage2 = CodeChunk.from(
     //language=WGSL
     `
-fn brick4_sh3_color_decode_from_storage(
+fn brick4_sh3_color_decode_from_storage_v1_scaled(
     storage_buf: ptr<storage, array<u32>>, 
     offset: u32
 ) -> array<vec3<f32>, 9> {

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_decode_from_storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick4_sh3_color_decode_from_storage.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_decode_from_storage.js"],"names":[],"mappings":"AAEA,mEAuCE;0BAzCwB,6CAA6C"}
+{"version":3,"file":"chunk_brick4_sh3_color_decode_from_storage.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_decode_from_storage.js"],"names":[],"mappings":"AAuBA,mEAuCE;0BA9DwB,6CAA6C"}

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_decode_from_storage.js

@@ -1,9 +1,30 @@
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
 
+/*
+ * The v1 brick4 SH3 probe encoding: nine RGB coefficients as fourteen f16 pairs.
+ *
+ * **Superseded by `../v2`, which is what the live bake and load run.** v2 packs a probe into seven
+ * words (rgbe9995 DC plus `sh3_compress`), and `BRICK4_PROBE_ENCODED_SIZE` is 7 — so v1's fourteen-word
+ * layout contradicts the shipped size and cannot be swapped in. Nothing imports `encoding/v1`. It is kept
+ * because `@woosh/meep-engine` publishes raw `src`, so an unreferenced export is public surface.
+ *
+ * Every WGSL function here carries a `_v1` suffix, and the scaled pair a `_v1_scaled` one. They did not:
+ * the two encode chunks in this directory both declared `fn brick4_sh3_color_encode_to_storage` with
+ * *incompatible* layouts — one steals slot 0.x for a shared scale factor and shifts every coefficient by
+ * half a word, the other packs straight through — and the plain encode/decode pair collided with v2's
+ * functions of the same names. The `2` that distinguished them lived on the JS export, so at an import
+ * site the collision was invisible: pulling both into one shader is a redefinition error, and pulling one
+ * and pairing it with the wrong decoder shifts every coefficient by half a word, which reads as
+ * plausible-but-wrong indirect lighting.
+ *
+ * The JS export names are unchanged, since those are the published surface.
+ */
+
+
 export const chunk_brick4_sh3_color_decode_from_storage = CodeChunk.from(
     //language=WGSL
     `
-fn brick4_sh3_color_decode_from_storage(
+fn brick4_sh3_color_decode_from_storage_v1(
     storage_buf: ptr<storage, array<u32>>, 
     offset: u32
 ) -> array<vec3<f32>, 9> {

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick4_sh3_color_encode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_encode.js"],"names":[],"mappings":"AAEA,sDAsBC;AAGD;;;GAGG;AACH,wDAFU,SAAS,CA0ClB;0BAvEyB,6CAA6C"}
+{"version":3,"file":"chunk_brick4_sh3_color_encode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_encode.js"],"names":[],"mappings":"AAuBA,sDAsBC;AAGD;;;GAGG;AACH,wDAFU,SAAS,CA0ClB;0BA5FyB,6CAA6C"}

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_encode.js

@@ -1,9 +1,30 @@
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
 
+/*
+ * The v1 brick4 SH3 probe encoding: nine RGB coefficients as fourteen f16 pairs.
+ *
+ * **Superseded by `../v2`, which is what the live bake and load run.** v2 packs a probe into seven
+ * words (rgbe9995 DC plus `sh3_compress`), and `BRICK4_PROBE_ENCODED_SIZE` is 7 — so v1's fourteen-word
+ * layout contradicts the shipped size and cannot be swapped in. Nothing imports `encoding/v1`. It is kept
+ * because `@woosh/meep-engine` publishes raw `src`, so an unreferenced export is public surface.
+ *
+ * Every WGSL function here carries a `_v1` suffix, and the scaled pair a `_v1_scaled` one. They did not:
+ * the two encode chunks in this directory both declared `fn brick4_sh3_color_encode_to_storage` with
+ * *incompatible* layouts — one steals slot 0.x for a shared scale factor and shifts every coefficient by
+ * half a word, the other packs straight through — and the plain encode/decode pair collided with v2's
+ * functions of the same names. The `2` that distinguished them lived on the JS export, so at an import
+ * site the collision was invisible: pulling both into one shader is a redefinition error, and pulling one
+ * and pairing it with the wrong decoder shifts every coefficient by half a word, which reads as
+ * plausible-but-wrong indirect lighting.
+ *
+ * The JS export names are unchanged, since those are the published surface.
+ */
+
+
 export const chunk_brick4_sh3_color_encode = CodeChunk.from(
     //language=WGSL
     `
-fn brick4_sh3_color_encode(sh: array<vec3<f32>,9>) -> array<u32, 14>{
+fn brick4_sh3_color_encode_v1(sh: array<vec3<f32>,9>) -> array<u32, 14>{
     return array<u32, 14>(
         pack2x16float(vec2<f32>(sh[0].x, sh[0].y)),
         pack2x16float(vec2<f32>(sh[0].z, sh[1].x)),
@@ -32,7 +53,7 @@ fn brick4_sh3_color_encode(sh: array<vec3<f32>,9>) -> array<u32, 14>{
 export const chunk_brick4_sh3_color_encode_to_storage2 = CodeChunk.from(
     //language=WGSL
     `
-fn brick4_sh3_color_encode_to_storage(
+fn brick4_sh3_color_encode_to_storage_v1_scaled(
     out: ptr<storage, array<u32>, read_write>,
     out_offset: u32,
     sh: array<vec3<f32>, 9>

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_encode_to_storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick4_sh3_color_encode_to_storage.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_encode_to_storage.js"],"names":[],"mappings":"AAEA,iEAwBC;0BA1ByB,6CAA6C"}
+{"version":3,"file":"chunk_brick4_sh3_color_encode_to_storage.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_encode_to_storage.js"],"names":[],"mappings":"AAuBA,iEAwBC;0BA/CyB,6CAA6C"}

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v1/chunk_brick4_sh3_color_encode_to_storage.js

@@ -1,9 +1,30 @@
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
 
+/*
+ * The v1 brick4 SH3 probe encoding: nine RGB coefficients as fourteen f16 pairs.
+ *
+ * **Superseded by `../v2`, which is what the live bake and load run.** v2 packs a probe into seven
+ * words (rgbe9995 DC plus `sh3_compress`), and `BRICK4_PROBE_ENCODED_SIZE` is 7 — so v1's fourteen-word
+ * layout contradicts the shipped size and cannot be swapped in. Nothing imports `encoding/v1`. It is kept
+ * because `@woosh/meep-engine` publishes raw `src`, so an unreferenced export is public surface.
+ *
+ * Every WGSL function here carries a `_v1` suffix, and the scaled pair a `_v1_scaled` one. They did not:
+ * the two encode chunks in this directory both declared `fn brick4_sh3_color_encode_to_storage` with
+ * *incompatible* layouts — one steals slot 0.x for a shared scale factor and shifts every coefficient by
+ * half a word, the other packs straight through — and the plain encode/decode pair collided with v2's
+ * functions of the same names. The `2` that distinguished them lived on the JS export, so at an import
+ * site the collision was invisible: pulling both into one shader is a redefinition error, and pulling one
+ * and pairing it with the wrong decoder shifts every coefficient by half a word, which reads as
+ * plausible-but-wrong indirect lighting.
+ *
+ * The JS export names are unchanged, since those are the published surface.
+ */
+
+
 export const chunk_brick4_sh3_color_encode_to_storage = CodeChunk.from(
     //language=WGSL
     `
-fn brick4_sh3_color_encode_to_storage(
+fn brick4_sh3_color_encode_to_storage_v1(
     out:ptr<storage, array<u32>,read_write>,
     out_offset: u32,
     sh: array<vec3<f32>,9>

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.d.ts

@@ -1,4 +1,3 @@
-export function sh3_sample_irradiance_by_direction(result: any, result_offset: any, harmonics: any, harmonics_offset: any, dimension_count: any, direction: any, direction_offset: any): void;
 /**
  *
  * @param {Object} options
@@ -16,4 +15,6 @@ export function lpv_visualise_probes({ scene_context, colors_enabled, probe_size
     probe_size?: number;
     bounds?: AABB3;
 }): void;
+export { sh3_sample_irradiance_by_direction };
+import { sh3_sample_irradiance_by_direction } from "../../../../core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js";
 //# sourceMappingURL=lpv_visualise_probes.d.ts.map

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lpv_visualise_probes.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js"],"names":[],"mappings":"AA6BA,8LAoDC;AAkKD;;;;;;;;;;GAUG;AACH;IARoC,aAAa;IAEpB,cAAc,GAAhC,OAAO;IACU,UAAU,GAA3B,MAAM;IACU,MAAM;SAiEhC"}
+{"version":3,"file":"lpv_visualise_probes.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js"],"names":[],"mappings":"AA0MA;;;;;;;;;;GAUG;AACH;IARoC,aAAa;IAEpB,cAAc,GAAhC,OAAO;IACU,UAAU,GAA3B,MAAM;IACU,MAAM;SAiEhC;;mDA7PM,iFAAiF"}