@woosh/meep-engine 3.26.0 → 3.28.0

package/src/shade/playground/vgeo_viewer/sample_asset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sample_asset.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/sample_asset.js"],"names":[],"mappings":"AAyFA;;;;;;;;;;;GAWG;AACH,2CALW,MAAM,UACN,MAAM,cACN,MAAM,GACJ;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAiBtD;+BAzGM,+DAA+D"}
+{"version":3,"file":"sample_asset.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/sample_asset.js"],"names":[],"mappings":"AA0GA;;;;;;;;;;;GAWG;AACH,2CALW,MAAM,UACN,MAAM,cACN,MAAM,GACJ;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAiBtD;+BA1HM,+DAA+D"}

package/src/shade/renderer/Renderer.d.ts

@@ -389,7 +389,10 @@ export class Renderer {
      *
      * @param {PerspectiveCamera} camera
      * @param {Scene} scene
-     * @param {number} [time_delta_seconds]
+     * @param {number} [time_delta_seconds] simulation seconds this frame advances by — the particle
+     * simulation, the animation tick and exposure adaptation all step by it. Zero by default, which
+     * draws the current state and moves nothing; a fixed fraction of a second here instead would run
+     * the simulation at that rate no matter what the caller's clock was doing.
      * @returns {boolean} whether frame was rendered, will return false if previous frame hasn't finished yet
      */
     render(camera: PerspectiveCamera, scene: Scene, time_delta_seconds?: number): boolean;

package/src/shade/renderer/Renderer.d.ts.map

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

package/src/shade/renderer/Renderer.js

@@ -1720,13 +1720,16 @@ export class Renderer {
      *
      * @param {PerspectiveCamera} camera
      * @param {Scene} scene
-     * @param {number} [time_delta_seconds]
+     * @param {number} [time_delta_seconds] simulation seconds this frame advances by — the particle
+     * simulation, the animation tick and exposure adaptation all step by it. Zero by default, which
+     * draws the current state and moves nothing; a fixed fraction of a second here instead would run
+     * the simulation at that rate no matter what the caller's clock was doing.
      * @returns {boolean} whether frame was rendered, will return false if previous frame hasn't finished yet
      */
     render(
         camera,
         scene,
-        time_delta_seconds = 0.01666
+        time_delta_seconds = 0
     ) {
         if (this.#device_lost) {
             // device is lost, can't render — and asking the context for a texture would throw

package/src/shade/renderer/extension/RENDER_EXTENSION_DESIGN.md

@@ -677,7 +677,7 @@ add_extension(e); remove_extension(e); extension_count(phase);
 
 ## 8. Migration
 
-Nine live systems, one probe, one prototype viewer. Every one of them is the same mechanical change:
+Nine live systems and one probe. Every one of them is the same mechanical change:
 a closure becomes a class, `context.color` becomes `frame.get(SceneColor).color`, and the return
 value becomes a publication.
 
@@ -693,7 +693,6 @@ value becomes a publication.
 | `DebugDrawSystem` | `AfterTransparency` | `after: [FogOfWarExtension]` |
 | `Trail3DSystem` | `AfterTransparency` | — |
 | `probeShadePassInjection` | all | the gate is rewritten and gains the two checks it is currently blind to: a G-buffer replacement, and an order flip |
-| `vgeo_viewer` playground | `AfterTransparency` | prototype; mechanical |
 
 **The `AfterTransparency` chain is settled, not open.** Fog of war is last among the content
 extensions, because it conceals and therefore belongs over everything it is meant to conceal —

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.d.ts

@@ -72,6 +72,17 @@ export class GPUGeometryBVHManager {
      */
     get empty_tree_address(): number;
     get gpu_memory_usage(): number;
+    /**
+     * Bytes of the node arena that trees actually occupy: its capacity, less every region
+     * {@link #allocator} still holds free.
+     *
+     * Beside {@link gpu_memory_usage}, which is what the arenas cost whether or not anything is
+     * in them. The gap between the two is what a released tree gives back and what the next tree
+     * of that size takes, so it is the one worth watching.
+     *
+     * @returns {number} in bytes
+     */
+    get gpu_memory_usage_occupied(): number;
     /**
      * The tree belonging to `owner`, registered against `source`'s shape if it does not exist yet.
      *

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometryBVHManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js"],"names":[],"mappings":"AAmBA;;;GAGG;AAEH;;;;;GAKG;AACH,gDAGG;AAEH;;;;;;;;;;;GAWG;AACH,sCAFU,MAAM,CAEyB;AAoBzC;;;;;;;;;;;;;;GAcG;AACH;IA0II;;;OAGG;IACH,+BAoDC;IA1LD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,6BAEC;IAuCD;;OAEG;IACH,gCAEC;IAOD;;OAEG;IACH,mCAEC;IA+BD;;OAEG;IACH,gCAEC;IA6ED;;;;OAIG;IACH,iCAEC;IAED,+BAoBC;IAED;;;;;;;;;;;;;;OAcG;IACH,cALW,MAAM,UACN,eAAe,GAEb,sBAAsB,CAalC;IA8DD;;;;;;;;;;;;OAYG;IACH,wBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAqB3I;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAU5B;IAED;;;;;;;;;OASG;IACH,0BAFW,WAAW,QAQrB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,GACJ,OAAO,CA8BnB;IA4LD;;;;;;;OAOG;IACH,eAOC;;CAuIJ;8BAxzBY,OAAO,uBAAuB,EAAE,eAAe;yBAC/C,OAAO,sDAAsD,EAAE,UAAU;6BAbzD,mCAAmC;uCASzB,6BAA6B"}
+{"version":3,"file":"GPUGeometryBVHManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js"],"names":[],"mappings":"AAkBA;;;GAGG;AAEH;;;;;GAKG;AACH,gDAGG;AAEH;;;;;;;;;;;GAWG;AACH,sCAFU,MAAM,CAEyB;AAoBzC;;;;;;;;;;;;;;GAcG;AACH;IA0II;;;OAGG;IACH,+BAoDC;IA1LD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,6BAEC;IAuCD;;OAEG;IACH,gCAEC;IAOD;;OAEG;IACH,mCAEC;IA+BD;;OAEG;IACH,gCAEC;IA6ED;;;;OAIG;IACH,iCAEC;IAED,+BAoBC;IAED;;;;;;;;;OASG;IACH,wCAIC;IAED;;;;;;;;;;;;;;OAcG;IACH,cALW,MAAM,UACN,eAAe,GAEb,sBAAsB,CAalC;IA8DD;;;;;;;;;;;;OAYG;IACH,wBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAqB3I;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAU5B;IAED;;;;;;;;;OASG;IACH,0BAFW,WAAW,QAQrB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,GACJ,OAAO,CA8BnB;IA4LD;;;;;;;OAOG;IACH,eAOC;;CAgIJ;8BAj0BY,OAAO,uBAAuB,EAAE,eAAe;yBAC/C,OAAO,sDAAsD,EAAE,UAAU;6BAbzD,mCAAmC;uCASzB,6BAA6B"}

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js

@@ -4,7 +4,6 @@ import { platform_compute_endianness } from "../../../../core/binary/platform_co
 import { array_buffer_copy } from "../../../../core/collection/array/typed/array_buffer_copy.js";
 import { Deque } from "../../../../core/collection/queue/Deque.js";
 import { round_up } from "../../../../core/math/round_up.js";
-import { number_format_by_thousands } from "../../../../core/primitives/numbers/number_format_by_thousands.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
@@ -307,6 +306,22 @@ export class GPUGeometryBVHManager {
         return r;
     }
 
+    /**
+     * Bytes of the node arena that trees actually occupy: its capacity, less every region
+     * {@link #allocator} still holds free.
+     *
+     * Beside {@link gpu_memory_usage}, which is what the arenas cost whether or not anything is
+     * in them. The gap between the two is what a released tree gives back and what the next tree
+     * of that size takes, so it is the one worth watching.
+     *
+     * @returns {number} in bytes
+     */
+    get gpu_memory_usage_occupied() {
+        const free_nodes = this.#allocator.storageReport().totalFreeSpace;
+
+        return (this.#node_capacity - free_nodes) * BVH2_NODE_STRUCT.size;
+    }
+
     /**
      * The tree belonging to `owner`, registered against `source`'s shape if it does not exist yet.
      *
@@ -828,13 +843,6 @@ export class GPUGeometryBVHManager {
             );
         }
 
-        const free_nodes = this.#allocator.storageReport().freeStorage;
-
-        console.warn(
-            `BLAS size: ${number_format_by_thousands((this.#node_capacity - free_nodes) * BVH2_NODE_STRUCT.size)} bytes` +
-            ` of ${number_format_by_thousands(this.#node_capacity * BVH2_NODE_STRUCT.size)}`
-        );
-
         device.queue.submit([encoder.finish()])
 
         // free up the temp buffer

package/src/shade/renderer/geometry/meshlet/GPUMeshletManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshletManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/GPUMeshletManager.js"],"names":[],"mappings":"AAuFA;IAqEI;;;;;;OAMG;IACH;QAJ8B,MAAM;QACR,qBAAqB,GAAtC,MAAM;QACW,yBAAyB,GAA1C,MAAM;OAkChB;IAzFD,6BAEC;IAOD,iCAEC;IAgFD,gBAKC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,sBAHW,MAAM,uBACN,MAAM,QAuHhB;IAqRD;;;;;;;;;;;OAWG;IACH,qBAJW,4BAA4B,GAE1B,OAAO,CAmBnB;IAgCD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+BAHW,4BAA4B,GAC1B,4BAA4B,CA8BxC;IAED;;;;;;;;;;;;OAYG;IACH,gBAFW,sBAAsB,QA8GhC;IAED,gBAGC;IAED;;;;OAIG;IACH,iBAHW,YAAY,GACV,4BAA4B,CA6BxC;IAED,mCASC;IAED,wCAQC;IAED,+BAYC;;CACJ;yBA/4BY,OAAO,sDAAsD,EAAE,UAAU;qCACzE,OAAO,2CAA2C,EAAE,sBAAsB;2BAC1E,OAAO,mBAAmB,EAAE,YAAY;AA6BrD;IACI;;OAEG;IACH,UAFU,UAAU,CAEZ;IACR;;OAEG;IACH,MAFU,UAAU,CAEhB;IAEJ;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,0BAFU,WAAW,CAEI;IAEzB;;;OAGG;IACH,aAAsB;CACzB"}
+{"version":3,"file":"GPUMeshletManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/GPUMeshletManager.js"],"names":[],"mappings":"AAuFA;IA4EI;;;;;;OAMG;IACH;QAJ8B,MAAM;QACR,qBAAqB,GAAtC,MAAM;QACW,yBAAyB,GAA1C,MAAM;OAkChB;IAhGD,6BAEC;IAOD,iCAEC;IAuFD,gBAKC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,sBAHW,MAAM,uBACN,MAAM,QAuHhB;IAoRD;;;;;;;;;;;OAWG;IACH,qBAJW,4BAA4B,GAE1B,OAAO,CAkBnB;IAgCD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+BAHW,4BAA4B,GAC1B,4BAA4B,CA8BxC;IAED;;;;;;;;;;;;OAYG;IACH,gBAFW,sBAAsB,QA8GhC;IAED,gBAGC;IAED;;;;OAIG;IACH,iBAHW,YAAY,GACV,4BAA4B,CA6BxC;IAED,mCASC;IAED,wCAQC;IAED,+BAYC;;CACJ;yBAp5BY,OAAO,sDAAsD,EAAE,UAAU;qCACzE,OAAO,2CAA2C,EAAE,sBAAsB;2BAC1E,OAAO,mBAAmB,EAAE,YAAY;AA6BrD;IACI;;OAEG;IACH,UAFU,UAAU,CAEZ;IACR;;OAEG;IACH,MAFU,UAAU,CAEhB;IAEJ;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,0BAFU,WAAW,CAEI;IAEzB;;;OAGG;IACH,aAAsB;CACzB"}

package/src/shade/renderer/geometry/meshlet/GPUMeshletManager.js

@@ -129,10 +129,17 @@ export class GPUMeshletManager {
     #deallocations_since_last_rebuild = 0;
 
     /**
+     * Every live allocation, in the order it was made — which is the order a rebuild packs them in.
      *
-     * @type {MeshletBatchAllocationRecord[]}
+     * A `Set` and not an array: {@link remove_batch} used to find its record with `indexOf` and take
+     * it out with `splice`, a walk of every record the manager held per removal. A static scene
+     * never noticed. A virtual-geometry tier evicts pages every frame, and each eviction paid a
+     * scan of every resident page and every static batch — 15 µs at 64,000 records, and an asset's
+     * unregister paid it once per page (RUNTIME_PLAN_2026_09_14 §0, step 0).
+     *
+     * @type {Set<MeshletBatchAllocationRecord>}
      */
-    #records = [];
+    #records = new Set();
 
     /**
      * Queue of GPU-side clones that have been allocated but not yet
@@ -407,7 +414,7 @@ export class GPUMeshletManager {
         const device = this.#device;
 
         const records = this.#records;
-        const record_count = records.length;
+        const record_count = records.size;
         const new_allocator_data = new OffsetAllocator(
             new_data_size,
             Math.max(record_count * 2, ALLOCATION_LIMIT)
@@ -438,9 +445,8 @@ export class GPUMeshletManager {
 
         const moved_records = [];
 
-        // move data
-        for (let i = 0; i < record_count; i++) {
-            const record = records[i];
+        // move data, in allocation order, which is the order the set keeps
+        for (const record of records) {
 
             const new_allocation_data = new_allocator_data.allocate(record.data_size);
             const new_allocation_metadata = new_allocator_metadata.allocate(record.meshlet_count);
@@ -613,7 +619,7 @@ export class GPUMeshletManager {
 
         record.metadata_buffer_original = batch.metadata_buffer;
 
-        this.#records.push(record);
+        this.#records.add(record);
 
         return record;
     }
@@ -633,8 +639,7 @@ export class GPUMeshletManager {
     remove_batch(record) {
         assert.defined(record, 'record');
 
-        const index = this.#records.indexOf(record);
-        if (index === -1) {
+        if (!this.#records.has(record)) {
             return false;
         }
 
@@ -643,7 +648,7 @@ export class GPUMeshletManager {
         this.#allocator_data.free(record.data);
         this.#allocator_metadata.free(record.metadata);
 
-        this.#records.splice(index, 1);
+        this.#records.delete(record);
         this.#deallocations_since_last_rebuild++;
 
         return true;
@@ -722,7 +727,7 @@ export class GPUMeshletManager {
         // the clone's metadata correctly under its new data offset.
         record.metadata_buffer_original = source.metadata_buffer_original;
 
-        this.#records.push(record);
+        this.#records.add(record);
 
         // The queue names the two records rather than the addresses they
         // hold right now. Both are in `#records`, so a rebuild between

package/src/shade/renderer/geometry/meshlet/MeshletBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AAkEA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAqBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAoFlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IA4LD,qBA+BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,QASlB;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;uBA1gBY,OAAO,gBAAgB,EAAE,QAAQ"}
+{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AAwCA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAqBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAoFlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IA4LD,qBA+BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,QASlB;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;uBA/eY,OAAO,gBAAgB,EAAE,QAAQ"}

package/src/shade/renderer/geometry/meshlet/MeshletBatch.js

@@ -11,10 +11,11 @@ import { aabb3_from_v3_array } from "../../../../core/geom/3d/aabb/aabb3_from_v3
 import { round_up } from "../../../../core/math/round_up.js";
 import { read_wgsl_type_value } from "../../shader/type/serde/read_gpu_typed_buffer.js";
 import { write_wgsl_type_value } from "../../shader/type/serde/write_gpu_typed_buffer.js";
-import { encode_normals_to_octahedral_u32 } from "../normals/encode_normals_to_octahedral_u32.js";
-import { encode_tangents_to_u32 } from "../normals/encode_tangents_to_u32.js";
 import { StandardAttributes } from "../StandardAttributes.js";
 import { geometry_to_meshlets_meshoptimizer } from "./build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js";
+import {
+    ENCODED_ATTRIBUTE_DEFAULT_VALUES
+} from "./encoding/ENCODED_ATTRIBUTE_DEFAULT_VALUES.js";
 import { ENCODED_ATTRIBUTE_SIZES } from "./encoding/ENCODED_ATTRIBUTE_SIZES.js";
 import { ENCODED_ORDERED_ATTRIBUTES } from "./encoding/ENCODED_ORDERED_ATTRIBUTES.js";
 import { MESHLET_ATTRIBUTE_COMPRESSION_FLAGS } from "./encoding/MESHLET_ATTRIBUTE_COMPRESSION_FLAGS.js";
@@ -30,33 +31,6 @@ import { meshlet_get_attribute_offset } from "./meshlet_get_attribute_offset.js"
  */
 
 
-const ENCODED_ATTRIBUTE_DEFAULT_VALUES = {
-    [StandardAttributes.Color]: 0xFFFFFFFF,
-    [StandardAttributes.TextureCoordinates0]: [0, 0],
-    [StandardAttributes.TextureCoordinates1]: 0,
-    [StandardAttributes.Normal]: 0,
-    [StandardAttributes.Tangent]: 0,
-    [StandardAttributes.SkinningJoints]: [0,0],
-    // Single u32 with all four packed unorm8 weights at zero —
-    // matches the new 1-u32-per-vertex layout (was [0,0] for the
-    // old f16×4 / 2-u32 layout).
-    [StandardAttributes.SkinningWeights]: 0,
-}
-
-{
-    const default_normal = new Uint32Array(1);
-    encode_normals_to_octahedral_u32(default_normal, 0, 1, [0, 0, 1]);
-
-    ENCODED_ATTRIBUTE_DEFAULT_VALUES[StandardAttributes.Normal] = default_normal[0];
-}
-
-{
-    const default_tangent = new Uint32Array(1);
-    encode_tangents_to_u32(default_tangent, 0, 1, [0, 0, 1, 1]);
-
-    ENCODED_ATTRIBUTE_DEFAULT_VALUES[StandardAttributes.Tangent] = default_tangent[0];
-}
-
 const DEBUG_ATTRIBUTE_SIZE_TOTALS = {};
 
 globalThis.meshlet_debug = DEBUG_ATTRIBUTE_SIZE_TOTALS;

package/src/shade/renderer/geometry/meshlet/encoding/ENCODED_ATTRIBUTE_DEFAULT_VALUES.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What an attribute section holds, already encoded, when the geometry does not carry the attribute
+ * at all. The section is written once and flagged compressed, so this is the value every vertex of
+ * that meshlet reads.
+ *
+ * It lives in its own module because it is not private to the encoder that writes it: the virtual
+ * geometry builder produces payloads that must be **byte-identical** to these, and the only way to
+ * hold it to that is for its spec to compare against this object rather than against a copy of it.
+ * Every other table the two share — order, word sizes, compression flags — is already shared that
+ * way; this was the one that was not, and so the one whose drift nothing would have caught.
+ *
+ * Note what is deliberately asymmetric: colour's default is opaque white with its alpha byte set,
+ * while `encode_colors_to_u32` writes three channels and leaves alpha zero. A geometry with no
+ * colour channel therefore reads a different word than one whose every vertex is white. That is
+ * long-standing behaviour and changing it would change what every existing asset decodes to.
+ *
+ * Position has no entry: it is never absent.
+ *
+ * @type {Object<StandardAttributes, number|number[]>}
+ */
+export const ENCODED_ATTRIBUTE_DEFAULT_VALUES: any;
+//# sourceMappingURL=ENCODED_ATTRIBUTE_DEFAULT_VALUES.d.ts.map

package/src/shade/renderer/geometry/meshlet/encoding/ENCODED_ATTRIBUTE_DEFAULT_VALUES.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ENCODED_ATTRIBUTE_DEFAULT_VALUES.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/meshlet/encoding/ENCODED_ATTRIBUTE_DEFAULT_VALUES.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mDAUE"}

package/src/shade/renderer/geometry/meshlet/encoding/ENCODED_ATTRIBUTE_DEFAULT_VALUES.js

@@ -0,0 +1,49 @@
+import { encode_normals_to_octahedral_u32 } from "../../normals/encode_normals_to_octahedral_u32.js";
+import { encode_tangents_to_u32 } from "../../normals/encode_tangents_to_u32.js";
+import { StandardAttributes } from "../../StandardAttributes.js";
+
+/**
+ * What an attribute section holds, already encoded, when the geometry does not carry the attribute
+ * at all. The section is written once and flagged compressed, so this is the value every vertex of
+ * that meshlet reads.
+ *
+ * It lives in its own module because it is not private to the encoder that writes it: the virtual
+ * geometry builder produces payloads that must be **byte-identical** to these, and the only way to
+ * hold it to that is for its spec to compare against this object rather than against a copy of it.
+ * Every other table the two share — order, word sizes, compression flags — is already shared that
+ * way; this was the one that was not, and so the one whose drift nothing would have caught.
+ *
+ * Note what is deliberately asymmetric: colour's default is opaque white with its alpha byte set,
+ * while `encode_colors_to_u32` writes three channels and leaves alpha zero. A geometry with no
+ * colour channel therefore reads a different word than one whose every vertex is white. That is
+ * long-standing behaviour and changing it would change what every existing asset decodes to.
+ *
+ * Position has no entry: it is never absent.
+ *
+ * @type {Object<StandardAttributes, number|number[]>}
+ */
+export const ENCODED_ATTRIBUTE_DEFAULT_VALUES = {
+    [StandardAttributes.Color]: 0xFFFFFFFF,
+    [StandardAttributes.TextureCoordinates0]: [0, 0],
+    [StandardAttributes.TextureCoordinates1]: 0,
+    [StandardAttributes.Normal]: 0,
+    [StandardAttributes.Tangent]: 0,
+    [StandardAttributes.SkinningJoints]: [0, 0],
+    // Single u32 with all four packed unorm8 weights at zero — matches the 1-u32-per-vertex
+    // layout (was [0,0] for the old f16×4 / 2-u32 layout).
+    [StandardAttributes.SkinningWeights]: 0,
+};
+
+{
+    const default_normal = new Uint32Array(1);
+    encode_normals_to_octahedral_u32(default_normal, 0, 1, [0, 0, 1]);
+
+    ENCODED_ATTRIBUTE_DEFAULT_VALUES[StandardAttributes.Normal] = default_normal[0];
+}
+
+{
+    const default_tangent = new Uint32Array(1);
+    encode_tangents_to_u32(default_tangent, 0, 1, [0, 0, 1, 1]);
+
+    ENCODED_ATTRIBUTE_DEFAULT_VALUES[StandardAttributes.Tangent] = default_tangent[0];
+}

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

@@ -28,8 +28,10 @@ consumer reads it, and `runtime/RUNTIME_PLAN.md` §4.8 says why: at the moment a
 per-cluster test the cut has already passed is strictly tighter than any page-level test, so the
 page-level one can never reject anything. Its consumer is prefetch, which is a later campaign.
 
-`shade/playground/vgeo_viewer/` drives the reader end to end, and its `select_cut.js` is a CPU
-reference traversal of the cut rule this format was shaped around.
+`shade/playground/vgeo_runtime/` and `shade/playground/vgeo_scene/` drive the reader end to end
+against a device, and `runtime/cut/__fixtures__/vgeo_select_cut.js` is a CPU reference traversal of the
+cut rule this format was shaped around — the oracle the GPU cut is held to, and the only traversal
+of it that is not a kernel.
 
 ## 1. Design constraints (inherited, binding)
 
@@ -116,7 +118,7 @@ All u64/u128 fields are naturally 8-byte aligned.
 | offset | type      | field                    | notes |
 |-------:|-----------|--------------------------|-------|
 | 0      | u32       | magic                    | `'VGEO'` = 0x4F454756 |
-| 4      | u16       | format_version           | 3 today; breaking layout changes only |
+| 4      | u16       | format_version           | 4 today; breaking layout changes only |
 | 6      | u16       | min_reader_version       | 3 today; reader MUST reject if its version is lower |
 | 8      | u16       | header_size              | = 256 |
 | 10     | u8        | hash_algo                | 0 = xxHash3; readers MUST reject unknown values |
@@ -145,6 +147,15 @@ All u64/u128 fields are naturally 8-byte aligned.
 | 160    | [u8; 88]  | reserved                 | |
 | 248    | u64       | header_checksum          | xxh3-64 of bytes 0–255 with this field zeroed (`asset_id` already final) |
 
+**`format_version` 4 moved and `min_reader_version` did not**, which is the pair working as
+intended rather than an oversight. 4 added the parent tables (§6.3, §6.4): they occupy bytes that
+were reserved and written as zero, and they sit between the cluster records and the payload, so
+every offset a version-3 reader computes lands exactly where it did and such a reader reads a
+version-4 file correctly by ignoring them. In the other direction a version-4 reader meets
+`parent_table_offset = 0` on an older file and takes it as "this container has no upward edge",
+which is true — so neither direction needs a version test, and nothing has to be rebuilt to stay
+readable.
+
 ### 4.1 Level table (`level_count` × 32 B, immediately after the header)
 
 Statistics per level, at `256 + 32·i`, ending where the root page frame begins. Small —
@@ -293,9 +304,15 @@ about 0.6 ms for a 256 KB page.
 ## 6. Decoded page
 
 ```
-[ PageHeader (56 B) ] [ Group table ] [ Node table ] [ Cluster records ] [ Payload ]
+[ PageHeader (56 B) ] [ Group table ] [ Node table ] [ Cluster records ]
+[ Parent-page table ] [ Group-parent table ] [ Payload ]
 ```
 
+The two parent tables sit between the cluster records and the payload, and that placement is the
+reason `min_reader_version` did not move (§4): `node_table_offset`'s `= 56 + 8·group_count` stays
+true, every earlier offset is where it was, and both tables hold 4-byte entries over sections that
+are already multiples of four, so §11.8's word-aligned payload survives.
+
 PageHeader:
 
 | offset | type | field                 | notes |
@@ -309,7 +326,9 @@ PageHeader:
 | 12     | u32  | payload_offset        | |
 | 16     | u32  | payload_size          | |
 | 20     | u32  | node_table_offset     | = `56 + 8·group_count`; the node table follows the group table |
-| 24     | [u8; 8] | reserved           | |
+| 24     | u32  | parent_table_offset   | start of the parent section — the parent-page table, then the group-parent table. **0 means the page carries neither**, which is what every container written before `format_version` 4 says about itself |
+| 28     | u16  | parent_entry_count    | entries in the group-parent table (§6.3) = Σ `parent_cluster_count` over this page's groups |
+| 30     | u16  | parent_page_count     | entries in the parent-page table (§6.4) |
 | 32     | metric | metric             | this page's own traversal metric (§6.2) — the root node's, repeated here so an installed page can be tested from itself |
 
 Group table — `group_count` × 8 B. Groups are the atomic LOD/residency unit; because a
@@ -320,8 +339,44 @@ construction — no global group index exists or is needed:
 |-------:|------|----------------------|-------|
 | 0      | u16  | cluster_first        | index into this page's cluster records |
 | 2      | u16  | cluster_count        | ≥ 1; ≤ 4096 (format cap, §11.5) |
-| 4      | u16  | parent_cluster_count | number of parent clusters referencing this group, `SAME_PAGE` references included; 0 exactly for the root page's topmost-level groups — drives activation (§10) |
-| 6      | u16  | reserved             | |
+| 4      | u16  | parent_cluster_count | number of parent clusters referencing this group, `SAME_PAGE` references included; 0 exactly for the root page's topmost-level groups — drives activation (§10). Also the length of this group's run in the group-parent table |
+| 6      | u16  | parent_first         | index of that run's first entry (§6.3). Groups tile the table in order, exactly as `cluster_first` tiles the cluster records |
+
+### 6.3 Group-parent table (`parent_entry_count` × 4 B)
+
+The format's **only upward edge**, and the mirror of the child table with everything a parent does
+not need taken out. Every entry here is the reverse of exactly one cluster's
+`child_ref`/`child_group` pair, and §11.16 holds the two to each other.
+
+| offset | type | field          | notes |
+|-------:|------|----------------|-------|
+| 0      | u16  | parent_ref     | index into the parent-page table (§6.4), or `SAME_PAGE` |
+| 2      | u16  | parent_cluster | cluster index within that page |
+
+**Four bytes an entry, against the child table's 48**, because the two directions are not
+symmetric. A child reference carries a fetch range and a metric copy because the child may be
+absent and the decision to fetch it is taken before it arrives. A parent of a group in the cut is
+resident already — `VGEO_GROUP_FLAG_SELECTABLE` is exactly "every parent reference is live" — so a
+parent reference has nothing to decide and only has to say where.
+
+Measured across 8,899 pages of 30 converted containers: 17.4 entries a page on average and 26 at
+the worst, so the table runs to about 70 bytes against pages of 56–256 KB, and compresses with the
+rest of them (§5: tables are 7% of page bytes at 1.6×).
+
+What it is *for* is a cut that is kept between frames. A cut that has descended to a group and then
+sees the camera pull back has to draw the clusters that consumed that group instead, and without
+this it could only find them by descending from the root again — which is the cost keeping a cut is
+meant to remove, paid on the common case.
+
+### 6.4 Parent-page table (`parent_page_count` × 4 B)
+
+One `page_index u32` per **distinct other** page holding a parent of one of this page's groups,
+deduplicated and ascending. A parent inside this page spends `SAME_PAGE` in §6.3 instead and has no
+entry here, so a page never appears in its own table.
+
+It lives in the decoded page rather than beside the plaintext child table because nothing needs it
+before decode: no fetch range is computed from it, and in the blob it compresses with the other
+tables. Measured: 4.9 entries a page on average, 18 at the worst.
 
 ### 6.1 Node table (`node_count` × 32 B)
 
@@ -734,6 +789,21 @@ clustering and simplification dominate regardless.
    into more bytes than a page holds has no layout, and the builder refuses it naming the page size
    that would work, rather than writing a page over the size the header states.
 
+15. **Parent-table bounds.** `parent_entry_count ≤ 65,535`, so that a group record's u16
+    `parent_first` can index the whole table, and `parent_page_count ≤ parent_entry_count`, since
+    no entry can name more than one page. The first is a cap rather than a wider field because the
+    distance is not close: the worst page of 8,899 measured carries 26 entries, which leaves the
+    bound standing 2,521× above it, and widening `parent_first` would cost the group record its
+    8-byte size. A builder that ever approached the cap would split the page.
+
+16. **The two edges agree.** Every entry of a page's group-parent table (§6.3) resolves to a
+    cluster whose `child_group` is the group whose run the entry is in; each group's run holds
+    exactly the clusters that name it, with no repeats; and the run is sorted by
+    (page index, cluster index). The first is what makes a coarsen legal at all. The third is what
+    lets a runtime elect one appender out of a group's several parents by taking the first entry of
+    the run, rather than carrying a dedup bitmask sized by instances × groups — so the order is
+    load-bearing and not presentation.
+
 ## 12. Open
 
 - Page codec ids beyond raw and LZ4 (§5). LZ4 is the default and is where the cheap

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

@@ -15,12 +15,14 @@ RAM tier's budget, and `runtime/` is everything §7 describes — the selection
 pass, the VRAM page pool, the feedback loop, and the seam through which VG instances enter the
 meshlet pipeline ([runtime/RUNTIME_PLAN.md](./runtime/RUNTIME_PLAN.md)).
 
-Two playgrounds prove two different things and it is worth not confusing them.
-`shade/playground/vgeo_viewer/` puts a clamped **CPU** cut of a streaming container on screen
-through Shade's direct geometry path — it proves the DAG, the format and the clamp, and by
-construction it proves nothing about the engine. `shade/playground/vgeo_runtime/` puts an ordinary
-`Mesh` in an ordinary `Scene` and draws it entirely from a **GPU** cut through the meshlet
-pipeline — it proves the seam and nothing about the DAG. §10 says which milestone that leaves us
+`shade/playground/vgeo_runtime/` puts an ordinary `Mesh` in an ordinary `Scene` and draws it
+entirely from a **GPU** cut through the meshlet pipeline — it proves the engine seam, and
+`shade/playground/vgeo_scene/` opens a whole converted set at once, where the claim about a *scene*
+is measured. What proves the DAG, the format and the clamp is not a page at all: it is
+`runtime/cut/__fixtures__/vgeo_select_cut.js`, a CPU traversal of the same rule that every cut
+spec is held to. A third playground once drew that traversal on screen through Shade's direct
+geometry path, with its own renderer and its own streaming loop; once the GPU page could show
+everything it showed, it was a second runtime for no gain, and it was retired. §10 says which milestone that leaves us
 in, and the order the work actually arrived in.
 
 ## 1. What and why
@@ -245,8 +247,12 @@ Pinned:
   same answer as by stopping its descent rather than by evaluating it everywhere: draw a
   cluster iff
 
-  `project(parent) > τ AND (project(self) ≤ τ OR child group non-selectable)`
+  `own group selectable AND project(parent) > τ AND (project(self) ≤ τ OR child group
+  non-selectable)`
 
+  The first term is not decoration: a group that is resident but not yet selectable satisfies
+  the rest of the rule while the coarser stand-in still covers the same surface, and both are
+  drawn a few microns apart — which reads as corrupt geometry rather than as a missing page.
   The clamp is what makes "no holes, ever" (§6) true: without it, when the τ-selected
   level lies below the streaming frontier, *no* resident cluster on that path satisfies
   the pure rule and the guaranteed stand-in is never selected. The child-group
@@ -265,16 +271,18 @@ Pinned:
   scale this design targets is millions of clusters every frame, most of them off-screen. A
   traversal costs the cut. It also gets two things for free that the flat rule pays for
   separately — a missing page simply stops the descent, which *is* the residency clamp, and
-  culling at an interior node discards a whole region rather than one cluster. The parallelism
-  objection is answered by nvpro's persistent-thread and subgroup-ballot scheme (see the
-  vk_lod_clusters comparison, §2.4); and the hierarchy it descends exists at two granularities. Pages
-  form a rooted, acyclic, fully-reachable DAG (§11.3–11.4 of the format), measurably
+  culling at an interior node discards a whole region rather than one cluster. WebGPU guarantees no
+  forward progress across workgroups, so the persistent-thread answer (nvpro, vk_lod_clusters
+  comparison §2.4) is unbounded waiting and is not available; a wave redistributes its own
+  production among its lanes instead, and the descent's depth runs inside one dispatch. The
+  hierarchy it descends exists at two granularities. Pages form a rooted, acyclic,
+  fully-reachable DAG (§11.3–11.4 of the format), measurably
   many-parented on any asset large enough to have more than one page per band, and every
   child-table entry and page header now carries a **traversal metric** so a page can be tested
   *before* it is fetched. Below page granularity, each page carries a tree over its own groups
   (format §6.1–6.2). Cost, measured: 0.3%–1.6% of asset size.
 
-  *What exists.* `playground/vgeo_viewer/select_cut.js` is this rule on the CPU, against a
+  *What exists.* `runtime/cut/__fixtures__/vgeo_select_cut.js` is this rule on the CPU, against a
   partially resident container: descend from the root's parentless groups, refine where
   `project(parent) > τ`, take the cluster where it does not, and stop where the child group is
   not selectable — recording the want that would unblock it. It is the reference the GPU pass
@@ -493,12 +501,11 @@ because activation is safe at every arrival order). RAM eviction is no longer op
    material upstream of the builder), so the mesh-keyed material buckets downstream stay
    unchanged.
 
-   What it reads is the **VG selection buffer** — a VG-owned, densely maintained table of
-   resident clusters (two (sphere, error) pairs, geometry id, own-page and child-page/group
-   indices, child-group selectable bit — the page indices are what touch and want emission
-   stamp), plus per-geometry resident-cluster index tables. The existing metadata buffer is
-   *not* usable for this (freed slices hold garbage, and it carries no error pairs), which is
-   why the selection buffer exists.
+   What it reads is the **page arena** — one fixed-stride slot per resident page, holding that
+   page's header, node rows, group rows and cluster rows — and the per-geometry lookup that
+   resolves a child page index to a slot (RUNTIME_PLAN §3.1). There is no selection buffer and
+   no page table: a page's header is the first words of its own slot, and the two (sphere,
+   error) pairs are in its cluster rows.
 
    Superseded: this step previously specified a **flat** evaluation of the rule over every
    row of that buffer, at a cost of `O(Σ over visible instances of resident(geometry))`. §4
@@ -513,10 +520,16 @@ because activation is safe at every arrival order). RAM eviction is no longer op
    instances enter through their own expansion step. M0 was where that seam was to be fixed
    and it was not (§10); it is the first thing M1 has to do.
 
-Open: shadow views (v1 takes the one cut per view of §4, sharing setup rather than results,
-and a proxy where a view does not justify a cut); DRS τ semantics; the traversal's GPU shape —
-persistent threads over a queue, per nvpro, against what WebGPU without 64-bit atomics actually
-makes affordable.
+The traversal's GPU shape is settled and built: one indirect dispatch per spill generation, the
+descent's depth inside the kernel, work redistributed across a subgroup's lanes by prefix sum. A
+step costs about 0.5 µs whatever the wave holds, so a light asset pays for the shape of its descent
+rather than for its geometry, while a container with real work in the frontier pays mostly for the
+work. How many dispatches a cut needs is a queue-drain quantity rather than depth divided by the
+step count: a wave keeps `subgroup_size` children and spills the rest to the next dispatch.
+CUT_PLAN_2026_09_14 proposes to stop re-walking from the root by keeping the cut between frames.
+
+Open: shadow views (v1 takes the one cut per view of §4, sharing setup rather than results, and a
+proxy where a view does not justify a cut); DRS τ semantics.
 
 Settled since: **flat evaluation versus a hierarchy is no longer a measurement to take.** §4
 pins the traversal, and the hierarchy it descends is already written into every built asset
@@ -618,7 +631,7 @@ is the piece still missing, and M1 is where the work now starts.
   Acceptance: crack-free under τ sweep and flythrough (incl. group-boundary polyline and
   flip validation); drawn-triangle count tracks resolution, not source size; §3 build
   validations green.
-  **Done**: the builder; a CPU cut (`playground/vgeo_viewer/select_cut.js`) that is a traversal
+  **Done**: the builder; a CPU cut (`runtime/cut/__fixtures__/vgeo_select_cut.js`) that is a traversal
   rather than the flat pass planned here, and that runs against a partially resident container,
   which was M2's job; τ-sweep watertightness as a spec (`build/vgeo_cut.spec.js` counts edges
   used by one triangle instead of two, at a spread of thresholds, and wants zero); the