@woosh/meep-engine 3.60.3 → 3.60.5

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

@@ -1,1218 +0,0 @@
-# AVBOIT — ledger
-
-Companion to [`AVBOIT_PLAN_2026_09_03.md`](./AVBOIT_PLAN_2026_09_03.md). One entry per step of §8, in the
-order they landed, each recording what was built, how it was verified, and what the step found that the plan
-did not predict. Findings that change the plan are noted here and the plan's revision header is bumped, never
-silently edited.
-
-Branch: `claude/avboit-transparency-pipeline-192cff`, worktree
-`.claude/worktrees/avboit-transparency-pipeline-192cff`, from `9ab84a154`.
-
----
-
-## 0. Survey — 2026-09-03
-
-**Done.** Read the deck (text extraction via `pdftotext`; the page renderer is not installed here) and the
-MBOIT pipeline end to end: orchestrator, three shaders, frame-graph API, resource descriptors, the bucket →
-draw-command prep, the emulator's capabilities, the software device's recording API, and the `Renderer` call
-site and mode-switch precedents.
-
-**Findings that shaped the plan:**
-
-- The sorted meshlet buffer the draws consume has no count header
-  (`shader_sort_meshlets_by_material.js:20` writes a bare `array<MeshletDefinition>`); the collection *before*
-  sorting does, and the prep helper already builds an indirect dispatch command over it. The occupancy pass
-  needs both, so the helper returns two more handles (plan §3.1).
-- No render pipeline in the tree writes a storage buffer from the fragment stage, and the pipeline-layout
-  helper applies one visibility to all groups. The splat pass builds its layout per group (plan §3.11).
-- The emulator models `atomic<T>` as `{ value }` objects and implements `atomicAdd/Min/Max/Or`, `textureStore`
-  on 3D `CPUBitmapData`, `extractBits/insertBits`, `countOneBits`; barriers are no-ops and there is no
-  workgroup-cooperative dispatch. The warp build is therefore a single invocation so it stays
-  emulator-testable (plan §3.4).
-- View-space depth sign: the volumetrics take `-(view_matrix × p).z`, so the camera looks down −Z; the
-  occupancy pass uses the same (plan §3.3).
-- `float32-blendable` is on the device floor purely for MBOIT's `r32float`/`rgba32float` targets; AVBOIT
-  blends `rgba16float` only (plan §3.11).
-- The in-app browser pane cannot run the full renderer (immediate data unsupported there, per memory), so the
-  playground look (step 9) needs a real Chrome tab; module compilation (step 8) works in either.
-
----
-
-## 1. Skeleton and switch — 2026-09-03
-
-**Done.** `ShadeTransparencyMode` (`MBOIT = 0`, `AVBOIT = 1`), `Renderer.transparency_mode` defaulting to
-MBOIT, a ternary at the single transparency call site selecting the recorder, and
-`graph_prepare_meshlet_draw_commands_by_material` returning `meshlet_collection` and
-`meshlet_iterator_command` beside what it returned before. `Renderer.js` and the prep helper are CRLF files;
-edited byte-exactly.
-
-**Verified.** The rasterize spec tree (14 files, 81 tests) passes with the helper change; the source-level spec
-in `graph_rasterize_meshes_transparent_avboit.spec.js` pins the import, the default and the ternary.
-
-**Found.** Nothing the plan did not predict.
-
----
-
-## 2. Depth curve, packing, warp — 2026-09-03
-
-**Done.** `chunk_avboit_depth_curve` (t(z), z(t)), `chunk_avboit_pack` (10|10|10, counts ↔ extinction ↔
-transmittance, the overflow predicate), `AVBOIT_WARP_STRUCT`, `chunk_avboit_warp` (φ, and the view-depth →
-virtual → physical composition), each with an emulator spec.
-
-**Found.**
-
-- The emulator hands a `u32` with its top bit set back as a negative JS number (`0xFFFFFF00` reads as
-  `-256`). Specs compare through `>>> 0`. `countOneBits` and the shift operators are unsigned internally, so
-  the shaders themselves are unaffected.
-- `vec3<f32>` values travel as `Float32Array` through the emulator, so round-trip expectations are f32-exact
-  (six digits), not f64.
-
----
-
-## 3. Occupancy and warp build — 2026-09-03
-
-**Done.** `chunk_avboit_occupancy` (range, word mask, dilate, fold), `shader_avboit_occupancy` (per meshlet,
-indirect over the filtered collection), `shader_avboit_build_warp` (one invocation: dilate → count → halve
-until it fits, then the exclusive-prefix LUT), with specs for the chunk and for the whole build shader
-dispatched through the emulator.
-
-**Found.** The implementation dilates at *every* level it evaluates rather than once at the finest and once at
-the settled level, which is the same thing where it matters (the settled level) and simpler to reason about.
-`AVBOIT_OCCUPANCY_DILATION` at the prepass is therefore only a belt-and-braces one slice. Plan §3.4 describes
-the per-level version.
-
-Specs pin: empty → `V_max` and an all-zero LUT; a run that dilates to exactly `P` does not halve; one over
-halves once and is re-dilated at the coarser level; everywhere-occupied halves down to `V = P`; the prefix is
-exclusive, monotone, and never exceeds `P`.
-
----
-
-## 4. Splat — 2026-09-03
-
-**Done.** `shader_avboit_splat`: low-resolution render pass, no depth attachment, a `r8unorm` dummy target
-with `writeMask: 0`, per-group pipeline layout with the atomics group fragment-only, linear splat with
-per-channel overflow marks stored inverted under `atomicMax`. `chunk_avboit_tint` factored out so the splat
-and the draw compute the transmission tint from one function.
-
-**Found.** No un-jitter in the splat: `unjitter_uv` is derivative-based and the jitter is in
-internal-resolution pixels, so at 1/8 resolution the correction would be eight times too large. Recorded in
-the shader's docblock; the plan did not mention it.
-
-**Verified.** Validity tier (vertex + fragment) and the tier-3 layout spec: group 3 entries are `FRAGMENT`
-with `buffer.type === "storage"`, groups 0–2 are `VERTEX | FRAGMENT`, the target's `writeMask` is 0, no
-`depthStencil`.
-
----
-
-## 5. Integrate — 2026-09-03
-
-**Done.** `shader_avboit_integrate`, 8×8 workgroups, exclusive prefix into a `P + 1`-deep `rgba8unorm` 3D
-storage texture, per-channel saturation and overflow pinning. Emulator spec over one column: exclusive
-prefix, independent channels, saturation, a summed field past 255 saturating in one step, an overflow mark
-pinning only its channel, a mark at slice 0.
-
-**Found.** Nothing unpredicted.
-
----
-
-## 6. Draw and sample — 2026-09-03
-
-**Done.** `chunk_avboit_sample_transmittance` (bias in virtual slices, warp, `(p + 0.5) / (P + 1)` depth
-coordinate, `exp`), `avboit_draw_fragment_body` (one WGSL text shared by the IBL and Brick4 pipelines, where
-the two MBOIT resolve shaders share theirs by duplication), `shader_avboit_draw_ibl`,
-`shader_avboit_draw_brick4`, `AVBOIT_INTEGRAL_SAMPLER_DESCRIPTOR`. Emulator spec of the sample chunk against a
-hand-built integral: run boundaries land on texel centres, an event in front attenuates by `exp(-E × ln 256)`,
-the bias clears a surface's own linear splat, a gap sample reads the previous run's total and none of the
-next run's, beyond the far plane the sample reads the total.
-
-**Found.** The emulator's `null` sampler is the linear clamp-to-edge fallback the spec wants, so no sampler
-object is built there.
-
----
-
-## 7. Resolve, orchestrator, tier 3 — 2026-09-03
-
-**Done.** `shader_avboit_resolve` (reads the scene, writes a fresh `rgba16float`; RGB total transmittance
-cannot blend in place), the full `graph_rasterize_meshes_transparent_avboit` with its sub-recorders exported
-(`graph_avboit_occupancy`, `_build_warp`, `_splat`, `_integrate`, `_draw`),
-`avboit_shaders_wgsl_validity.spec.js` (10 modules, zero diagnostics),
-`graph_rasterize_meshes_transparent_avboit.spec.js` on the software device.
-
-**Found.**
-
-- `graph_compute_pass` cannot create a `read_write` storage buffer from a descriptor: the helper puts every
-  readable binding through the read path first, so the descriptor arrives at `pass.write` as an object. The
-  warp build is recorded by hand instead, and its `settings` uniform is serialized with
-  `encoder.allocateTransientValueBuffer` — the plain-object convenience only exists inside the graph
-  helpers, not in `ComputeShader.dispatch`. Plan §3.1's table is unchanged; the pass is the same, just not
-  via the helper.
-- No spec builds a `GPUViewContext` over a scene on the mock, so the tier-3 spec pins the exported
-  sub-recorders (warp build: one workgroup into a buffer of the struct's size; integration: the dispatch
-  covers the voxel grid and the texture is `3d`, `P + 1` deep, storage + sampled; resolve: one 3-vertex draw
-  into a fresh target) and the `Renderer` switch at source level. The whole orchestrator's first encode is on
-  a real device (steps 8–9).
-
-**Verified.** 62 tests across the avboit directory; 81 across `rasterize/`; the full `src/shade` suite
-(489 files, 3360 tests) passes; `scripts/check-types.mjs` reports the declaration emit clean and zero
-consumer-visible errors.
-
----
-
-## 8–9. Real compile and the look — 2026-09-03, handed over
-
-**Done.** `src/shade/playground/avboit/`: the deck's harness in miniature (a stack of cards at a controlled
-spacing, a tinted glass pane, an opaque backdrop), the MBOIT/AVBOIT switch, and a **Compile check** that
-pushes all ten AVBOIT modules through `createShaderModule` on the live device and prints
-`getCompilationInfo`. The README carries the one scripted session (six steps) with what "pass" looks like
-for each.
-
-**Not done here, and why.** The in-app browser pane returned `null` from `requestAdapter()` this session
-(its `wgslLanguageFeatures` are present, the adapter is not — the same state
-`playground-needs-immediate-data` recorded on 2026-09-02), and no Claude-in-Chrome browser was connected.
-So neither the real compile nor the picture happened on this side. What the pane did prove: the page
-loads under the dev server, every import resolves (the ten shader modules assemble at import time, so a
-chunk-dependency or struct error would have thrown there), and `start()` runs up to
-`Renderer.initialize`, which reports `requestAdapter returned null` cleanly. The sources were dumped
-(`scratchpad/wgsl/*.wgsl`, 217 KB) for a pane compile should an adapter come back. What is known: every
-module passes the validator, which has no type checker; the type-level risks are listed below so the first
-compile failure, if any, is quick to place.
-
-**Type-level things the validator could not see** (in the order a compiler would meet them):
-
-- `avboit_warp` takes `ptr<storage, AVBOITWarp, read>`; the splat and draw pass `&warp` where `warp` is
-  declared through `addStorageBuffer(..., false)`. `var<storage>` without an explicit mode is `read`, which
-  matches.
-- `atomicAdd(&extinction_volume[column + u32(s)], …)` indexes an `array<atomic<u32>>` binding from the
-  fragment stage — core WGSL, but the first such pipeline in the tree.
-- `textureStore(integral, vec3<i32>, vec4<f32>)` on `texture_storage_3d<rgba8unorm, write>`.
-- `select(vec3<u32>, vec3<u32>, vec3<bool>)` and `select(vec3<f32>, vec3<f32>, vec3<bool>)` in the
-  integration; both are the component-wise overload.
-- The splat fragment entry has no return type against a pipeline with one colour target at `writeMask: 0`.
-
----
-
-## 10. Docs — 2026-09-03
-
-**Done.** `RENDERER_CONTRACT.md` §2 says which mode needs `float32-blendable`; §9 lists
-`transparency_mode`. `CHANGELOG.md` carries the entry under the unreleased 4.0.0 "Added". The plan is at
-revision 1; nothing in steps 1–9 required a revision of its design sections.
-
-**Open, for the session in the playground README:** the ten real compiles; the first frame under AVBOIT;
-the stack at the default spacing (does the bar behind it show through?); the spacing at which the cards
-fall into one slice; the red pane's tint on the backdrop. Results go here as entry 11.
-
----
-
-## 11. Path-traced reference on the playground — 2026-09-03
-
-**Done.** A third mode on the page, "path traced (reference)": `feature_path_tracing_enabled` on, TAA
-forced off while it is, the tracer's running-mean floor lowered from 0.01 to 0.002 so the image keeps
-settling past 100 samples, a **Reset accumulation** button, and a once-a-second readout of how converged
-the image is. That readout needed one small engine addition: `AccumulatingPathTracer.min_sample_count`,
-the sample count of the tile that has had the fewest (the per-tile counters were private, and frames
-elapsed is not a sample count — a frame advances one tile).
-
-**What the reference is good for, and not** (README "The reference"):
-
-- The tracer rolls each transparent hit against alpha and continues the ray, so it converges to the
-  exact order-independent composite of the card stack — the thing both OIT modes approximate. Good.
-- It has no per-channel transmission tint (thin-walled transmission carries only `(1 - F)`), so it
-  cannot confirm AVBOIT's glass tint; the pane is compared with the tint off.
-- Its shadow rays treat geometry as opaque (the tracer's own `TODO`), so the cards cast full shadows
-  there and none under either OIT mode. The stack, not its shadow, is the comparison.
-
-**Verified.** `path_tracer/` has no specs of its own; the getter is a read of a private array. The
-page's module graph was re-loaded in the pane (see entry 8–9 for what the pane can and cannot prove).
-
----
-
-## 12. First renders on a real device — 2026-09-03
-
-Alex ran the playground and pasted three canvas captures at the default settings (four cards, alpha
-0.85, spacing 1.5, red glass pane): path traced, AVBOIT, MBOIT. Read against the code, not measured.
-
-**The stack — the deck's depth-complexity claim reproduces.** Under MBOIT the green card, two layers
-back, shows through both the red and the blue card as a lighter rectangle inside the red one. Under
-the path tracer and under AVBOIT it does not; the overlap is red with the blue card directly behind
-faintly visible. AVBOIT is the closer of the two to the reference on the stack. Both rasterized modes
-render the cards darker than the tracer, and they agree with each other, so that is a forward-shading
-versus tracer difference and not this pipeline's.
-
-**Also as predicted:** the tracer casts full shadows from the cards (its occlusion query treats
-geometry as opaque), neither OIT mode does.
-
-**The glass pane — the tint is working as written, and is the wrong default.** Under AVBOIT the pane
-is deep red; under the tracer and MBOIT it is clear glass. The material is transmission 1 with a red
-base colour, and `chunk_avboit_tint` multiplies transmitted light by that base colour, so green and
-blue drop to ~14 %. It is not opaque — the horizon shows through as the dark-to-bright step at floor
-level — but it is a material semantic the other paths do not have: the forward shader states there is
-no per-channel transmission tint in the material model, and the tracer's thin-walled transmission
-carries only the Fresnel split. The contract's promise that the two modes take the same inputs and
-are safe to flip per frame does not survive a flip that recolours glass.
-
-Two corrections to what the code says about itself: the chunk docblock calls base-colour-as-tint
-"the OpenPBR default", which it is not (OpenPBR's transmission colour defaults to white; glTF's
-transmission extension is the one that uses the base colour); and plan §4's first row rests on the
-same reading.
-
-**Proposed:** keep the RGB plumbing, default the tint off, expose it as a runtime switch
-(`renderer.avboit.transmission_tint_from_base_color`, carried in the warp header so the splat and
-draw agree per frame), a checkbox on the page, plan to revision 2. The alternative — keep it on and
-document it as an AVBOIT-only semantic — makes one asset mean two things depending on a renderer
-switch. Alex chose the first; entry 14.
-
-**Also closed by these renders:** step 8's real compile, for the IBL variant. An AVBOIT frame on a real
-device means the occupancy, warp, splat, integrate, IBL draw and resolve modules all compiled and the
-pipeline ran end to end. The Brick4 draw variant is not exercised by the page (`indirect_lighting_mode`
-is IBL there) and remains compiled only by the validator.
-
----
-
-## 13. The deck's opaque-card case on the page — 2026-09-03
-
-**Done.** At Alex's request: a small pale quad, alpha 1 on a `Transparent` material, one unit behind
-the last card and offset so part of it is seen through the stack and part stands against the backdrop
-and the dark bar. Both pipelines clamp its coverage at `OIT_COVERAGE_MAX` (0.997), so it is the "0 %
-transmittance card" of deck slides 35–38: the case where a moment reconstruction cannot hold the
-step, leaks the background through the surface, and tears along the depth discontinuity at its edge.
-A checkbox (`opaque_quad`, default on) and step 8 of the README's session.
-
-**What to expect from AVBOIT here, from the design:** the quad's extinction saturates its slice
-(`-ln(1 - 0.997) / ln 256 ≈ 1.05`, clamped to 1.0), so the integral behind it reads 1.0 and every
-fragment further back is weighted by a transmittance of 1/256. Its edge is a step in the extinction
-volume at 1/8 resolution, softened by the draw's trilinear sample over about one voxel — so a slight
-halo of that width is the expected artefact, not a leak. Anything behind the quad showing through its
-interior would be a finding.
-
----
-
-## 14. The tint, kept and off by default — 2026-09-03
-
-**Done.** `AVBOITSettings` on `Renderer.avboit` with one switch, `transmission_tint_from_base_color`
-(default false). The orchestrator takes `avboit` beside its other inputs (the MBOIT one ignores it), the
-warp build copies it into a new `tint_from_base_color` header word, and both the splat and the draw
-weight `chunk_avboit_tint` by `transmission_factor × f32(warp.tint_from_base_color)`. The chunk's
-docblock now says whose semantics the mapping is (glTF's, not OpenPBR's). Plan to revision 2 (§3.5,
-§4, §7). Contract §9 lists `avboit`. The page has a checkbox for it, off by default, and step 6 of the
-session turns it on before comparing the pane.
-
-**Why a header word and not a shader constant:** the splat and the draw must agree within a frame, and
-the header is already the one place both read per-frame facts from; a runtime flag lets the page do
-the A/B without a rebuild.
-
-**Verified.** Build-warp emulator spec asserts the header copies the flag; validity tier over the
-edited modules; rasterize spec tree.
-
----
-
-## 15. Decisions on the open items — 2026-09-03
-
-Alex's answers to the open list, and what each became.
-
-**Slice floor — mine to call; 5 cm is a spacing worth resolving.** Virtual slice thickness is
-`(z0 + z - near) · ln(1 + (far - near) / z0) / V`. At the page's camera (`near 0.1`, `far 200`,
-`z0 = 0.8`) and `V = 1024` that was 5.8 cm at 10 m: one slice, under the two-slice bias, so 5 cm
-blended. `AVBOIT_VIRTUAL_SLICES_MAX` is now 4096 — 1.5 cm at 10 m, 2.8 cm at 20 m, 7 cm at 50 m — so
-5 cm resolves out to about 17 m before the bias eats it, and the adaptive halving still pulls it back
-when more than 128 slices are occupied. The bias stays at 2.0 rather than dropping to the analytic
-1.5: the half-slice margin is what covers the depth difference between a splat fragment (a
-1/8-resolution pixel centre) and a draw fragment on a sloped surface. Cost: 128 occupancy words, a
-16 KB LUT, a longer single-lane loop in the warp build. Specs unchanged in intent (they read the
-constant) and green.
-
-**The opaque quad — fine as is.** Stays on the page.
-
-**Camera.** `OrbitalCameraController` on the page (drag, wheel, right-drag), **Copy camera** to the
-clipboard and a box, **Apply camera** from the box, `camera_state()` / `apply_camera()` /
-`configure({ camera })` from the console. Plan §9 gains the slope risk in its own words: a splat
-fragment carries its low-resolution pixel centre's depth, and on a grazing surface that can exceed
-the bias.
-
-**Brick4 — should land.** The variant exists and is validator-clean; the page now has an
-indirect-lighting select (IBL / Brick4) so the Brick4 draw pipeline compiles and draws on a device.
-The scene has no probes, so the indirect term is black either way; the step is in the session.
-
-**Timings — hook up the profiler.** Done as on `volumetrics_froxel`: **Profile** starts a
-`GPUProfileSession` at `WORKLOAD`, pressing it again drains and downloads
-`avboit-<mode>-<timestamp>.sgpt` for the gpu-inspector-tool, with the mode and the page's settings in
-the note and the adapter in the meta. Same settings, two recordings, one per mode, is the comparison.
-
-**Software device — wrong tool for an end-to-end spec, and that is fine.** Plan §6 tier 3 now says
-so; the full-orchestrator spec is off the list.
-
-**Phase 2 — only clean, unambiguous, non-situational.** Decided item by item in plan §7 revision 3.
-One landed: the draw discards a fragment the volume already calls extinct (`T ≤ 1/256` in every
-channel) *before* forward shading. No new resource or pass; the error is bounded by `1/256` of the
-background (`AVBOIT_EXTINCT_TRANSMITTANCE`), below the 8-bit volume's own resolution. Tile skipping
-(no: sub-millisecond passes), the zero-transmittance depth cull (not now: situational, touches the
-depth other passes read, wants its own plan and a scene that needs it), the monochrome buffer (no:
-two representations for content we do not have), the sparse texture (no: speculative).
-
-**Back-sided materials — ignored for now.** Plan §7 keeps the note.
-
-**AVBOIT is the default.** `Renderer.transparency_mode = ShadeTransparencyMode.AVBOIT`; the enum,
-the contract (§2 keeps `float32-blendable` on the floor while MBOIT is selectable; §9 row), the
-changelog and the page's default select follow. The source-level spec pins the new default.
-
-**Committed** on the branch after this entry.
-
----
-
-## 16. The page's camera and profile buttons, reported not working — 2026-09-03
-
-Alex: the camera could not be moved, and **Profile** appeared to do nothing with no way to stop it.
-
-**What was verified here.** The page was restructured so the camera, its controller and every control
-are wired *before* the device is requested. That made the input path testable in the in-app pane,
-which has no adapter: a synthetic pointer drag dispatched on the canvas orbited the camera from
-`(0, 2.5, 12)` to `(-7.3, 3.7, 9.4)` and a wheel event zoomed it, read back through `camera_state()`.
-So `OrbitalCameraController` on `document.body`, the pointer device and the transform write are
-correct as wired. What could not be reproduced is the failure in a real session.
-
-**What the restructure found.** Building geometry before `Renderer.initialize` threw
-`Cannot read properties of undefined (reading 'exports')`: the meshlet builder runs on a WASM
-instance (`MeshoptClusterizer`) that instantiates asynchronously at import, and the renderer's own
-initialization had been what gave it time. The page now awaits `MeshoptClusterizer.ready` itself. Not
-the reported fault (the committed order built geometry after the device), but the same class of
-thing: a step that silently depended on another step's timing.
-
-**Made robust, since the fault could not be seen.** Every control handler runs through a guard that
-puts a failure into the report panel (`<what> failed: <message>`) instead of only the console; the
-final settings application is guarded so a settings error cannot stop the frame loop from starting;
-the Profile button carries a `recording` state (label and red border) so a running capture is
-unmistakable and the same button stops it; the controls are spelled out under the canvas. If a real
-session still does not orbit, the report panel now says why.
-
-**Suspicion, unverified.** With HMR off, a reload taken while the page's files were being rewritten
-on disk can pair one version of `index.html` with another of `main.js` or `Renderer.js`; a
-`TypeError` in the settings step then killed `start()` before the frame loop, which is the one
-sequence that leaves the buttons registered, the camera frozen and no picture of the cause. A hard
-reload after this commit is the first thing to try.
-
----
-
-## 17. First timings — 2026-09-03
-
-Alex ran a short profiling session on the page (the deck's harness in miniature: four cards, the
-glass pane, the opaque quad, 1280x720): **AVBOIT 289.9 us, MBOIT 282.4 us**, averages of the
-transparency work, which he reads as within the noise. Device and capture files not recorded here.
-
-**What that says.** On this scene the two pipelines cost the same. That is the expected shape, not a
-surprise: the deck's cost argument (AVBOIT approaching no-OIT, slides 106-110) comes from VFX content
-with tens of millions of overdrawn transparent pixels, where the 1/8-resolution splat, the saturated
-integral and the early-out remove most of the shading work. Six quads at 720p have almost nothing
-for those to remove, and AVBOIT's fixed costs — the occupancy pass, the warp build, the integration
-over a 160x90x129 volume, the resolve into a fresh target — are of the same order as MBOIT's two
-full-resolution passes over the same few quads. So the number closes the question "does the new path
-cost more on light content" (no), and leaves open the one the deck actually answers, which needs a
-scene with real transparent overdraw. Plan §9's contention risk is unmeasured until then.
-
-**Committed** with this entry.
-
----
-
-## 18. Review against the engine — 2026-09-03
-
-Alex asked three questions of the code: is anything reinvented, does it follow one function per
-chunk, does it fight the engine. Surveyed and fixed; plan to revision 4.
-
-**Reinvented, now reused.**
-
-- *The depth curve.* `chunk_avboit_depth_curve` (t(z), z(t), a `z0` knob) was a second copy of what the
-  light clusters and the froxels already use: `cluster_depth_to_z_slice` with parameters from
-  `build_light_cluster_parameters`. That builder's `scale` argument is the linearization the deck
-  describes; `avboit_build_depth_curve` chooses it so the curve is pure log from the near offset,
-  because the warp makes near precision free. Gone: the chunk, its inverse, its spec, the
-  `AVBOIT_DEPTH_CURVE_LINEARIZATION` constant, and the camera binding of the warp build (the curve now
-  arrives as three floats in the settings and in the occupancy pass's own settings uniform).
-- *The bit fold.* `avboit_fold_pairs` is the OR of the even bits compacted and the odd bits compacted,
-  which is `decode32_morton2`'s job. Found on the way: for a 32-bit code that function's `.y` is *not*
-  the odd bits — the `<< 31` that separates them in the 16-bit variant (`<< 15`) cannot work in 32
-  bits — and the first reuse trusted it; the warp-build spec caught it as an occupied count of 70
-  against 66. The fold now goes through the correct `.x` half twice, once on `x >> 1`, and has a spec
-  against a bit-by-bit reference. `decode32_morton2` is used nowhere else in the tree; its `.y` is a
-  latent engine defect, noted for whoever reaches for it next.
-- *The sampler.* `AVBOIT_INTEGRAL_SAMPLER_DESCRIPTOR` duplicated `SAMPLER_LINEAR_UPSCALE` (linear,
-  clamped on every axis), which the draw already binds as `sLinear` for the split-sum LUT. The integral
-  samples through that; one binding fewer in the view group.
-- *The draw loop.* `material_draw` existed privately in both orchestrators. It is
-  `rasterize/native/material_draw_indirect.js` now, with the material bind-group layout it needs,
-  imported by both.
-
-**Convention.** 650 of the engine's ~700 chunk files hold exactly one function named after the file;
-mine held two to six. Five chunks became seventeen (`chunk_avboit_pack_counts`, `_unpack_counts`,
-`_transmittance_to_extinction`, `_extinction_to_transmittance`, `_extinction_to_counts`,
-`_counts_to_extinction`, `_overflows`, `_occupancy_range`, `_occupancy_word_mask`, `_dilate_word`,
-`_fold_pairs`, `_warp`, `_view_depth_to_virtual`, `_view_depth_to_physical`,
-`_integral_depth_coordinate`, `_sample_transmittance`, `_transmission_tint`), each with its spec; the
-hand-built warp and the curve's inverse the specs share live in `avboit_spec_support.js`, test-only.
-
-**Kept, on purpose.** `avboit_draw_fragment_body.js` shares one WGSL text between the IBL and Brick4
-draw pipelines where MBOIT duplicates its resolve body. No precedent either way in the tree; two
-45-line bodies drifting apart is the worse failure, and the two files stay concrete modules with no
-conditionals in them.
-
-**Also checked and found conforming:** the manual frame-graph passes match the MBOIT orchestrator's
-shape; `AVBOITSettings` on `Renderer.avboit` matches the other sub-object settings; the settings
-structs defined beside their shaders match `shader_read_out_bucket`; the bit packing uses WGSL's
-`insertBits`/`extractBits` directly, which is what the engine's `bitfield_*` chunks are thin proxies
-for; no `safe_*` math helper was reinvented — the one floor (`max(T, 1e-6)` before a log) has no
-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.
-
-## 22. Trails as the second side channel — 2026-09-24
-
-Alex asked whether `Trail3D` went through AVBOIT (it did not: `Trail3DSystem` drew its tubes with
-`GPUDynamicMeshRenderer` from an `AfterTransparency` extension, straight alpha over the resolved
-frame, depth-tested against the opaque scene only — so a trail behind a transparent card was drawn
-on top of it), then: *"implement this please. Keep within the parameters - AVBOIT for Trails only,
-and refactoring necessary to make it happen."* MBOIT is being deprecated and was out of scope.
-
-**The door.** Side channels could only come from inside the renderer: `#particle_side_channels`
-held the GPU particle system and nothing else, and `RENDER_EXTENSION_DESIGN.md` §9 names "extensions
-cannot participate in OIT" as the phase model's ceiling. `Renderer.add_transparency_channel` /
-`remove_transparency_channel` / `transparency_channel_count` open it, and `GraphicsEngine` holds
-channels across a restart exactly as it holds extensions. The frame's list (now `#side_channels`) is
-the particles, then every registered channel that does not say it is empty — `avboit_is_empty`, an
-optional fourth member of the contract — because the orchestrator runs whenever it is handed a
-channel, and one that is always registered would otherwise buy every frame the pipeline's fixed
-cost. Registering one channel twice is refused: it would draw everything twice.
-
-**The channel.** `DynamicMeshAVBOITChannel` meets the three contracts for a `DynamicMeshBatch`:
-
-- *Liveness is decided once, at occupancy*: a mesh is live when visible, with positive flat alpha,
-  and with a triangle one vertex of which has positive alpha. The splat and the draw take the same
-  list — and refuse a graph the occupancy was not recorded into — so the occupancy, the volume and
-  the accumulators agree about which meshes exist.
-- *Occupancy from CPU boxes.* The vertices are CPU data already, so a box per live mesh is taken
-  there (`dynamic_mesh_live_bounds`), carried to world space by the mesh's transform, uploaded as a
-  transient buffer and marked on the GPU through the particles' own chunks. **Per triangle, not
-  per vertex**: a trail's faint tail is a triangle whose far corners have aged to zero, and bounds
-  over the live vertices would stop a segment short; while an aged-out knot keeps its old position,
-  so bounds over every position would reserve depth for a stopped trail's whole history.
-- *The upload happens in the occupancy pass*, the channel's first to execute; the splat and the draw
-  read the buffers later in the same frame, behind the warp the occupancy feeds.
-- *Splat and draw* are the particle passes' shape with the dynamic-mesh vertex stage: coverage
-  through `avboit_coverage` in both, the draw routed through `avboit_premultiplied_contribution`,
-  fogged and weighted by the transmittance in front. Straight alpha with no coverage carries no
-  light, so the draw masks the emission target rather than blending zeros into it.
-- Group 0 of both pipelines is `DYNAMIC_MESH_RESOURCES`' own group — the same object — so a mesh's
-  bindings are the ones `GPUDynamicMeshResidency.create_bindings` already builds; the pass groups are
-  built by name (entry 21).
-
-**Shared, not copied.** Out of the particle channel into chunks, the particles switched onto them
-with their specs unchanged: `avboit_coverage`, `avboit_premultiplied_contribution` (everything
-`particle_avboit_contribution` did after its premultiply), `aabb3_view_depth_range` and
-`avboit_occupancy_mark`. Out of `GPUDynamicMeshRenderer`: `GPUDynamicMeshResidencyTable` (buffers,
-staging, the once-per-version upload) and `chunk_dynamic_mesh_vertex` (the vertex pull) — pinned by
-a new execute-level spec of the renderer written against the old code first, since there was none.
-Entry 21's layout-kind check is `recorded_binding_kind_mismatches` now, shared by both recorder
-specs. **Left alone on purpose:** the meshlet occupancy and the meshlet splat keep their own copies
-of the slice marking and the two-slice split — this change does not touch the core passes.
-
-**Trails.** `Trail3DSystem` registers its batch's channel with the facade instead of an extension;
-`TrailExtension` is gone (breaking, and its only use was internal). A trail is now occluded and
-tinted by transparent surfaces and particles in front of it, occludes them behind it, and picks up
-the volumetric fog at its depth — it was drawn unfogged over a fogged scene. Under MBOIT, or with
-transparency off, trails are not drawn, as particles are not. Fog of war still covers them: it runs
-at `AfterTransparency`, after the resolve they are now part of.
-
-**Verified.** Tiers 1–3: emulator specs for the four chunks, the dynamic-mesh occupancy pass and the
-live bounds; the WGSL validity tier for every new and changed shader; software-device specs for the
-channel's three passes (order, attachments, per-draw binding kinds, liveness, refusal, residency),
-for `GPUDynamicMeshRenderer`, for registration on the renderer and the facade, and **the whole
-orchestrator run with a real channel and no transparent materials**; `Trail3DSystem`'s specs; the
-type check at budget. Tier 4, on a Metal adapter in the Browser pane — which hands out an adapter
-again: every new and changed module compiles and every pipeline builds with no validation error.
-On the playground page here, a real `Trail3D` driven by `seed_trail_tube` / `advance_trail` /
-`trail_tube_write_geometry` and registered with `renderer.add_transparency_channel`:
-
-- laid in front of the card stack it is drawn over all four cards; laid behind it, it is hidden by
-  them at alpha 0.997 (the old path drew it on top), dimmed card by card at 0.3, and faint at 0.85;
-- behind the red pane with **tint transmitted light by base colour** on, it is filtered to the
-  desaturated tone the resolve predicts, `(0.19, 0.14, 0.14)`-ish against the pane's red, while its
-  head clear of the pane stays cyan;
-- under MBOIT it is absent, and back under AVBOIT it returns.
-
-On `../../playground/particle_ecs/` in `?debug` (frames driven by `__step`, the pane being hidden), a
-real `Trail3DSystem` added to the running `EntityManager` and a `Trail3D` entity circling the fire: the
-stretch behind the plume is dimmed and warmed by the smoke and flames in front of it, the stretch in
-front hides the smoke and embers behind it; removing the system takes its channel out of the live
-renderer and adding it back re-uploads from nothing. **Zero uncaptured device errors** across every
-frame of both sessions. The bonfire's sprites need `build/bundle-worker-image-decoder.js`, which the
-dev server does not build: `npx rollup -c rollup.config.js` first (the output is gitignored).
-
-## 23. Adversarial review of the trail channel — 2026-09-25
-
-Alex asked for an adversarial review, "especially on the blast radius". Three reviewers read
-`master...feature/trail-avboit` independently — blast radius, GPU correctness, lifecycle and API —
-and every finding below was checked against the code before it was acted on. None was critical or
-high. Both reviewers who compared the shared chunks with master found them textually equivalent, the
-dynamic-mesh upload moved without change, and the meshlet passes untouched; the GPU reviewer
-confirmed the splat and the draw agree on coverage, depth and fragments, that emission is
-unreachable from straight alpha, and that the fog is not counted twice.
-
-**Fixed.**
-
-- *Buffers from the old device.* An `Engine` with an external `EntityManager` stops `GraphicsEngine`
-  without shutting its systems down (`Engine.stop`), and a restart then replays the channel into a
-  renderer on a new device while its residency holds buffers made on the old one — written with
-  `queue.writeBuffer` and bound into bind groups on the new device, a validation error that loses the
-  frame's commands. Not new: `GPUDynamicMeshRenderer`'s map did the same for path display and debug
-  draw, and `TrailExtension` was replayed the same way. But entry 22 advertised channels as held across
-  a restart, so `GPUDynamicMeshResidencyTable` now drops everything when the device changes — the
-  pattern `GPUParticleEmitterSystem` already has for its atlas — which fixes all three drawers.
-- *The last frame kept alive.* The channel held `#frame_graph` — the whole frame graph, every pass
-  closure in it, the imported canvas — and its live meshes until it was next asked, which for a
-  channel whose last trail had faded, or whose renderer had been replaced, is never; `Renderer.js`
-  calls exactly that retention a bug in its profiler path. The decision is now a per-frame record,
-  dropped when the draw is recorded; the passes carry their own references to the list and the boxes.
-  Each frame's list and boxes being its own also closes the aliasing the GPU reviewer called fragile
-  (record A, record B, execute A drew B's meshes into A): a spec now records two frames before
-  executing either, and fails against the old code.
-- *Consulted when nothing would draw it.* `avboit_is_empty` ran every frame under MBOIT and with
-  transparency off; registered channels are now consulted only when the pipeline that takes them will
-  run.
-- *An assert that shipped builds strip.* Registering a channel twice was refused by `assert` — gone
-  in a shipped build, where the channel would then be drawn twice — and the facade recorded a
-  registration the renderer had refused. Both are idempotent now; a repeat is a no-op.
-- *The optional method unchecked.* A non-function `avboit_is_empty` passed registration and threw in
-  the middle of every frame; it is refused at the door.
-- *`TrailExtension` removed outright.* meep ships ES modules, and an import that stops linking stops
-  the application loading, not just its trails — the reason `Trail3DSystem3` is kept. It is a
-  deprecated extension again, recording nothing and warning once.
-- *No frustum test in the occupancy.* A live trail behind the camera or off to the side reserved its
-  whole depth run, and the warp fitted the on-screen surfaces into what was left. The dynamic-mesh
-  occupancy now tests each box against `camera.frustum` first. On the device, the real camera's planes
-  keep a visible trail's box and cull one behind the camera. The particles' occupancy still has no
-  such test (entry 20's open item); this change does not touch it.
-- *Nothing pinned "the fog covers trails".* It used to be a declaration in
-  `after_transparency_order.spec.js`; it is construction now — the transparency call site precedes the
-  `AfterTransparency` phase — and a source pin says so.
-
-**Disclosed, not changed** — each is in the CHANGELOG entry too:
-
-- *Draw order at `AfterTransparency`.* Trails were the last content extension there; they are
-  resolved before that phase now, so path display, the selection highlight and the deprecated CPU
-  `ParticleEmitterSystem` draw over a trail whatever its depth, where they drew under it. Neither
-  order was depth-correct; the GPU particles are the ones that now sort against trails.
-- *The fixed cost.* A frame with a live trail runs the transparency pipeline even with nothing else
-  transparent — occupancy, warp, integration, the accumulator clears, the resolve — where it had one
-  blended pass. Of the order of entry 17's 0.3 ms at 720p on light content.
-- *Shared precision.* A trail spanning a deep range marks a long run and the warp halves its virtual
-  resolution to fit: the GPU reviewer's example, a box spanning 10–60 m at near 0.1 / far 200, takes
-  the warp from 4096 to 256 virtual slices, about 1.6 cm to 25 cm at 10 m. Emitter boxes do the same;
-  it is how the adaptive warp shares its 128 slices. Off-screen trails no longer take part.
-- *Thin trails and the 1/8-resolution splat.* A tube narrower than about one voxel reaches the volume
-  only in the columns whose low-resolution pixel centres it covers. The GPU reviewer's numbers: a 0.1 m
-  trail at 20 m, 1080p, 60° is 0.58 voxel wide, and in a missed column a smoke card behind an α 0.8
-  trail comes out 3.5× too strong through it, crawling in 8-pixel blocks as the trail moves. Plan §9's
-  sub-pixel risk, which meshlets and small particles share. The suggested mitigation — widen the
-  splat's triangles by half a voxel — trades the misses for halos wherever the widened footprint falls
-  between two other layers, and is left for a decision rather than taken.
-- *Renderer-wide channels.* A thumbnail rendered through the same renderer includes live trails that
-  fall in its view, as it did when they were an extension — and now brings the pipeline with them on
-  those frames. Particles are per scene; channels, like extensions, are not.
-- *Work done twice.* The emptiness query and the gather both walk the first live mesh's triangles, and
-  each live mesh's group-0 bindings — a transient uniform — are built once for the splat and once for
-  the draw. Small at trail counts; noted, not shaved.
-
-**Verified.** Before the fixes, the whole engine suite: the only failures were
-`VGeoResidency.spec.js`, failing identically on master, and a `PromiseWatcher` timeout under load that
-passes alone. After them, the suites the change reaches (217 files, 2386 tests) and the type check at
-budget. On the device: every new and changed module compiles and its pipeline builds; on the bonfire
-page, the trail through the plume again, with every fix in, and no uncaptured device errors.
-
-## 24. Thin trails: a coverage-weighted splat — 2026-09-25
-
-Alex said *"continue please"*, then *"Try again"*; the open item was entry 23's thin trail, disclosed and
-left for a decision. It is taken here, for the trail channel only — the meshlet and particle splats are
-unchanged.
-
-**Confirmed on the device first.** On the playground page, a dimmed trail at α 0.8, 0.04 wide (about
-3.7 pixels, 0.46 of a voxel), laid across the red card at eight offsets an eighth of a voxel apart —
-one voxel's period — and read at the trail's centre. TAA off:
-
-| offset | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
-|---|---|---|---|---|---|---|---|---|
-| before | 107,144 | 107,144 | 77,166 | 76,167 | 73,168 | 72,169 | 111,140 | 111,140 |
-| after | 95,155 | 93,156 | 90,158 | 88,160 | 85,162 | 85,162 | 95,154 | 100,151 |
-
-(red, green; the card alone is 147,77; the same trail 0.3 wide, which covers whole voxels, is 72,169.)
-Before, the trail either crossed a voxel centre and occluded the card fully or missed it and did not
-occlude it at all: two colours and a jump of 39 between neighbouring offsets. With TAA on it was the
-same split (70–111, a jump of 38), so the temporal filter does not hide it: it moves as the trail does.
-
-**The options.**
-
-- *Widen the splat's triangles by half a voxel* (entry 23's suggestion): every voxel the trail touches
-  gets its full extinction — halos wherever the widened footprint falls between two other layers.
-- *Multisample and write the full extinction if any sample is covered*: the same halo, and worse — the
-  triangles of one ribbon sharing a voxel would each add a whole layer.
-- *Multisample and weight by the covered share* — taken. Four samples, the only count above one WebGPU
-  guarantees; the fragment runs where any is covered and scales its extinction by
-  `countOneBits(sample_mask) / 4`. The triangles of one mesh cover disjoint samples, so their shares in
-  a voxel add to at most one layer, and a fully covered voxel is written exactly as before. The voxel
-  gets the trail's extinction averaged over its footprint, which is what a volume that coarse can hold.
-- *More samples* — a raster at twice the volume's resolution, sixteen per voxel. A model of the lookup
-  (a 0.46-voxel band at α 0.8, transmittance behind the trail's centre over every position) says it is
-  not worth four times the fragments: one sample 0.20–1.00, four 0.45–0.78, sixteen 0.45–0.73, and an
-  exact area average 0.48–0.69. What is left at four is mostly the floor: a band thinner than a voxel,
-  box-averaged into voxels and read back through the draw's bilinear lookup, still sees more of itself
-  where it sits on a voxel centre than between two.
-
-**What changed.** `shader_dynamic_mesh_avboit_splat` has `multisample: { count: 4 }` and the weight;
-`graph_dynamic_mesh_avboit_splat` makes its own 4-sample `r8unorm` target at the volume's resolution
-(never written, cleared and discarded — about 130 KB at 1080p, transient) and hands the volume's
-single-sampled one back untouched, since a multisampled pipeline cannot draw into it; the channel passes
-it the `voxel_resolution` the orchestrator already offered. The shared vertex chunk interpolates at the
-**centroid**: a thin triangle covering samples but not the pixel centre would otherwise have its depth
-and alpha extrapolated past its edge, which on a ribbon seen nearly edge-on moves the extinction off the
-ribbon. The draw is single-sampled, where a fragment exists only if the centre is covered and the
-centroid is the centre, so its output does not change.
-
-**After, on the device.** The table's second row, and with TAA on 82–102 with a largest jump of 19. On a
-curved thin trail — the case that beaded — the per-column red at the trail's centre over 225 columns:
-
-| | stdev | range | mean | neighbours ≥ 10 apart |
-|---|---|---|---|---|
-| TAA off, before → after | 13.7 → 4.8 | 67–109 → 78–101 | 85.8 → 85.5 | 6 → 0 |
-| TAA on, before → after | 12.7 → 5.0 | 58–108 → 71–98 | 79.8 → 81.5 | 20 → 5 |
-
-Two and a half to three times steadier, and the same on average, as an area average of point samples
-should be. The wide trail reads 69,170 against 72,169 before.
-
-**What remains, and what it costs.**
-
-- *The average's own bias.* A trail a fraction of a voxel wide occludes what is behind it by about that
-  fraction of its extinction, steadily. The trail itself still draws at full resolution and full
-  opacity; only its occlusion of what is behind it is diluted. That is the resolution the volume has.
-- *Faint trails can round away.* The volume counts 255 steps per `ln 256` of extinction, so a voxel a
-  trail below about α 0.04 only grazes gets nothing, where before a centre it happened to cross got a
-  step. Occlusion of about 2 %.
-- *More fragments.* Every voxel a thin trail crosses runs the fragment, not only those whose centres
-  it covers — two to three times as many along a thin trail, one more row along each edge of a wide
-  one, and never more than four per voxel per layer.
-
-The emulator compiles WGSL to JavaScript and takes names as they are, so a fragment parameter named
-`in` — a JavaScript keyword — failed to load; the splat's is `fragment`.
-
-**Verified.** A new emulator spec runs the splat's fragment with each sample mask and checks the share it
-writes, that four disjoint quarters add to one layer, and that a faded fragment writes nothing; with the
-weight removed it fails five of its eight tests. The channel's recorder spec checks the target is the
-pass's own, has the pipeline's sample count, is cleared and discarded, and that the volume's target
-comes back untouched; with the old recorder it fails exactly those two. Every spec the change can
-reach — the dynamic-mesh directory, the orchestrator run with a real channel, `Trail3DSystem`: 11 files,
-93 tests — passes, and the type check is at budget. On the Metal adapter, `@builtin(sample_mask)` and
-`@interpolate(perspective, centroid)` compile and the multisampled pipeline builds; no uncaptured device
-errors, including 240 frames of a live trail on a moving path, fading in and out.
-
-## 25. A trail's draw constants go up once a frame — 2026-09-27
-
-Entry 23 left each live mesh's constants built twice — a transient uniform and a bind group of its own
-for the splat, and again for the draw — noted, not shaved. They are shaved here, as part of moving
-every dynamic mesh's per-draw constants into a table (CHANGELOG, Unreleased, Rendering): the
-occupancy, after its upload, writes the frame's `GPUDynamicMeshDrawList` — one transient storage
-buffer and one write per 1,024 draws — and the splat and the draw both bind it and name their rows by
-`first_instance`. The splat's layout is four groups now (constants, geometry, warp, volume), which is
-WebGPU's default `maxBindGroups`.
-
-**Measured** with 1,500 live meshes through the channel at 1280×720 on the RTX 4090, asserts
-stripped, paired: 9.8–11.4 ms of CPU a frame to 2.0–2.5; 3,032 copies a frame to 34 and 7,624
-`setBindGroup` to 3,131. The pictures after equal frame counts are bit-identical to before.
-
-**Verified.** `DynamicMeshAVBOITChannel.draws.spec.js` checks the splat and the draw read each mesh's own
-constants from one table, and fails with a draw pass that uploads its own copy (two tables).
-`chunk_dynamic_mesh_vertex.spec.js` runs the shared AVBOIT vertex stage on the emulator and checks a
-vertex is carried by the row its draw names. The other half of the item — the emptiness query and the
-gather both walking the first live mesh's triangles — is left as it was.
-
-
-## 26. Review against the deck and the Godot proof of concept — 2026-10-04
-
-Alex asked for the implementation to be checked against the deck and against
-`github.com/IsaacMarovitz/godot-avoit` (*"AVBOIT works and is shipped, but I'm worried there might be
-mistakes"*), then for an adversarial review of the proposal before it was carried out, and for the
-particle off-centre read to be looked at again. The work is on a branch, not on master, for him to look at
-first.
-
-**Checked against the deck and found faithful.** The 10|10|10 packing with two guard bits, and the
-per-channel first-overflow mark the integration pins from (slides 57–60); the exclusive-prefix integral at
-`P + 1` slice boundaries; the continuous piecewise-linear warp, which gets what the deck's "filterable"
-begin/end flags are for (slide 95) without them; the two-slice bias taken in virtual space; halving with a
-fresh dilation per level; the resolve (slides 13–15). Two choices differ from the deck without being
-defects: halving keeps the curve's shape and doubles every slice, where the deck re-adjusts its log curve so
-that precision near the camera holds; and the per-fragment extinct discard stands in for the
-zero-transmittance depth cull.
-
-**The splat's rounding — measured, not a defect.** Meshes, particles and trails split a fragment's float
-extinction between its two slices and round each share; the water rounded once and partitioned the counts.
-Through the shipped chunks: the first makes a faint surface's count depend on where it sits in its slice
-(α 3 %: one count or two) and is right on average over depth; the second is stable over depth and biased
-(α 1.5 %: one count where 0.7 is exact). Either way an event below α ≈ 1.1 % registers nothing — the deck's
-8-bit floor.
-
-**Found and measured.** Items 1 and 3 are fixed, each red then green; item 2 is open.
-
-1. *Tilted surfaces striped* — plan §9's sloped-surface risk, never measured until now. Every voxel column
-   holds a surface at the depth under its centre, and the draw reads the four nearest columns bilinearly; on a
-   surface tilted away from the camera the near-side neighbour holds the same surface nearer by its depth change
-   over up to a voxel, and past the two-slice bias the surface occluded itself by an amount that depended on
-   where the pixel sat in its voxel. A model of two overlapping α 0.5 cards at 1080p, through the shipped warp
-   build, curve, rounding and lookup, put it from about 30° (red −13 %, green +25 % at 45° with the front one
-   tilted). On the RTX 4090, the playground at 720p with a card tilted behind a camera-facing one: a sawtooth
-   locked to `x mod 8`, 52.2–55.5 sRGB codes in red at 45° and 50.5–55.6 at 60°, against a flat 52.3 under
-   MBOIT and a flat camera-facing control. Fixed by `avboit_footprint_bias`: the lookup goes a further
-   `8 × fwidth(v)` virtual slices toward the camera — the bilinear reach — capped at `2 V / P`, the base
-   bias of the coarsest slicing (§3.8). After, on the device: 52.3–52.4 at 45°, flat in the interior at 60°.
-   The cost is the band: a tilted fragment is not occluded by what lies within its own voxel's depth span in
-   front of it. Past the cap — about 85° at 1080p in a sparse volume — the stripes can return.
-2. *The water pinned the warp at its floor.* Its occupancy marked every 8×8 tile's depth range, and a water
-   plane covers every depth from the shore to the horizon, so the warp halved to `V = P` whenever water was on
-   screen — AVBOIT became plain 128-slice VBOIT. Modelled with the shipped warp build: two α 0.5 cards at 10 m
-   separate at 0.25 m without water (V = 4096) and blend into one average at 0.25–0.5 m with a water plane
-   spanning 2–200 m in view, partly at 1 m. **Open.** A fix was built and taken out again: the water
-   moved out of the volume into a full-resolution *transmittance layer* that every other draw compared its
-   depth against. Alex: *"It's Anti-OIT."* It put a water special case into every transparent pipeline —
-   two bindings and a depth comparison per fragment in the mesh, particle and trail draws, a pass every
-   frame without water to bind something, and a contract every channel inherits — where order independence
-   means every source goes through the one volume. The water is in the volume again, exactly as before
-   this entry, and now takes the footprint like every surface that splats (its splat takes the nearest
-   depth over its 8×8 tile, so a voxel's width covers its own column; a neighbour's nearest point can lie
-   further). What bears on the pinning from inside the warp — hysteresis on halving and the deck's curve
-   re-adjustment — is measured in entry 27.
-3. *The particle splat read the soft fade at the voxel's corner*, `8 × voxel`: the top-left pixel, and not
-   the voxel's own footprint at all when the volume does not divide the frame. On a floor the row four pixels
-   up is farther by a good part of the 0.5 m fade range, so a smoke card standing on the floor went into the
-   volume at up to 2.4× the coverage it was drawn with (0.94 against a voxel average of 0.39 at 10 m) — entry
-   20's seam, one layer down again. Fixed by `chunk_particle_avboit_voxel_fade`: four reads at WebGPU's
-   standard 4× multisample positions over the voxel's footprint, through the exact low-to-full mapping.
-
-**The adversarial review of the proposal**, before any of it was built, changed it in four places:
-
-- *The footprint's reach.* A throwaway version at half a voxel cut the device sawtooth to 0.5 and 1.5 codes;
-  the bilinear lookup reaches a full voxel, so the full voxel is what removes it, and the spec holds that to no
-  self-occlusion at all.
-- *The footprint's cap.* Unbounded, it runs away at silhouettes and grazing angles — a sphere's rim would
-  ignore everything in front of it. It is capped at the coarsest slicing's base bias, the separation every
-  surface already has whenever the volume is full: the extra a fragment ignores is never more than that.
-  The whole reach, base bias included, is at most `2 + 2 V / P` virtual slices.
-- *The fade's sampling.* A read at the centre under-records the floor contact (0.24 against 0.39 at 10 m).
-  Over fifteen modelled contacts a 2×2 grid was off the voxel average by 0.05 on average and 0.12 at worst;
-  the rotated grid by 0.05 and 0.08, because its four reads fall on four rows and four columns.
-- *Withdrawn:* the meshlet splat takes glass's Fresnel from the geometric normal where the draw uses the
-  normal-mapped one. At the splat's coarse mip a high-frequency normal map averages back to the geometric
-  normal, and glass's Fresnel at near-normal incidence barely moves (about 0.04 across ±20°), so the two agree
-  well within what the volume resolves.
-
-**Corrected.** `AVBOIT_EXTINCT_TRANSMITTANCE`'s docblock bounded the discard's error by `1/256` of the
-background. That holds where the 1/8-resolution volume is right at the full-resolution pixel; behind a gap
-narrower than a voxel in a near-opaque layer the volume calls the pixel extinct and the surface seen through
-the gap is discarded, where the resolve's normalization would have drawn it. Constructed, not seen on a
-scene; the deck's zero-transmittance cull has the same limit. **Out of date:** entry 20's "the occupancy
-marks every emitter, with no frustum test" — the particles now mark the box their bounds pass measures from
-the quads, and skip additive emitters and unknown bounds.
-
-**The Godot proof of concept** is monochrome and composited over Godot's own transparents; every piece of it
-ports to WGSL. It splats at full resolution weighted by the cell's pixel area (64× the atomics), stores 16.16
-fixed point per slice (no 8-bit floor), reconstructs with a 4×4×4 cubic B-spline (whose wider XY footprint
-would stripe worse on slopes), takes occupancy from rasterized fragments, and keeps hysteresis on halving — it
-refines only once the occupied count drops below three quarters of the budget. That last is the one idea worth
-having here, where the virtual resolution is decided afresh every frame and a scene hovering at the budget
-could flip between two slicings; unmeasured.
-
-**An independent review of the commits**, by a reviewer who had only the diffs, the plan and this
-ledger, found nothing high or medium; it checked `fwidth` before any branch or discard at every call site
-and the spec's splat against the shader's. Taken from it:
-
-- *Additive particles took a footprint.* They write nothing into the volume, so nothing of theirs can
-  occlude them; the derivative is still taken in uniform control flow and selected away.
-- *Wording.* Camera-facing and stretched billboards are built from the camera's right and up, so their
-  footprint is zero (the draw's comment said they were tilted); the cap bounds the band, not the whole
-  reach; the side-channel contract now names the footprint.
-- Its findings about the layer went with the layer.
-- *Left:* the fade's four reads land on pixel boundaries at a scale of 8 and take the pixel past each, half a
-  pixel off the voxel's centre — inside what four reads resolve.
-
-**Verified.** Each fix red, then green, as above. The suites the change reaches (130 files, 1,518 tests
-with the layer gone); the whole engine suite (2,897 files, 22,247 tests, none failing, before the layer
-came out); the type check (declaration emit clean, 18 consumer-visible errors against the budget of 19, as
-before). On the RTX 4090, from the scratchpad and not in the repo: the slope probe; every AVBOIT module
-through `createShaderModule` and a frame under Brick4; the water page with the water back in the volume
-and taking the footprint, the card below the surface filtered by it (red 65 → 2 against the same view
-dry); no WebGPU validation error on any page (the water page's "Worker error" is the image-decoder worker
-bundle the dev server does not build, entry 22). A dev server left running across the revert's
-`git checkout` served the old recorder beside the new shader and threw; restarted, clean.
-
-## 27. Hysteresis and the curve re-adjustment, measured — 2026-10-04
-
-Alex, after entry 26's water layer was taken out: *"Go ahead and try hysteresis and the curve
-re-adjustment, I want you to measure the results."* Both are in the warp build behind two switches on
-`Renderer.avboit`, off by default, so the shipped frame is unchanged until one is turned on.
-
-**The deck's re-adjustment does nothing from a pure-log curve — measured, not built.** When the deck lowers
-its virtual slice count it re-parametrizes its log curve so slices near the camera keep their thickness.
-Searched over the free parameter of the engine's curve family (`build_light_cluster_parameters`:
-`slice = scale · log2(B z + O)`, pinned at the offset plane and the far plane), for each reference depth,
-the thinnest slice any member allows after halving 4096 → 2048 (near 0.1, far 200):
-
-| at | the deck wants | uniform halving | best member |
-|---|---|---|---|
-| 0.5 m | 0.08 cm | 0.16 cm | 0.10 cm — and 1.37× thicker at 50 m |
-| 1 m | 0.16 cm | 0.32 cm | 0.30 cm |
-| 2 m | 0.32 cm | 0.64 cm | 0.64 cm (pure log) |
-| 5 m | 0.79 cm | 1.59 cm | 1.48 cm |
-
-The same ratios hold for every halving. The deck's base curve is linearized and its re-adjustment moves it
-toward log; AVBOIT's curve is pure log at every level, the near-preserving end of the family already.
-
-**What re-adjusting can recover is the octave's waste** (`AVBOITSettings.warp_steps_per_octave`). Halving
-lands the occupied count anywhere from about half the budget to all of it. With four steps per octave the
-build tries `2 L · 2^(-i/4)` between the octave that fits and the one above it, finest first, rewriting the
-finest bits into those slices conservatively, run by run; consumers take any virtual count unchanged.
-
-- *Random scenes* (emulator, the shipped shader; 4–64 objects at 1–150 m log-uniform, extents 0.1–20 % of
-  their depth; 120 scenes per count): where the warp halves, the virtual resolution reached is 1.28–1.43×
-  finer on average (medians 1.19–1.41, at most 1.68), and the share of the 128 slices used goes from
-  72–83 % to 93–95 %.
-- *The bonfire* (`playground/particle_ecs`, `?debug`, 400 stepped frames, RTX 4090, the virtual count read
-  back every frame through a hook on the history buffer, no engine change): octaves sit at **128, the
-  floor, every frame**; four steps at **215**, 1.68× finer.
-- *Cost* (the build dispatched alone on the 4090, warmed, configurations interleaved, medians of 320):
-  12 runs of occupied slices 34 → 54 µs, 40 runs 22.5 → 53 µs, 600 fragmented runs 22.5 → 317 µs — the
-  single-lane run walk, three times per frame at most.
-
-**Hysteresis** (`AVBOITSettings.warp_hysteresis`, `AVBOIT_WARP_RELEASE` = 0.75, Godot's figure). The
-virtual resolution the warp settled on is kept per view in a one-word GPU buffer; a finer one is taken only
-when it fits in three quarters of the budget, coarsening is immediate.
-
-- *Synthetic* (emulator, the shipped shader, 600 frames; a smoke column's extent jittering frame to frame at
-  the extent where the level steps): without hysteresis the level flips about 290 times, every other frame,
-  at 1, 3 and 10 % jitter alike; with it, none — the frames that flipped to the finer level are held at the
-  coarser one instead (2× coarser with octaves, 1.19× with steps). A slow drift through the threshold:
-  25 flips → 1 with octaves, 62 → 2 with steps.
-- *The release* (a replica of the decision, agreeing with the shader on 400 of 400 frames): it sets the
-  jitter tolerated and the precision given up while a scene shrinks. With four steps:
-
-| release | flips at 10 % jitter | at 25 % | budget used, shrinking scene |
-|---|---|---|---|
-| 1 (off) | 314 | 310 | 0.90 |
-| 0.95 | 104 | 259 | 0.87 |
-| 0.9 | 0 | 198 | 0.84 |
-| 0.75 | 0 | 34 | 0.75 |
-
-  With octaves the cost is larger, down to 0.59 of the budget at 0.75: refining needs the next level's count,
-  twice this one's, to fit in three quarters.
-- *The bonfire*: with the camera still, **no flip in 400 frames** at any setting — real particle bounds did
-  not jitter across a threshold here. Orbiting 90°: octaves flipped twice (128 ↔ 256), steps twice
-  (215 ↔ 256), steps with hysteresis never — held at 215 for the 21 frames where 256 was available.
-- *Cost*: one load and one store in a single-invocation pass; nothing measurable.
-
-**Found on the way: the warp build's serial LUT costs 136 µs whenever the volume is sparse.** With the
-occupancy fitting at 4096 virtual slices the build took 136 µs on the 4090, against 22.5 µs at 128: one
-invocation writing 4,097 LUT entries. Entry 15 raised `AVBOIT_VIRTUAL_SLICES_MAX` to 4096 counting "a longer
-single-lane loop in the warp build" among costs that do not register; it registers, against entry 17's
-290 µs for the whole of the transparency work on a page whose occupancy fits at 4096. A workgroup prefix
-sum would take it to a few microseconds, and the steps' run walk with it. Not done here.
-
-**Verified.** Seven new emulator specs on the build: the first step down that fits, the fall-through to the
-octave, a step's slices covering every finest slice they overlap, hysteresis holding without room to spare
-and refining with it, coarsening at once, the history recorded when hysteresis is off. The suites the change
-reaches (132 files, 1,537 tests); the type check at 18 against the budget of 19. On the 4090 the build
-compiles and runs with both switches in the bonfire, no validation error.
-
-**Open:** whether to turn either on — the steps are a measured 1.2–1.7× in over-budget scenes for 20–300 µs
-of single-lane work, hysteresis a guard against a flicker the bonfire did not show; the release, if
-hysteresis goes on (0.9 with steps by the table above); a parallel warp build, which would make the steps
-nearly free and take back the 136 µs.
-
-## 28. The warp build, one workgroup — 2026-10-04
-
-Alex: *"go ahead and parallelize the warp build please, go ahead and use subgroups too if it's relevant"*,
-with a snippet from the IOI Smolder talk — CuteSort, which ranks a lane by `WaveActiveBallot` per key bit
-and `countbits`.
-
-**What it was.** One invocation — §3.4 had it that a 1 K-entry prefix sum is not a workload, and that a single
-lane keeps the shader runnable in the emulator. Entry 27 measured it at 22.5 µs halving to 128 virtual
-slices, 136 µs whenever the occupancy fits at 4096 (the 4,097-entry LUT written serially), and 317 µs with
-four steps over 600 fragmented runs (the run walk).
-
-**What it is.** One workgroup of 128 invocations, one per occupancy word, each holding its finest word in a
-register for the whole build.
-
-- *A resolution tried:* every invocation marks the virtual slices its word's runs touch
-  (`chunk_avboit_warp_marks`) — finest slice `f` touches `floor(f V / V_max)` to `ceil((f + 1) V / V_max) - 1`,
-  division-free because `V_max` is a power of two, and 32 finest slices touch at most two virtual words — and
-  `atomicOr`s them into workgroup memory. Each invocation then dilates its own word of that resolution
-  (`chunk_avboit_warp_level_word`), and a `subgroupAdd` per subgroup and one pass over the partials count
-  them. Octaves are marked by the same rule, so halving is no longer a fold of the level above; where
-  `V_max / V` is a power of two the overlap rule is the fold.
-- *Decisions* are made on that count read back through `workgroupUniformLoad`, which is what lets Tint accept
-  loops with barriers and subgroup operations inside: the octave loop bounded at 13, the steps loop by the
-  uniform setting.
-- *The LUT:* `subgroupExclusiveAdd` over the chosen words' counts plus the earlier subgroups' totals, then 32
-  coalesced writes per invocation (`chunk_avboit_warp_lut_entry`).
-- The marks alternate between two halves of a workgroup array, each try zeroing the half the next will mark,
-  so a try costs three barriers.
-
-A first cut had each invocation compute its virtual word straight from the finest bits — 34 slices, two
-integer divisions each. Bit-exact, and 7 µs at 4096, but slower than the single lane wherever the warp halves
-(26.6 µs against 22.5 at 128): at 128 virtual slices four invocations had a word and 124 waited. Marking from
-the finest side keeps all 128 busy at every resolution.
-
-**The CuteSort snippet.** Its rank — the popcount of a ballot masked to the lower lanes — is what a LUT entry
-already is: `countOneBits(word & ((1u << bit) - 1u))`. An occupancy word is that ballot, 32 slices to a
-word, so within a word no subgroup operation is needed and nothing anywhere needs sorting; subgroups carry the
-counts across words.
-
-**Measured** (RTX 4090, headless Chrome; the build dispatched alone, warm, single-lane and parallel
-interleaved in alternating order, medians of 240):
-
-| occupancy | V | single-lane | one workgroup |
-|---|---|---|---|
-| sparse, fits at 4096 (steps 1 or 4) | 4096 | 136.2 µs | 3.1 µs |
-| 12 runs, steps 1 | 512 | 33.8 µs | 3.1 µs |
-| 12 runs, steps 4 | 724 | 54.3 µs | 4.1 µs |
-| 40 runs (bonfire-like), steps 1 | 128 | 22.5 µs | 4.1 µs |
-| 40 runs, steps 4 | 128 | 53.3 µs | 5.1 µs |
-| 600 fragmented runs, steps 1 | 128 | 22.5 µs | 7.2 µs |
-| 600 fragmented runs, steps 4 | 128 | 317.4 µs | 9.2 µs |
-| occupied everywhere, steps 1 | 128 | 22.5 µs | 4.1 µs |
-| occupied everywhere, steps 4 | 128 | 34.8 µs | 5.1 µs |
-
-A step tried now costs about a microsecond, so the cost half of entry 27's open question is gone.
-
-**Verified.**
-
-- *Bit-exact against the single-lane build on the 4090:* both shaders in one page on the same inputs, every
-  word of the warp and the history word compared. 5,304 cases: 397 occupancy patterns (empty, full, single
-  slices at word edges, runs sized around every octave's budget at seven offsets, trains of runs, 160 random
-  run sets, random bits at seven densities) × physical 128 (96 and 200 on a third of them) × steps 1, 2, 4, 7
-  × hysteresis off and on with assorted previous resolutions. Every level from 64 to 4096 was reached; no
-  word differs. Tint compiles it with no message.
-- *Through the shipped pipeline* (the bonfire, entry 27's probe, 80 frames per setting): 128 virtual slices
-  with octaves, 215 with steps, the same two flips orbiting and none with hysteresis; no validation error.
-- *Not exercised:* subgroup sizes other than the 4090's 32. The scan takes invocations to fill subgroups in
-  index order, as `shader_prefix_scan_csdldf` does.
-- *Specs:* the emulator cannot run the workgroup, so — as with the bucket sorts (entry 22's sort, the
-  rasterization buckets) — the shader's spec holds the assembled source to the parser and the validator, and
-  the five new chunks carry their own: the marks against the overlap definition at octaves and between, runs
-  split across words, a word straddling a virtual word; the dilation and the cut at `V`; the budget; the
-  steps; the LUT entry. Flooring a run's last slice instead of ceiling it fails four of the marks specs. The
-  14 emulator tests of the whole single-lane build went with it; their scenarios are among the device cases.
-  The suites the change reaches: 160 files, 1,619 tests; the type check at 18 against 19.
-
-`chunk_avboit_fold_pairs` has no consumer now; kept.
-
-The water playground got a tickbox for the steps on the way (d915095b2). Its one view sits at 256 virtual
-slices in all six presets with or without them: the water's occupancy fits at 256 and at none of 431, 362
-or 304.
-
-**Open:** entry 27's — whether to turn the steps or hysteresis on, the steps now at about a microsecond per
-resolution tried.
-
-## 29. Four steps per octave by default; hysteresis removed — 2026-10-04
-
-Alex, after the warp, its defaults and entries 27–28 were explained: *"make 4 default, remove hysteresis."*
-
-**Steps.** `AVBOITSettings.warp_steps_per_octave` is 4. What it was measured to buy (entry 27): 1.28–1.43×
-finer virtual slices on average where the warp halves, 1.68× in the bonfire (128 → 215), and smaller level
-changes when the count crosses a threshold (215 ↔ 256 orbiting the bonfire, against 128 ↔ 256). What it
-costs since entry 28: about a microsecond per resolution tried, at most three per view per frame. Where
-halving already lands close to the budget no step fits and the warp is the octave's, as before. The water
-playground's tickbox starts ticked, mirroring the default.
-
-**Hysteresis** is gone: `AVBOITSettings.warp_hysteresis`, `AVBOIT_WARP_RELEASE`, `chunk_avboit_warp_budget`,
-the warp build's `history` binding and the per-view buffer behind it (`graph_avboit_build_warp` no longer
-takes a `history_key`). It guarded against a flicker measured only in synthetic jitter — the bonfire with a
-still camera never changed level — and cost precision whenever a scene shrinks, holding the coarser
-slicing until a quarter of the budget was free.
-
-**Verified.** The build without the history binding against the single-lane build of entry 27 with
-hysteresis off, on the 4090: entry 28's 397 occupancy patterns × physical counts × steps 1, 2, 4, 7, 2,652
-cases, every word of the warp identical; timing unchanged (3.1–9.2 µs). The suites the change reaches; the
-type check.
-
-**Open:** none from this.
-