@woosh/meep-engine 3.20.0 → 3.22.0

package/src/shade/renderer/particles/graph/particle_group_json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_group_json.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_json.js"],"names":[],"mappings":"AA+CA;;;;;;;;;GASG;AAEH;;;GAGG;AACH,gDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,iBAAiB,CAmC7B;AAED;;;;;;;;;;GAUG;AACH;IAPqC,IAAI,EAA9B,iBAAiB;IACsB,cAAc;IAES,OAAO,UAA5D,MAAM,KAAE,CAAC,0BAAwB,SAAS,CAAC;IAElD,OAAO,wBAAwB,EAAE,iBAAiB,CAiD9D;AAED;;;;;;;GAOG;AACH,mDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,8BAA8B,EAAE,uBAAuB,EAAE,CAI5E;AA9JD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAEwC;AAExD;;GAEG;AACH,yCAFU,MAAM,CAE0C;;UAS5C,MAAM;WACN,MAAM;UACN,MAAM;UACN,MAAM;YACN,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;aACxC,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;UACxC,OAAO,0BAA0B,EAAE,iBAAiB"}
+{"version":3,"file":"particle_group_json.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_json.js"],"names":[],"mappings":"AA+CA;;;;;;;;;GASG;AAEH;;;GAGG;AACH,gDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,iBAAiB,CAmC7B;AAED;;;;;;;;;;GAUG;AACH;IAPqC,IAAI,EAA9B,iBAAiB;IACsB,cAAc;IAES,OAAO,UAA5D,MAAM,KAAE,CAAC,0BAAwB,SAAS,CAAC;IAElD,OAAO,wBAAwB,EAAE,iBAAiB,CAiD9D;AAED;;;;;;;GAOG;AACH,mDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,8BAA8B,EAAE,uBAAuB,EAAE,CAI5E;AA9JD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAEwC;AAExD;;GAEG;AACH,yCAFU,MAAM,CAE0C;;UAS5C,MAAM;WACN,MAAM;UACN,MAAM;UACN,MAAM;YACN,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;aACxC,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;UACxC,OAAO,0BAA0B,EAAE,iBAAiB"}

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

@@ -9,11 +9,9 @@
  *   -> bucket -> bounds -> build indirect
  *
  * and it leaves the frame's alive list, the pool and the indirect draw args as graph handles for
- * whoever draws. Nothing here depends on how they will be drawn, which is why the render mode
- * ({@link ParticleRenderMode}) selects only what `execute` records AFTER this: the depth sort and
- * the billboard draw (`sort/graph_particle_sort.js`, `graph_particles_billboard.js`), or nothing at
- * all, because the AVBOIT orchestrator will draw them later off these same handles
- * (`graph_particles_avboit.js`).
+ * the draw. That draw is not here and is not recorded by `execute` either: the AVBOIT transparency
+ * orchestrator makes it later in the frame, off these same handles, through the side channels in
+ * `graph_particles_avboit.js`.
  *
  * ## Spawning is decided here, on the GPU
  *
@@ -33,42 +31,50 @@
  * into emit and simulate would union this frame's newborns with last frame's survivors, and would
  * pay six atomics per particle inside the pass whose register pressure sets the system's occupancy.
  *
- * ## Two orderings, kept apart
+ * ## Two lists, kept apart
  *
  * Simulate does NOT read the alive list. It reads `sim_list`, the program-coherent indirection list
  * the bucketing pass (`coherence/`) built from last frame's alive list: the same pool slots
- * regrouped so each wave runs one VM program, with every run padded out to a whole workgroup. That
- * ordering is camera-independent and changes only when emitters or their programs change.
+ * regrouped so each wave runs one VM program, with every run padded out to a whole workgroup. Its
+ * arrangement changes only when emitters or their programs do.
  *
- * The RENDER ordering — back-to-front by view depth, from `sort/` — is a different list in a
- * different buffer, produced by different passes, and the standalone billboard draw is the only
- * thing that consumes it, so it is built only in that mode. Reordering the render list for
- * coherence would break premultiplied transparency; depth-sorting the simulation list would destroy
- * the coherence. They share no buffer and no counter slot.
+ * The alive list is the other one, and it is the draw's: compacted, unpadded, one entry per live
+ * particle. Drawing the padded coherence list instead would draw its sentinels. Neither list is
+ * ordered by view depth and neither needs to be — the AVBOIT volume and its accumulators are sums,
+ * so no arrangement of the draw changes a pixel.
  *
  * ## Nothing is sized from the CPU
  *
  * Simulate's workgroup count comes from `dispatch_args` (written by LAST frame's build-indirect
  * pass) via `dispatchWorkgroupsIndirect`, and its element bound from the `ALIVE_IN` counter
- * snapshot; the draw, and the sort's two per-particle passes when there is a sort, are sized the
- * same way, from this frame's alive count. A CPU count is inevitably stale and corrupts the pool
- * (orphaned slots when the population grows, double-freed slots when it shrinks).
+ * snapshot; the draw is sized the same way, from this frame's alive count. A CPU count is inevitably
+ * stale and corrupts the pool (orphaned slots when the population grows, double-freed slots when it
+ * shrinks).
  *
  * All persistent buffers are imported (owned by the feature, not the graph). Writing an imported
  * buffer marks the pass a side-effect so it always executes, and returns a renamed handle downstream
  * passes must read — exactly the ReSTIR reservoir pattern. Every persistent buffer is imported
  * exactly once: two imports of one buffer are two resource entries the graph cannot tell apart.
  *
+ * ## What is imported, and what the graph owns
+ *
+ * A buffer is imported only if its contents cross the frame boundary: the pool, the free list, the
+ * counters, the alive lists, `sim_list` (written here, read by next frame's simulate),
+ * `dispatch_args` (the same), the program blob and the two CPU-uploaded queues. Everything else is
+ * produced and consumed inside one graph, so the pass that first writes it declares it with a
+ * {@link BufferResourceDescriptor} in place of a handle and the graph allocates it just in time and
+ * releases it after its last reader — into the pool every other feature draws from. That is the
+ * spawn counts and the emit command, the VM's wide register file, the draw args and the bucketing
+ * scratch (`coherence/`).
+ *
  * On the very first frame `dispatch_args` must be zero-initialised (WebGPU zero-fills new buffers)
  * and the `ALIVE_IN` counter 0, so simulate is a no-op until the first build-indirect has run.
  */
 /**
  * @typedef {object} ParticleSimulationHandles
  * @property {number} pool the particle pool, after this frame's INIT and UPDATE
- * @property {number} alive this frame's compacted alive list — the render order's input
- * @property {number} counters the atomic counters, after build-indirect
- * @property {number} draw_args the billboard draw's indirect args: six vertices, one instance per live particle
- * @property {number} sim_dispatch_args one workgroup per live particle, for a per-particle pass
+ * @property {number} alive this frame's compacted alive list — what the draw walks
+ * @property {number} draw_args the draw's indirect args: six vertices, one instance per live particle
  * @property {number} emitter_database the emitter database, after the bounds pass published the
  *   measured box into each emitter's state row
  */
@@ -135,21 +141,13 @@ export type ParticleSimulationHandles = {
      */
     pool: number;
     /**
-     * this frame's compacted alive list — the render order's input
+     * this frame's compacted alive list — what the draw walks
      */
     alive: number;
     /**
-     * the atomic counters, after build-indirect
-     */
-    counters: number;
-    /**
-     * the billboard draw's indirect args: six vertices, one instance per live particle
+     * the draw's indirect args: six vertices, one instance per live particle
      */
     draw_args: number;
-    /**
-     * one workgroup per live particle, for a per-particle pass
-     */
-    sim_dispatch_args: number;
     /**
      * the emitter database, after the bounds pass published the
      * measured box into each emitter's state row

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

@@ -1 +1 @@
-{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA7BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IACS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CAuTrC;;;;;UA/Va,MAAM;;;;WACN,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;uBACN,MAAM;;;;;sBACN,MAAM"}
+{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA7BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IACS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CA4TrC;;;;;UAlWa,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;;sBACN,MAAM"}

package/src/shade/renderer/particles/graph_particles.js

@@ -48,11 +48,9 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
  *   -> bucket -> bounds -> build indirect
  *
  * and it leaves the frame's alive list, the pool and the indirect draw args as graph handles for
- * whoever draws. Nothing here depends on how they will be drawn, which is why the render mode
- * ({@link ParticleRenderMode}) selects only what `execute` records AFTER this: the depth sort and
- * the billboard draw (`sort/graph_particle_sort.js`, `graph_particles_billboard.js`), or nothing at
- * all, because the AVBOIT orchestrator will draw them later off these same handles
- * (`graph_particles_avboit.js`).
+ * the draw. That draw is not here and is not recorded by `execute` either: the AVBOIT transparency
+ * orchestrator makes it later in the frame, off these same handles, through the side channels in
+ * `graph_particles_avboit.js`.
  *
  * ## Spawning is decided here, on the GPU
  *
@@ -72,32 +70,42 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
  * into emit and simulate would union this frame's newborns with last frame's survivors, and would
  * pay six atomics per particle inside the pass whose register pressure sets the system's occupancy.
  *
- * ## Two orderings, kept apart
+ * ## Two lists, kept apart
  *
  * Simulate does NOT read the alive list. It reads `sim_list`, the program-coherent indirection list
  * the bucketing pass (`coherence/`) built from last frame's alive list: the same pool slots
- * regrouped so each wave runs one VM program, with every run padded out to a whole workgroup. That
- * ordering is camera-independent and changes only when emitters or their programs change.
+ * regrouped so each wave runs one VM program, with every run padded out to a whole workgroup. Its
+ * arrangement changes only when emitters or their programs do.
  *
- * The RENDER ordering — back-to-front by view depth, from `sort/` — is a different list in a
- * different buffer, produced by different passes, and the standalone billboard draw is the only
- * thing that consumes it, so it is built only in that mode. Reordering the render list for
- * coherence would break premultiplied transparency; depth-sorting the simulation list would destroy
- * the coherence. They share no buffer and no counter slot.
+ * The alive list is the other one, and it is the draw's: compacted, unpadded, one entry per live
+ * particle. Drawing the padded coherence list instead would draw its sentinels. Neither list is
+ * ordered by view depth and neither needs to be — the AVBOIT volume and its accumulators are sums,
+ * so no arrangement of the draw changes a pixel.
  *
  * ## Nothing is sized from the CPU
  *
  * Simulate's workgroup count comes from `dispatch_args` (written by LAST frame's build-indirect
  * pass) via `dispatchWorkgroupsIndirect`, and its element bound from the `ALIVE_IN` counter
- * snapshot; the draw, and the sort's two per-particle passes when there is a sort, are sized the
- * same way, from this frame's alive count. A CPU count is inevitably stale and corrupts the pool
- * (orphaned slots when the population grows, double-freed slots when it shrinks).
+ * snapshot; the draw is sized the same way, from this frame's alive count. A CPU count is inevitably
+ * stale and corrupts the pool (orphaned slots when the population grows, double-freed slots when it
+ * shrinks).
  *
  * All persistent buffers are imported (owned by the feature, not the graph). Writing an imported
  * buffer marks the pass a side-effect so it always executes, and returns a renamed handle downstream
  * passes must read — exactly the ReSTIR reservoir pattern. Every persistent buffer is imported
  * exactly once: two imports of one buffer are two resource entries the graph cannot tell apart.
  *
+ * ## What is imported, and what the graph owns
+ *
+ * A buffer is imported only if its contents cross the frame boundary: the pool, the free list, the
+ * counters, the alive lists, `sim_list` (written here, read by next frame's simulate),
+ * `dispatch_args` (the same), the program blob and the two CPU-uploaded queues. Everything else is
+ * produced and consumed inside one graph, so the pass that first writes it declares it with a
+ * {@link BufferResourceDescriptor} in place of a handle and the graph allocates it just in time and
+ * releases it after its last reader — into the pool every other feature draws from. That is the
+ * spawn counts and the emit command, the VM's wide register file, the draw args and the bucketing
+ * scratch (`coherence/`).
+ *
  * On the very first frame `dispatch_args` must be zero-initialised (WebGPU zero-fills new buffers)
  * and the `ALIVE_IN` counter 0, so simulate is a no-op until the first build-indirect has run.
  */
@@ -105,10 +113,8 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
 /**
  * @typedef {object} ParticleSimulationHandles
  * @property {number} pool the particle pool, after this frame's INIT and UPDATE
- * @property {number} alive this frame's compacted alive list — the render order's input
- * @property {number} counters the atomic counters, after build-indirect
- * @property {number} draw_args the billboard draw's indirect args: six vertices, one instance per live particle
- * @property {number} sim_dispatch_args one workgroup per live particle, for a per-particle pass
+ * @property {number} alive this frame's compacted alive list — what the draw walks
+ * @property {number} draw_args the draw's indirect args: six vertices, one instance per live particle
  * @property {number} emitter_database the emitter database, after the bounds pass published the
  *   measured box into each emitter's state row
  */
@@ -134,8 +140,8 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
  * @param {object} params.frame per-frame scalars
  * @param {number} params.frame.dt
  * @param {number} params.frame.time
- * @param {number} params.frame.index
- * @param {boolean} [params.frame.rebucket] program assignments changed since the previous frame
+ * @param {number} params.frame.index
+ * @param {boolean} [params.frame.rebucket] program assignments changed since the previous frame
  * @param {number} params.frame.max_catchup seconds of missed spawning a woken emitter makes up
  * @param {number} params.frame.spawn_command_count entries in `gpu.spawn_commands` this frame
  * @param {number} params.frame.warmup_count entries in `gpu.warmup_queue` this frame — emitters
@@ -163,9 +169,16 @@ export function graph_particles_simulate({
     assert.isPositiveInteger(capacity, "capacity");
 
     const gr_program = graph_import_buffer(graph, gpu.program, "particles/program");
-    let gr_sim_list = graph_import_buffer(graph, gpu.sim_list, "particles/sim_list");
-    let gr_dispatch = graph_import_buffer(graph, gpu.dispatch_args, "particles/dispatch_args");
-    let gr_draw = graph_import_buffer(graph, gpu.draw_args, "particles/draw_args");
+    let gr_sim_list = graph_import_buffer(graph, gpu.sim_list, "particles/sim_list");
+    let gr_dispatch = graph_import_buffer(graph, gpu.dispatch_args, "particles/dispatch_args");
+    // The draw args are the one indirect buffer that does NOT cross the frame boundary: build-
+    // indirect writes all four words at the end of the frame and this frame's draw is the only
+    // reader, so the pass that writes them declares them and the graph owns them. `gr_dispatch` is
+    // the opposite case and stays imported — next frame's simulate is its reader.
+    let gr_draw = BufferResourceDescriptor.from(
+        4 * Uint32Array.BYTES_PER_ELEMENT,
+        GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+    );
 
     // Buffers mutated by more than one pass must be THREADED: each compute pass writing an imported
     // buffer returns a renamed (versioned) handle, and the next pass must read THAT handle — reading
@@ -177,34 +190,34 @@ export function graph_particles_simulate({
     // Two tables in one buffer — the emitter records the CPU authors and the state the GPU
     // integrates — so the passes that write the state rename the handle every reader after them
     // takes.
-    let emitter_database = graph_import_buffer(graph, gpu.emitter_database, "particles/emitter_database");
-
-    /** @type {import("./coherence/graph_particle_bucket.js").ParticleBucketScratch|undefined} */
-    let bucket_scratch;
-    if (frame.rebucket) {
-        // Live program edits can split a previously uniform wave. Rebuild from the previous
-        // compact alive list BEFORE reset discards its count and before simulate broadcasts code.
-        const bucketed = graph_particle_bucket({
-            graph, gpu, emitter_database, pool, counters, bucket_count,
-            alive: graph_import_buffer(graph, gpu.alive_read, "particles/alive_read"),
-            sim_list: gr_sim_list,
-        });
-        gr_sim_list = bucketed.sim_list;
-        bucket_scratch = bucketed.scratch;
-        const indirect = graph_compute_pass({
-            graph, shader: shader_particle_build_indirect,
-            bindings: {
-                counters: bucketed.counters, dispatch_args: gr_dispatch, draw_args: gr_draw,
-                u_workgroup_size: PARTICLE_SIMULATE_WORKGROUP_SIZE,
-            },
-            group_count: [1, 1, 1],
-        });
-        counters = indirect.counters;
-        gr_dispatch = indirect.dispatch_args;
-        gr_draw = indirect.draw_args;
-    }
+    let emitter_database = graph_import_buffer(graph, gpu.emitter_database, "particles/emitter_database");
 
-    // 1. Reset the alive/sorted/sim-padded counters (dead count + ALIVE_IN snapshot persist) and
+    /** @type {import("./coherence/graph_particle_bucket.js").ParticleBucketScratch|undefined} */
+    let bucket_scratch;
+    if (frame.rebucket) {
+        // Live program edits can split a previously uniform wave. Rebuild from the previous
+        // compact alive list BEFORE reset discards its count and before simulate broadcasts code.
+        const bucketed = graph_particle_bucket({
+            graph, emitter_database, pool, counters, capacity, bucket_count,
+            alive: graph_import_buffer(graph, gpu.alive_read, "particles/alive_read"),
+            sim_list: gr_sim_list,
+        });
+        gr_sim_list = bucketed.sim_list;
+        bucket_scratch = bucketed.scratch;
+        const indirect = graph_compute_pass({
+            graph, shader: shader_particle_build_indirect,
+            bindings: {
+                counters: bucketed.counters, dispatch_args: gr_dispatch, draw_args: gr_draw,
+                u_workgroup_size: PARTICLE_SIMULATE_WORKGROUP_SIZE,
+            },
+            group_count: [1, 1, 1],
+        });
+        counters = indirect.counters;
+        gr_dispatch = indirect.dispatch_args;
+        gr_draw = indirect.draw_args;
+    }
+
+    // 1. Reset the alive/sim-padded counters (dead count + ALIVE_IN snapshot persist) and
     //    seed the frame's spawn budget from the free count.
     counters = graph_compute_pass({
         graph,
@@ -406,14 +419,14 @@ export function graph_particles_simulate({
     //    and this pass's rewrite of it on unrelated dependency chains.
     const bucketed = graph_particle_bucket({
         graph,
-        gpu,
         emitter_database,
         pool,
         alive: alive_write,
         counters,
-        sim_list: gr_sim_list,
-        bucket_count,
-        scratch: bucket_scratch,
+        sim_list: gr_sim_list,
+        capacity,
+        bucket_count,
+        scratch: bucket_scratch,
     });
     counters = bucketed.counters;
 
@@ -421,8 +434,8 @@ export function graph_particles_simulate({
     //    rows the tick and the AVBOIT occupancy read. After the bucketing because the dispatch is
     //    the one the coherence reset sized from the GPU's own alive count.
     {
-        const out = graph_particle_bounds({
-            graph,
+        const out = graph_particle_bounds({
+            graph,
             emitter_database,
             pool,
             alive: alive_write,
@@ -450,9 +463,7 @@ export function graph_particles_simulate({
     return {
         pool,
         alive: alive_write,
-        counters: indirect.counters,
         draw_args: indirect.draw_args,
-        sim_dispatch_args: bucketed.dispatch_args,
         emitter_database,
     };
 }

package/src/shade/renderer/particles/graph_particles_avboit.js

@@ -6,9 +6,9 @@ import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/sha
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { shader_particle_avboit_occupancy } from "./shaders/shader_particle_avboit_occupancy.js";
 import {
-    PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
-    PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE,
-    PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE,
     PARTICLE_AVBOIT_DRAW_RESOURCES,
 } from "./shaders/shader_particle_avboit_draw.js";
 import {
@@ -26,9 +26,9 @@ import {
  * GPU-driven: the draws are `drawIndirect` over the GPU's own alive count, and the occupancy walks
  * the emitter table's pages. Nothing here knows how many particles there are.
  *
- * Order does not matter to any of them — the volume and the accumulators are order-independent — so
- * the depth sort the standalone billboard draw needs is not run for this path, and its buffers are
- * never made. That is what {@link ParticleRenderMode.AVBOIT} means.
+ * Order does not matter to any of them: the volume and the accumulators are sums, so no arrangement
+ * of the draw changes a pixel. That is why the particles are never depth-sorted — the alive list
+ * comes off the simulation compacted, and it is drawn as it stands.
  */
 
 /** The accumulators' view: one mip, the one the frame draws into. */
@@ -270,7 +270,7 @@ export function graph_particle_avboit_draw({
         // allowed because the attachment is read-only.
         const pass_encoder = encoder.constructRenderPass({
             label: "Particle AVBOIT Draw",
-            pipeline: PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
+            pipeline: PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
             bindings,
             colorAttachments: [
                 attachment(data.color),
@@ -283,15 +283,15 @@ export function graph_particle_avboit_draw({
                 depthReadOnly: true,
             },
         });
-        // All three use the alive list; their vertex stages select disjoint particle groups.
-        // Premultiplied particles can both cover and emit, so they retain the general pipeline.
-        const args = resources.get(data.draw_args);
-        pass_encoder.drawIndirect(args, 0);
-        pass_encoder.setPipeline(graphics.render_pipelines.obtain(PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE));
-        pass_encoder.drawIndirect(args, 0);
-        pass_encoder.setPipeline(graphics.render_pipelines.obtain(PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE));
-        pass_encoder.drawIndirect(args, 0);
-        pass_encoder.end();
+        // All three use the alive list; their vertex stages select disjoint particle groups.
+        // Premultiplied particles can both cover and emit, so they retain the general pipeline.
+        const args = resources.get(data.draw_args);
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.setPipeline(graphics.render_pipelines.obtain(PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE));
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.setPipeline(graphics.render_pipelines.obtain(PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE));
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.end();
     }
 
     const pass_data = {};

package/src/shade/renderer/particles/isa/ParticleVMISA.d.ts.map

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

package/src/shade/renderer/particles/isa/particle_assembly.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_assembly.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/particle_assembly.js"],"names":[],"mappings":"AAyKA;;;;;;;;GAQG;AAMH;;;;;;;;;;;GAWG;AACH,sDALW,eAAe;IAEE,MAAM,GAAvB,MAAM;IACJ,MAAM,CAmClB;AAwJD;;;;;;;;;;;GAWG;AACH,8CAHW,MAAM;aACM,eAAe,GAAC,IAAI;iBAAe,0BAA0B,EAAE;EA8IrF;AAED;;;;;;;;GAQG;AACH,gDAJW,MAAM,GACJ,eAAe,CAkB3B;AA9gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,oEAAoE;AACpE,6CAD0D,MAAM,CACV;AAEtD,sEAAsE;AACtE,+CAD4D,MAAM,CACR;AAE1D,+DAA+D;AAC/D,oDADqD,MAAM,CACO;AAElE,kEAAkE;AAClE,gDADwD,MAAM,CACJ;AAE1D,iEAAiE;AACjE,iDADuD,MAAM,CACP;AAEtD;;;;;GAKG;AACH,gDAFU,MAAM,CAEqC;AAErD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEoC;;;;;;;;;;UA+CtC,MAAM;aACN,MAAM;;;;;;UA6hBN,MAAM;;;;UACN,MAAM;;;;gBACN,MAAM;;;;YACN,MAAM;;gCA1sBY,sBAAsB"}
+{"version":3,"file":"particle_assembly.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/particle_assembly.js"],"names":[],"mappings":"AAyKA;;;;;;;;GAQG;AAMH;;;;;;;;;;;GAWG;AACH,sDALW,eAAe;IAEE,MAAM,GAAvB,MAAM;IACJ,MAAM,CAmClB;AAwJD;;;;;;;;;;;GAWG;AACH,8CAHW,MAAM,GACJ;IAAC,OAAO,EAAE,eAAe,GAAC,IAAI,CAAC;IAAC,WAAW,EAAE,0BAA0B,EAAE,CAAA;CAAC,CA8ItF;AAED;;;;;;;;GAQG;AACH,gDAJW,MAAM,GACJ,eAAe,CAkB3B;AA9gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,oEAAoE;AACpE,6CAD0D,MAAM,CACV;AAEtD,sEAAsE;AACtE,+CAD4D,MAAM,CACR;AAE1D,+DAA+D;AAC/D,oDADqD,MAAM,CACO;AAElE,kEAAkE;AAClE,gDADwD,MAAM,CACJ;AAE1D,iEAAiE;AACjE,iDADuD,MAAM,CACP;AAEtD;;;;;GAKG;AACH,gDAFU,MAAM,CAEqC;AAErD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEoC;;;;;;;;;;UA+CtC,MAAM;aACN,MAAM;;;;;;UA6hBN,MAAM;;;;UACN,MAAM;;;;gBACN,MAAM;;;;YACN,MAAM;;gCA1sBY,sBAAsB"}

package/src/shade/renderer/particles/layout/ParticleLayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/layout/ParticleLayout.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAcI;;;;OAIG;IACH,wBAJW,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,EAyClE;IAtDD;;;OAGG;IACH,YAFU,IAAI,MAAM,EAAE;QAAC,MAAM,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,SAAS,CAAA;KAAC,CAAC,CAE1E;IAEvB;;;OAGG;IACH,aAFU,MAAM,CAE8B;IA8C9C;;;OAGG;IACH,UAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ;QAAC,MAAM,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAQ9D;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,cAHW,cAAc,GACZ,OAAO,CA8BnB;IAED;;;;;;;;;OASG;IACH,QAFa,MAAM,CAclB;CACJ"}
+{"version":3,"file":"ParticleLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/layout/ParticleLayout.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAcI;;;;OAIG;IACH,wBAJW,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,EAyClE;IAtDD;;;OAGG;IACH,YAFU,IAAI,MAAM,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,SAAS,CAAA;KAAC,CAAC,CAE1E;IAEvB;;;OAGG;IACH,aAFU,MAAM,CAE8B;IA8C9C;;;OAGG;IACH,UAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAQ9D;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,cAHW,cAAc,GACZ,OAAO,CA8BnB;IAED;;;;;;;;;OASG;IACH,QAFa,MAAM,CAclB;CACJ"}

package/src/shade/renderer/particles/optimizer/dag/particle_vector_lift.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_vector_lift.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_lift.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,oDARW,OAAO,4BAA4B,EAAE,mBAAmB,gBACxD,UAAU,UAAU,MAAM,CAAC,CAAC;IAEF,SAAS,EAAnC,UAAU,MAAM,CAAC;IACF,cAAc,EAA7B,MAAM;IACJ,2BAA2B,GAAC,IAAI,CAgK5C;AAED;;;;;;;;;;GAUG;AACH,4BAJW,OAAO,4BAA4B,EAAE,mBAAmB,UACxD,mBAAmB,EAAE,GACnB;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAmB5C;;;;;WAlNa,MAAM;;;;UACN,MAAM;;;;;;;YAKN,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,mBAAmB,CAAC;QAAC,QAAQ,MAAM,CAAA;KAAC,CAAC;;;;WAEjE,mBAAmB,EAAE;;;;gBACrB,MAAM;;;;WACN,MAAM,EAAE;;;;gBACR,MAAM,EAAE"}
+{"version":3,"file":"particle_vector_lift.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_lift.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,oDARW,OAAO,4BAA4B,EAAE,mBAAmB,gBACxD,UAAU,UAAU,MAAM,CAAC,CAAC;IAEF,SAAS,EAAnC,UAAU,MAAM,CAAC;IACF,cAAc,EAA7B,MAAM;IACJ,2BAA2B,GAAC,IAAI,CAgK5C;AAED;;;;;;;;;;GAUG;AACH,4BAJW,OAAO,4BAA4B,EAAE,mBAAmB,UACxD,mBAAmB,EAAE,GACnB;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAmB5C;;;;;WAlNa,MAAM;;;;UACN,MAAM;;;;;;;YAKN,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,mBAAmB,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC;;;;WAEjE,mBAAmB,EAAE;;;;gBACrB,MAAM;;;;WACN,MAAM,EAAE;;;;gBACR,MAAM,EAAE"}

package/src/shade/renderer/particles/optimizer/dag/particle_vector_pack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_vector_pack.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_pack.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,6CALW,OAAO,4BAA4B,EAAE,mBAAmB,WACxD,OAAO,2BAA2B,EAAE,2BAA2B,cAC/D,OAAO,8BAA8B,EAAE,uBAAuB,GAC5D,OAAO,6BAA6B,EAAE,oBAAoB,CA8OtE;AA4YD;;;;;;;GAOG;AACH,qCAHW,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,QAAQ,MAAM,CAAA;CAAC,CAAC,GACzE,MAAM,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,QAAQ,MAAM,CAAA;CAAC,CAAC,CAAC,CAsB9F;AAtaD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEiC"}
+{"version":3,"file":"particle_vector_pack.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/optimizer/dag/particle_vector_pack.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,6CALW,OAAO,4BAA4B,EAAE,mBAAmB,WACxD,OAAO,2BAA2B,EAAE,2BAA2B,cAC/D,OAAO,8BAA8B,EAAE,uBAAuB,GAC5D,OAAO,6BAA6B,EAAE,oBAAoB,CA8OtE;AA4YD;;;;;;;GAOG;AACH,qCAHW,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC,GACzE,MAAM,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,CAsB9F;AAtaD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEiC"}

package/src/shade/renderer/particles/optimizer/optimize_particle_program.d.ts

@@ -184,7 +184,7 @@ export type ParticleOptimizerContext = {
      * returns its first word index — {@link  ../isa/ParticleAssembler.js}'s `constant`. Without it a
      * pass can read the pool but not add to it, which only costs it the folds that need a new literal.
      */
-    intern_constant: (values: number[]) => number;
+    intern_constant: ((values: number[]) => number) | null;
     /**
      * size of the register file
      */

package/src/shade/renderer/particles/optimizer/optimize_particle_program.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimize_particle_program.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/optimize_particle_program.js"],"names":[],"mappings":"AA+IA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,kDAxBW,iBAAiB;IAEW,SAAS,GAArC,UAAU,MAAM,CAAC;IAEoB,eAAe,UAA3C,MAAM,EAAE,KAAG,MAAM;IACM,MAAM,GAAtC,cAAc,MAAM,CAAC;IAEJ,cAAc,GAA/B,MAAM;IACY,SAAS,GAA3B,OAAO;IAGU,cAAc,GAA/B,MAAM;IACY,qBAAqB,GAAvC,OAAO;IACW,YAAY,GAA9B,OAAO;IACW,mBAAmB,GAArC,OAAO;IAEU,gBAAgB,GAAjC,MAAM;IACY,iBAAiB,GAAnC,OAAO;IACW,uBAAuB,GAAzC,OAAO;IACW,oBAAoB,GAAtC,OAAO;IACW,WAAW,GAA7B,OAAO;IACL,iBAAiB,CAqC7B;AAuFD;;;;;;GAMG;AACH,iDAHc,MAAM,KACP,MAAM,EAAE,CAIpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,mDAJW,eAAe,YACf,MAAM,GACJ,eAAe,CAsC3B;AAsFD;;;GAGG;AACH,yCAHW,WAAW,GACT,iBAAiB,CAU7B;AAnbD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH;;;;;GAKG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,wCAFU,MAAM;IAAC,MAAM,MAAM,CAAC;IAAC,GAAG,EAAE,qBAAqB,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAC,CAAC,CAwBrH;AAEF;;;;;;;;GAQG;AACH,gDAFU,cAAc,MAAM,CAAC,CAI7B;AAEF;;;;;;;;GAQG;AACH,oDAFU,MAAM,CAEuC;mDAnE5C,MAAM,EAAE,EAAE,WACV,wBAAwB,KACtB,MAAM,EAAE,EAAE,GAAC,IAAI;;;;;eAKd,UAAU,MAAM,CAAC;;;;;;8BACP,MAAM,EAAE,KAAK,MAAM;;;;oBAG7B,MAAM;;;;oBACN,MAAM;;kCApFc,6BAA6B;gCAE/B,2BAA2B"}
+{"version":3,"file":"optimize_particle_program.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/optimize_particle_program.js"],"names":[],"mappings":"AA+IA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,kDAxBW,iBAAiB;IAEW,SAAS,GAArC,UAAU,MAAM,CAAC;IAEoB,eAAe,UAA3C,MAAM,EAAE,KAAG,MAAM;IACM,MAAM,GAAtC,cAAc,MAAM,CAAC;IAEJ,cAAc,GAA/B,MAAM;IACY,SAAS,GAA3B,OAAO;IAGU,cAAc,GAA/B,MAAM;IACY,qBAAqB,GAAvC,OAAO;IACW,YAAY,GAA9B,OAAO;IACW,mBAAmB,GAArC,OAAO;IAEU,gBAAgB,GAAjC,MAAM;IACY,iBAAiB,GAAnC,OAAO;IACW,uBAAuB,GAAzC,OAAO;IACW,oBAAoB,GAAtC,OAAO;IACW,WAAW,GAA7B,OAAO;IACL,iBAAiB,CAqC7B;AAuFD;;;;;;GAMG;AACH,iDAHc,MAAM,KACP,MAAM,EAAE,CAIpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,mDAJW,eAAe,YACf,MAAM,GACJ,eAAe,CAsC3B;AAsFD;;;GAGG;AACH,yCAHW,WAAW,GACT,iBAAiB,CAU7B;AAnbD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH;;;;;GAKG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,wCAFU,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,qBAAqB,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAC,CAAC,CAwBrH;AAEF;;;;;;;;GAQG;AACH,gDAFU,cAAc,MAAM,CAAC,CAI7B;AAEF;;;;;;;;GAQG;AACH,oDAFU,MAAM,CAEuC;mDAnE5C,MAAM,EAAE,EAAE,WACV,wBAAwB,KACtB,MAAM,EAAE,EAAE,GAAC,IAAI;;;;;eAKd,UAAU,MAAM,CAAC;;;;;;qBACjB,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC,GAAC,IAAI;;;;oBAGnC,MAAM;;;;oBACN,MAAM;;kCApFc,6BAA6B;gCAE/B,2BAA2B"}

package/src/shade/renderer/particles/optimizer/particle_program_equivalence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AA2GA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;;YACM,WAAW;YAAU,OAAO;eAAa,MAAM;EAerE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW;YACA,UAAU;YAAU,OAAO;EAkEhD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,qDAVW;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,SACzD;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;IAErC,SAAS,GAA7B,MAAM;IACkD,KAAK,GAA7D;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI;IAIxC,MAAM,GAAC,IAAI,CAuCvB;AAED;;;;;;;;;;;;;;GAcG;AACH;IARkG,MAAM,EAA7F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACS,KAAK,EAA5F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACvD,YAAY,GAAnC,MAAM,MAAM,CAAC;IACG,UAAU,GAA1B,MAAM;IAGJ,MAAM,GAAC,IAAI,CAqBvB;AAED;;;;;;;GAOG;AACH,qGAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB;AArRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,MAAM,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAA;CAAC,CAAC,CAOjG"}
+{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AA2GA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;IACJ;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAevE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW,GACT;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,CAkEjD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,qDAVW;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,SACzD;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;IAErC,SAAS,GAA7B,MAAM;IACkD,KAAK,GAA7D;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI;IAIxC,MAAM,GAAC,IAAI,CAuCvB;AAED;;;;;;;;;;;;;;GAcG;AACH;IARkG,MAAM,EAA7F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACS,KAAK,EAA5F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACvD,YAAY,GAAnC,MAAM,MAAM,CAAC;IACG,UAAU,GAA1B,MAAM;IAGJ,MAAM,GAAC,IAAI,CAqBvB;AAED;;;;;;;GAOG;AACH,qGAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB;AArRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAA;CAAC,CAAC,CAOjG"}

package/src/shade/renderer/particles/runtime/EmitterRegistry.d.ts

@@ -75,13 +75,13 @@ export class EmitterRegistry {
      * The emitter table.
      * @returns {GPUTypedTable}
      */
-    get table(): GPUTypedTable;
+    get table(): import("../../buffer/table/GPUTypedTable.js").GPUTypedTable<any>;
     /**
      * The GPU-owned state table: one row per emitter, at the emitter's row, claimed and released
      * here and otherwise the GPU's.
      * @returns {GPUTypedTable}
      */
-    get state_table(): GPUTypedTable;
+    get state_table(): import("../../buffer/table/GPUTypedTable.js").GPUTypedTable<any>;
     /**
      * @returns {number} number of live emitters
      */
@@ -214,6 +214,7 @@ export class EmitterRegistry {
     build_program(): Uint32Array;
     #private;
 }
+export type GPUTypedTable = import("../../buffer/table/GPUTypedTable.js").GPUTypedTable<any>;
 import { GPUDatabase } from "../../buffer/table/GPUDatabase.js";
 import { ProgramHeap } from "./ProgramHeap.js";
 import { ParticleEmitter } from "./ParticleEmitter.js";

package/src/shade/renderer/particles/runtime/EmitterRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EmitterRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/EmitterRegistry.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IA8EI;;OAEG;IACH,+BASC;IAxFD;;OAEG;IACH,UAFU,WAAW,CAEZ;IAET;;;OAGG;IACH,UAFU,WAAW,CAEQ;IAE7B;;;OAGG;IACH,4BAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,QAFU,eAAe,EAAE,CAEf;IAEZ;;;;;;;;;;OAUG;IACH,8BAEC;IA8CD;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,iCAEC;IAED;;OAEG;IACH,oBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;OAOG;IACH,iCAEC;IAED;;;;;;;;;OASG;IACH,iBAHW,eAAe,GACb,yBAAyB,GAAC,SAAS,CAI/C;IAED;;;;;;;;OAQG;IACH,YANW,eAAe,GAAC,MAAM,kBAEtB,MAAM,GAEJ,eAAe,CA+B3B;IAED;;;;;;;;;;;;;OAaG;IACH,gBAFW,eAAe,QA6BzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAHW,eAAe,WACf,OAAO,2BAA2B,EAAE,eAAe,QA0B7D;IAED;;;;;OAKG;IACH,SAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;;;OAMG;IACH,2BAHW,eAAe,iBACf,MAAM,QAehB;IAED;;;;;;;;;OASG;IACH,0BAHW,eAAe,UACf,UAAU,MAAM,CAAC,QAoB3B;IAED;;;;;;;;;;;;;OAaG;IACH,cA4BC;IAED;;;;;;;;;OASG;IACH,iBAFa,WAAW,CAMvB;;CACJ;4BAzc2B,mCAAmC;4BAYnC,kBAAkB;gCADd,sBAAsB;0CADZ,gCAAgC"}
+{"version":3,"file":"EmitterRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/EmitterRegistry.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IA8EI;;OAEG;IACH,+BASC;IAxFD;;OAEG;IACH,UAFU,WAAW,CAEZ;IAET;;;OAGG;IACH,UAFU,WAAW,CAEQ;IAE7B;;;OAGG;IACH,4BAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,QAFU,eAAe,EAAE,CAEf;IAEZ;;;;;;;;;;OAUG;IACH,8BAEC;IA8CD;;;OAGG;IACH,8EAEC;IAED;;;;OAIG;IACH,oFAEC;IAED;;OAEG;IACH,oBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;OAOG;IACH,iCAEC;IAED;;;;;;;;;OASG;IACH,iBAHW,eAAe,GACb,yBAAyB,GAAC,SAAS,CAI/C;IAED;;;;;;;;OAQG;IACH,YANW,eAAe,GAAC,MAAM,kBAEtB,MAAM,GAEJ,eAAe,CA+B3B;IAED;;;;;;;;;;;;;OAaG;IACH,gBAFW,eAAe,QA6BzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAHW,eAAe,WACf,OAAO,2BAA2B,EAAE,eAAe,QA0B7D;IAED;;;;;OAKG;IACH,SAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;;;OAMG;IACH,2BAHW,eAAe,iBACf,MAAM,QAehB;IAED;;;;;;;;;OASG;IACH,0BAHW,eAAe,UACf,UAAU,MAAM,CAAC,QAoB3B;IAED;;;;;;;;;;;;;OAaG;IACH,cA4BC;IAED;;;;;;;;;OASG;IACH,iBAFa,WAAW,CAMvB;;CACJ;;4BA7c2B,mCAAmC;4BAYnC,kBAAkB;gCADd,sBAAsB;0CADZ,gCAAgC"}

package/src/shade/renderer/particles/runtime/EmitterRegistry.js

@@ -13,6 +13,10 @@ import { GPUParticleEmitterContext } from "./GPUParticleEmitterContext.js";
 import { ParticleEmitter } from "./ParticleEmitter.js";
 import { ProgramHeap } from "./ProgramHeap.js";
 
+/**
+ * @typedef {import("../../buffer/table/GPUTypedTable.js").GPUTypedTable} GPUTypedTable
+ */
+
 /**
  * Staging for one emitter row. Reused across every write — the table serializes it into its page
  * shadow synchronously, so nothing outlives the call. This is what keeps a frame's flush free of
@@ -61,13 +65,13 @@ export class EmitterRegistry {
      * Packed instruction + constant buffers for every distinct program in the set.
      * @type {ProgramHeap}
      */
-    programs = new ProgramHeap();
-
-    /**
-     * Changes when a live emitter moves to different bytecode; invalidates simulation grouping.
-     * @type {number}
-     */
-    program_assignment_version = 0;
+    programs = new ProgramHeap();
+
+    /**
+     * Changes when a live emitter moves to different bytecode; invalidates simulation grouping.
+     * @type {number}
+     */
+    program_assignment_version = 0;
 
     /**
      * The live emitters, in no particular order — the row in {@link context} is the identity.
@@ -226,8 +230,8 @@ export class EmitterRegistry {
 
         const context = new GPUParticleEmitterContext();
 
-        context.placement = this.programs.acquire(emitter.program);
-        context.program = emitter.program;
+        context.placement = this.programs.acquire(emitter.program);
+        context.program = emitter.program;
 
         context.generation = this.#generation;
         this.#generation = particle_generation_next(this.#generation);
@@ -287,8 +291,8 @@ export class EmitterRegistry {
 
         this.programs.release(context.placement);
 
-        context.placement = null;
-        context.program = null;
+        context.placement = null;
+        context.program = null;
 
         this.#contexts.delete(emitter);
     }
@@ -323,12 +327,12 @@ export class EmitterRegistry {
         // unpacks it nor gives it a new id
         context.placement = this.programs.acquire(program);
 
-        emitter.program = program;
-        context.program = program;
-
-        if (context.placement !== previous) {
-            this.program_assignment_version++;
-        }
+        emitter.program = program;
+        context.program = program;
+
+        if (context.placement !== previous) {
+            this.program_assignment_version++;
+        }
 
         this.programs.release(previous);
 
@@ -411,16 +415,16 @@ export class EmitterRegistry {
      * Stages through the one module-static record, so a frame's restaging allocates nothing however
      * many rows it touches.
      */
-    flush() {
-        const table = this.table;
-
-        // Reconcile plain-field edits before checking relocation: an acquire can repack the heap
-        // and move placements of rows we would otherwise have already staged.
-        for (const [emitter, context] of this.#contexts) {
-            if (emitter.program !== context.program) {
-                this.set_program(emitter, emitter.program);
-            }
-        }
+    flush() {
+        const table = this.table;
+
+        // Reconcile plain-field edits before checking relocation: an acquire can repack the heap
+        // and move placements of rows we would otherwise have already staged.
+        for (const [emitter, context] of this.#contexts) {
+            if (emitter.program !== context.program) {
+                this.set_program(emitter, emitter.program);
+            }
+        }
 
         const placement_version = this.programs.placement_version;