@woosh/meep-engine 3.20.0 → 3.21.0

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

@@ -0,0 +1,271 @@
+import { VGEO_ATTRIBUTE } from "../attribute/VGEO_ATTRIBUTE.js";
+import { VGEO_ATTRIBUTES } from "../attribute/VGEO_ATTRIBUTES.js";
+import { VGEO_CHILD_OFFSET } from "../frame/VGEO_CHILD_OFFSET.js";
+import { VGEO_CHILD_TABLE_ENTRY_SIZE } from "../frame/VGEO_CHILD_TABLE_ENTRY_SIZE.js";
+import { VGEO_CLUSTER_OFFSET } from "../cluster/VGEO_CLUSTER_OFFSET.js";
+import { VGEO_CLUSTER_RECORD_SIZE } from "../cluster/VGEO_CLUSTER_RECORD_SIZE.js";
+import { VGEO_CODEC_LZ4 } from "../frame/VGEO_CODEC_LZ4.js";
+import { VGEO_CODEC_RAW } from "../frame/VGEO_CODEC_RAW.js";
+import { vgeo_decode_frame_blob } from "../frame/vgeo_decode_frame_blob.js";
+import { VGEO_FRAME_HEADER_SIZE } from "../frame/VGEO_FRAME_HEADER_SIZE.js";
+import { VGEO_FRAME_OFFSET } from "../frame/VGEO_FRAME_OFFSET.js";
+import { vgeo_frame_decode_bound } from "../frame/vgeo_frame_decode_bound.js";
+import { VGEO_GROUP_RECORD_SIZE } from "../page/VGEO_GROUP_RECORD_SIZE.js";
+import { VGEO_PAGE_HEADER_SIZE } from "../page/VGEO_PAGE_HEADER_SIZE.js";
+import { VGEO_PAGE_MAGIC } from "../frame/VGEO_PAGE_MAGIC.js";
+import { VGEO_PAGE_OFFSET } from "../page/VGEO_PAGE_OFFSET.js";
+import { vgeo_read_frame_extent } from "../frame/vgeo_read_frame_extent.js";
+import { VGeoPage } from "./VGeoPage.js";
+
+/**
+ * Everything in the container is little-endian (`VGEO_FORMAT.md` §2).
+ * @type {boolean}
+ */
+const LE = true;
+
+/**
+ * The `encoding_flags` bit that says a cluster's normal section holds one constant-compressed word
+ * for the whole cluster instead of one per vertex.
+ * @type {number}
+ */
+const NORMAL_COMPRESSION_FLAG = VGEO_ATTRIBUTES[VGEO_ATTRIBUTE.NORMAL].compression_flag;
+
+/**
+ * Turn one fetched frame into a page.
+ *
+ * This is the unit of incremental reading. It is handed the bytes of exactly one frame — the range a
+ * parent's child table named, or the header's `root_page_fetch_size` — and it needs nothing else:
+ * no whole-file image, no directory, no other page. That is a property of the format rather than of
+ * this function (§5: blobs are independent, no match reaches outside the page), and it is the whole
+ * reason a reader can be partial at all.
+ *
+ * Both refusals below happen before a byte is allocated. The second matters more than it looks:
+ * `decoded_size` is four bytes of untrusted file, and honouring one that no block of that length
+ * could produce turns corruption into an out-of-memory throw rather than a rejected file.
+ *
+ * @param {Uint8Array} frame_bytes the frame's exact range, from its first byte
+ * @param {number} page_index the frame ordinal this range was fetched as — the caller knows it from
+ *     the child-table entry or the directory record that named the range
+ * @returns {VGeoPage}
+ * @throws {Error} when the range is not a frame, uses a codec with no decoder here, or does not
+ *     decode as its own header says
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_read_page(frame_bytes, page_index) {
+    const frame_view = new DataView(
+        frame_bytes.buffer, frame_bytes.byteOffset, frame_bytes.byteLength
+    );
+
+    if (frame_bytes.byteLength < VGEO_FRAME_HEADER_SIZE) {
+        throw new Error(
+            `page ${page_index}: ${frame_bytes.byteLength} bytes is shorter than a frame header`
+        );
+    }
+
+    const magic = frame_view.getUint32(VGEO_FRAME_OFFSET.MAGIC, LE);
+
+    /*
+     A prefix scan must not use the magic as its terminator (§5), but this is not a scan: the range
+     came from a child-table entry or a directory record that claimed a frame lives exactly here. A
+     wrong magic therefore means the pointer was wrong, and saying so is worth far more than
+     decoding whatever the bytes happen to be.
+     */
+    if (magic !== VGEO_PAGE_MAGIC) {
+        throw new Error(
+            `page ${page_index}: the fetched range starts 0x${magic.toString(16)},`
+            + ` not a page frame (0x${VGEO_PAGE_MAGIC.toString(16)})`
+        );
+    }
+
+    // Rebased to the fetched range rather than the file: the offsets on the extent are what the
+    // decoder indexes `frame_bytes` with, and the caller keeps the absolute one.
+    const frame = vgeo_read_frame_extent(frame_view, 0, page_index);
+
+    if (frame.codec !== VGEO_CODEC_RAW && frame.codec !== VGEO_CODEC_LZ4) {
+        throw new Error(
+            `page ${page_index} uses codec ${frame.codec};`
+            + ` this reader decodes ${VGEO_CODEC_RAW} (raw) and ${VGEO_CODEC_LZ4} (lz4)`
+        );
+    }
+
+    if (frame.decoded_size > vgeo_frame_decode_bound(frame.codec, frame.stored_size)) {
+        throw new Error(
+            `page ${page_index} claims ${frame.decoded_size} decoded bytes,`
+            + ` more than codec ${frame.codec} could produce from ${frame.stored_size} stored`
+        );
+    }
+
+    if (frame.extent > frame_bytes.byteLength) {
+        throw new Error(
+            `page ${page_index}: its frame runs to ${frame.extent} bytes`
+            + ` and ${frame_bytes.byteLength} were fetched`
+        );
+    }
+
+    const result = new VGeoPage();
+
+    result.index = page_index;
+    result.codec = frame.codec;
+    result.stored_size = frame.stored_size;
+    result.decoded_size = frame.decoded_size;
+    result.fetch_size = frame.fetch_size;
+
+    const bytes = new Uint8Array(frame.decoded_size);
+
+    vgeo_decode_frame_blob(bytes, 0, frame_bytes, frame);
+
+    result.bytes = bytes;
+    result.data = new DataView(bytes.buffer);
+
+    read_child_table(result, frame_view, frame);
+    read_page_header(result);
+    read_group_table(result);
+    read_cluster_table(result);
+
+    return result;
+}
+
+/**
+ * The child table is plaintext inside the frame, never compressed — which is exactly what lets a
+ * traversal read fetch ranges without decoding anything. So it is read from the frame's own bytes
+ * and not from the decoded page, which does not contain it.
+ *
+ * @param {VGeoPage} page
+ * @param {DataView} frame_view over the fetched frame
+ * @param {VGeoFrameExtent} frame rebased to `frame_view`
+ */
+function read_child_table(page, frame_view, frame) {
+    const count = frame.child_page_count;
+
+    page.child_page_index = new Uint32Array(count);
+    page.child_frame_offset = new Float64Array(count);
+    page.child_fetch_size = new Uint32Array(count);
+    page.child_decoded_size = new Uint32Array(count);
+
+    for (let i = 0; i < count; i++) {
+        const entry = VGEO_FRAME_HEADER_SIZE + i * VGEO_CHILD_TABLE_ENTRY_SIZE;
+
+        page.child_page_index[i] = frame_view.getUint32(entry + VGEO_CHILD_OFFSET.PAGE_INDEX, LE);
+
+        /*
+         A u64 offset into a Float64Array. Every offset the format can express past 2^53 names a
+         file no browser will hold anyway, and a double indexes the ones it can exactly — while
+         BigInt here would put a heap object on the hot path of every child-table read.
+         */
+        page.child_frame_offset[i] =
+            Number(frame_view.getBigUint64(entry + VGEO_CHILD_OFFSET.FRAME_OFFSET, LE));
+
+        page.child_fetch_size[i] = frame_view.getUint32(entry + VGEO_CHILD_OFFSET.FETCH_SIZE, LE);
+        page.child_decoded_size[i] = frame_view.getUint32(entry + VGEO_CHILD_OFFSET.DECODED_SIZE, LE);
+    }
+}
+
+/**
+ * @param {VGeoPage} page
+ */
+function read_page_header(page) {
+    const data = page.data;
+
+    if (page.bytes.byteLength < VGEO_PAGE_HEADER_SIZE) {
+        throw new Error(
+            `page ${page.index}: decoded to ${page.bytes.byteLength} bytes,`
+            + ` shorter than a page header`
+        );
+    }
+
+    page.cluster_count = data.getUint16(VGEO_PAGE_OFFSET.CLUSTER_COUNT, LE);
+    page.min_level = data.getUint8(VGEO_PAGE_OFFSET.MIN_LEVEL);
+    page.max_level = data.getUint8(VGEO_PAGE_OFFSET.MAX_LEVEL);
+    page.node_count = data.getUint16(VGEO_PAGE_OFFSET.NODE_COUNT, LE);
+    page.payload_offset = data.getUint32(VGEO_PAGE_OFFSET.PAYLOAD_OFFSET, LE);
+    page.payload_size = data.getUint32(VGEO_PAGE_OFFSET.PAYLOAD_SIZE, LE);
+}
+
+/**
+ * @param {VGeoPage} page
+ */
+function read_group_table(page) {
+    const data = page.data;
+
+    const count = data.getUint16(VGEO_PAGE_OFFSET.GROUP_COUNT, LE);
+
+    page.group_cluster_first = new Uint16Array(count);
+    page.group_cluster_count = new Uint16Array(count);
+    page.group_parent_count = new Uint16Array(count);
+
+    for (let i = 0; i < count; i++) {
+        const record = VGEO_PAGE_HEADER_SIZE + i * VGEO_GROUP_RECORD_SIZE;
+
+        page.group_cluster_first[i] = data.getUint16(record, LE);
+        page.group_cluster_count[i] = data.getUint16(record + 2, LE);
+        page.group_parent_count[i] = data.getUint16(record + 4, LE);
+    }
+}
+
+/**
+ * @param {VGeoPage} page
+ */
+function read_cluster_table(page) {
+    const data = page.data;
+
+    const count = page.cluster_count;
+
+    const table = data.getUint32(VGEO_PAGE_OFFSET.CLUSTER_TABLE_OFFSET, LE);
+
+    const end = table + count * VGEO_CLUSTER_RECORD_SIZE;
+
+    if (end > page.bytes.byteLength) {
+        throw new Error(
+            `page ${page.index}: its ${count} cluster records end at ${end},`
+            + ` past the ${page.bytes.byteLength} bytes it decoded to`
+        );
+    }
+
+    page.self_sphere = new Float32Array(count * 4);
+    page.bounds_sphere = new Float32Array(count * 4);
+    page.self_error = new Float32Array(count);
+    page.parent_error = new Float32Array(count);
+    page.child_ref = new Uint16Array(count);
+    page.child_group = new Uint16Array(count);
+    page.encoding_flags = new Uint32Array(count);
+    page.cluster_payload_offset = new Uint32Array(count);
+    page.vertex_count = new Uint8Array(count);
+    page.triangle_count = new Uint8Array(count);
+    page.group_of_cluster = new Uint16Array(count);
+
+    for (let i = 0; i < count; i++) {
+        const record = table + i * VGEO_CLUSTER_RECORD_SIZE;
+
+        for (let c = 0; c < 4; c++) {
+            page.self_sphere[i * 4 + c] =
+                data.getFloat32(record + VGEO_CLUSTER_OFFSET.SELF_SPHERE + c * 4, LE);
+            page.bounds_sphere[i * 4 + c] =
+                data.getFloat32(record + VGEO_CLUSTER_OFFSET.BOUNDS_SPHERE + c * 4, LE);
+        }
+
+        page.self_error[i] = data.getFloat32(record + VGEO_CLUSTER_OFFSET.SELF_ERROR, LE);
+        page.parent_error[i] = data.getFloat32(record + VGEO_CLUSTER_OFFSET.PARENT_ERROR, LE);
+        page.child_ref[i] = data.getUint16(record + VGEO_CLUSTER_OFFSET.CHILD_REF, LE);
+        page.child_group[i] = data.getUint16(record + VGEO_CLUSTER_OFFSET.CHILD_GROUP, LE);
+        page.encoding_flags[i] = data.getUint32(record + VGEO_CLUSTER_OFFSET.ENCODING_FLAGS, LE);
+        page.cluster_payload_offset[i] =
+            data.getUint32(record + VGEO_CLUSTER_OFFSET.PAYLOAD_OFFSET, LE);
+        page.vertex_count[i] = data.getUint8(record + VGEO_CLUSTER_OFFSET.VERTEX_COUNT);
+        page.triangle_count[i] = data.getUint8(record + VGEO_CLUSTER_OFFSET.TRIANGLE_COUNT);
+
+        if ((page.encoding_flags[i] & NORMAL_COMPRESSION_FLAG) === 0) {
+            page.per_vertex_normal_cluster_count++;
+        }
+    }
+
+    for (let group = 0; group < page.group_cluster_first.length; group++) {
+        const first = page.group_cluster_first[group];
+        const members = page.group_cluster_count[group];
+
+        for (let i = 0; i < members; i++) {
+            page.group_of_cluster[first + i] = group;
+        }
+    }
+}

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brick4_bake_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH;;YAF4D,WAAW;GA2DtE"}
+{"version":3,"file":"brick4_bake_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,uGAFa,QAAQ;IAAC,IAAI,yBAAyB;IAAC,MAAM,EAAE,WAAW,CAAA;CAAC,CAAC,CA2DxE"}

package/src/shade/renderer/global_illumination/clipmap/GPUClipMap3D.d.ts

@@ -19,7 +19,7 @@ export class GPUClipMap3D {
      *
      * @param {number} v
      */
-    set cascade_resolution(arg: number);
+    set cascade_resolution(v: number);
     /**
      *
      * @return {number}
@@ -29,7 +29,7 @@ export class GPUClipMap3D {
      *
      * @param {number} v
      */
-    set cascade_count(arg: number);
+    set cascade_count(v: number);
     /**
      *
      * @return {number}

package/src/shade/renderer/global_illumination/clipmap/GPUClipMap3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUClipMap3D.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/clipmap/GPUClipMap3D.js"],"names":[],"mappings":"AAMA;IA4DI;;;OAGG;IACH,+BAiCC;IA/DD;;;OAGG;IACH,iCAIC;IAQD;;;OAGG;IACH,+BAIC;IAyCD,eAOC;IAuCD;;;OAGG;IACH,oCAWC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,+BAYC;IAED;;;OAGG;IACH,4BAEC;IAED,gBAGC;;CACJ;kCA3MiC,oCAAoC;+BADvC,gCAAgC"}
+{"version":3,"file":"GPUClipMap3D.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/clipmap/GPUClipMap3D.js"],"names":[],"mappings":"AAMA;IA4DI;;;OAGG;IACH,+BAiCC;IA/DD;;;OAGG;IACH,iCAIC;IAQD;;;OAGG;IACH,+BAIC;IAyCD,eAOC;IAuCD;;;OAGG;IACH,kCAWC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,6BAYC;IAED;;;OAGG;IACH,4BAEC;IAED,gBAGC;;CACJ;kCA3MiC,oCAAoC;+BADvC,gCAAgC"}

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

@@ -12,7 +12,7 @@ export class LightProbeVolume {
      * @returns {TetrahedralMesh}
      */
     get mesh(): TetrahedralMesh;
-    set positions(arg: Float32Array);
+    set positions(data: Float32Array);
     /**
      *
      * @returns {Float32Array}

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

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;;GAEG;AACH;IASI;;;OAGG;IACH,iCAEC;IAKD;;;OAGG;IACH,4BAEC;IAUD,iCAMC;IAdD;;;OAGG;IACH,8BAEC;IAUD;;;OAGG;IACH,0BAEC;IAID;;;OAGG;IACH,sBAEC;IAED,eAEC;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,UAehB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAiBhB;IAuBD,mBAUC;IAED;;;;OAIG;IACH,mBAHW,KAAK,cACL,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAA;KAAC,QAchD;;CACJ;oBAjKY,OAAO,wCAAwC,EAAE,KAAK;gCAJnC,wDAAwD"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;;GAEG;AACH;IASI;;;OAGG;IACH,iCAEC;IAKD;;;OAGG;IACH,4BAEC;IAUD,kCAMC;IAdD;;;OAGG;IACH,8BAEC;IAUD;;;OAGG;IACH,0BAEC;IAID;;;OAGG;IACH,sBAEC;IAED,eAEC;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,UAehB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAiBhB;IAuBD,mBAUC;IAED;;;;OAIG;IACH,mBAHW,KAAK,cACL,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAA;KAAC,QAchD;;CACJ;oBAjKY,OAAO,wCAAwC,EAAE,KAAK;gCAJnC,wDAAwD"}

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.d.ts

@@ -15,7 +15,7 @@ export class GPULightProbeVolumeRenderer {
      *
      * @param {GPUTextureContext} v
      */
-    set environment(arg: GPUTextureContext);
+    set environment(v: GPUTextureContext);
     /**
      *
      * @returns {GPUTextureContext}

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAqBA;IA+GI;;;;OAIG;IACH,qEAMC;IAhCD;;;;OAIG;IACH,+DAcC;IAtFD;;;OAGG;IACH,wCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,4BAahB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAgGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;kCAnYiC,uCAAuC;uCAFlC,8CAA8C"}
+{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAqBA;IA+GI;;;;OAIG;IACH,qEAMC;IAhCD;;;;OAIG;IACH,+DAcC;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,4BAahB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAgGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;kCAnYiC,uCAAuC;uCAFlC,8CAA8C"}

package/src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.d.ts

@@ -8,7 +8,7 @@ export class SpatialHashRadianceCache {
     get buffer_hash_entries(): GPUBuffer;
     get buffer_voxel_data(): GPUBuffer;
     get size(): number;
-    set scene_scale(arg: number);
+    set scene_scale(value: number);
     get scene_scale(): number;
     /**
      *

package/src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialHashRadianceCache.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.js"],"names":[],"mappings":"AAaA;IAkDI;;;;OAIG;IACH,8CAFW,MAAM,EAkBhB;IA1DD,qCAEC;IASD,mCAEC;IAQD,mBAEC;IAQD,6BAIC;IARD,0BAEC;IAiCD;;;;;;;;OAQG;IACH,gHAyGC;IAED,gBAEC;IAED,gBAEC;IAED,cAiBC;IAGD,gBAUC;IAED;;;OAqBC;IAED;;;OAGG;IACH,+BAYC;;CACJ"}
+{"version":3,"file":"SpatialHashRadianceCache.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.js"],"names":[],"mappings":"AAaA;IAkDI;;;;OAIG;IACH,8CAFW,MAAM,EAkBhB;IA1DD,qCAEC;IASD,mCAEC;IAQD,mBAEC;IAQD,+BAIC;IARD,0BAEC;IAiCD;;;;;;;;OAQG;IACH,gHAyGC;IAED,gBAEC;IAED,gBAEC;IAED,cAiBC;IAGD,gBAUC;IAED;;;OAqBC;IAED;;;OAGG;IACH,+BAYC;;CACJ"}

package/src/shade/renderer/gpu_primitive/bvh/check_bvh_structure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check_bvh_structure.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/check_bvh_structure.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;GAYG;AACH,qCAHW,WAAW,GAAC,MAAM,EAAE;WACV,WAAW;YAAU,YAAY;EASrD;AAED;;;;;;;GAOG;AACH,qCALW,WAAW,UACX,YAAY,QACZ,MAAM,GACJ;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAC,CAY7E;AAED;;;;;;GAMG;AACH,kCAJW,MAAM,EAAE,QACR,MAAM,EAAE,GACN,MAAM,CAQlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,0CALW,WAAW,GAAC,MAAM,EAAE,cACpB,MAAM,qBACN,MAAM,EAAE,GAAC,WAAW;cACP,MAAM,EAAE;cAAY,MAAM,EAAE;qBAAmB,MAAM,EAAE;eAAa,MAAM;SAAO,MAAM;0BAAwB,IAAI,MAAM,EAAE,MAAM,CAAC;WAAS,WAAW;YAAU,YAAY;EA2HnM;AAED;;;;;GAKG;AACH,wDAHW,MAAM,EAAE,GACN,MAAM,CAOlB;AAhOD;;GAEG;AACH,4BAFU,MAAM,CAEwB;AAExC;;;;;;;;GAQG;AACH,mCAFU,MAAM,CAEuB"}
+{"version":3,"file":"check_bvh_structure.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/check_bvh_structure.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;GAYG;AACH,qCAHW,WAAW,GAAC,MAAM,EAAE,GAClB;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAC,CAStD;AAED;;;;;;;GAOG;AACH,qCALW,WAAW,UACX,YAAY,QACZ,MAAM,GACJ;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAC,CAY7E;AAED;;;;;;GAMG;AACH,kCAJW,MAAM,EAAE,QACR,MAAM,EAAE,GACN,MAAM,CAQlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,0CALW,WAAW,GAAC,MAAM,EAAE,cACpB,MAAM,qBACN,MAAM,EAAE,GAAC,WAAW,GAClB;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,IAAI,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAC,CA2HpM;AAED;;;;;GAKG;AACH,wDAHW,MAAM,EAAE,GACN,MAAM,CAOlB;AAhOD;;GAEG;AACH,4BAFU,MAAM,CAEwB;AAExC;;;;;;;;GAQG;AACH,mCAFU,MAAM,CAEuB"}

package/src/shade/renderer/light/LightCollection.d.ts

@@ -8,7 +8,7 @@ export class LightCollection {
      * Must be an octahedral-encoded spherical texture
      * @param {ShadeTexture} v
      */
-    set environment(arg: ShadeTexture);
+    set environment(v: ShadeTexture);
     /**
      *
      * @returns {ShadeTexture}
@@ -23,7 +23,7 @@ export class LightCollection {
      *
      * @param {boolean} v
      */
-    set needsUpdate(arg: boolean);
+    set needsUpdate(v: boolean);
     /**
      *
      * @param {Light} light

package/src/shade/renderer/light/LightCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/LightCollection.js"],"names":[],"mappings":"AAGA;IAQI;;;OAGG;IACH,wBAEC;IAgBD;;;OAGG;IACH,mCAMC;IAlBD;;;OAGG;IACH,gCAEC;IAiBD;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,8BAIC;IAED;;;OAGG;IACH,wBAIC;IAED;;;;;OAKG;IACH,sBAFa,OAAO,CAUnB;;CACJ"}
+{"version":3,"file":"LightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/LightCollection.js"],"names":[],"mappings":"AAGA;IAQI;;;OAGG;IACH,wBAEC;IAgBD;;;OAGG;IACH,iCAMC;IAlBD;;;OAGG;IACH,gCAEC;IAiBD;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,4BAIC;IAED;;;OAGG;IACH,wBAIC;IAED;;;;;OAKG;IACH,sBAFa,OAAO,CAUnB;;CACJ"}

package/src/shade/renderer/light/model/PointLight.d.ts

@@ -1,6 +1,6 @@
 export class PointLight extends Light {
     distance: number;
-    set intensity_lumens(arg: number);
+    set intensity_lumens(value: number);
     /**
      * Luminous power (Φ) in lumens. View of `intensity` (in cd) using the
      * isotropic point-source conversion `cd = lm / (4π)`.

package/src/shade/renderer/light/model/PointLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PointLight.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/model/PointLight.js"],"names":[],"mappings":"AAEA;IAII,iBAAa;IAgBb,kCAEC;IAZD;;;;;OAKG;IACH,+BAEC;IAOL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;CANhC;sBAzBqB,YAAY"}
+{"version":3,"file":"PointLight.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/model/PointLight.js"],"names":[],"mappings":"AAEA;IAII,iBAAa;IAgBb,oCAEC;IAZD;;;;;OAKG;IACH,+BAEC;IAOL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;CANhC;sBAzBqB,YAAY"}

package/src/shade/renderer/light/model/SpotLight.d.ts

@@ -14,7 +14,7 @@ export class SpotLight extends Light {
      * @type {number}
      */
     penumbra: number;
-    set intensity_lumens(arg: number);
+    set intensity_lumens(value: number);
     /**
      * Luminous power (Φ) in lumens. View of `intensity` (in cd) using the
      * cone-solid-angle conversion `cd = lm / (2π(1 − cos θ))`, where θ is the

package/src/shade/renderer/light/model/SpotLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpotLight.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/model/SpotLight.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,UAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,OAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAyBb,kCAGC;IApBD;;;;;;;;;;;OAWG;IACH,+BAGC;IAQL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;sBAhDqB,YAAY"}
+{"version":3,"file":"SpotLight.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/model/SpotLight.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,UAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,OAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAyBb,oCAGC;IApBD;;;;;;;;;;;OAWG;IACH,+BAGC;IAQL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;sBAhDqB,YAAY"}

package/src/shade/renderer/loader/gltf/fix_up_material_sides.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fix_up_material_sides.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/fix_up_material_sides.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,8CAHW,MAAM;yBACiB,MAAM;sBAAoB,MAAM;EAoGjE"}
+{"version":3,"file":"fix_up_material_sides.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/fix_up_material_sides.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,8CAHW,MAAM,GACJ;IAAC,mBAAmB,EAAC,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CAoGlE"}

package/src/shade/renderer/loader/gltf/gltf_create_material.d.ts

@@ -5,7 +5,7 @@
  * @returns {StandardShadeMaterial}
  */
 export function gltf_create_material(gltf_material: {
-    pbrMetallicRoughness?: any;
+    pbrMetallicRoughness?;
     normalTexture?: number;
     doubleSided?: boolean;
 }, textures: ShadeTexture[]): StandardShadeMaterial;

package/src/shade/renderer/loader/gltf/gltf_create_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf_create_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_create_material.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH;;oBAJiD,MAAM;kBAAc,OAAO;aACjE,cAAc,GACZ,qBAAqB,CAoQjC;sCAnRqC,yCAAyC"}
+{"version":3,"file":"gltf_create_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_create_material.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,oDAJW;IAAC,oBAAoB,CAAC,CAAC;IAAA,aAAa,CAAC,EAAC,MAAM,CAAC;IAAA,WAAW,CAAC,EAAC,OAAO,CAAA;CAAC,YAClE,cAAc,GACZ,qBAAqB,CAoQjC;sCAnRqC,yCAAyC"}

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -65,8 +65,8 @@ export class TinyGltf {
      * @return {Promise<{asset}|*>}
      */
     loadFromJson(json: {
-        bufferViews: any;
-        asset: any;
+        bufferViews;
+        asset;
         accessors: [];
         nodes: [];
         samplers?: [];

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tiny-gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/tiny-gltf.js"],"names":[],"mappings":"AA4UA;IAoEI;;;;;;;;;;;;;OAaG;IACH,+CAFU,aAAa,CAEgC;IA3BvD;;;;OAIG;IACH,qFAFW,qBAAqB,EAQ/B;IAjED,oBAA2B;IAE3B;;;;;;;;OAQG;IACH,iDAAmD;IAEnD;;;;;;;;;OASG;IACH,SAFU,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC,GAAC,SAAS,CAElC;IAqKpB;;;OAGG;IACH,iBAHW,MAAM,GACJ,QAAQ,QAAQ,CAAC,CAgB7B;IAED;;;;;;OAMG;IACH,4BAJW,WAAW,WACX,MAAM,GACL,QAAQ;QAAC,KAAK,CAAA;KAAC,MAAE,CAAC,CAM7B;IAED;;;;;;OAMG;IACH;;;mBALwC,EAAE;eAAO,EAAE;mBAAW,EAAE;iBAAS,EAAE;mBAAW,EAAE;kBAAW,EAAE;gBAAS,EAAE;gBAAQ,EAAE;gBAC/G,MAAM,gBACN,UAAU,GACT,QAAQ;QAAC,KAAK,CAAA;KAAC,MAAE,CAAC,CAuR7B;;CAGJ;8BA5yB6B,qDAAqD"}
+{"version":3,"file":"tiny-gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/tiny-gltf.js"],"names":[],"mappings":"AA4UA;IAoEI;;;;;;;;;;;;;OAaG;IACH,+CAFU,aAAa,CAEgC;IA3BvD;;;;OAIG;IACH,qFAFW,qBAAqB,EAQ/B;IAjED,oBAA2B;IAE3B;;;;;;;;OAQG;IACH,iDAAmD;IAEnD;;;;;;;;;OASG;IACH,SAFU,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC,GAAC,SAAS,CAElC;IAqKpB;;;OAGG;IACH,iBAHW,MAAM,GACJ,QAAQ,QAAQ,CAAC,CAgB7B;IAED;;;;;;OAMG;IACH,4BAJW,WAAW,WACX,MAAM,GACL,QAAQ;QAAC,KAAK,CAAA;KAAC,MAAE,CAAC,CAM7B;IAED;;;;;;OAMG;IACH,mBALW;QAAC,WAAW,CAAC;QAAA,KAAK,CAAC;QAAA,SAAS,EAAC,EAAE,CAAC;QAAA,KAAK,EAAC,EAAE,CAAC;QAAA,QAAQ,CAAC,EAAC,EAAE,CAAC;QAAA,OAAO,EAAC,EAAE,CAAC;QAAA,SAAS,EAAC,EAAE,CAAC;QAAC,QAAQ,EAAC,EAAE,CAAC;QAAC,MAAM,EAAC,EAAE,CAAC;QAAA,MAAM,EAAC,EAAE,CAAA;KAAC,WAChH,MAAM,gBACN,UAAU,GACT,QAAQ;QAAC,KAAK,CAAA;KAAC,MAAE,CAAC,CAuR7B;;CAGJ;8BA5yB6B,qDAAqD"}

package/src/shade/renderer/loader/usd/usd_decode_image.d.ts

@@ -7,7 +7,7 @@
 export function decode_data_url(url: string): {
     mimeType: string;
     data: Uint8Array;
-};
+} | null;
 /**
  * Decode a PNG to 8-bit RGBA pixels.
  *

package/src/shade/renderer/loader/usd/usd_decode_image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usd_decode_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_decode_image.js"],"names":[],"mappings":"AA4BA;;;;;GAKG;AACH,qCAHW,MAAM;cACQ,MAAM;UAAQ,UAAU;EAgChD;AAGD;;;;;;;;;GASG;AACH,sCAHW,UAAU,GAAC,WAAW;WACH,MAAM;YAAU,MAAM;cAAY,MAAM;YAAU,UAAU;GA0DzF;AAGD;;;;;GAKG;AACH,2DAHW;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GACrE,YAAY,CAexB;6BAnI4B,+BAA+B"}
+{"version":3,"file":"usd_decode_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_decode_image.js"],"names":[],"mappings":"AA4BA;;;;;GAKG;AACH,qCAHW,MAAM,GACJ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,IAAI,CAgCzD;AAGD;;;;;;;;;GASG;AACH,sCAHW,UAAU,GAAC,WAAW,GACpB,QAAQ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC,CA0D5F;AAGD;;;;;GAKG;AACH,2DAHW;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GACrE,YAAY,CAexB;6BAnI4B,+BAA+B"}

package/src/shade/renderer/material/util/material_convert_metallic_roughness_to_specular_glossiness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material_convert_metallic_roughness_to_specular_glossiness.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/util/material_convert_metallic_roughness_to_specular_glossiness.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,uFALW,KAAK,YACL,MAAM,aACN,MAAM;cACM,KAAK;aAAU,KAAK;gBAAc,MAAM;EA4B9D;sBAtCqB,iCAAiC"}
+{"version":3,"file":"material_convert_metallic_roughness_to_specular_glossiness.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/util/material_convert_metallic_roughness_to_specular_glossiness.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,uFALW,KAAK,YACL,MAAM,aACN,MAAM,GACJ;IAAC,QAAQ,EAAC,KAAK,CAAC;IAAC,OAAO,EAAC,KAAK,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4B/D;sBAtCqB,iCAAiC"}

package/src/shade/renderer/material/util/material_convert_specular_glossiness_to_metallic_roughness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material_convert_specular_glossiness_to_metallic_roughness.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/util/material_convert_specular_glossiness_to_metallic_roughness.js"],"names":[],"mappings":"AAiDA;;;;;;GAMG;AACH,oFALW,KAAK,YACL,KAAK,cACL,MAAM;eACO,MAAM;gBAAc,KAAK;cAAY,MAAM;EAmClE;sBAzFqB,iCAAiC"}
+{"version":3,"file":"material_convert_specular_glossiness_to_metallic_roughness.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/util/material_convert_specular_glossiness_to_metallic_roughness.js"],"names":[],"mappings":"AAiDA;;;;;;GAMG;AACH,oFALW,KAAK,YACL,KAAK,cACL,MAAM,GACL;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAmCnE;sBAzFqB,iCAAiC"}

package/src/shade/renderer/particles/DESIGN.md

@@ -311,11 +311,15 @@ or simulation, the previous compact alive list is bucketed again and its padded
 are rebuilt. This prevents a previously shared wave from executing one emitter's newly edited program
 over another emitter's particles. Ordinary frames keep the existing end-of-frame bucketing only;
 content-identical replacements need no repair. Both bucket runs on an edit frame reuse the latest
-graph handles for their scratch buffers, so each persistent buffer is imported once.
+graph handles for their scratch, so it is created once and both runs share one dependency chain.
 
-The coherence list is persistent GPU state, including its padding. Growing the bucket capacity copies
-it to the replacement buffer before destroying the old one. The old count and indirect dispatch
-remain valid across growth; only the per-frame histogram/cursor/key scratch may be discarded.
+The coherence list is persistent GPU state, including its padding — the one thing the bucketing
+leaves behind. Growing the bucket capacity copies it to the replacement buffer before destroying the
+old one; the old count and indirect dispatch remain valid across growth. The histogram, cursors, keys
+and dispatch args beside it live and die inside one frame graph, so the passes that write them
+declare them (a `BufferResourceDescriptor` in place of a handle) and the graph allocates and releases
+them around their users. None asks for a clear: the reset pass already covers every word it will
+read, and `keys` is written by the same indirect dispatch that reads it.
 
 Every row of a frame is staged through one module-static record (`EmitterRegistry`), so a flush
 allocates nothing however many rows it restages.
@@ -493,6 +497,9 @@ camera uniform's view matrix, `graph_prefix_scan_csdldf` the bin counts to offse
 payload). The sorted index list feeds the instanced draw. Both per-particle passes are bounded by
 the alive counter and dispatched by the args the bucket reset wrote from it.
 
+Every buffer the sort touches is the graph's, made at the pass that writes it and released after the
+draw, so a system drawn through AVBOIT — which records none of these passes — allocates none of it.
+
 Reordering the render list for program coherence would break transparency; depth-sorting the
 simulation list would destroy the coherence. They share no buffer and no counter slot —
 `PARTICLE_COUNTER.SORTED` belongs to the render order, `SIM_PADDED` to the simulation order.
@@ -627,9 +634,13 @@ through `GPUTextureContext`.
 
 ### Ownership: `GPUParticleSystem`
 
-Constructed once against a `GPUSceneContext`, in the mould of `ReSTIRDI`. It owns every persistent
-buffer — pool, alive lists, dead list, counters, both indirect-args buffers, the coherence and sort
-scratch, the emitter database (both tables), the packed program buffer, the spawn-command ring — and grows the ones that depend on the emitter set inside `execute`. The
+Constructed once against a `GPUSceneContext`, in the mould of `ReSTIRDI`. It owns persistent buffers
+and only those — a buffer is reserved here if and only if its contents cross the frame boundary:
+pool, alive lists, dead list, counters, the coherence list, simulate's indirect dispatch args, the
+emitter database (both tables), the packed program buffer, the spawn-command ring and the warm-up
+queue — and grows the ones that depend on the emitter set inside `execute`. Everything else a frame
+touches is the frame graph's, declared by the pass that first writes it: the bucketing scratch, the
+whole depth sort, the draw args, the spawn counts and the wide register file. The
 default atlas is a 1x1 white texel. `execute({graph, camera, scene_database, color, depth, dt})`
 sweeps the scene, pushes what changed (on a command context opened only when something needs
 one), and records the whole frame through `graph_particles`, returning the colour handle after

package/src/shade/renderer/particles/GPUParticleSystem.d.ts

@@ -5,15 +5,24 @@
  *
  * ## What it owns
  *
- * Every piece of persistent GPU state: the particle pool, the ping-pong alive lists, the dead
- * free-list, the counters, both indirect-args buffers, the simulation-order (coherence) scratch,
- * the emitter database (the emitter table and the GPU-owned state table, one buffer), the packed
- * program buffer, and the spawn-command ring. Buffers that depend on the emitter set — the
- * coherence scratch on the number of distinct programs, the program buffer on the heap, the
+ * Persistent GPU state, and only that: a buffer is reserved here if and only if its contents have
+ * to survive to the next frame. That is the particle pool, the ping-pong alive lists, the dead
+ * free-list, the counters, the simulation-order (coherence) list, simulate's indirect dispatch args
+ * (written at the end of one frame, read by the next), the emitter database (the emitter table and
+ * the GPU-owned state table, one buffer), the packed program buffer, and the two CPU-uploaded
+ * queues — the spawn-command ring and the warm-up queue. Buffers that depend on the emitter set —
+ * the coherence list on the number of distinct programs, the program buffer on the heap, the
  * database on its own pages, the counters on the emitter table's element capacity (they carry the
- * per-emitter bounds accumulator, see `bounds/`) — are grown inside
- * {@link execute}, the way ReSTIR's reservoirs follow the resolution. The render-order (sort)
- * scratch is not in that list because it is not unconditional: see below.
+ * per-emitter bounds accumulator, see `bounds/`) — are grown inside {@link execute}, the way
+ * ReSTIR's reservoirs follow the resolution.
+ *
+ * Everything else a frame touches is the frame graph's. The bucketing's bins, cursors and keys, the
+ * whole depth sort, the draw args, the spawn counts and the VM's wide register file are produced
+ * and consumed inside one graph, so the pass that first writes each one declares it and the graph
+ * allocates it just in time and releases it after its last reader — into the pool the rest of the
+ * renderer allocates from. Reserving them here instead would be six megabytes at the default
+ * capacity that no other feature could ever borrow, and four of them are cleared by a reset pass
+ * every frame regardless.
  *
  * Every pass stays within the eight storage buffers a stage gets by default: the emitter record
  * and the GPU-owned state are two tables of one database buffer, and the VM's constants and code
@@ -61,7 +70,8 @@
  * ({@link avboit_occupancy}, {@link avboit_splat}, {@link avboit_draw}). Those read the same handles
  * and composite into a volume and a set of accumulators that are sums, so an ordering would buy
  * nothing — and the sort is four passes and a scan over every live particle, plus two lists a word
- * per particle each, which is why the mode also decides whether those buffers exist at all.
+ * per particle each. Under `AVBOIT` none of those passes is recorded, so the graph never allocates
+ * their buffers either.
  *
  * ## Allocation
  *
@@ -310,7 +320,11 @@ export class GPUParticleSystem {
      */
     sync_membership(): void;
     /**
-     * Sizes of the persistent buffers, in bytes, as they stand. Exposed for tests.
+     * Sizes of the persistent buffers, in bytes, as they stand — one entry per distinct buffer, so
+     * this is the feature's reserved footprint and not a list of the names it binds them under.
+     * `alive_read` and `alive_write` are the two `alive` entries under the frame's names for them,
+     * and would otherwise be counted a second time each. Exposed for tests.
+     *
      * @returns {Object<string, number>}
      */
     bufferSizes(): {

package/src/shade/renderer/particles/GPUParticleSystem.d.ts.map

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