@woosh/meep-engine 3.19.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/StandardShadeMaterial.js

@@ -1,8 +1,8 @@
 import { combine_hash } from "../../../core/collection/array/combine_hash.js";
 import { Color } from "../../../core/color/Color.js";
 import LinearModifier from "../../../core/model/stat/LinearModifier.js";
-import { optional_equality } from "../../descriptor/util/optional_equality.js";
-import { optional_hash } from "../../descriptor/util/optional_hash.js";
+import { optional_equality } from "../../../core/model/object/optional_equality.js";
+import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { ShadeMaterial } from "./ShadeMaterial.js";
 
 export class StandardShadeMaterial extends ShadeMaterial {

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

@@ -22,7 +22,7 @@ the decision to spawn is the GPU's.
 - Distinct per-particle lifecycle: **no** built-in age/position — the schema + program define state.
 - Billboard renderer reuses engine shader chunks incl. lighting (forward-shaded, optional per emitter).
 - Blend modes (alpha + additive) via a **single** premultiplied blend setup.
-- `AnimationCurve` sampling during simulation (reuse `chunk_animation_curve_evaluate`).
+- Authored curves and RGB/RGBA gradients compiled into arithmetic for simulation.
 - Spawning decided on the GPU, per emitter, with the CPU able to ask for bursts through the same path.
 - No per-frame allocation on the CPU beyond the frame graph's own records.
 
@@ -159,7 +159,7 @@ recursion, no data-dependent jumps — conditionals are predicated via CMP/SELEC
   Word 0 packs the opcode (bits 0..7), the lane count (8..10), each source's `VM_KIND` (two bits per
   slot at 16..21) and the destination slot (24..31). A source word means what its kind says: `REG`
   is a base slot plus a swizzle, `IMM` is an `f32` bit pattern read in every lane, and `NONE` is a
-  raw field the opcode reads for itself (attribute word-offset+comp / curve handle / builtin id /
+  raw field the opcode reads for itself (attribute word-offset+comp / builtin id /
   pool index).
 - Constant pool: `array<vec4f>` per program, referenced by `LOAD_CONST`.
 - Two entry sections per program: **INIT** and **UPDATE** (offsets in the emitter record). INIT
@@ -167,8 +167,6 @@ recursion, no data-dependent jumps — conditionals are predicated via CMP/SELEC
 - Builtins (`LOAD_BUILTIN`): DT, EMITTER_AGE, EMITTER_POSITION, EMITTER_DIRECTION, EMITTER_UP,
   PARTICLE_INDEX, SPAWN_FRACTION, TIME … assembled per-invocation by the host shader. The emitter's
   position and axes are its node's `global` out of the scene database.
-- `CURVE dst, handle, s0`: `dst.x = animation_curve_evaluate(curves[handle], s0.x)` — reuses the
-  engine's GPU AnimationCurve chunk + database.
 
 #### Two interpreters
 
@@ -212,11 +210,13 @@ A core `NodeGraph` holds particle nodes (ports + parameters) for INIT and UPDATE
 2. lowers each node to VM ops (nodes emit via a small builder that allocates result registers),
 3. linear-scan register allocation with liveness,
 4. interns constants into the pool,
-5. resolves curve/attribute references,
-6. emits `Program { init, update, constants, reg_count, attributes, curves }`.
+5. resolves attribute references,
+6. emits `Program { init, update, constants, reg_count, attributes }`.
 
 Standard node library: constants, attribute get/set, arithmetic/vector/math, random (uniform/sphere/
-disk/cone), curve-sample, noise (curl), integrate, gravity, emit-shapes, compare/select, kill-if.
+disk/cone), authored curves and RGB/RGBA gradients, noise (curl), integrate, gravity, emit-shapes,
+compare/select, kill-if. Curves and gradients expand into graph nodes that emit ordinary VM
+arithmetic; no animation-table binding or sampling opcode is needed.
 
 ### Emitters are scene nodes
 
@@ -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
@@ -684,7 +695,6 @@ src/shade/renderer/particles/
   warmup/chunk_particle_warmup_step.js       one particle's advance: per-lane decode, jittered tick
   warmup/shader_particle_warmup_advance.js   the advance over the fast file (+ _wide.js)
   warmup/graph_particle_warmup.js            the loop, recorded on a frame that registered a pre-warm
-  shaders/chunk_particle_curve_disabled.js   the no-curves-bound CURVE provider
   shaders/chunk_particle_billboard_vertex.js the billboard vertex stage, shared by every draw
   shaders/shader_particle_avboit_*.js        occupancy / splat / draw through AVBOIT
   bounds/*                           the measured emitter box: accumulate, publish
@@ -743,6 +753,5 @@ was seeded.
 Done: `Renderer.feature_particles_enabled` (off by default), `Renderer.particles(scene_ctx)` creating
 one system per scene context on first use, `simulate` recorded before the transparency pass and the
 system passed to the AVBOIT orchestrator as its side channel. Remaining:
-1. For lit emitters, compile a simulate/render variant that swaps the disabled curve/lighting hooks
-   for `chunk_particle_curve_animation` (+ bind `GPUAnimationManager.database.buffer`) and a
-   shading-chunk-backed lighting hook (+ the `SHADING_LIGHT_RESOURCE_GROUP`).
+1. For lit emitters, compile a render variant that swaps the disabled lighting hook for a
+   shading-chunk-backed lighting hook (+ the `SHADING_LIGHT_RESOURCE_GROUP`).