@woosh/meep-engine 3.60.3 → 3.60.5

package/src/engine/sound/simulation/IMPLEMENTATION_PLAN.md

@@ -1,432 +0,0 @@
-# Acoustic Simulation — Implementation Plan
-
-> A geometry-driven acoustic **simulation** layer for meep that feeds the **sopra** sound engine.
-> Steam-Audio-equivalent in *role* (occlusion, transmission, medium, later reflections / reverb /
-> pathing), built ECS-first and almost entirely in JS for **real-time, in-browser** use. The simulation
-> computes scalars / IRs against meep geometry; **sopra renders them through WebAudio**. The two never
-> blur: this folder produces data, sopra turns data into sound.
->
-> Status: **P0–P6 BUILT + GREEN, all render paths wired** (full `engine/sound` suite 360 pass / 0
-> regressions). The simulation engine + the occlusion/transmission/medium RENDER seam + the **probe-baked
-> reverb RENDER** + the **corner-leakage (pathing) RENDER** are complete and wired into sopra + the ECS
-> (`AudioEmitterSystem`). Reverb render uses **option B** — a new acoustic-owned `ProbeReverbRenderer`
-> (its own double-buffered ConvolverNode crossfade, IR from the nearest probe's baked decay), leaving
-> sopra's static `ReverbEffect` untouched. Pathing render is an **engine-wide `AcousticSimulator.pathing`
-> toggle** (off by default, zero cost when off): one single-source Dijkstra from the listener per frame
-> (`AcousticPathGraph.computeExitField`) gives every probe its exit point; each occluded source routes a
-> second exit-spatialized send (`EventInstance` path branch). No per-source flag — threaded from the
-> engine config like `acoustic`. **ECS WIRING HELPER LANDED (2026-06-20):** `configureAcousticSimulation`
-> (`simulation/configureAcousticSimulation.js`) — one call from a config builds/reuses the shared
-> `AcousticSimulator`, adds `AcousticSimulationSystem` + `AcousticVolumeSystem` (via `addManySystems`),
-> and injects the simulator (+ optional `ProbeReverbRenderer`) into the `AudioEmitterSystem`. So the only
-> meep-internal integration is done; **Remaining:** the EXTERNAL config call (`makeMirEngineConfig`, in moh
-> — out of meep scope) + save/load serialization registration, both gated on the sopra strangler
-> migration. Serialization adapters are deliberately NOT built yet — they mirror `AudioEmitter`, which has
-> none either (the new sound stack defers binary save integration); the acoustic components carry JSON
-> `toJSON`/`fromJSON` + `typeName` for when the migration lands. To wire reverb: connect a sopra bus send →
-> `ProbeReverbRenderer.input`, pass `probeReverb` to `configureAcousticSimulation` (or set
-> `system.probeReverb`) + `renderer.setProbeField(bakedField)`. To wire pathing: `sim.pathing = true` +
-> `sim.setPathGraph(bakeVisibility(probeField, sim.occluderIndex))`.
->
-> **What landed per phase:**
-> - **P0** — `AcousticMaterial`, `RayHit`, `AcousticOccluderIndex` (per-body local ebvh BLAS, O(1) `setTransform`).
-> - **P1** — `OcclusionSolver` (volumetric fibonacci rays + seeded jitter + EMA), `VolumeField`, `AcousticMedium`/`AcousticSolution`/`AcousticSourceState`.
-> - **P2** — `AcousticBody` + `AcousticSimulationSystem` (reactive); `AcousticSimulator`; occluder shapes raycast directly via `AbstractShape3D.raycast` (no triangulation).
-> - **P3** — `EventInstance.setAcoustic` + node insert (occlusion gain + lowpass + transmission); `AudioEmitter.acoustic`; `AudioEmitterSystem` apply + `LiveEmitterSet` acoustic threading. **First audible occlusion — wired.**
-> - **P4** — `AcousticVolume` + `AcousticVolumeSystem` (medium, blended, live-tracked).
-> - **P5** — world-AABB broadphase (measurement-driven via `bench/occlusion.bench.spec.js`); temporal amortization proven.
-> - **P6** — `AcousticProbe` + `bakeReverb` + `ProbeField` + `bakeProbeField` (geometry-derived reverb, density knob, serialized); `AcousticPathGraph` + `bakeVisibility` + `findAcousticPath` (probe-visibility routing around obstacles).
->
-> **Post-P6 cleanup + accel pass (2026-06-20, all committed, `engine/sound` 373 pass):** the occluder
-> index now **raycasts shapes directly** via `AbstractShape3D.raycast` (no triangulation;
-> `acoustic_geometry_from_shape` deleted) and sits behind a **TLAS** — a dynamic BVH over the bodies'
-> world AABBs (P5's deferred TLAS, landed early). `RayHit` carries the world hit **point + normal** (no
-> `hit` flag, no `triangleIndex`). Per-source state is **pooled** in a `BinaryElementPool`
-> (`Map<EventInstance, id>`, flyweight cursor) instead of a `Map<…, AcousticSourceState>`. The probe
-> substrate moved to **`RowFirstTable` + a probe BVH** (nearest via `bvh_query_user_data_nearest_to_point`)
-> and **`CSRGraph`** connectivity. `sourceRadius` moved onto `AudioEmitter`/`EventInstance`;
-> `pathMaxDistance` was removed (path falloff now derives from the source's authored attenuation curve);
-> `AcousticSolution.exit` is a vector. Below, §3.1 / §4 / D5 / P5 describe the v1 triangle-BLAS +
-> linear-scan design that this pass superseded — read them as history. The remaining headline work is the
-> ray-traced reflection IR (see `REFLECTION_IR_PLAN.md`).
->
-> **FOA directional reverb LANDED (2026-06-20):** the first of P6's two premium tiers — the **FOA
-> (first-order ambisonic / B-format) directional reverb field**. The bake now captures, per band, the
-> energy-weighted **arrival direction** (a 0..1 anisotropy vector) by reciprocity — a ray's reverberant
-> energy arrives from its launch direction (`acoustic_trace_energy` accumulates it, `bakeReverbBands`
-> normalises it). `ProbeField` widened stride 6→15 to store the three per-band direction vectors (JSON
-> round-trips them). Render: a new `render/FoaProbeReverbRenderer` convolves the mono send into a B-format
-> set (`foaReverbImpulseResponse` — `W` omni + `X/Y/Z` steered by the baked direction, one-factor W-energy
-> normalised) and decodes to stereo by **rotating the decoder, not the soundfield** (two virtual cardioids
-> whose look dirs are rotated into world space by the listener orientation — six decode gains/frame, the IR
-> re-baked only on probe-cell change). `AudioEmitterSystem` now threads the listener rotation to
-> `probeReverb.update()` (the scalar `ProbeReverbRenderer` ignores it). Stereo decode is isolated so a
-> binaural/HRTF (SOFA) decoder can replace it later.
->
-> **Source directivity LANDED (2026-06-20):** the second of P6's premium tiers. `AcousticDirectivity`
-> (`simulation/definition/`) is the Steam-Audio dipole model — `gain = |(1−w) + w·cosθ|^p`
-> (`w` = `dipoleWeight` 0=omni/0.5=cardioid/1=dipole, `p` = `dipolePower`), `cosθ` = source forward · the
-> source→listener direction. Authored on `AudioEmitter.directivity` (default omni → zero cost; `isOmni`
-> short-circuits). The simulator's `apply` computes it per non-omni source (forward = `Vector3.forward`
-> rotated by the source's orientation) into `AcousticSolution.directivityGain`, which `EventInstance.setAcoustic`
-> multiplies into the direct-path gain. Orientation (shared `Transform.rotation` ref) + the directivity ref
-> plumb through `playEvent`/`LiveEmitterSet` exactly like `sourceRadius`/`position`. **P6 premium tiers now
-> both done;** the only remaining acoustic work is the external `makeMirEngineConfig` activation + save/load
-> serialization (gated on the sopra strangler migration) and the deferred optional refinements (NEE early
-> reflections, pathing live-recheck, door variants, binaural/SOFA decode).
->
-> **DISTANCE AIR ABSORPTION LANDED (2026-06-20):** "low frequencies travel further." `AcousticMedium.airAbsorption`
-> is now **dB/metre**; `VolumeField.integrateAbsorption` line-integrates it over the source→listener path
-> (`∫ α ds`; no-region case is closed-form `ambient·distance`, else 8-midpoint march reusing `sample`) into the
-> new `AcousticSolution.airLoss[3]` (per-band total dB). The point-sampled `AcousticSolution.medium` was
-> REMOVED (superseding §6's `airAbsLP.frequency ← solution.medium.airAbsorption` — air is now path-integrated,
-> not point-sampled). Render (`EventInstance.setAcoustic`) anchors the tilt at the LOW band — only
-> `airLoss[high] − airLoss[low]` darkens the cutoff (`OPEN·2^(−tilt/6dB-oct)`, floored), so a uniform loss (the
-> distance **attenuation curve's** job, a windowed/irradiance falloff — *not* physical) causes no darkening:
-> the curve owns loudness, air owns the spectral tilt, and the two compose via separate series nodes. Default
-> ambient = a small low-anchored atmosphere (`DEFAULT_AIR_ABSORPTION [0, 0.03, 0.1] dB/m`, tunable). Applied to
-> the DIRECT path only (the leak send's longer path is a deferred refinement, like directivity-on-leak).
->
-> **CORNER-LEAK REFINEMENTS + DYNAMIC RECHECK + SERIALIZATION LANDED (2026-06-21):** the three corner-leak
-> gaps are closed, plus the acoustic binary adapters. (1) **Leak now carries directivity + air.**
-> `AcousticSimulator.#applyPath` walks the leaked polyline ONCE (source→…→listener via
-> `ProbeFieldPathingSolution.next`) and does three things: integrates air per leg
-> (`VolumeField.integrateAbsorption`) into the new `AcousticSolution.pathAirLoss[3]`; folds **directivity toward
-> the FIRST hop** (the corner the source radiates into, not the blocked listener — `#directivityGainToward`)
-> into `pathGain`; and marks each traversed edge for the recheck. `EventInstance`'s leak branch renders through
-> its own 3-band crossover (`#leak3Band`), gained per band by `(1 − transmission[b])` × the `pathAirLoss`
-> low-anchored tilt (so a longer routed leak darkens more, and a band-selective wall leaks only its blocked
-> bands around the corner — consistent with the direct path's 3-band render).
-> (2) **Budgeted dynamic-geometry recheck** (`AcousticSimulator.pathingRecheck` + `recheckBudget`, off by
-> default): `ProbeVisibilityRecheck` re-verifies (within budget, FIFO round-robin) the edges leaks traverse
-> against live geometry (`probe_edge_visible`, extracted + shared with `bakeVisibility`); a now-blocked edge →
-> `EDGE_WEIGHT_BLOCKED` (Float32 max — finite, no topology change, blows the path distance past audibility),
-> restored to the inter-probe distance when it re-opens. No structural mutation; the baked graph self-heals.
-> (3) **Binary serialization** adapters for `AcousticMaterial`/`AcousticMedium`/`AcousticDirectivity` (value
-> types) + `AcousticBody`/`AcousticVolume` (components, delegating; shape omitted like `toJSON`), with
-> `populateAcousticSerializationRegistry`. (`AudioEmitter`'s own adapter — needing the full sopra
-> `EventDescription` clip-graph chain — is still deferred.) Plus a **two-rooms-and-a-corridor integration
-> test** (`two_rooms_corridor.spec.js`) verifying bake (per-band reverb), reachability, leak direction
-> (emerges from the corridor, not through the wall), routed-vs-straight attenuation, and a sealed-divider
-> disconnection control. **Remaining deferred** (optional/premium): NEE early reflections, binaural/SOFA
-> decode, opt-in door variants + re-bake-on-streaming, region-aware air over the leak polyline, the full
-> external `makeMirEngineConfig` activation (gated on the sopra strangler migration).
-
----
-
-## 0. The one rule: simulation vs. render
-
-```
-  SIMULATION (this folder — engine geometry, JS, no WebAudio)        RENDER (sopra — WebAudio)
-  ───────────────────────────────────────────────────────────       ─────────────────────────
-  AcousticBody   (occluder shapes + material) ─┐
-  AcousticVolume (medium)                      ├─► AcousticSolution ─► EventInstance.setAcoustic()
-  ebvh rays + Ray3 + sphere_fibonacci_point ───┘    (a class)            (gain + biquad insert)
-```
-
-`simulation/core` and `simulation/ecs` import **no WebAudio**. The *only* WebAudio touch is the seam
-where `AudioEmitterSystem` hands an `AcousticSolution` to `EventInstance.setAcoustic(...)` (that method
-lives in sopra, where the node chain already lives). Consequence: the whole simulation is unit-testable
-on real geometry with **zero `MockAudioContext`** — only the one render seam needs it.
-
-We do **not** put medium on `EventDescription`. An event is a recipe for *a source*; the medium (air,
-room) is a property of *the world*. Medium lives on `AcousticVolume` components; a source merely **opts
-in** to simulation via one flag (`AudioEmitter.acoustic`). No god-object `AcousticScene` — the occluder
-set is just the entities that have an `AcousticBody`, indexed by a system-owned acceleration structure.
-This is an ECS engine at the top level; the data model is components.
-
----
-
-## 1. Layout
-
-```
-sound/simulation/
-  IMPLEMENTATION_PLAN.md
-  definition/                          authored, immutable, serializable (sopra/definition style)
-    AcousticMaterial.js                value class: absorption[3], scattering, transmission[3]
-    AcousticMaterialSerializationAdapter.js
-  core/                                ECS-agnostic AND WebAudio-agnostic — the testable heart
-    RayHit.js                          result class: t / material / bodyHandle / world position + normal
-    AcousticOccluderIndex.js           OccluderBody shapes + world transform behind a TLAS BVH; closestHit / anyHit
-    AcousticMedium.js                  value class: airAbsorption (per-band)
-    AcousticSolution.js                result class the render seam consumes: occlusion, transmission[3], medium
-    AcousticSourceState.js             transient per-source accumulation (rolling occlusion, smoothing)
-    OcclusionSolver.js                 solve(listener, source, index, rayCount, state, out) — explicit args, out-param
-    VolumeField.js                     sample(volumes, x, y, z, out) — out-param, no allocation
-    sampleDirections.js                sphere_fibonacci_point set + per-tick seededRandom rotation
-  ecs/                                 thin ECS binding (real-component tested)
-    AcousticBody.js                    component: AcousticMaterial + "is occluder"; pairs with Collider + Transform
-    AcousticBodySerializationAdapter.js
-    AcousticVolume.js                  component: AbstractShape3D + AcousticMedium + transition band
-    AcousticVolumeSerializationAdapter.js
-    AcousticSimulationSystem.js        System: maintain index + volume set (reactive); apply(liveInstances, listener)
-  probe/                               P6 — the baked substrate for reverb + pathing (see D6)
-  bench/
-    occlusion.bench.spec.js            rays/tick + ms/tick calibration (raycast.bench methodology)
-```
-
-The render-side additions (`EventInstance.setAcoustic`, the node insert, `AudioEmitter.acoustic`) live in
-**sopra**, not here — see §6.
-
----
-
-## 2. Reused meep primitives (verified to exist)
-
-| Primitive | Path | Used for |
-|---|---|---|
-| `ebvh_geometry_query_nearest_triangle_ray` | `core/bvh2/bvh3/` | closest-hit ray → `[triangleIndex,u,v,t]` |
-| `ebvh_build_for_geometry_morton` | `core/bvh2/bvh3/` | build a body's BLAS from its triangle soup |
-| `BVH` | `core/bvh2/bvh3/BVH.js` | the per-body tree (`new BVH()`, `release_all`, `allocate_linear`, `root`) |
-| `Ray3` (`Float32Array(7)`: o,d,tMax) | `core/geom/3d/ray/Ray3.js` | the ray type; slots into the ebvh query as-is; `applyMatrix4` for local transform |
-| `m4_invert` / `m4_inverse_rotation_translation` | `core/geom/3d/mat4/` | per-body world→local inverse |
-| `sphere_fibonacci_point` | `core/geom/3d/sphere/` | even source-sphere / hemisphere sampling |
-| `v3_orthonormal_matrix_from_normal` + `v3_matrix3_rotate` | `core/geom/vec3/` | hemisphere sampling around a normal (P6) |
-| `seededRandom` (Mulberry32) | `core/math/random/` | per-tick ray jitter; **never `Math.random`** |
-| `AbstractShape3D.signed_distance_at_point` / `contains_point` | `core/geom/3d/shape/` | `AcousticVolume` boundary blend |
-| `AnimationCurve` | `engine/animation/curve/` | distance→cutoff curves (reuse, don't invent) |
-| `BinarySerializationRegistry` + adapter pattern | `ecs/storage/binary/` | serialize materials/bodies/volumes |
-| SH toolkit (`sh3_rotate_bl`, `sh3_sample_by_direction`, `sh3_add`) | `core/geom/3d/sphere/harmonics/` | ambisonic field (P6) |
-| `AssetManager` + `OfflineAudioContext` | `engine/asset/` / browser | baked probe data + offline IR (P6) |
-
----
-
-## 3. Encapsulation (the clean core)
-
-**Two non-negotiables, applied everywhere below:**
-- **No opaque config bags.** Tunables (`rayCount`, …) are passed as explicit arguments. Configuration
-  objects rot — a function that needs a ray count takes a ray count.
-- **No magic structs / `@typedef`.** Every result/value shape is a real **class** (`RayHit`,
-  `AcousticSolution`, `AcousticMedium`, `AcousticSourceState`, `AcousticMaterial`). Hot-path queries are
-  **allocation-free**: the caller allocates the result and passes it in; the function writes into it.
-
-### 3.1 `AcousticOccluderIndex.js` — the (internal) acceleration structure, fully dynamic
-Not a public "scene". Owns a list of **bodies**, each a *local-space* triangle BLAS (`BVH` built once via
-`ebvh_build_for_geometry_morton`) plus a world transform (and its cached inverse) and one
-`AcousticMaterial`. API:
-
-```js
-addBody(positions, indices, material, matrix?) → handle   // BLAS built once from local triangles
-setTransform(handle, matrix)                              // O(1): store matrix + recompute inverse
-removeBody(handle)
-closestHit(ray /* Ray3 */, out /* RayHit */) → boolean    // nearest hit across all bodies, into `out`
-anyHit(ray /* Ray3 */) → boolean                          // early-out
-```
-
-`closestHit` transforms the world ray into each body's local frame (a module-static `Ray3` scratch +
-`applyMatrix4(inverse)`), runs the ebvh query against that body's BLAS bounded by the running best-`t`,
-and keeps the nearest; `out` receives `{ t, material, bodyHandle, triangleIndex }`. **Fully dynamic**:
-a moving body is just `setTransform` (O(1), no rebuild) — the ECS layer drives it from
-`Transform.position.onChanged`. Material is **per body** (a wall has one material); per-triangle
-materials are a later refinement, not a v1 need. *Precondition: rigid transforms (no scale), so local
-`t` equals world `t`* (documented, not guarded — see house rules). A body-level BVH (TLAS) over the bodies
-is the **P5** scaling step; v1 linear-scans the (few) bodies, BLAS does the real work.
-
-### 3.2 `OcclusionSolver.js` — the per-source solve (pure, explicit args, out-param)
-```js
-solve(listenerPose, sourceX, sourceY, sourceZ, sourceRadius, index, rayCount, state, out) → void
-```
-Shoots `rayCount` rays from the listener toward a `sphere_fibonacci_point` set over the source's sphere
-(`sourceRadius`), rotated per tick by a `seededRandom` orientation (so accumulation covers the sphere).
-Each ray is bounded (`tMax` = listener→sample distance) so far subtrees prune. Blocked-ray fraction →
-instantaneous occlusion; blocked rays' materials accumulate the transmission 3-band. Folded into `state`
-(`AcousticSourceState`, a rolling window) and smoothed; written into `out` (`AcousticSolution`).
-**Pure function of geometry + state**, deterministic for a seed; no ECS, no WebAudio, no allocation.
-
-### 3.3 `VolumeField.js` — medium zones (pure, out-param)
-```js
-sample(volumes, x, y, z, out /* AcousticMedium */) → void
-```
-Each `AcousticVolume` has an `AbstractShape3D` and a `transition` band. Weight =
-`smooth(-signed_distance / transition)` clamped to `[0,1]` (1 deep inside, 0 outside, smooth across the
-boundary). Normalize weights over overlapping volumes; blend the medium into `out`. A few
-`signed_distance_at_point` evals per query — cheap. Queried at the listener every tick; at sources
-optionally. **Pure**, allocation-free.
-
-### 3.4 result + state classes
-`RayHit`, `AcousticSolution`, `AcousticMedium`, `AcousticSourceState`, `AcousticMaterial` are all real
-classes with named fields and a `reset()`/`clear()` where they are reused. The system owns a
-`Map<EventInstance, AcousticSourceState>`, dropped on `instance.onEnded` — so `EventInstance` stays
-ignorant of solver internals.
-
----
-
-## 4. The component model (ECS)
-
-### `AcousticBody` (occluder) — pairs with `Collider` + `Transform`
-Serializable component carrying an `AcousticMaterial` and the "this entity occludes audio" semantic. The
-**shape** comes from the entity's existing `Collider`/mesh; `AcousticBody` contributes the acoustic
-*properties*. The system triangulates the body's collider shape once into the occluder index (local
-space) and drives its transform reactively. Tagging a wall = adding the component; nothing
-acoustically-inert occludes unless tagged — that closes the "physics BVH contains everything" problem the
-ECS way.
-
-### `AcousticVolume` (medium) — pairs with `Transform`
-Serializable component: an `AbstractShape3D` (its region), a `transition` distance (boundary blend band),
-and an `AcousticMedium` (air-absorption coefficients). Volumes overlap and blend (§3.3). **Medium only —
-no reverb here.** (Authored "reverb zones" are the wrong primitive; real reverb is the geometry-traced /
-baked output of the probe volume in P6. Until then, sopra's existing reverb stands unchanged.)
-
-### `AcousticSimulationSystem` — the binding
-`extends System`, `dependencies` covering `AcousticBody`/`AcousticVolume`:
-- `link/unlink AcousticBody` → `index.addBody/removeBody` + subscribe `transform.position.onChanged`
-  (and rotation) → `index.setTransform`. **Reactive, no per-tick refit loop** (mirrors
-  `SpatialAudioIndex`).
-- `link/unlink AcousticVolume` → add/remove from the volume list.
-- `apply(liveInstances, listenerPose)` — **called by `AudioEmitterSystem`** between `liveSet.refresh`
-  and `sopra.update`. Samples the listener medium once, then for each **live 3D** instance opted into
-  acoustics: `OcclusionSolver.solve(...)` (+ optional per-source `VolumeField.sample`) into a pooled
-  `AcousticSolution` → `instance.setAcoustic(solution)`. Bounded to ≤ budget (consumes the live set,
-  never iterates all registered emitters).
-
-`AudioEmitterSystem` takes an **optional injected** `acousticSim` collaborator (default none → behaviour
-identical to today). Feature is off-by-default and testable in isolation.
-
----
-
-## 5. Key decisions
-
-- **D1 — Event carries no medium; one opt-in flag.** `AudioEmitter.acoustic` (default `false`) plumbs to
-  the instance; `EventInstance` builds the acoustic nodes only when set; `setAcoustic` is a no-op
-  otherwise. `EventDescription` stays medium-free. (Owner-directed.)
-- **D2 — No `AcousticScene`; geometry is `AcousticBody` components, indexed internally.**
-- **D3 — `AcousticVolume` is medium-only.** No authored reverb zones. Reverb is the P6 traced/baked
-  output; sopra's existing reverb stands until then.
-- **D4 — `simulation/` imports no WebAudio.** It emits `AcousticSolution`s; sopra renders. The whole
-  simulation is testable without `MockAudioContext`.
-- **D5 — Occluders are fully dynamic.** No static merge. Per-body local BLAS + an O(1) `setTransform`;
-  the ECS layer refits reactively via `Transform.onChanged` (meep is reactive end-to-end — there is no
-  static/dynamic flag and no per-tick iteration). A body-level TLAS is the P5 scaling step, not a
-  correctness requirement.
-- **D6 — Using the sim requires a built probe volume; the bake is automatic.** When acoustics is enabled
-  for a scene, a **probe volume** must be built (it is the substrate for reverb + pathing). The bake is
-  **fully automatic** save for a few knobs (chiefly **maximum probe density**): it places probes across
-  the playable space, computes their data (reflection/reverb IR + inter-probe visibility for pathing),
-  and **serializes** the result. Triggering the bake is the user's responsibility (an explicit call /
-  editor action — it is not free), but the user authors no probes by hand. Runtime then just loads and
-  selects/blends baked probe data. (This is why pathing/reverb are P6: they consume the probe volume.)
-- **D7 — No opaque config bags; explicit args.** Tunables are parameters, not config objects.
-- **D8 — No magic structs; classes + caller-allocated out-params.** Hot-path queries allocate nothing.
-- **D9 — Cosmetic-only, so no determinism gate.** Rays use `seededRandom` (reproducible tests, clean
-  jitter), but there is no lockstep/networking requirement. If acoustics ever become gameplay-affecting
-  (AI hearing), that is a different project with a different bar.
-- **D10 — Bounded, amortized, allocation-free.** Work is capped to the ≤ budget (64) live voices;
-  `rayCount` is amortized across frames into `AcousticSourceState`; apply is throttleable; results +
-  scratch are pooled. JS constant factors are accepted; the budget is the contract.
-
----
-
-## 6. Render seam (in sopra — the only WebAudio change)
-
-`EventInstance.#buildOutputChain` (today `voices → instanceGain → attenuationGain → panner → bus`) gains,
-**only when the instance is acoustic**, an insert + a parallel transmission branch:
-
-```
-voices → instanceGain → attenuationGain → airAbsLP → occlusionGain → occlusionLP → panner → bus
-                                                    └→ transmission 3-band (parallel GainNodes) ─┘
-```
-
-`EventInstance.setAcoustic(solution)` ramps those `AudioParam`s (smoothing — no zipper):
-`occlusionGain ← 1-occlusion`, `occlusionLP.frequency ← f(occlusion)`, the three transmission band gains
-← `(1-occlusion) + occlusion·transmission[band]` (**parallel crossover, not series shelves** — band gains
-are independent and linear), `airAbsLP.frequency ← solution.medium.airAbsorption`. All nodes default to
-unity / open → an acoustics-off or 2D event is byte-identical to today. (Reverb is untouched here; it is
-the P6 probe-driven concern.)
-
----
-
-## 7. Phased plan
-
-Each phase ships behind black-box `*.spec.js` run from `H:/git/moh` root
-(`npx jest --config jest.conf.json engine/sound/simulation`). Real objects per house rules; the WebAudio
-boundary (only P3+) uses `MockAudioContext`.
-
-- **P0 — Core occluder substrate (no ECS, no WebAudio). ← building now.** `AcousticMaterial` class +
-  adapter; `RayHit` class; `AcousticOccluderIndex` (per-body local BLAS via `ebvh_build_for_geometry_morton`,
-  `Ray3`-based `closestHit`/`anyHit` into a caller `RayHit`, O(1) `setTransform`).
-  *Exit:* a hand-built box room answers closest-hit + per-body material correctly; a ray through an
-  opening misses; moving a body via `setTransform` changes the result; `anyHit` early-outs; material
-  round-trips. Zero ECS/WebAudio.
-- **P1 — `OcclusionSolver` + `VolumeField` + state (still no ECS/WebAudio).** Volumetric sampling
-  (`sphere_fibonacci_point` + `seededRandom` rotation), temporal accumulation in `AcousticSourceState`,
-  smoothing; `VolumeField` blend with `AcousticMedium`.
-  *Exit:* occlusion monotonic vs. wall coverage; fully walled → 1 with the wall's material in
-  transmission; open → 0; frame-stable; deterministic for a seed; volume blend + boundary interpolation
-  correct. Pure functions on geometry, allocation-free.
-- **P2 — ECS binding for occlusion.** `AcousticBody` + adapter; `AcousticSimulationSystem`
-  (reactive link/unlink + `setTransform`; `apply` loops live 3D instances → solver; owns the per-instance
-  state map).
-  *Exit:* real `EntityManager` + real `AcousticBody`/`Transform`/`Collider`; add/remove/move a body
-  changes the solution; cost bounded to ≤ budget. No WebAudio (assert on returned solutions).
-- **P3 — Render seam (first audible occlusion + transmission).** `EventInstance.setAcoustic` + the
-  no-op-default node insert; `AudioEmitter.acoustic` flag; `AudioEmitterSystem` calls `acousticSim.apply`
-  between `refresh` and `sopra.update`.
-  *Exit (MockAudioContext):* occlusion moves the gain + lowpass; transmission bands respond to material;
-  acoustics-off events identical to today; off-by-default.
-- **P4 — `AcousticVolume` (medium).** Component + adapter; `VolumeField` wired so air-absorption follows
-  the listener's blended volume.
-  *Exit:* blend weights + boundary interpolation correct; air absorption follows the listener's volume;
-  no pop crossing a boundary.
-- **P5 — Perf hardening + occluder TLAS.** Amortization/throttle knobs; scratch-pool audit (zero
-  per-frame alloc); a body-level BVH (TLAS) so `closestHit` is O(log bodies); `bench/` calibrating
-  ms/tick + rays/tick at budget=64.
-  *Exit:* measured ≤ target ms/tick; no GC churn; many-body scenes scale.
-- **P6 — Probe volume + premium tiers (gated).** The automatic probe-volume **bake** (D6: density-knobbed
-  probe placement over the playable space, per-probe reflection/reverb IR + inter-probe visibility,
-  serialized via the registry, user-triggered) → **reverb** (probe IR into a double-buffered
-  `ConvolverNode` on sopra's reverb send bus, crossfaded as the listener crosses probe cells) and
-  **pathing** (baked probe-visibility graph — **NOT** navmesh; navmesh connectivity ≠ acoustic
-  connectivity: a window/cliff/ramp carries sound with no navmesh edge). Plus **FOA directional reverb
-  field** (✓ LANDED 2026-06-20 — per-band baked arrival direction + B-format `FoaProbeReverbRenderer`; see
-  the dated note up top) and **source directivity** (✓ LANDED 2026-06-20 — `AcousticDirectivity`
-  monopole/dipole on `AudioEmitter`, solved into `directivityGain`; see the dated note up top).
-
----
-
-## 8. Runtime cost (the contract)
-
-Bounded by the ≤ 64 live voices, **world-size-independent**. Calibration constant `c` = per-ray ebvh
-closest-hit (≈1 µs occlusion in JS — measure with `bench/`). Occlusion+transmission =
-`liveVoices × rayCount × c`: 8 rays/voice ≈ 0.5 ms, 16 ≈ 1.0 ms; temporal amortization (rayCount spread
-over F frames) + throttle (15–20 Hz) cut it 3–4×. Medium (air absorption) + volume blend are closed-form
-(< 0.05 ms). Realistic v1 (occlusion + transmission + medium, reverb still sopra's existing) ≈
-**0.3–1.0 ms/tick** main-thread, dominated by occlusion ray count. Render adds ~5 native nodes per
-acoustic voice on the **separate** audio thread. The lever is `liveVoices × rayCount`; the only spike
-(traced reflections, P6) is precomputed into the probe volume and never on the per-frame path.
-
----
-
-## 9. Integration & blast radius
-
-| Touch | Change | Risk |
-|---|---|---|
-| `AudioEmitterSystem` | optional injected `acousticSim`; one `apply()` call between refresh & tick; read `listenerTransform.rotation` | low |
-| `LiveEmitterSet` | +1 accessor to enumerate live instances (bounded) | low |
-| `EventInstance` (sopra) | `setAcoustic` + no-op-default node insert in `#buildOutputChain` | **med** (hot chain — unity default, re-run `spatialization.spec`) |
-| `AudioEmitter` | `acoustic` opt-in flag (+ later `directivity`) | low |
-| `ReverbEffect`/`BusGraph` (sopra) | double-buffered convolver for probe reverb (**P6 only**) | med (reverb path, deferred) |
-| **New** | all of `sound/simulation/**` | n/a (self-contained) |
-
-**Untouched:** `SopraEngine` public API, the clip graph / containers / parameters / `VoiceManager` /
-voice-stealing / bus tree / snapshots / ducking, the `SpatialAudioIndex`/`LiveEmitterSet` cull+budget
-logic, the legacy `SoundEmitter` path, save-format back-compat. The simulation **consumes** the live set;
-it never alters culling, polyphony, or the mixer graph. `EventDescription` carries no medium.
-
-**Gate:** lands on the `AudioEmitter`/`AudioEmitterSystem` path, not yet in `makeMirEngineConfig`. Nothing
-here is observable in-game until the sopra strangler cut-over completes.
-
----
-
-## ECS wiring notes (probe field + regions)
-
-**`AcousticProbeFieldSystem` — single field (v1).** The baked `AcousticProbeField` is an ECS component
-(`typeName` + `toJSON`/`fromJSON` + `AcousticProbeFieldSerializationAdapter`); the system links it and wires
-it into the simulator (`setProbeField`) for pathing + probe reverb. **Only one field is supported for now:**
-the FIRST linked field is wired, any others are silently ignored (no error). TODO — **multiple probe fields**:
-e.g. per-region / streamed fields with the active field selected by listener position, or merged into one
-graph. Needs a field registry + a selection rule on the simulator (today `setProbeField` holds exactly one).
-Until then a scene has exactly one probe field.
-
-**Region index refit.** `AcousticRegionIndex` is BVH-backed (O(log n) blend queries); regions track
-`Transform.position` by reference, so the simulator re-fits ALL region leaves once per frame in `apply()`.
-TODO — refit only the regions that actually moved (needs move tracking on `AcousticVolumeSystem`, like the
-occluder system's `onChanged` subscription); fine while region counts are small.