@woosh/meep-engine 3.29.0 → 3.31.0

package/src/shade/renderer/geometry/virtual/build/gltf/gltf_collect_geometries.js

@@ -139,11 +139,12 @@ function select_meshes(gltf, selection, selected_nodes) {
 }
 
 /**
+ * @param {object} gltf resolved
  * @param {object} primitive
  * @param {GltfCollectReport} report
  * @returns {boolean} whether this primitive is a geometry the builder can convert
  */
-function primitive_is_usable(primitive, report) {
+function primitive_is_usable(gltf, primitive, report) {
     if ((primitive.mode ?? GLTF_PRIMITIVE_MODE_DEFAULT) !== GLTF_PRIMITIVE_MODE.TRIANGLES) {
         report.skip('primitive is not a triangle list');
 
@@ -175,6 +176,34 @@ function primitive_is_usable(primitive, report) {
         }
     }
 
+    /*
+     glTF §3.7.2.1: every attribute accessor of a primitive has the same count. A document that
+     breaks it — a truncated export, or normals re-exported after a weld — reads as far as POSITION
+     says and past the end of every shorter channel, and an index past a Float32Array is undefined,
+     which stores INTO a Float32Array as NaN. A NaN normal survives everything after it:
+     `v3_normalize_array` leaves it alone, `vgeo_normalize_source` does not re-derive the channel
+     because the channel WAS carried, and the collapse touches attribute channels only in the
+     shading-frame recompute for vertices that are not pinned — so it reaches the payload encoder,
+     octahedral-encodes to a garbage word, and the asset validates and ships.
+
+     Refused like every other primitive this cannot read, on the same (mesh, primitive) list, rather
+     than drawn wrongly.
+    */
+    const position_count = gltf.accessors[primitive.attributes.POSITION].count;
+
+    for (const name of Object.keys(primitive.attributes)) {
+        const accessor = gltf.accessors[primitive.attributes[name]];
+
+        if (accessor === undefined || accessor.count !== position_count) {
+            report.skip(
+                `primitive's ${name} accessor holds ${accessor?.count} elements`
+                + ` against POSITION's ${position_count}`
+            );
+
+            return false;
+        }
+    }
+
     return true;
 }
 
@@ -251,7 +280,7 @@ export function gltf_collect_geometries(document, selection) {
         const mesh = meshes[mesh_index];
 
         mesh.primitives.forEach((primitive, primitive_index) => {
-            if (!primitive_is_usable(primitive, report)) {
+            if (!primitive_is_usable(gltf, primitive, report)) {
                 return;
             }
 

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

@@ -38,6 +38,24 @@ export class VGeoFrontier {
      * @type {Quadric3[]}
      */
     quadrics: Quadric3[];
+    /**
+     * How far each vertex of {@link mesh} already sits from the source surface, carried unbroken
+     * from it the way {@link quadrics} is — and for the opposite reason.
+     *
+     * The quadric is what the placement is chosen by, and it is a *mean* over the planes a vertex
+     * stands for, so it is not a bound on anything: a vertex that destroyed one feature and stands
+     * for a thousand planes it sits exactly on reports the feature divided by all of them. This is
+     * the bound, composed at every collapse by the triangle inequality, and it is the number the
+     * cut's threshold is a threshold on.
+     *
+     * Combined across steps by **max**, not by the gains-minus-results the quadrics need. Two steps
+     * sharing a pinned boundary vertex leave it exactly where it is, so neither adds movement to it
+     * — and where both fold victims into it, each result is separately a valid bound on what that
+     * step folded in, so the vertex has to carry the larger.
+     *
+     * @type {Float64Array}
+     */
+    bounds: Float64Array;
     /**
      * Which of the mesh's channels travel through a collapse, and where each one sits in
      * {@link attribute_values}. Constant for a whole build — the channel set is the source's.

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

@@ -1 +1 @@
-{"version":3,"file":"VGeoFrontier.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/VGeoFrontier.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH;IACI;;OAEG;IACH,0BAAY;IAEZ;;OAEG;IACH,UAFU,wBAAwB,CAEpB;IAEd;;;OAGG;IACH,eAFU,MAAM,EAAE,EAAE,CAED;IAEnB;;;;;;;;;;;;;;OAcG;IACH,UAFU,UAAU,CAEN;IAEd;;;;OAIG;IACH,kBAFU;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,EAAE,CAAA;KAAC,CAE3C;IAEnD;;;;;OAKG;IACH,mBAFU,YAAY,CAEkB;IAExC;;;;;;;;;;;;;;;OAeG;IACH,oBAFU,YAAY,CAEmB;IAEzC;;;;;;;;;;OAUG;IACH,mBAAc;CAEjB"}
+{"version":3,"file":"VGeoFrontier.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/VGeoFrontier.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH;IACI;;OAEG;IACH,0BAAY;IAEZ;;OAEG;IACH,UAFU,wBAAwB,CAEpB;IAEd;;;OAGG;IACH,eAFU,MAAM,EAAE,EAAE,CAED;IAEnB;;;;;;;;;;;;;;OAcG;IACH,UAFU,UAAU,CAEN;IAEd;;;;;;;;;;;;;;;;OAgBG;IACH,QAFU,YAAY,CAEO;IAE7B;;;;OAIG;IACH,kBAFU;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,EAAE,CAAA;KAAC,CAE3C;IAEnD;;;;;OAKG;IACH,mBAFU,YAAY,CAEkB;IAExC;;;;;;;;;;;;;;;OAeG;IACH,oBAFU,YAAY,CAEmB;IAEzC;;;;;;;;;;OAUG;IACH,mBAAc;CAEjB"}

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

@@ -42,6 +42,25 @@ export class VGeoFrontier {
      */
     quadrics = [];
 
+    /**
+     * How far each vertex of {@link mesh} already sits from the source surface, carried unbroken
+     * from it the way {@link quadrics} is — and for the opposite reason.
+     *
+     * The quadric is what the placement is chosen by, and it is a *mean* over the planes a vertex
+     * stands for, so it is not a bound on anything: a vertex that destroyed one feature and stands
+     * for a thousand planes it sits exactly on reports the feature divided by all of them. This is
+     * the bound, composed at every collapse by the triangle inequality, and it is the number the
+     * cut's threshold is a threshold on.
+     *
+     * Combined across steps by **max**, not by the gains-minus-results the quadrics need. Two steps
+     * sharing a pinned boundary vertex leave it exactly where it is, so neither adds movement to it
+     * — and where both fold victims into it, each result is separately a valid bound on what that
+     * step folded in, so the vertex has to carry the larger.
+     *
+     * @type {Float64Array}
+     */
+    bounds = new Float64Array(0);
+
     /**
      * Which of the mesh's channels travel through a collapse, and where each one sits in
      * {@link attribute_values}. Constant for a whole build — the channel set is the source's.

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];
     }
 
     /*
@@ -248,11 +256,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;
@@ -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/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"}

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

@@ -6,7 +6,6 @@ import {
     bt_face_compute_newell_normal
 } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_compute_newell_normal.js";
 import { VGEO_ATTRIBUTE } from "../../format/attribute/VGEO_ATTRIBUTE.js";
-import { VGEO_CREASE_ANGLE } from "./VGEO_CREASE_ANGLE.js";
 
 /**
  * One corner's normal, on its way into the format's channel.
@@ -25,18 +24,28 @@ const scratch_normal = new Float32Array(3);
 const scratch_face = new Float32Array(3);
 
 /**
- * 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.
@@ -62,12 +71,11 @@ const scratch_face = new Float32Array(3);
  *     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, pinned, crease_angle = VGEO_CREASE_ANGLE) {
+export function vgeo_compute_vertex_normals(mesh, pinned) {
     const normals = mesh.layers[VGEO_ATTRIBUTE.NORMAL];
 
     assert.notNull(normals, 'mesh normal channel');
@@ -84,7 +92,8 @@ export function vgeo_compute_vertex_normals(mesh, pinned, crease_angle = VGEO_CR
     const face_normal = new Float64Array(face_pool.size * 3);
 
     /**
-     * Its length, so the angle test does not recompute one.
+     * Its length, which is twice the face's area, and so zero exactly where the face has none. Only
+     * the liveness test reads it now that nothing measures an angle.
      * @type {Float64Array}
      */
     const face_length = new Float64Array(face_pool.size);
@@ -122,8 +131,6 @@ export function vgeo_compute_vertex_normals(mesh, pinned, crease_angle = VGEO_CR
         group[loop] = loop;
     }
 
-    const smooth_cosine = Math.cos((crease_angle * Math.PI) / 180);
-
     const edge_pool = topology.edges;
 
     for (let edge = 0; edge < edge_pool.size; edge++) {
@@ -163,19 +170,6 @@ export function vgeo_compute_vertex_normals(mesh, pinned, crease_angle = VGEO_CR
             continue;
         }
 
-        const left_face = topology.loop_read_face(left);
-        const right_face = topology.loop_read_face(right);
-
-        const cosine = (
-            face_normal[left_face * 3] * face_normal[right_face * 3]
-            + face_normal[left_face * 3 + 1] * face_normal[right_face * 3 + 1]
-            + face_normal[left_face * 3 + 2] * face_normal[right_face * 3 + 2]
-        ) / (face_length[left_face] * face_length[right_face]);
-
-        if (cosine < smooth_cosine) {
-            continue;
-        }
-
         /*
          A loop's edge runs from its own vertex to the next loop's, so on an edge's loop those two
          are the edge's endpoints. Matching them up by vertex is what pairs the corner of one face

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

@@ -42,12 +42,10 @@
  * @param {VirtualGeometryMesh} mesh mutated in place
  * @param {number} weld_ratio fraction of the bounding-box diagonal; see
  *     {@link VGeoBuildOptions#weld_ratio}
- * @param {number} [crease_angle] degrees; see {@link VGeoBuildOptions#crease_angle}. Only reaches a
- *     channel the source did not author.
  * @returns {number} the object-space distance the ratio came to for this mesh
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_normalize_source(mesh: VirtualGeometryMesh, weld_ratio: number, crease_angle?: number): number;
+export function vgeo_normalize_source(mesh: VirtualGeometryMesh, weld_ratio: number): number;
 //# sourceMappingURL=vgeo_normalize_source.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vgeo_normalize_source.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,6EATW,MAAM,iBAEN,MAAM,GAEJ,MAAM,CA+ClB"}
+{"version":3,"file":"vgeo_normalize_source.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/mesh/vgeo_normalize_source.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,6EAPW,MAAM,GAEJ,MAAM,CA+ClB"}

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

@@ -20,7 +20,6 @@ import {
 import { bt_mesh_validate } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_mesh_validate.js";
 import { VGEO_ATTRIBUTE } from "../../format/attribute/VGEO_ATTRIBUTE.js";
 import { vgeo_mesh_wedges } from "../../format/attribute/vgeo_mesh_wedges.js";
-import { VGEO_CREASE_ANGLE } from "./VGEO_CREASE_ANGLE.js";
 import { vgeo_compute_vertex_normals } from "./vgeo_compute_vertex_normals.js";
 import { vgeo_compute_vertex_tangents } from "./vgeo_compute_vertex_tangents.js";
 
@@ -75,14 +74,12 @@ const NOTHING_PINNED = new Set();
  * @param {VirtualGeometryMesh} mesh mutated in place
  * @param {number} weld_ratio fraction of the bounding-box diagonal; see
  *     {@link VGeoBuildOptions#weld_ratio}
- * @param {number} [crease_angle] degrees; see {@link VGeoBuildOptions#crease_angle}. Only reaches a
- *     channel the source did not author.
  * @returns {number} the object-space distance the ratio came to for this mesh
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_normalize_source(mesh, weld_ratio, crease_angle = VGEO_CREASE_ANGLE) {
+export function vgeo_normalize_source(mesh, weld_ratio) {
     const topology = mesh.topology;
 
     const weld_distance = bt_mesh_relative_merge_distance(topology, weld_ratio);
@@ -110,7 +107,7 @@ export function vgeo_normalize_source(mesh, weld_ratio, crease_angle = VGEO_CREA
     // Normals first: the tangent solve reads them, and a synthesized normal beside an authored
     // tangent is still the pair the frame is built from.
     if (mesh.synthesized[VGEO_ATTRIBUTE.NORMAL]) {
-        vgeo_compute_vertex_normals(mesh, NOTHING_PINNED, crease_angle);
+        vgeo_compute_vertex_normals(mesh, NOTHING_PINNED);
     }
 
     /*

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

@@ -137,7 +137,7 @@ export async function vgeo_build(geometry, options) {
 
     const mesh = VirtualGeometryMesh.from_geometry(geometry);
 
-    const weld_distance = vgeo_normalize_source(mesh, options.weld_ratio, options.crease_angle);
+    const weld_distance = vgeo_normalize_source(mesh, options.weld_ratio);
 
     const source_face_count = mesh.topology.faces.count();
     const source_vertex_count = mesh.topology.vertices.count();

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"}