@woosh/meep-engine 3.16.0 → 3.17.0

package/src/shade/playground/particle_editor/README.md

@@ -35,6 +35,20 @@ edits it at both altitudes.
   the moment it arrives. Arrow keys move the choice; Escape closes. Nodes are listed and headed by
   what they are called rather than by the mnemonic they compile as — "Divide", not `div` — each with
   the glyph its type carries; both are searched, so looking for either finds it.
+- **Copy, paste, duplicate.** `Ctrl+C` takes a copy of the selected nodes and of every wire they hold
+  whole — a wire with one end outside the selection is not brought along, because the node it reached
+  is not part of what was copied. `Ctrl+V` puts it in the middle of what you are looking at, keeping
+  the arrangement it was copied in; a repeat paste steps aside so copies do not hide each other.
+  `Ctrl+D` puts a second of the selection beside it and leaves the clipboard alone. Each is one step
+  on the undo timeline, and what lands is what is selected afterwards, ready to be dragged where it
+  is wanted. One clipboard serves both phases and every group body, so a copy taken in INIT pastes in
+  UPDATE. It is the editor's own clipboard rather than the system one: what it holds is node types,
+  which only mean anything to a canvas that shares the library.
+- **An input holds one wire.** Drop a second one on it and it replaces the first, in one step on the
+  undo timeline — the editor cannot be made to put two sources on an input. Drag *out* of an input
+  that already has one and you are holding that wire rather than making another: let it go on
+  another input to move it there, on the port it came from to leave it alone, and on open canvas to
+  take it off.
 - **Drop a wire on empty canvas** and the same menu opens, narrowed to the types that have a port
   which could take it — the ones with an input, when the wire came out of an output — and picking one
   wires it up as it arrives. The node and the wire are one step on the undo timeline, because they
@@ -61,8 +75,20 @@ edits it at both altitudes.
 - Node parameters are edited in the node: four fields for a vector, a swatch and an alpha field for
   a colour, a picker for an ISA enum, a picker of the effect's own attributes for an attribute
   reference, `xyzw` for a swizzle.
-- The strip along the bottom lists every problem with the effect, from **both** phases. Click one to
-  jump to the phase it is in and select the node; the node is outlined in the graph too.
+- Two of them are **ramps**, edited as a picture. An **RGBA Gradient** (and an RGB one) is a strip of
+  the colour it produces with its stops underneath: drag a stop, click the lane to add one — in the
+  colour the gradient already is there, so adding never changes anything — and middle-click to remove.
+  A **Curve** is the unit square with its keys in it, and the picker under it decides the selected
+  key's tangents. Neither is sampled from a table at runtime: both are written out into the program as
+  arithmetic, which is what the **Code** tab shows. `Curve Table`, which *is* the table, is the other
+  node — it takes a row handle rather than a curve.
+- The strip along the bottom lists every problem with the effect, from **both** phases, loudest
+  first. Click one to jump to the phase it is in and select the node; the node is outlined in the
+  graph too.
+- **A node nothing reads is not a problem.** Only what reaches a sink is compiled, so half-built work
+  sitting next to a working graph cannot break it: such a node is dimmed, noted once at the bottom of
+  the strip, and nothing else found against it — an unbound input, a mistyped value — is reported at
+  all. The strip still says there are no problems, because there are none.
 
 **Code** is the same effect as instructions.
 
@@ -106,14 +132,27 @@ be gone exactly when it is wanted.
   and the preview carries on with the last good program.
 - Add an attribute in the inspector, then bind a render channel to it. Remove one that a channel was
   bound to: the channel unbinds, and every node that named it is reported against the node.
+- Drag the wire out of a bound input and drop it on the input below. It moves, rather than being
+  copied — and `Ctrl+Z` puts it back in one go. Drag it out again and let go over open canvas: it is
+  gone, and the menu opens offering what could take the value it was carrying.
 - Drag a wire out of an output and let go over open canvas. Only the nodes that could take it are
   offered; pick one and it arrives already wired.
 - Drag a box around the four or five nodes that build the initial direction and press `Ctrl+G`. The graph gets
   smaller and the program does not change at all — check it in **Code**. Open the group, rename it in
   the breadcrumb, and watch the node on the canvas behind it change with it.
+- Select the two or three nodes that make the initial speed, press `Ctrl+D`, and drag the copy
+  somewhere. Then `Ctrl+C`, switch to **UPDATE**, and `Ctrl+V`: the same nodes, wired the same way, in
+  the other phase. `Ctrl+Z` takes the whole paste back in one go.
 - Add a `Simplex Noise 3D` and open it. Three hundred instructions of arithmetic, drawn — and read
   only, because it is one of the library's own. `Curl Noise 4D` is twelve of those; the **Code** tab
   is where to see what that means.
+- Add a `Flow Noise 3D` instead and wire `alpha` to the elapsed time. It is the same kind of field
+  with two differences worth the instructions: its gradients turn as `alpha` moves, so the field
+  swirls in place rather than sliding past, and it hands back its own derivative alongside the value.
+  `Tiling Flow Noise 3D` is that with a period you can name, per axis.
+- Drop an `RGBA Gradient` on a `Write Attribute` bound to `color`, wire `t` to the particle's
+  normalised age, and drag the stops while the preview runs. Then look at **Code**: the gradient is a
+  literal, a saturate and a multiply-add per stop, and there is no table anywhere.
 - Set **blend** to `alpha` and back to `additive`. The preview composites accordingly.
 - `Ctrl+Z` in the graph. Every edit — a wire, a move, a parameter, a node from the menu — is one
   timeline.
@@ -150,6 +189,8 @@ used only here:
 | making one out of a selection | `src/shade/renderer/particles/graph/make_particle_group.js` |
 | a group in a file | `src/shade/renderer/particles/graph/particle_group_json.js` |
 | the groups the editor ships with | `src/shade/renderer/particles/graph/groups/` |
+| a gradient and a curve, and the arithmetic they become | `src/shade/renderer/particles/graph/particle_ramp.js` |
+| the controls those two are edited with | `editor/view/particles/effect/ParticleGradientEditorView.js`, `ParticleCurveEditorView.js` |
 | code layer | `editor/view/particles/effect/ParticleCodeEditorView.js` |
 | emitter + attributes | `editor/view/particles/effect/ParticleEmitterInspectorView.js` |
 | preview | `editor/view/particles/effect/ParticlePreviewView.js` |

package/src/shade/playground/particle_system/particle_prototype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_prototype.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_prototype.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH;IAL4B,UAAU,GAA3B,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,eAAe,GAAhC,MAAM;;YACK,cAAc;YAAU,MAAM;aAAW,MAAM;EAgHpE;AAED;;;;GAIG;AACH;YAFsB,cAAc;YAAU,MAAM;aAAW,MAAM;EAcpE;AAED;;;;;;;;;;;;;GAaG;AACH,yCANW,OAAO,+BAA+B,EAAE,KAAK;IAEa,IAAI,GAA9D,OAAO,gCAAgC,EAAE,MAAM;;UAEtC,eAAe;WAAS,eAAe;EAe1D;+BA5L8B,mDAAmD;gCAElD,qDAAqD"}
+{"version":3,"file":"particle_prototype.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_prototype.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH;IAL4B,UAAU,GAA3B,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,eAAe,GAAhC,MAAM;;YACK,cAAc;YAAU,MAAM;aAAW,MAAM;EAgHpE;AAED;;;;GAIG;AACH;YAFsB,cAAc;YAAU,MAAM;aAAW,MAAM;EAapE;AAED;;;;;;;;;;;;;GAaG;AACH,yCANW,OAAO,+BAA+B,EAAE,KAAK;IAEa,IAAI,GAA9D,OAAO,gCAAgC,EAAE,MAAM;;UAEtC,eAAe;WAAS,eAAe;EAe1D;+BA3L8B,mDAAmD;gCAElD,qDAAqD"}

package/src/shade/playground/particle_system/particle_prototype.js

@@ -135,13 +135,13 @@ export function fire_effect({ size_curve, alpha_curve, flipbook_frames = 16 } =
     const effect = create_particle_effect({ layout, init, update });
 
     const emitter = {
-        effect,
+        ...effect,
         spawn_rate: 120,
         flags: { blend: EMITTER_BLEND.ADDITIVE, projection: EMITTER_PROJECTION.BILLBOARD },
         render: { position: "position", size: "size", color: "color", frame: "frame" },
         bounds: { center: [0, 1.5, 0], radius: 2.5 },
-        // A 4x4 flipbook packed as the whole atlas here; a real atlas would use a sub-rect.
-        atlas_region: [0, 0, 1, 1],
+        // No texture, so the flipbook runs over the default atlas — one white texel, read as a
+        // 4x4 grid of it. A real effect names an image and the system packs it.
         flipbook: [4, 4],
     };
 
@@ -156,12 +156,11 @@ export function fire_effect({ size_curve, alpha_curve, flipbook_frames = 16 } =
 export function smoke_effect() {
     const { layout, effect } = fire_effect({ flipbook_frames: 8 });
     const emitter = {
-        effect,
+        ...effect,
         spawn_rate: 25,
         flags: { blend: EMITTER_BLEND.ALPHA, projection: EMITTER_PROJECTION.BILLBOARD, soft_depth: true, lighting: true, sort: true },
         render: { position: "position", size: "size", color: "color", frame: "frame" },
         bounds: { center: [0, 3, 0], radius: 5 },
-        atlas_region: [0, 0, 1, 1],
         flipbook: [1, 1],
     };
     return { layout, effect, emitter };

package/src/shade/playground/particle_system/particle_scene.js

@@ -115,7 +115,7 @@ export function create_particle_emitters() {
     // smoke — alpha, soft-depth, a rising column above the fire
     const smoke = ParticleEmitter.from({
         name: "smoke",
-        effect: make_effect(PARTICLE_EMITTER_MOTION.smoke),
+        ...make_effect(PARTICLE_EMITTER_MOTION.smoke),
         spawn_rate: 60,
         flags: { blend: EMITTER_BLEND.ALPHA, projection: EMITTER_PROJECTION.BILLBOARD, soft_depth: true },
         render: { position: "position", size: "size", color: "color" },
@@ -127,7 +127,7 @@ export function create_particle_emitters() {
     // sparks — additive, velocity-stretched, fast, short-lived, under gravity, by the block
     const sparks = ParticleEmitter.from({
         name: "sparks",
-        effect: make_effect(PARTICLE_EMITTER_MOTION.sparks),
+        ...make_effect(PARTICLE_EMITTER_MOTION.sparks),
         spawn_rate: 350,
         flags: { blend: EMITTER_BLEND.ADDITIVE, projection: EMITTER_PROJECTION.STRETCHED },
         render: { position: "position", size: "size", color: "color", velocity: "velocity" },
@@ -139,7 +139,7 @@ export function create_particle_emitters() {
     // dust — alpha, soft-depth, a slow wide drift across the ground
     const dust = ParticleEmitter.from({
         name: "dust",
-        effect: make_effect(PARTICLE_EMITTER_MOTION.dust),
+        ...make_effect(PARTICLE_EMITTER_MOTION.dust),
         spawn_rate: 120,
         flags: { blend: EMITTER_BLEND.ALPHA, projection: EMITTER_PROJECTION.BILLBOARD, soft_depth: true },
         render: { position: "position", size: "size", color: "color" },
@@ -155,7 +155,7 @@ export function create_particle_emitters() {
 
     const torch = ParticleEmitter.from({
         name: "torch",
-        effect: make_effect(PARTICLE_EMITTER_MOTION.torch),
+        ...make_effect(PARTICLE_EMITTER_MOTION.torch),
         spawn_rate: 200,
         flags: { blend: EMITTER_BLEND.ADDITIVE, projection: EMITTER_PROJECTION.BILLBOARD },
         render: { position: "position", size: "size", color: "color" },

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

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AAmGA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;OAQG;IACH,2BAFU,OAAO,CAEiB;IAElC;;;;;;;OAOG;IACH,mBAFU,MAAM,GAAC,SAAS,CAEI;IAE9B,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAgB/B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAeD;;;;;;OAMG;IACH,uCAFa,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EAkOC;IAED;;OAEG;IACH,gBAQC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAw6BnB;;CACJ;6BAjiF4B,yBAAyB;0CACZ,gCAAgC;sCACpC,4BAA4B;+BACnC,6CAA6C;2BA3BjD,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAwC7C,uBAAuB;gCA7CnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCA8Ed,gCAAgC;2BA3DvC,2BAA2B;iCAyDrB,0CAA0C;4CA3C/B,+DAA+D;yBAgClF,yBAAyB;kCAChB,kCAAkC;kCASlC,wBAAwB;oBA9BtC,0BAA0B;uCAPP,sDAAsD"}

package/src/shade/renderer/Renderer.js

@@ -67,6 +67,7 @@ import { RasterizationJob } from "./rasterize/RasterizationJob.js";
 import { graph_rasterize_scene } from "./rasterize/standard/graph_rasterize_scene.js";
 import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { GPUParticleSystem } from "./particles/GPUParticleSystem.js";
+import { ParticleRenderMode } from "./particles/ParticleRenderMode.js";
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
@@ -2329,11 +2330,22 @@ export class Renderer {
         if (this.feature_particles_enabled) {
             const particles = this.particles(scene_ctx);
 
-            particles.simulate({
+            // The simulation runs here; the drawing is the side channels', below. AVBOIT mode is
+            // what says so: the colour comes back untouched, no sort is recorded, and none of the
+            // sort's scratch is ever allocated, because the accumulators it would feed are sums.
+            //
+            // Not conditional on {@link transparency_mode}. MBOIT has no particle channel, so under
+            // it the particles simulate and are not drawn — the same as before this was a mode, and
+            // the `ShadeTransparencyMode` docs say why the legacy path stays as it is. Giving MBOIT
+            // `BILLBOARD` here would draw them, but over the transparency composite rather than
+            // through it, which is a worse picture than none.
+            current_color_out = particles.execute({
                 graph,
                 camera: gr_buffer_camera_current,
                 scene_database: gr_scene_database_for_velocity,
+                color: current_color_out,
                 dt: time_delta_seconds,
+                mode: ParticleRenderMode.AVBOIT,
             });
 
             particle_side_channels.push(particles);

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

@@ -33,7 +33,7 @@ authoring:   NodeGraph (nodes+ports)      ──compile──▶  Program (bytec
              standard node library                       │
                                                          ▼
 runtime CPU: ParticleEmitter (a Node3D) ── Scene ──▶ GPUSceneContext (transforms table)
-             EmitterRegistry ── GPUDatabase(emitters + emitter_state) ─┤  ProgramArena ([header][constants][code])
+             EmitterRegistry ── GPUDatabase(emitters + emitter_state) ─┤  ProgramHeap ([header][constants][code])
              GPUParticleSystem (owns every buffer, records the frame)
                                                          ▼
 runtime GPU: particle pool (array<u32>, uniform stride) + alive/dead lists + counters
@@ -128,8 +128,10 @@ A compute stage gets eight storage buffers by default, and the design does not a
 things keep every pass under it: the emitter record and the GPU-owned state are two tables of one
 database buffer, read through one binding; and the VM's constants and code are one packed buffer —
 `[header][constants][code]`, the header's first word saying where the code starts
-(`ParticleConstants.PARTICLE_PROGRAM_HEADER_WORDS`). Emit and simulate bind exactly eight;
-`particle_shaders_wgsl_validity.spec` pins the count for every pass.
+(`ParticleConstants.PARTICLE_PROGRAM_HEADER_WORDS`). Emit and simulate bind exactly eight; their
+wide-register variants bind nine, which is the one place the system spends past the default and is
+still inside the ten the engine demands of an adapter. `particle_shaders_wgsl_validity.spec` pins
+the count for every pass.
 
 ### The VM (`ParticleVM`)
 
@@ -137,9 +139,20 @@ Register machine, emulator-safe (bounded instruction loop + big `switch`, no sub
 recursion, no data-dependent jumps — conditionals are predicated via CMP/SELECT, destruction via
 `KILL`).
 
-- Register file: `array<vec4f, REG_COUNT>` (default 16). Scalars use `.x`; vectors use `.xyz(w)`.
-- Instruction: fixed **5×u32** words `[op, dst, s0, s1, s2]`. Operand meaning is per-opcode
-  (register index / const-pool index / attribute word-offset+comp / curve handle / builtin id).
+- Register file: `array<f32>`, a register being one slot and a value of width *w* occupying *w*
+  consecutive ones. The interpreter reaches it through `vm_reg_read` / `vm_reg_write`, which a
+  **backing chunk** supplies, and the two backings are the two interpreters:
+  `vm/chunk_particle_vm_registers_fast.js` puts the file in `var<private>`
+  (`PARTICLE_VM_FAST_REGISTER_SLOTS`, dynamically indexed, so its size is the shader's register
+  footprint), and `vm/chunk_particle_vm_registers_wide.js` puts it in a storage buffer
+  (`PARTICLE_VM_REGISTER_SLOTS` — every slot an 8-bit operand base can name). See **Two
+  interpreters** below.
+- Instruction: fixed **4×u32** words `[op | width << 8 | kinds << 16 | dst << 24, s0, s1, s2]`.
+  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 /
+  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
   gives an already-allocated record its state; it has no say in whether the particle exists.
@@ -149,6 +162,35 @@ recursion, no data-dependent jumps — conditionals are predicated via CMP/SELEC
 - `CURVE dst, handle, s0`: `dst.x = animation_curve_evaluate(curves[handle], s0.x)` — reuses the
   engine's GPU AnimationCurve chunk + database.
 
+#### Two interpreters
+
+The register file normally lives in shader registers, which is what makes it fast and what makes it
+small. An effect whose compiled program wants more slots than it holds is not an error and not an
+authoring ceiling: the whole system swaps emit and simulate for variants whose file is a storage
+buffer, and everything runs, slowly.
+
+- **The trigger is the set, not the program.** `ProgramHeap` reports `max_register_count` over the
+  programs it holds, and `GPUParticleSystem` is where that number is compared against
+  `PARTICLE_VM_FAST_REGISTER_SLOTS` — the store has no opinion about what a register budget means,
+  and which backing a pass is compiled against is the VM's business. One hungry effect moves every
+  emitter onto the wide pair; there is one pipeline per pass and it is chosen once, per frame, in
+  `graph_particles`. It moves back when that effect is unregistered: the heap knows what it holds,
+  so the number is a maximum over the live set rather than a high-water mark.
+- **The launch is bounded.** The wide passes need a register file per invocation in flight, so they
+  do not run one lane per particle — that would size the buffer by pool capacity. They launch
+  `PARTICLE_VM_WIDE_LAUNCH_LANES` lanes whatever the workload and walk their input with a grid-stride
+  loop, so the file is `LANES * SLOTS * 4` bytes and nothing else. The stride is a whole number of
+  workgroups, which is what keeps a wave inside one coherence bucket and the wave-uniform section
+  decode sound.
+- **Slot-major, and never cleared.** `vm_registers[slot * LANES + lane]`, so a wave reading one slot
+  reads a coalesced run. The buffer is transient and no pass zeroes it: a register is undefined until
+  written, and a program that reads one first is corrupt. That is the one place the two backings are
+  not interchangeable — the fast file zeroes, so the reference executor and the fast VM agree on a
+  value the wide VM has no opinion about.
+- **Held to the same bar.** `vm/chunk_particle_vm.spec.js` runs every parity case, fuzz included,
+  against BOTH backings; `shaders/particle_wide_register_passes.spec.js` runs the wide passes against
+  the fast ones under the emulator and exercises the grid-stride loop.
+
 **Parity strategy.** The opcode numbers + operand semantics live in one source of truth
 (`isa/ParticleVMISA.js`). Two executors implement it: a JS reference VM (`vm/ParticleVMReference.js`)
 and a hand-written WGSL interpreter (`vm/chunk_particle_vm.js`). A spec runs identical programs
@@ -180,13 +222,34 @@ per-frame transform copy, and an emitter under a GPU-animated joint follows it
 CPU-side copy of `transform_global` could not do, since the CPU never updates that matrix for a
 node the GPU owns.
 
+**The node knows nothing about the GPU.** A `ParticleEmitter` is a transform, an attribute
+`layout`, a compiled `program`, a `texture` URL, and the emission parameters — all of it the
+author's, all of it meaning the same thing with no device present, all of it what a saved effect is
+made of. Everything the system assigns is a `GPUParticleEmitterContext`, held by the
+`EmitterRegistry` against the emitter and reached through `registry.context(emitter)`: the table
+row, the generation, the program placement, the node's `transforms` row, the atlas patch. So an
+emitter cannot be saved with a row in it, cannot be given one by hand, and "is this emitter live?"
+is asked of the registry rather than read off a `-1` that anything could have written. The record
+writer is where the two meet — `write_emitter_record(record, emitter, context)`, next to the struct
+it fills.
+
+Restaging is driven by `Node3D#version`, the node's own change counter, which the renderer already
+reads to decide whether a transform needs re-uploading; the context remembers the version its row
+was staged from. An author who edits an emitter says so the way they say it for any node —
+`needsUpdate = true` — and there is no second flag to forget. A change to the context itself (a
+`transforms` row, a repacked atlas patch) moves no version, so the context marks itself instead.
+
 ### Emitter table (`GPUDatabase`)
 
 One `emitters` table (CPU-managed, low churn). Row = `PARTICLE_EMITTER_STRUCT`: program
 offsets+lengths, constant-pool offset, seed, spawn rate, **node** (transforms row), **generation**,
 bounds sphere, flags (lighting/soft/sort/cull/blend/projection), render binding (attr offsets for
-position/size/color/rotation/frame/velocity), atlas region + flipbook grid, and the dense program id
-the coherence pass buckets on. Programs+constants live in a packed `ProgramArena` buffer
+position/size/color/rotation/frame/velocity), atlas region + flipbook grid, and the program id
+the coherence pass buckets on. The atlas region is resolved, not authored: the emitter names an
+image and the system packs it, the way `ShaderManager` packs the old engine's sprites, so a repack
+moves every patch without any emitter changing. The seed is resolved too — an emitter left at 0 gets
+its registration's generation, which no other emitter of the registry shares, rather than being
+written to. Programs+constants live in a packed `ProgramHeap` buffer
 (variable length → not a fixed-stride table).
 
 The struct is the ONLY statement of that layout. The JS writer is the database's
@@ -209,11 +272,26 @@ or a later tenant's — so a hard removal frees the emitter's particles within a
 row cannot adopt a stranger's. Graceful retirement (rate to zero, remove once the tail has died)
 remains an author's choice rather than a correctness rule.
 
-Programs are the exception: the arena is append-only and content-deduplicated, and removing an
-emitter does not reclaim its program. The dense `program_id`s are baked into every other emitter's
-record, so compacting them would mean rewriting the whole table to recover a few hundred words.
-The consequence to know about is that `bucketCount()` only ever grows, and the simulation-order
-buffers are sized from it — which the system does itself.
+**Programs are edited the same way.** `ProgramHeap` is a pair of range allocators
+(`OffsetAllocator`) over the two sections of the packed buffer, keyed by a `HashMap` on the bytecode
+itself — `ParticleProgram` answers `equals`/`hash`, so content deduplication is the map's doing
+rather than a stringified key's. `acquire` takes a reference and `release` gives one back, so the
+last emitter of an effect is what unpacks it, and `EmitterRegistry.set_program` swaps an emitter onto
+different bytecode while it is live. What makes that possible is that a program is **relocatable**:
+instructions carry no absolute addresses and constant references are program-local, so the heap can
+move one by copying its words and rewriting the placement.
+
+Two things are deliberately NOT reclaimed. **Program ids** are reused rather than renumbered — they
+are baked into every emitter record, so compacting them would mean rewriting the whole table — and
+`bucketCount()` is sized from the id capacity, the set's peak, so it does not move every time an
+effect comes or goes. An id below the peak with nothing in it is an empty bin, which rounds up to
+zero workgroups and shifts nothing after it. **Section capacity** only rises: a repack (which happens
+when a section has no contiguous run long enough) compacts what is live and grows only if it must,
+so a set that peaked at a hundred effects does not pay for a resize every time it returns to three.
+
+A repack is the one change no emitter announces, since it is not an edit to any of them.
+`EmitterRegistry.flush` asks the heap once per frame — `placement_version` — and restages every row
+when it has moved.
 
 Every row of a frame is staged through one module-static record (`EmitterRegistry`), so a flush
 allocates nothing however many rows it restages.
@@ -247,8 +325,8 @@ unit, branch the opcode switch on a scalar and index the register file through M
 waterfall. A wave holding two programs would run one over the other's particles, so the coherence
 pass is part of simulate's correctness. Emit keeps a per-lane decode: its waves span emitters.
 
-The bucket key is the **program**, not the emitter: `ProgramArena` deduplicates by content and hands
-back a dense `program_id` the emitter record carries, so emitters compiled from the same graph share
+The bucket key is the **program**, not the emitter: `ProgramHeap` deduplicates by content and hands
+back a `program_id` the emitter record carries, so emitters compiled from the same graph share
 one bucket. Each bucket is padded out to `PARTICLE_SIMULATE_WORKGROUP_SIZE` (64 — a multiple of both
 plausible subgroup widths, so no shader needs to query `subgroup_size`), which is what makes the
 grouping hold at wave granularity: an unpadded boundary lands mid-wave and that wave spans two
@@ -345,12 +423,17 @@ src/shade/renderer/particles/
   isa/ParticleAssembler.js           tiny assembler (build programs in tests/library)
   vm/ParticleVMReference.js          JS reference executor
   vm/chunk_particle_vm.js            WGSL interpreter CodeChunk (parity target)
+  vm/chunk_particle_vm_registers_fast.js  register file in var<private> — the interpreter that runs
+  vm/chunk_particle_vm_registers_wide.js  register file in storage — the fallback
+  shaders/chunk_particle_simulate_step.js one particle's simulate, shared by both simulate shaders
+  shaders/chunk_particle_emit_step.js     one newborn's emit, shared by both emit shaders
   graph/ParticleNodeDescription.js   node type base (ports + lowering)
   graph/ParticleNodeRegistry.js      standard node library (a NodeRegistry)
   graph/particle_graph_authoring.js  authoring sugar over core/model/node-graph
   graph/compile_particle_graph.js    graph → Program (register alloc, const intern)
   layout/ParticleLayout.js           attribute schema ↔ record word offsets
   data/PARTICLE_EMITTER_STRUCT.js    the emitter row + flag/blend/projection encoding
+  data/particle_emitter_record.js    emitter + context -> one row of that struct
   data/PARTICLE_EMITTER_STATE.js     the GPU-owned per-emitter state row (second table of the database)
   data/PARTICLE_DATABASE_SPEC.js     the GPUDatabase schema, and the emitter table's descriptor
   data/PARTICLE_COUNTERS.js          counter slot indices
@@ -358,9 +441,11 @@ src/shade/renderer/particles/
   coherence/particle_program_buckets.js  CPU reference for the simulation-order bucketing
   coherence/shader_particle_bucket.js    reset / histogram / pad / scatter / fill
   coherence/graph_particle_bucket.js     frame-graph wiring, around graph_prefix_scan_csdldf
-  runtime/ProgramArena.js            the one packed [header][constants][code] buffer
-  runtime/ParticleEmitter.js         one emitter — a Node3D, and the CPU model of one table row
-  runtime/EmitterRegistry.js         GPUDatabase(emitters) + the live emitters + the arena
+  runtime/ProgramHeap.js             the one packed [header][constants][code] buffer, allocator-backed
+  runtime/ProgramPlacement.js        where one program sits in it — what an emitter record carries
+  runtime/ParticleEmitter.js         one emitter — a Node3D and an effect, with no GPU in it
+  runtime/GPUParticleEmitterContext.js  what a registry assigns one: row, generation, placement, patch
+  runtime/EmitterRegistry.js         GPUDatabase(emitters) + the live emitters + their contexts + the program heap
   runtime/create_particle_effect.js  layout + INIT/UPDATE graphs → compiled effect
   shaders/shader_particle_spawn_commands.js  CPU bursts → pending spawns
   shaders/shader_particle_emitter_tick.js    per-emitter spawn decision
@@ -384,7 +469,7 @@ src/shade/renderer/particles/
 
 ## Testing
 
-- Pure JS: layout packing, assembler, register allocator, node compiler, arena/emitter/registry
+- Pure JS: layout packing, assembler, register allocator, node compiler, heap/emitter/registry
   bookkeeping (via `SoftwareGPUDevice`), the header encoding.
 - WGSL via emulator: VM opcode parity (JS vs WGSL), curve sampling, sort key/depth, atlas+flipbook
   UV math, billboard expansion, soft-depth fade, and every compute pass on small fixtures — the tick

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

@@ -6,16 +6,29 @@
  * ## 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) and
- * render-order (sort) 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 arena, the database on its own pages — are grown inside {@link execute}, the way
- * ReSTIR's reservoirs follow the resolution.
+ * 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
+ * database on its own pages — 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.
  *
  * 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
- * are one packed buffer.
+ * are one packed buffer. The one exception is the wide-register fallback (below), whose emit and
+ * simulate passes bind a ninth for the register file — inside the ten the engine already demands of
+ * an adapter, but past the default.
+ *
+ * ## Two interpreters
+ *
+ * The VM's register file normally lives in shader registers, and is therefore small — see
+ * {@link ./ParticleConstants.js PARTICLE_VM_FAST_REGISTER_SLOTS}. An effect whose compiled program
+ * needs more than it holds does not fail: the whole system swaps emit and simulate for variants
+ * that keep the file in a storage buffer, which is far slower and effectively unbounded. The choice
+ * is per-frame, whole-system, and made here — the registry reports `max_register_count` over the
+ * effects it holds and this is where that number meets the VM's; nothing about authoring a graph has
+ * a register ceiling.
  *
  * ## Emitters are scene nodes
  *
@@ -34,15 +47,20 @@
  * command list that a pass adds to the emitter's pending spawns, on the same path as everything
  * else. See `graph_particles.js` for the frame.
  *
- * ## Drawing
+ * ## Drawing, and the one thing the mode changes
  *
- * {@link simulate} records everything that moves particles and leaves the alive list and the
- * indirect draw args as graph handles. Two things draw them. Under the renderer the system is an
- * `AVBOITSideChannel`: the transparency orchestrator asks it for its occupancy, its extinction and
- * its draw at the three points where the transparent meshes have contributed theirs
- * ({@link avboit_occupancy}, {@link avboit_splat}, {@link avboit_draw}), and the particles
- * composite order-independently with them. A page without that pipeline calls {@link execute},
- * which sorts and draws the billboards straight over a colour target.
+ * {@link execute} is the whole per-frame call, once per frame. It always records everything that
+ * moves particles and leaves the alive list and the indirect draw args as graph handles; what it
+ * records after that is the {@link ParticleRenderMode} it was given.
+ *
+ * `BILLBOARD` sorts the alive list back-to-front and draws it over a colour target, because
+ * premultiplied over-blending is order-dependent. `AVBOIT` records neither: under the renderer the
+ * system is an `AVBOITSideChannel`, and the transparency orchestrator asks it for its occupancy, its
+ * extinction and its draw at the three points where the transparent meshes have contributed theirs
+ * ({@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.
  *
  * ## Allocation
  *
@@ -99,7 +117,7 @@ export class GPUParticleSystem {
     max_catchup_seconds: number;
     /**
      * View-depth range the render sort quantises: particles nearer than `[0]` share the front bin,
-     * farther than `[1]` the back one.
+     * farther than `[1]` the back one. Read only by {@link ParticleRenderMode.BILLBOARD}.
      * @type {Float32Array}
      */
     sort_depth_range: Float32Array;
@@ -112,7 +130,7 @@ export class GPUParticleSystem {
     /** @type {GPUSampler} */
     atlas_sampler: GPUSampler;
     /**
-     * The persistent GPU buffers, by the names {@link graph_particles} binds them under. Exposed for
+     * The persistent GPU buffers, by the names the graph functions bind them under. Exposed for
      * inspection — a harness copying the counters out to display them — never for the frame loop,
      * which reads nothing back. Entries that grow with the emitter set are replaced in place.
      *
@@ -130,11 +148,15 @@ export class GPUParticleSystem {
      */
     get emitters(): import("./runtime/ParticleEmitter.js").ParticleEmitter[];
     /**
-     * Number of simulation-order buckets — one per distinct compiled program.
+     * Number of simulation-order buckets — one per program id the registry can hand out, which is
+     * its peak number of distinct compiled programs rather than its current one.
      *
      * This is the coherence pass's only host-provided number, and it is static topology rather than
-     * per-frame state: it changes when a new effect is registered, not as particles are born and
-     * die. Everything the pass measures per frame stays on the GPU.
+     * per-frame state: it changes when an effect the set has never held is registered, not as
+     * particles are born and die. Everything the pass measures per frame stays on the GPU. Sizing it
+     * from the peak rather than the live count is what keeps it from moving every time an effect is
+     * unregistered — the bins of released ids are empty, and an empty bin rounds up to zero
+     * workgroups and shifts nothing after it.
      *
      * @returns {number}
      */
@@ -154,11 +176,16 @@ export class GPUParticleSystem {
      */
     spawn(emitter: import("./runtime/ParticleEmitter.js").ParticleEmitter, count: number): void;
     /**
-     * The simulation half of the frame: reconcile the emitter set with the scene, push what changed
-     * to the GPU, and record every pass that moves particles — through to the indirect draw args.
-     * What it leaves as graph handles is what a draw consumes: {@link execute} draws them
-     * standalone, and the AVBOIT side-channel methods below draw them through the renderer's
-     * transparency pipeline.
+     * The system's whole contribution to the frame: the simulation, then whatever `mode` says draws
+     * it.
+     *
+     * {@link ParticleRenderMode.BILLBOARD} adds the depth sort and one billboard draw over `color`
+     * with fixed-function blending, for a page with no transparency pipeline of its own.
+     * {@link ParticleRenderMode.AVBOIT} adds nothing: the orchestrator draws the particles later in
+     * the frame through {@link avboit_occupancy}, {@link avboit_splat} and {@link avboit_draw}, off
+     * the handles this just produced, and its accumulators are order-independent — so the sort is
+     * skipped and its buffers are never allocated. `color` comes straight back either way, so a
+     * caller can assign the result unconditionally and let the mode be the only difference.
      *
      * Call after the scene context has built for the frame (`GPUSceneContext#update`), so every
      * emitter node has its `transforms` row, and after the hierarchy pass has run, so the rows'
@@ -176,36 +203,22 @@ export class GPUParticleSystem {
      * @param {number} params.scene_database graph handle of the scene database — the one the
      *   hierarchy pass returned, so this reads the matrices it composed
      * @param {number} params.dt seconds since the previous frame
-     * @returns {import("./graph_particles.js").ParticleSimulationHandles}
-     */
-    simulate({ graph, camera, scene_database, dt }: {
-        graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-        camera: number;
-        scene_database: number;
-        dt: number;
-    }): import("./graph_particles.js").ParticleSimulationHandles;
-    /**
-     * The whole standalone frame: {@link simulate}, then the depth sort and one billboard draw over
-     * a colour target with fixed-function blending. For a page without the renderer's transparency
-     * pipeline; under the renderer the drawing is AVBOIT's.
-     *
-     * @param {object} params every parameter of {@link simulate}, plus a target to draw over
-     * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
-     * @param {number} params.camera graph handle of the camera uniform buffer
-     * @param {number} params.scene_database graph handle of the scene database
-     * @param {number} params.dt seconds since the previous frame
-     * @param {number} params.color graph handle of the colour target to draw over
-     * @param {number} params.depth graph handle of the scene depth (tested, never written)
-     * @returns {number} the colour handle after the particle draw
+     * @param {ParticleRenderMode} [params.mode] who draws, and so whether there is a sort
+     * @param {number} [params.color] graph handle of the colour target to draw over. Required by
+     *   `BILLBOARD`; returned untouched by `AVBOIT`
+     * @param {number} [params.depth] graph handle of the scene depth (tested, never written).
+     *   Required by `BILLBOARD`
+     * @returns {number|undefined} the colour handle after the particle draw, or `color` unchanged
      */
-    execute({ graph, camera, scene_database, color, depth, dt }: {
+    execute({ graph, camera, scene_database, color, depth, dt, mode }: {
         graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
         camera: number;
         scene_database: number;
         dt: number;
-        color: number;
-        depth: number;
-    }): number;
+        mode?: ParticleRenderMode;
+        color?: number;
+        depth?: number;
+    }): number | undefined;
     /**
      * `AVBOITSideChannel#avboit_occupancy`: the emitters' bounds spheres, as depth slices.
      *
@@ -295,4 +308,5 @@ export class GPUParticleSystem {
     #private;
 }
 import { EmitterRegistry } from "./runtime/EmitterRegistry.js";
+import { ParticleRenderMode } from "./ParticleRenderMode.js";
 //# sourceMappingURL=GPUParticleSystem.d.ts.map

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