@woosh/meep-engine 3.15.0 → 3.16.0

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts

@@ -0,0 +1,87 @@
+/**
+ * A source of transparent fragments that is not a meshlet bucket, drawn through the AVBOIT pipeline
+ * alongside the transparent meshes: particles today, anything quad- or point-shaped tomorrow.
+ *
+ * The orchestrator (`graph_rasterize_meshes_transparent_avboit`) collects three things from every
+ * transparent surface in the frame, in this order, and a side channel is asked for each at the
+ * point where the meshlet buckets have just contributed theirs:
+ *
+ * 1. **occupancy** — which virtual depth slices the channel's fragments can land in, OR-ed into the
+ *    occupancy bits before the warp is built. Conservative bounds are fine; a fragment outside the
+ *    slices its channel marked lands on the boundary of the nearest run rather than anywhere wrong,
+ *    but marking what will be splatted is what keeps it sharp.
+ * 2. **splat** — each fragment's RGB extinction, added into the voxel volume at the volume's
+ *    resolution, through `avboit_splat_slice`, after the meshlets' extinction is in.
+ * 3. **draw** — each fragment's shaded contribution into the four accumulators
+ *    (`avboit_draw_fragment_body`), at internal resolution, depth-tested against the opaque scene,
+ *    after the meshlets have drawn.
+ *
+ * The integrate and resolve passes see no difference between a meshlet's fragment and a channel's:
+ * a channel that follows the three contracts below composites exactly as a transparent mesh does,
+ * order-independently, against it and against every other channel.
+ *
+ * Every method takes the frame graph and the handles the orchestrator currently holds, and returns
+ * the handles the next reader must take — the frame-graph threading rule, unchanged. A channel with
+ * nothing to add returns what it was given.
+ */
+export type AVBOITSideChannel = {
+    /**
+     * add the channel's slices to the occupancy bits; returns the bits'
+     * handle after the write. `cluster_parameters` is the frame's depth curve (`avboit_build_depth_curve`).
+     */
+    avboit_occupancy: (args: {
+        graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        camera: number;
+        cluster_parameters: ArrayLike<number>;
+        occupancy: number;
+    }) => number;
+    /**
+     * add the channel's
+     * extinction to the volume; returns the volume's handles after the write. `depth_texture` is
+     * the opaque scene's depth, for a channel whose coverage depends on it — whatever it records
+     * here has to be the coverage its draw weights the accumulators by, or the volume occludes
+     * with a surface the accumulators never drew.
+     */
+    avboit_splat: (args: {
+        graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        camera: number;
+        warp: number;
+        depth_texture: number;
+        voxel_resolution: number[];
+        volume: {
+            extinction: number;
+            overflow: number;
+            dummy: number;
+        };
+    }) => {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    /**
+     * draw the
+     * channel's fragments into the accumulators; returns their handles after the draw.
+     */
+    avboit_draw: (args: {
+        graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext;
+        camera: number;
+        depth_texture: number;
+        warp: number;
+        integral: number;
+        volumetrics_lut: number;
+        volumetrics_metadata: number;
+        accumulators: {
+            color: number;
+            norm: number;
+            extinction: number;
+            emission: number;
+        };
+    }) => {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+};
+//# sourceMappingURL=AVBOITSideChannel.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA2BqB;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;yBAEM;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;wBAKzC;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js

@@ -0,0 +1,61 @@
+/**
+ * A source of transparent fragments that is not a meshlet bucket, drawn through the AVBOIT pipeline
+ * alongside the transparent meshes: particles today, anything quad- or point-shaped tomorrow.
+ *
+ * The orchestrator (`graph_rasterize_meshes_transparent_avboit`) collects three things from every
+ * transparent surface in the frame, in this order, and a side channel is asked for each at the
+ * point where the meshlet buckets have just contributed theirs:
+ *
+ * 1. **occupancy** — which virtual depth slices the channel's fragments can land in, OR-ed into the
+ *    occupancy bits before the warp is built. Conservative bounds are fine; a fragment outside the
+ *    slices its channel marked lands on the boundary of the nearest run rather than anywhere wrong,
+ *    but marking what will be splatted is what keeps it sharp.
+ * 2. **splat** — each fragment's RGB extinction, added into the voxel volume at the volume's
+ *    resolution, through `avboit_splat_slice`, after the meshlets' extinction is in.
+ * 3. **draw** — each fragment's shaded contribution into the four accumulators
+ *    (`avboit_draw_fragment_body`), at internal resolution, depth-tested against the opaque scene,
+ *    after the meshlets have drawn.
+ *
+ * The integrate and resolve passes see no difference between a meshlet's fragment and a channel's:
+ * a channel that follows the three contracts below composites exactly as a transparent mesh does,
+ * order-independently, against it and against every other channel.
+ *
+ * Every method takes the frame graph and the handles the orchestrator currently holds, and returns
+ * the handles the next reader must take — the frame-graph threading rule, unchanged. A channel with
+ * nothing to add returns what it was given.
+ *
+ * @typedef {object} AVBOITSideChannel
+ * @property {(args: {
+ *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
+ *     camera: number,
+ *     cluster_parameters: ArrayLike<number>,
+ *     occupancy: number,
+ * }) => number} avboit_occupancy add the channel's slices to the occupancy bits; returns the bits'
+ *     handle after the write. `cluster_parameters` is the frame's depth curve (`avboit_build_depth_curve`).
+ * @property {(args: {
+ *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
+ *     camera: number,
+ *     warp: number,
+ *     depth_texture: number,
+ *     voxel_resolution: number[],
+ *     volume: {extinction: number, overflow: number, dummy: number},
+ * }) => {extinction: number, overflow: number, dummy: number}} avboit_splat add the channel's
+ *     extinction to the volume; returns the volume's handles after the write. `depth_texture` is
+ *     the opaque scene's depth, for a channel whose coverage depends on it — whatever it records
+ *     here has to be the coverage its draw weights the accumulators by, or the volume occludes
+ *     with a surface the accumulators never drew.
+ * @property {(args: {
+ *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
+ *     view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext,
+ *     camera: number,
+ *     depth_texture: number,
+ *     warp: number,
+ *     integral: number,
+ *     volumetrics_lut: number,
+ *     volumetrics_metadata: number,
+ *     accumulators: {color: number, norm: number, extinction: number, emission: number},
+ * }) => {color: number, norm: number, extinction: number, emission: number}} avboit_draw draw the
+ *     channel's fragments into the accumulators; returns their handles after the draw.
+ */
+
+export {};

package/src/shade/renderer/rasterize/native/avboit/AVBOIT_LEDGER.md

@@ -461,3 +461,182 @@ counterpart in `shader/chunk/math/`.
 
 **Verified.** Every spec in `rasterize/` (the avboit directory's now-larger set, MBOIT's, the shared
 bucket code) and the type check.
+
+## 19. Side channels, and particles as the first one — 2026-09-04
+
+Alex: *"let's widen out AVBOIT so we can put particle render in there, that's where particles should
+go. Make sure the extension is clean. No need to bother with MBOIT, it's going to be deprecated...
+I don't think packing particle quads into meshlets is the way to go, so likely a side channel."*
+
+**The seam.** `AVBOITSideChannel.js` is a JSDoc contract, no base class: three methods, called by
+the orchestrator at the three points where the meshlet buckets have just contributed theirs —
+`avboit_occupancy` before the warp is built, `avboit_splat` before integrate, `avboit_draw` before
+resolve. Each takes the handles the orchestrator holds and returns the handles the next reader must
+take, which is the frame graph's own threading rule and nothing new. The orchestrator gained one
+parameter, `side_channels = []`, and one changed condition: it used to return early when no
+transparent material had meshlets, and now returns early only if there are also no channels.
+Integrate and resolve were not touched — they cannot tell a channel's fragment from a meshlet's,
+which is the property that makes this a seam rather than a special case.
+
+**The fourth accumulator.** An additive fragment covers nothing: it writes zero extinction and zero
+norm, so the resolve's renormalization — `(1 - T_total) / Σnorm`, which redistributes exactly the
+light the covering surfaces took from the scene — must not scale it. It cannot share the `color`
+accumulator for that reason. So `emission` joins as a fourth target, added to the resolve outside
+the normalization, holding light the draw already attenuated by the transmittance in front of it.
+The cost is honest and paid whether or not a channel is present: one more `rgba16float` at internal
+resolution, and every transparent mesh fragment writing `vec4(0)` to it. Buying it back would mean a
+three-target draw pipeline beside the four-target one — a variant, which the house rule and the
+plan's §5 both refuse — or a post-resolve additive pass with its own pipeline and bind group. One
+target is the cheaper of the three.
+
+**Shared, not copied.** The splat's voxel write (the two-slice linear split, the overflow mark) came
+out of the meshlet splat into `chunk_avboit_splat_slice`, so the particle splat writes the volume
+through the same code, not a second implementation of it. On the particle side the billboard vertex
+stage came out of the standalone renderer into `chunk_particle_billboard_vertex`, shared by three
+pipelines, and the emitter's world bounds sphere into `chunk_particle_emitter_world_sphere`, shared
+by the tick's frustum cull and the new occupancy.
+
+**What the review found.** Four things, all fixed here:
+
+- *A binding that lied.* The shared vertex chunk read its slot list from a binding named `sorted`.
+  The standalone path binds the depth-sorted list there; the AVBOIT passes bind the alive list,
+  because the volume makes order irrelevant and the sort does not run on that path. Renamed
+  `draw_list` in the chunk and all three pipelines: which list it is, is the caller's choice.
+- *Bounds with new teeth.* The occupancy is per emitter, from the bounds sphere — the field that
+  until now only fed the optional simulation culling and that an emitter not opting in could leave
+  at its default. A particle outside it still draws, but its extinction lands in whatever physical
+  slice the warp put nearest, so it occludes at slightly the wrong depth. Documented on the field
+  and in the particle design, because it is now a rendering input.
+- *One simulation per view.* `simulate` steps the system and hands out handles into the graph it
+  recorded into, so two views of one scene would step it twice. The renderer has one view per
+  `render` call, so it holds today; the fix when that changes is to separate the step from the
+  import. Documented on the method rather than built speculatively.
+- *A teardown that leaked.* `Renderer.destroy` did not destroy the particle systems it creates per
+  scene context. It does now.
+
+**Checked and found sound.** The volume and the accumulators are always created by the meshlet
+passes before a channel is asked, even at zero materials, so a particles-only frame has them; the
+splat's dummy attachment is cleared by the meshlet splat before the particle splat loads it; passes
+that write imported buffers are marked as side effects by `FramePassBuilder`, so the simulation
+still advances in a frame whose transparency pass is off; a fresh `FrameGraph` per frame makes the
+"simulated into this graph" assertion catch a stale handle set loudly; and the depth texture is
+bound as a read-only attachment and a sampled texture in the same pass, which WebGPU allows and the
+soft fade needs.
+
+**Under MBOIT.** Particles simulate and do not draw. MBOIT is the legacy path and gets no new
+sources; `Renderer.feature_particles_enabled` says so where a reader will hit it.
+
+**Verified.** Tiers 1–3: the WGSL validity spec (the three new pipelines parse, validate, and stay
+inside the eight-storage-buffer budget), the occupancy pass on the emulator against the depth
+curve's own arithmetic, the three graph passes on the software device (pass order, attachments,
+indirect draws, the read-only depth), the orchestrator's call order and the renderer's wiring, and
+the whole engine suite — 2321 files, 16119 tests — plus the type check. Not verified: any of it on a
+device. The Browser pane handed out no WebGPU adapter this session, so even the real Tint compile
+that ledger 18's review leaned on is still owed for these three shaders.
+
+## 20. Adversarial review of the side channel — 2026-09-04
+
+Alex ran the playground, said it works, and asked for an adversarial review. A picture that looks
+right is weak evidence for this pipeline: every defect below survives one, because each is either
+a second copy of something small, a disagreement between two passes about the same fragment, or a
+path the scene on screen does not take.
+
+**What the volume and the accumulators disagreed about.** The pipeline's whole contract is that the
+extinction the splat records is the coverage the draw weights its accumulators by
+(`avboit_draw_fragment_body`'s own header says so). Two fragments broke it:
+
+- *The soft fade.* The draw faded a particle's alpha against the scene depth; the splat had no depth
+  binding at all and recorded the unfaded coverage. A smoke card fading out where it meets the floor
+  drew nothing there and still wrote full extinction, so the floor was darkened through a card that
+  was invisible — the seam soft particles exist to remove, one layer down. The splat now samples the
+  same depth (one texel per voxel) and applies the same fade, through
+  `chunk_particle_scene_view_depth`, which the draw took its inline copy of the linearization from.
+  `avboit_splat` therefore takes `depth_texture` — the one contract change.
+- *Additive and the fog.* The draw composited volumetric in-scatter into every fragment and then put
+  additive ones in `emission`, which the resolve adds *outside* the normalization. The scene behind
+  already carries that in-scatter, and nothing subtracts it: a hundred overlapping sparks added a
+  hundred copies of the fog. An emitting fragment is now dimmed by the fog's transmittance and
+  carries none of its light; a covering one still re-adds it, weighted by the coverage it took,
+  because it hides the part of the scene it owes it to.
+
+**Two more in the same fragment.** `PREMULTIPLIED` with zero alpha is the engine's other spelling of
+additive — the billboard pipeline blends it that way — and the draw branched on the blend enum, so
+such a sprite was treated as covering, written to `color` with zero `norm`, and multiplied by a
+normalization of zero: it disappeared. The routing is on coverage now, which is what the splat
+already used, so the two agree by construction. And the coverage ceiling was applied to `norm` and
+`extinction` but not to `color`, unbounded above (a curve can drive alpha past 1) and unguarded
+below (a negative alpha made a negative extinction, and `exp(-sum)` then brightened the scene).
+
+All four are pinned on the emulator: the fragment's decision came out into
+`chunk_particle_avboit_contribution` as its own no-behaviour-change step, then nine tests, four of
+them red against the old code.
+
+**Teardown.** `destroy()` freed the buffers and left every emitter node holding a row of the table it
+had just freed. A renderer rebuilt after a device loss makes a fresh system whose membership sweep
+reads `row !== -1` as "already mine", takes the moved branch rather than the arrived one, and never
+registers the emitter: it stops emitting for good. It retires them now. The default 1×1 atlas was
+also unreachable — only its view was kept — and is held and freed.
+
+**The orchestrator can be run at tier 3 after all.** This file said it could not: it needs a view
+context over meshlet geometry no spec builds. That is true of a frame *with transparent meshes* —
+and the path side channels added is the other one. A scene with no transparent materials and one
+channel reaches for no geometry, so the whole orchestrator now runs on the mock, and the ordering
+contract and the handle threading are pinned from the outside instead of by reading the source for
+call order. The mock gained `indirect-first-instance` for it, on the argument its own header already
+makes for `subgroups`: it permits a field in an indirect draw the mock never reads, issuing a draw it
+never runs, and refusing it left the transparency orchestration untestable for a reason unrelated to
+what the tier asserts.
+
+**Found and left alone, on purpose:**
+
+- *The occupancy marks every emitter*, with no frustum test and no liveness test, where the meshlet
+  occupancy dispatches over the HZB-filtered collection. An idle or off-screen emitter still reserves
+  its depth run, and the warp then fits more occupied virtual slices into the same 128 physical ones.
+  It costs precision, never correctness. A frustum test is the obvious fix and belongs with a scene
+  that shows the cost.
+- *The occupancy sphere bounds particle centres*, not the quads' own depth extent, which for a
+  stretched or world-oriented particle reaches a size (or more) past the centre. Documented on
+  `ParticleEmitter.bounds_radius` rather than inflated by a guess.
+- *Particles have no motion vectors.* The transparency composite happens before TAA, so a fast spark
+  is reprojected with the background's motion and ghosts. Transparent meshes have had this property
+  since before AVBOIT; particles make it easier to see. The playground has a TAA switch.
+- *One system per scene context is never released*, mirroring `SceneManager`'s own map. A per-scene
+  release path is a design addition, not a fix.
+- *`simulate` steps once per view*, so two views of one scene would step it twice. Documented on the
+  method; the renderer has one view per `render` call today.
+
+**Verified.** The whole engine suite and the type check at budget. The playground page was loaded
+from the dev server again — import graph, WASM meshlet build, scene, camera controller under a
+synthetic drag, and every control handler including the two error paths added here. Still no adapter
+in the Browser pane, so still no picture and still no real Tint compile.
+
+## 21. What the device caught and the review did not — 2026-09-04
+
+Alex ran entry 20's work and got:
+
+```
+Binding entry textureView not set.
+ - While validating entries[6] against { binding: 6, ..., texture: {sampleType: UnfilterableFloat, ...} }
+ - While encoding [RenderPassEncoder "Particle AVBOIT Splat"].SetBindGroup(0, ...)
+```
+
+Entry 20 added `scene_depth` to the splat's bindings between the atlas and its sampler, and added
+the depth view to the *end* of the positional array the pass hands to `BindGroupDescriptor.from`.
+Everything after the insertion point slid along by one: binding 6 wanted a texture and got the
+sampler. Nothing on this side of the device could see it. The frame graph does not know what a
+binding means, the mock does not validate an entry against its layout, and both of entry 20's new
+tests looked for the depth view's *presence* in the group rather than its position.
+
+The fix is not the index. Both particle render passes now build their bindings by name, through
+`ShaderResourceSetDescriptor#generateBindings` — the path the standalone billboard pass already
+used, and the reason it never had this bug — so the order a shader declares its bindings in is the
+shader's own business and nothing here mirrors it. `constructRenderPass` sets the pipeline and every
+group from that, which also took the manual `setBindGroup` calls out.
+
+And the tier that missed it can see it now: `expect_bindings_match_layout` walks a recorded pass and
+asserts every entry is the *kind* — buffer, texture or sampler — its pipeline layout declares at that
+binding. It fails against the shipped code. That check is worth copying to any pass built by hand.
+
+**The lesson for this directory:** a positional bind-entry list is a latent version of this defect in
+every pass that has one, and it surfaces only on hardware, only when that pass first encodes. The
+meshlet passes here still build theirs positionally.

package/src/shade/renderer/rasterize/native/avboit/AVBOIT_PLAN_2026_09_03.md

@@ -1,6 +1,6 @@
 # Adaptive voxel-based order-independent transparency (AVBOIT) — implementation plan
 
-**Status:** implemented, default mode, device tier in progress — revision 4
+**Status:** implemented, default mode, device tier in progress — revision 5
 **Date:** 2026-09-03
 **Author:** Alex Goldring / Company Named Limited, with Claude
 **Scope:** `src/shade/renderer/rasterize/native/avboit/` (new), `src/shade/renderer/ShadeTransparencyMode.js`
@@ -26,6 +26,13 @@ Games, SIGGRAPH 2025 (talk deck, 60 pages, `AVBOIT_SIG2025_MDROBOT-final.pdf`)
 > slicing (§3.2) rather than a second one; the bit fold reuses the Morton decode; the integral samples through
 > the sampler the draw already binds; the per-material draw loop is one shared module for both pipelines; and
 > the chunks follow the one-function-per-file convention (§5).
+>
+> **Revision 5** (ledger entry 19) widens the pipeline past meshlets. `AVBOITSideChannel` is a contract for a
+> transparent source that is not a meshlet bucket — the GPU particles are the first — asked for its occupancy,
+> its splat and its draw at the three points where the meshlet buckets contribute theirs (§3.1). The draw grew
+> a fourth accumulator, `emission`, for additive fragments: they cover nothing, so the resolve's
+> renormalization must not scale them (§3.8, §3.9). Integrate and resolve are otherwise untouched, and MBOIT,
+> now the legacy path, gets no channel of its own.
 
 ---
 
@@ -137,6 +144,14 @@ additive and MBOIT ignores them.
 The front and double-sided variants of steps 4 and 6 exist for the same reason as in MBOIT: different
 `cullMode`, so a different pipeline, threaded through `rp_rewrite_for_primitive_state`.
 
+*Revision 5:* steps 2, 4 and 6 also take contributions from **side channels** — transparent sources that are
+not meshlet buckets, the GPU particles being the first. `graph_rasterize_meshes_transparent_avboit` takes
+`side_channels`, an array of `AVBOITSideChannel`, and asks each for its occupancy after the meshlet buckets'
+(step 2), its splat after theirs (step 4) and its draw after theirs (step 6), threading the handles the way
+every pass here does. Steps 5 and 7 are unchanged and cannot tell the two apart. Step 6 writes a fourth
+accumulator, `accum_emission` (§3.9). The orchestrator now returns early only when there are neither
+transparent materials nor channels.
+
 ### 3.2 Depth curve and virtual slices
 
 Let `z` be the fragment's view-space depth (`get_view_space_depth`, positive, world units). *Revision 4:* the
@@ -309,11 +324,19 @@ reads the scene colour as an input and writes a fresh `rgba16float` transient (t
 ```
 T_total = exp(-accum_ext)
 norm    = accum_norm > 1e-4 ? (1 - T_total) / accum_norm : 0
-out     = scene × T_total + accum_color × norm
+out     = scene × T_total + accum_color × norm + accum_emission
 ```
 
 with the same NaN backstop as MBOIT, falling back to the scene colour.
 
+*Revision 5:* `accum_emission` is the fourth accumulator, for fragments that emit without covering —
+additive particles today. Such a fragment writes zero extinction and zero norm, so the normalization, whose
+job is to redistribute exactly the `1 - T_total` the covering surfaces took from the scene, must not touch
+it; it joins the sum as it is, already attenuated by the transmittance in front of it at draw time. The
+alternative, a three-target draw pipeline for frames with no such source, is a variant of the draw the plan
+refuses to keep two of (§5); the cost of the fourth target is one `rgba16float` at internal resolution and a
+`vec4(0)` written by every transparent mesh fragment.
+
 ### 3.10 The switch
 
 `src/shade/renderer/ShadeTransparencyMode.js`:
@@ -390,6 +413,8 @@ src/shade/renderer/rasterize/native/avboit/
     chunk_avboit_integral_depth_coordinate.js   bias, warp, boundary-centred texel coordinate
     chunk_avboit_sample_transmittance.js    trilinear sample and exp
     chunk_avboit_transmission_tint.js       base colour × weight
+    chunk_avboit_splat_slice.js             the two-slice voxel write, shared with the side channels
+    AVBOITSideChannel.js                    the contract for a non-meshlet transparent source (rev 5)
     shader_avboit_occupancy.js              compute, per meshlet
     shader_avboit_build_warp.js             compute, one invocation
     shader_avboit_splat.js                  render pass, 1/8 resolution, atomics

package/src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.d.ts

@@ -6,17 +6,24 @@
  *
  * Per fragment (plan §3.8): full forward shading and the inline volumetric composite exactly as the
  * MBOIT resolve does them, then the transmittance of everything in front from the integral texture,
- * and three additive outputs:
+ * and four additive outputs:
  *
  * ```
  * color      += shaded × coverage × T            premultiplied, as MBOIT
  * norm       += (1 - T_self) × T                 per channel — the normalization denominator
  * extinction += -log(T_self)                     per channel — the total, resolved to exp(-Σ)
+ * emission   += 0                                light that occludes nothing; a surface has none
  * ```
  *
  * `T_self = (1 - coverage) × tint` is the same self-transmittance the splat recorded for this
  * surface, through the same chunk, which is what keeps the volume and the accumulators consistent.
  *
+ * `emission` is the accumulator for light that is added without covering anything — an additive
+ * particle, a glow. It is already attenuated by `T` when written and joins the resolve as it is,
+ * outside the coverage normalization the other three go through; a surface with coverage writes
+ * nothing to it. It exists so a side channel (`AVBOITSideChannel`) can add light through the same
+ * pass as the surfaces, in the same order-independent way.
+ *
  * The transmittance is sampled *before* shading, and a fragment the volume already calls extinct
  * (`T ≤ 1/256` in every channel) is discarded without being shaded — the per-fragment form of the
  * deck's zero-transmittance early-out, without its depth-buffer rewrite. The bound on what that
@@ -31,7 +38,7 @@ export const AVBOIT_DRAW_FRAGMENT_BODY: string;
  */
 export const AVBOIT_DRAW_FRAGMENT_DEPENDENCIES: CodeChunk[];
 /**
- * The three additive `rgba16float` targets, in `AVBOITDrawOutput` order.
+ * The four additive `rgba16float` targets, in `AVBOITDrawOutput` order.
  * @type {GPUColorTargetState[]}
  */
 export const AVBOIT_DRAW_TARGETS: GPUColorTargetState[];

package/src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"avboit_draw_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wCAFU,MAAM,CA8DV;AAEN;;;GAGG;AACH,gDAFU,WAAW,CASnB;AAEF;;;GAGG;AACH,kCAFU,qBAAqB,CAiB3B"}
+{"version":3,"file":"avboit_draw_fragment_body.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wCAFU,MAAM,CAgEV;AAEN;;;GAGG;AACH,gDAFU,WAAW,CASnB;AAEF;;;GAGG;AACH,kCAFU,qBAAqB,CAiB3B"}

package/src/shade/renderer/rasterize/native/avboit/avboit_draw_fragment_body.js

@@ -15,17 +15,24 @@ import { chunk_avboit_transmission_tint } from "./chunk_avboit_transmission_tint
  *
  * Per fragment (plan §3.8): full forward shading and the inline volumetric composite exactly as the
  * MBOIT resolve does them, then the transmittance of everything in front from the integral texture,
- * and three additive outputs:
+ * and four additive outputs:
  *
  * ```
  * color      += shaded × coverage × T            premultiplied, as MBOIT
  * norm       += (1 - T_self) × T                 per channel — the normalization denominator
  * extinction += -log(T_self)                     per channel — the total, resolved to exp(-Σ)
+ * emission   += 0                                light that occludes nothing; a surface has none
  * ```
  *
  * `T_self = (1 - coverage) × tint` is the same self-transmittance the splat recorded for this
  * surface, through the same chunk, which is what keeps the volume and the accumulators consistent.
  *
+ * `emission` is the accumulator for light that is added without covering anything — an additive
+ * particle, a glow. It is already attenuated by `T` when written and joins the resolve as it is,
+ * outside the coverage normalization the other three go through; a surface with coverage writes
+ * nothing to it. It exists so a side channel (`AVBOITSideChannel`) can add light through the same
+ * pass as the surfaces, in the same order-independent way.
+ *
  * The transmittance is sampled *before* shading, and a fragment the volume already calls extinct
  * (`T ≤ 1/256` in every channel) is discarded without being shaded — the per-fragment form of the
  * deck's zero-transmittance early-out, without its depth-buffer rewrite. The bound on what that
@@ -40,6 +47,7 @@ struct AVBOITDrawOutput {
     @location(0) color : vec4<f32>,
     @location(1) norm : vec4<f32>,
     @location(2) extinction : vec4<f32>,
+    @location(3) emission : vec4<f32>,
 }
 
 @fragment
@@ -90,6 +98,7 @@ fn main(
     out.color = vec4<f32>(color * coverage * transmittance, 0.0);
     out.norm = vec4<f32>((1.0 - self_transmittance) * transmittance, 0.0);
     out.extinction = vec4<f32>(-log(self_transmittance), 0.0);
+    out.emission = vec4<f32>(0.0);
 
     return out;
 }
@@ -109,10 +118,10 @@ export const AVBOIT_DRAW_FRAGMENT_DEPENDENCIES = [
 ];
 
 /**
- * The three additive `rgba16float` targets, in `AVBOITDrawOutput` order.
+ * The four additive `rgba16float` targets, in `AVBOITDrawOutput` order.
  * @type {GPUColorTargetState[]}
  */
-export const AVBOIT_DRAW_TARGETS = ["color", "norm", "extinction"].map(label => ({
+export const AVBOIT_DRAW_TARGETS = ["color", "norm", "extinction", "emission"].map(label => ({
     label,
     format: "rgba16float",
     blend: {

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Add one fragment's share of extinction to one physical slice of the voxel volume (plan §3.5), and
+ * record the slice in the per-channel overflow plane if a field crossed 255 — stored as `P - slice`
+ * under `atomicMax`, so the buffer's zero clear reads as "none" and the nearest overflow wins.
+ *
+ * The enclosing shader binds `warp` (`AVBOIT_WARP_STRUCT`), `extinction_volume` and
+ * `overflow_slice` (`array<atomic<u32>>`, read-write) under those names: this is the splat's write
+ * path, shared by the meshlet splat and every side channel's, so that a particle's extinction lands
+ * in the volume through exactly the code a mesh's does.
+ *
+ * A fragment is spread over two slices by its caller (linear splat, `c = p - 0.5`); this is one of
+ * the two.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_splat_slice: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_splat_slice.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_splat_slice.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAuCjB;0BAzDwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.js

@@ -0,0 +1,58 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_avboit_extinction_to_counts } from "./chunk_avboit_extinction_to_counts.js";
+import { chunk_avboit_overflows } from "./chunk_avboit_overflows.js";
+import { chunk_avboit_pack_counts } from "./chunk_avboit_pack_counts.js";
+
+/**
+ * Add one fragment's share of extinction to one physical slice of the voxel volume (plan §3.5), and
+ * record the slice in the per-channel overflow plane if a field crossed 255 — stored as `P - slice`
+ * under `atomicMax`, so the buffer's zero clear reads as "none" and the nearest overflow wins.
+ *
+ * The enclosing shader binds `warp` (`AVBOIT_WARP_STRUCT`), `extinction_volume` and
+ * `overflow_slice` (`array<atomic<u32>>`, read-write) under those names: this is the splat's write
+ * path, shared by the meshlet splat and every side channel's, so that a particle's extinction lands
+ * in the volume through exactly the code a mesh's does.
+ *
+ * A fragment is spread over two slices by its caller (linear splat, `c = p - 0.5`); this is one of
+ * the two.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_splat_slice = CodeChunk.from(
+    //language=WGSL
+    `
+fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec2<u32>) {
+    let physical = i32(warp.physical_count);
+    let s = clamp(slice, 0, physical - 1);
+
+    let counts = avboit_extinction_to_counts(extinction);
+
+    if (all(counts == vec3<u32>(0u))) {
+        return;
+    }
+
+    let previous = atomicAdd(&extinction_volume[column + u32(s)], avboit_pack_counts(counts));
+
+    let overflow = avboit_overflows(previous, counts);
+
+    if (any(overflow)) {
+        let base = (texel.y * warp.voxel_width + texel.x) * 3u;
+        // inverted so that the zero-cleared buffer means "no overflow" and max keeps the nearest
+        let mark = u32(physical - s);
+        if (overflow.x) {
+            atomicMax(&overflow_slice[base], mark);
+        }
+        if (overflow.y) {
+            atomicMax(&overflow_slice[base + 1u], mark);
+        }
+        if (overflow.z) {
+            atomicMax(&overflow_slice[base + 2u], mark);
+        }
+    }
+}
+    `, [
+        chunk_avboit_extinction_to_counts,
+        chunk_avboit_overflows,
+        chunk_avboit_pack_counts,
+    ]
+);

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts

@@ -89,6 +89,21 @@ export function graph_avboit_draw({ graph, view_ctx, material_count, materials,
     norm: number;
     extinction: number;
 };
+/**
+ * The four draw accumulators, created by the first pass that writes them — the meshlet draw, or a
+ * side channel's when there are no transparent materials. One place for their format and usage,
+ * so the meshlet draw and a side channel's draw cannot disagree on what they are drawing into.
+ *
+ * @param {FramePassBuilder} pass the pass that first writes them
+ * @param {ArrayLike<number>} resolution internal resolution
+ * @returns {{color: number, norm: number, extinction: number, emission: number}}
+ */
+export function avboit_create_accumulators(pass: FramePassBuilder, resolution: ArrayLike<number>): {
+    color: number;
+    norm: number;
+    extinction: number;
+    emission: number;
+};
 /**
  * Adaptive voxel-based order-independent transparency (Drobot, SIGGRAPH 2025). Does not write depth.
  *
@@ -96,6 +111,13 @@ export function graph_avboit_draw({ graph, view_ctx, material_count, materials,
  * selects between the two with `transparency_mode` alone. The passes it records are listed in
  * `AVBOIT_PLAN_2026_09_03.md` §3.1.
  *
+ * Fragments that are not meshlets — particles — join through `side_channels`: each is asked for its
+ * occupancy after the buckets have marked theirs, for its extinction after the buckets have
+ * splatted, and for its draw after the buckets have drawn, in that order, with the handles threaded
+ * through it. See `AVBOITSideChannel`. With side channels the frame runs even when no transparent
+ * material is in the scene; the bucket passes then have nothing to do and the channels' fragments
+ * composite against the opaque scene alone.
+ *
  * @param {FrameGraph} graph
  * @param {number} buckets
  * @param {GPUViewContext} view_ctx
@@ -111,7 +133,9 @@ export function graph_avboit_draw({ graph, view_ctx, material_count, materials,
  * @param {number} volumetrics_metadata
  * @param {ShadeIndirectLightingMode} indirect_lighting_mode
  * @param {AVBOITSettings} [avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
+ * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [side_channels] non-meshlet
+ *   sources of transparent fragments; the MBOIT orchestrator ignores them
  * @returns {number} resource ID of the composited color texture
  */
-export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, indirect_lighting_mode, avboit, }: FrameGraph): number;
+export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, indirect_lighting_mode, avboit, side_channels, }: FrameGraph): number;
 //# sourceMappingURL=graph_rasterize_meshes_transparent_avboit.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AAgEA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;GAWG;AACH,4JAFa,MAAM,CA4DlB;AAED;;;;;;;;;GASG;AACH,0HAFa,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAkJjE;AAED;;;;;;;;;GASG;AACH,8GAFa,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAwN7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kTAFa,MAAM,CA4PlB"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AAgEA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;GAWG;AACH,4JAFa,MAAM,CA4DlB;AAED;;;;;;;;;GASG;AACH,0HAFa,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAkJjE;AAED;;;;;;;;;GASG;AACH,8GAFa,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAyN7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,iUAFa,MAAM,CAqRlB"}