@woosh/meep-engine 3.60.4 → 3.60.5

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

@@ -1,999 +0,0 @@
-# Sopra — Implementation Plan
-
-> Object-oriented, FMOD/Wwise-style sound engine for **meep**, built on the WebAudio API.
-> Status: implemented through **P5** (P0–P4 build-out + P5 spatial scaling to 100k emitters), and the
-> cut-over is done on the meep side: `AudioEmitter`, `AudioEventTrigger` and their adapters are
-> registered in `populateEngineSerializationRegistry`, the legacy `SoundEmitter`/`SoundController`
-> behavioural path is deleted, and `convertLegacySoundComponents` turns old saves into native
-> components. See `../SOUND_EMITTER_RETIREMENT_PLAN.md`. Remaining: the game repo still has to register
-> `AudioEmitterSystem`/`AudioEventTriggerSystem` and port its own call sites.
-
-This plan was produced from a full read of the current sound engine + a deep survey of the
-surrounding meep architecture (ECS core, asset system, serialization, precedents, game-side
-coupling) and an FMOD/Wwise ⇄ WebAudio feasibility study. Every "verified" claim below was
-checked against source.
-
-**Source layout** (`engine/sound/sopra/`): `SopraEngine.js` (orchestrator) at the root;
-`definition/` = authored, immutable data (`EventDescription`, `BusDefinition`, `ParameterDefinition`,
-`SopraPanningModel`, `VoiceStealMode`, plus `clip/` and `effect/` families); `runtime/` = transient
-runtime + services (`EventInstance`, `Voice`, `VoicePool`, `BusGraph`, `VoiceManager`,
-`ParameterStore`, `SopraPlaybackContext`); `asset/` = buffer providers; `serialization/` = `sopraJSON`
-+ registry (binary adapters stay co-located with their classes); `util/` = `buildAttenuationCurve`,
-`fadeOutAndStop`, `MockAudioContext`; `legacy/` = the SoundEmitter→sopra translator. Specs sit next to
-the code they cover.
-
----
-
-## 0. Status
-
-- **P0 — Core skeleton + ser/de + bus inserts (no ECS): ✅ DONE** (26 tests green via
-  `npx jest --config jest.conf.json engine/sound/sopra`).
-  Delivered under `sopra/`: the finished clip hierarchy (`AbstractAudioClip`, `ContainerAudioClip`,
-  `SampleAudioClip`, `SilenceAudioClip`, `SequenceContainerAudioClip`, `RandomContainerAudioClip`),
-  `EventDescription`, `BusDefinition`, `ParameterDefinition` (3D attenuation reuses the existing
-  `AnimationCurve`), the effect hierarchy
-  (`AbstractAudioEffect`, `EqEffect`, `CompressorEffect`), runtime (`SopraEngine`, `BusGraph`,
-  `Voice`, `VoicePool`, `EventInstance`, `ParameterStore`), `BufferProvider` +
-  `AssetManagerBufferProvider`/`StubBufferProvider`, the click-safe `fadeOutAndStop` (with the
-  Firefox fallback, D1), polymorphic binary adapters (co-located) + JSON dispatchers (`sopraJSON`) +
-  `populateSopraSerializationRegistry`, and a `MockAudioContext` test double. `volume2dB`/`dB2Volume`
-  are now exported. Specs: `sopraSerialization.spec.js`, `SopraEngine.spec.js`,
-  `fadeOutAndStop.spec.js`.
-  Deferred to **P3** (integration, not P0): registering the adapters in
-  `GameBinarySerializationRegistry` and constructing `SopraEngine` in `makeMirEngineConfig`. P0 keeps
-  the legacy engine fully untouched.
-- **P1 — Timeline playback + containers + parameters: ✅ DONE** (sopra suite now 35 tests green).
-  Delivered: a polymorphic `AbstractAudioClip.planTimeline(env, gainDb, pitchCents, offset)` on each
-  clip (deterministic flatten of the clip graph to timed leaf plays, gain/pitch inheritance resolved
-  once; no `instanceof` switching) + `collectSampleClips`, `SopraPlaybackContext` (seeded RNG + random-container
-  avoid-repeat history — network-deterministic per D5), Sequence/Random/Silence playback through
-  `EventInstance`, per-trigger pitch/gain randomization on `SampleAudioClip`, and parameter→bus-volume
-  automation via the reused `AnimationCurve`.
-  NOTE: the pumping **lookahead Scheduler** moved to **P2**, where virtualization actually needs it
-  (re-spawning virtual voices in-phase). P1 schedules a *finite* timeline eagerly with WebAudio's own
-  sample-accurate future `start(when)` — correct and simpler for bounded events.
-- **P2 — Voice management + spatialization + cursor scheduling: ✅ DONE** (sopra suite now 43 tests
-  green). Cursor-based playback (each frame `EventInstance.update(now, listener)` evaluates the
-  timeline against the playhead, spawning leaves within a lookahead window only while audible);
-  **virtualization** — out-of-range instances stop their voices, keep the cursor, and revive at the
-  correct child + buffer-offset (D3); **3D spatialization** — per-instance `attenuationGain → panner →
-  bus` chain (D4), attenuation = `curve.evaluate(distance)`, with `buildAttenuationCurve` reproducing
-  the legacy falloff from `interpolate_irradiance_*`; HRTF/EqualPower panner choice; and a
-  **VoiceManager** (per-event `maxInstances` + steal oldest/quietest/none; defaults a no-op).
-  NOTES: the lookahead scheduler is realised as the per-instance cursor evaluation (a global priority
-  queue is a P4 optimization if profiling warrants); StereoPanner / "no-panner" modes deferred to P4.
-- **P3 — ECS binding / strangler cut-over: P3.1–P3.6 DONE (P3.7 cleanup remains).** `SoundEngine` owns
-  the sopra engine via `createSopra(bufferProvider)`; `SoundEmitterSystem(assetManager, soundEngine)`
-  (required 2-arg ctor — no switch, no `sopra === null` branch) creates it through an
-  `AssetManagerBufferProvider`, reuses the single `SoundAssetLoader` (D7), and drives `sopra.setListener`
-  + `sopra.update` from its tick. **sopra is now the single renderer:** every `SoundEmitter` routes
-  through a per-entity `SoundEmitterComponentContext` translation record (legacy tracks → sopra
-  `EventInstance`s; live `emitter.volume × track.volume` → instance gain; shared `transform.position`
-  Vector3; live `track.volume` sets also plumb to the instance gain via `__soundRuntime`). The locked
-  public API (`SoundEmitter`: tracks/channel/volume/flags/distanceMin/Max; `SoundTrack`:
-  on.ended/flags/volume/time/url — `duration` was dropped, never written) is preserved as
-  deprecate-and-plumb; the `nodes` getters + `setVolumeOverTime` throw, while
-  `distanceRolloff`/`buildNodes`/`endTrack` and the rest of the non-contract surface were removed
-  outright. Channel volume = sopra bus volume (`get/setChannelVolume` proxy; legacy mix intact).
-  `CombatEndMusicProcess.switchMusic` now crossfades via `fadeOutAllTracks(1)` + `tracks.add`. All 10
-  `new SoundEmitterSystem(...)` call sites updated; the dead `SoundEmitterChannel` (singular) +
-  `SoundTrackNodes` classes are deleted; full `engine/sound` suite green (62 tests).
-  STILL PENDING (P3.7): single listener-feeder convergence and the remaining `@deprecated` JSDoc sweep.
-- **P4 — build-out: STARTED.** Switch + Blend parameter-driven containers DONE
-  (`SwitchContainerAudioClip` = discrete RTPC-keyed single-child pick; `BlendContainerAudioClip` =
-  per-child parameter→gain curves, all audible layers play simultaneously). Parameter access threaded
-  into the planTimeline `env` (`getParameter`, read once at trigger). Both fully serialized (JSON +
-  binary + registry) and folded the dormant `material/` concepts (surface-switch / composition) into
-  general primitives. v1 Blend is a **trigger-time snapshot**, not live re-blend as the parameter
-  sweeps (follow-up below). **Reverb sends DONE:** `BusDefinition.sends` is now wired at build time
-  (post-fader copy → send gain → target bus input), and `ReverbEffect` (`ConvolverNode` + a
-  procedurally-generated decaying-noise IR — no IR asset, synchronous build) is a new bus insert.
-  **Mixer snapshots DONE:** `MixerSnapshot` (named per-bus target gains) + `SopraEngine.applySnapshot`
-  (instant or click-safe ramped blend, via `BusGraph.rampVolume`) + `captureSnapshot`. **Emulated
-  ducking DONE:** `DuckingRule` + `SopraEngine.addDucker`/`clearDuckers` — play-state sidechain (duck a
-  target bus while any instance plays on a trigger bus; `setTargetAtTime` attack/release via
-  `BusGraph.approachVolume`). **Native migration STARTED (additive-first):** native `AudioEmitter`
-  component (holds a full `EventDescription` directly) + `AudioEmitterSystem` done at the engine level —
-  shares the one sopra (idempotent `createSopra`), autoplay/stop/volume/position/listener, fully tested;
-  coexists with the untouched legacy `SoundEmitter`. (The autoplay-every-emitter behavior here is
-  **superseded by P5** spatial management — see below.) Remaining: `AudioEventTrigger` + game wiring
-  (config/editor/serialization registries) + the `SoundEmitter`→`LegacySoundEmitter` rename & call-site
-  flip (see §9). Sound banks were evaluated and DROPPED — the ECS data model (components + dataset +
-  AssetManager) already covers every bank role.
-  Full `engine/sound` suite green. **The remaining items here are now done** — see the retirement plan:
-  `AudioEventTrigger` exists, serialization is wired, and the legacy component is a frozen reader under
-  `sopra/legacy/` rather than a live path (no rename was needed — the behavioural half was deleted).
-- **P5 — spatial scaling to 100k emitters: ✅ DONE (P5.1–P5.6; see §15 for the full record).** A BVH
-  broadphase + live/dormant split so the engine carries far more 3D emitters than can sound at once. A
-  registered-but-dormant emitter costs only a BVH leaf (no instance, no nodes, no per-frame work); each
-  tick the nearest in-range emitters — up to a global voice **budget** (default 64) — are promoted to
-  live instances and the rest demoted. **P5.1** `SpatialAudioIndex` (BVH cull, reactive leaf refit via
-  `position.onChanged`, allocation-free `queryAudible`). **P5.2** `LiveEmitterSet` (promote/budget/
-  distance-priority stealing/rank-hysteresis). **P5.3** demotion policy (hard cut when culled out of
-  range, click-safe fade on contention). **P5.4** continuous-clock phase reconstruction (`EventInstance.startTime`
-  + looping-voice buffer-offset wrap). **P5.5** a cull throttle was added then **reverted** — the cull
-  runs every tick (BVH is microseconds). **P5.6** `AudioEmitterSystem` wired to `LiveEmitterSet`:
-  looping-3D autoplay → spatially managed; 2D + finite-3D-one-shot → direct; non-autoplay → inert;
-  per-emitter `AudioEmitter.volume` carried through promote/demote. Two `.skip`-ped 100k stress tests
-  prove only `budget` instances exist regardless of N and the BVH prunes the far field (per-frame
-  `refresh + tick` ≈ 5 ms at 100k). Full `engine/sound` suite green (298, 2 skipped).
-
-## 1. Recommendation in one paragraph
-
-Build sopra as an **ECS-agnostic runtime audio engine** (`SopraEngine` + its services) that is
-fully unit-testable with a mock `AudioContext`, then bind it to meep with a **thin ECS layer**, and
-keep the legacy `SoundEmitter` / `createSound` / channel surface alive as a **translating facade**
-during migration (the *strangler* pattern). There is always **exactly one renderer** (sopra);
-legacy classes become translators, never a second engine. The architecture grafts the best of three
-evaluated stances: the *ECS-agnostic, clock-injected core* (testability), the *clean component/system
-topology* (meep-idiomatic), and the *zero-churn facade* (ships v1 with no call-site / save / settings
-/ editor edits).
-
-The **spine** is the thing meep lacks and FMOD/Wwise are built on: a **definition / instance split**.
-Today `SoundTrack` conflates the spec (`url`/`time`/`volume`/flags) with the live, single-use
-`AudioBufferSourceNode`. Sopra splits this into immutable **definitions** (the `*AudioClip` tree),
-transient pooled **instances/voices**, and engine-owned **services** (mixer bus tree, scheduler,
-parameter store, voice manager).
-
----
-
-## 2. Engine philosophy this plan must respect (verified)
-
-**meep ECS** (`engine/ecs/`)
-- `System` subclasses declare `dependencies = [ClassA, ClassB]`; the engine auto-delivers
-  `link(...componentsInDependencyOrder, entity)` / `unlink(...)` (arity is validated as
-  `deps.length + 1`). `components_used = [ResourceAccessSpecification.from(Klass, access)]` is a
-  scheduling hint that also auto-registers component columns.
-- `simulate(dt)` runs a **fixed-step lock-step pass** (`fixedUpdate(fixedStep)`) then **one
-  variable pass** (`update(dt)`); `getFixedStepAlpha()` gives the sub-step remainder for
-  interpolation. `fixedStepTick` only advances in the fixed pass.
-- Components are **plain serializable object instances** stored column-wise
-  (`components[componentIndex][entityId]`). Runtime/WebAudio objects must NOT live on the
-  component — they live in a system-owned `this.data[entity]` context (the established
-  `SoundEmitterComponentContext` discipline).
-- Singletons (the listener) are fetched via `ecd.getAnyComponent(Klass)`. Gameplay→sound uses the
-  per-entity event bus (`addEntityEventListener` / `sendEvent`), as `SoundControllerSystem` does.
-
-**Conventions**: every persisted type has `toJSON`/`fromJSON` **and** a versioned
-`BinaryClassSerializationAdapter` registered by `typeName`; polymorphic trees recurse through
-`ObjectBasedClassSerializationAdapter` + the shared `objectAdapter` (the behavior-tree precedent);
-`Signal` for events, `List` for observable collections, `Vector1` for change-notifying scalars,
-flags as bitmask enums, `assert.*` (free in prod).
-
-**User memories (hard constraints)**
-- **Uniform control flow** — no `null = auto / value = override` sentinels.
-  ⚠️ `AbstractAudioClip.parent` / `.channel` are exactly this antipattern; resolve inheritance
-  **once** at voice instantiation (flatten), so the runtime tick never sees a sentinel.
-- **Reuse over micro-opt** — prefer tested primitives; lead with end-to-end measurement.
-- **Correctness first, no bandaids**; **black-box tests only** (assert observable outcomes — which
-  buffer, which bus, what gain, what `when`, how many real voices — never call counts);
-  **no silent catch** (expected failure → sentinel/defer; unexpected → throw); asserts are free.
-
----
-
-## 3. The current engine and its gaps
-
-| Layer | Current | FMOD/Wwise gap |
-|---|---|---|
-| Definition | `SoundEmitter` (List<SoundTrack>, channel, distance, attenuation enum, flags) | no event/instance split |
-| Playback | `SoundTrack` **conflates** spec + live single-use source + state | — |
-| Mixer | **flat** 3 channel `GainNode`s (effects 1.2 / music 0.1 / ambient) → master `Gain → DynamicsCompressor → destination` | no nestable buses, no inserts, no sends |
-| Spatial | per-emitter `PannerNode` (rolloff=0) + custom attenuation `GainNode` via `interpolate_irradiance_*`; BVH hearing-range cull | attenuation is a fixed 3-value enum, not a curve |
-| Voices | **plays every track of every in-range emitter**; only cull is BVH | no limits / priority / stealing / virtualization |
-| Params | none | no RTPC / automation |
-| Timing | `track.time += timeDelta` each frame; `Suspended` flag works around Chrome disconnected-source time-freeze | no lookahead scheduler; sequence/loop precision at mercy of frame rate |
-| Containers | `sopra/` stubs exist with **no** selection logic, scheduler, instance, or serialization | random / sequence / blend / switch are empty classes |
-
-Latent bug to *not* faithfully reproduce: `SoundEmitterSystem.update` line ~370 is
-`if (soundTrack.setFlag(...) && ...)` — `setFlag` returns `undefined`, so the suspended-track-end
-branch is dead code and it sets `Suspended|Playing` on every track every frame. Port the **intent**
-(logical time advances while virtual; revive in phase), not the mechanism.
-
----
-
-## 4. The sopra model — three layers
-
-### 4.1 Definition layer (immutable, serialized, `typeName` + adapter + `toJSON`/`fromJSON`)
-
-```
-AbstractAudioClip            (finish the stub: typeName, isAudioClip tag, .from(), compare/equals/hash/clone)
-├── SampleAudioClip          NEW leaf — the only buffer-referencing clip: assetRef(path|alias),
-│                            gainDb, pitch(cents), loop + loopStart/loopEnd, pitchRandom, gainRandom
-├── SilenceAudioClip         (stub) duration → pure schedule-cursor offset, emits no source
-├── ContainerAudioClip       (stub) children[]
-│   ├── SequenceContainerAudioClip   plays children in order (scheduled, not onended-chained)
-│   ├── RandomContainerAudioClip     (stub) avoid_repeating_last via recent-history ring + seededRandom
-│   ├── BlendContainerAudioClip      [deferred] parameter-driven crossfade
-│   └── SwitchContainerAudioClip     [deferred] discrete parameter selects child (subsumes material/)
-```
-
-Plus three non-clip definition types:
-- **`EventDescription`** — the triggerable unit: `label, rootClip, busId, maxInstances, priority,
-  stealMode, virtualThresholdDb, is3D, attenuation: AnimationCurve, distanceMin/Max`.
-  (FMOD `EventDescription` / Wwise Actor-Mixer object.)
-- **`BusDefinition`** — `{ id, parentId, gainDb, effects[], sends[] }`. In v1, `effects[]` is **live**
-  (an ordered chain of `AbstractAudioEffect` — `EqEffect`/`CompressorEffect`, see D10); `sends[]` ships
-  as a **data shape only** (reverb sends are P4) so adding them later is non-breaking.
-- **`AbstractAudioEffect`** (+ `EqEffect`, `CompressorEffect`) — serialized bus-insert effects with a
-  `build(ctx) → { input, output }` contract (see D10).
-- **`AnimationCurve`** (reused from `engine/animation/curve/`, a cubic-Hermite keyframe curve) —
-  used for **both** parameter automation (RTPC) and 3D distance attenuation. `EventDescription.attenuation`
-  is an `AnimationCurve`; since it has no `typeName`/binary adapter of its own, the event adapter
-  serializes its keyframes inline. (Supersedes the originally-planned bespoke `AutomationCurve`.)
-- **`ParameterDefinition`** — `{ name, range, default, scope }`.
-
-> **Uniform-flow fix:** `parent`/`channel`/`gain`/`pitch` inheritance is resolved **once** when an
-> `EventInstance` is created (top-down flatten). The runtime never branches on a `null`-means-inherit
-> sentinel.
-
-### 4.2 Runtime layer (transient, pooled, **never serialized**)
-
-- **`EventInstance`** — one trigger: resolved position, parameter overrides, **schedule cursor**,
-  active `Voice`s, one-shot|persistent lifetime. Owns **its** `PannerNode` + attenuation `GainNode`
-  (see decision D4). Modeled on `ParticleEmitter.build()`, *not* the behavior-tree re-armed node
-  (which cannot produce concurrent voices).
-- **`Voice`** — one throwaway `AudioBufferSourceNode` + a **pooled** trim `GainNode`. The source is
-  the only unavoidable per-play allocation (it is single-use).
-
-### 4.3 Services (single instances hung off `SoundEngine`, no ECS imports)
-
-- **`SopraEngine`** — ECS-agnostic public API: `playEvent / playOneShot / createInstance / stop`,
-  `bus(id)`, `setParameter / getParameter`, `setListener(pose)`, `update(now)`. Constructed with
-  `(audioContext, destinationNode, bufferProvider)`; **reuses the existing `AudioContext` + master
-  chain verbatim — never a second context.**
-- **`BusGraph`** — instantiates the `BusDefinition` tree into chained `GainNode`s; root →
-  `SoundEngine.destination`; **seeds the default `effects`/`music`/`ambient` buses with the exact
-  legacy mix (Effects 1.2, Music 0.1)**; exposes `get/setChannelVolume` (linear, see D6).
-- **`Scheduler`** — lookahead queue over `AudioContext.currentTime`; each `update(now)` drains events
-  due before `now + lookahead` and calls `start(when, offset, duration)`. Replaces `time += timeDelta`
-  and obsoletes the `Suspended` hack. (Reuse `BinaryHeap`.)
-- **`ParameterStore`** — `Map<name, number>` + per-instance overrides + `onChanged` `Signal`s; samples
-  bound `AnimationCurve`s → `setTargetAtTime`.
-- **`VoiceManager`** — active-voice registries keyed by `eventId` and `busId`; per-event
-  `maxInstances` + per-bus limits + priority + steal-oldest/quietest (by post-attenuation gain);
-  **virtualization** (stop+disconnect source, keep advancing the instance cursor, revive in phase).
-- **`VoicePool`** — `ObjectPoolFactory` of pre-wired trim-gain chains.
-- **`BufferProvider`** (interface) + **`AssetManagerBufferProvider`** — `get(ref) → Promise<AudioBuffer>`.
-  Prod wraps `AssetManager.promise(resolveAlias(ref) || ref, 'audio')` (shared immutable buffer);
-  a stub impl in tests is what makes the core ECS-free unit-testable.
-- **`fadeOutAndStop`** — the ONE click-safe fade primitive (see D1). No call site hand-rolls fades.
-
-### 4.4 ECS binding (thin)
-
-- **`SopraEmitter`** (component) `+ Transform` — plain serializable
-  `{ eventId, paramOverrides, busOverride, volume: Vector1, flags }`. Runtime `EventInstance` lives
-  in `system.data[entity]`.
-- **`SopraEmitterSystem`** `dependencies = [SopraEmitter, Transform]` — `link` → `createInstance`
-  + `BVH.link`; `update(dt)` → BVH cull around the listener (reuse `BVHQueryIntersectsSphere` +
-  `bvh_query_user_data_generic` + `IncrementalDeltaSet`), push position/params, `engine.update(now)`;
-  `unlink` → stop + release. Hosts `playOneShot(eventId, position, overrides)`.
-- **`SoundListener` / `SoundListenerSystem`** — **reused verbatim**; read via `getAnyComponent`,
-  forwarded through `SopraEngine.setListener`.
-- BVH out-of-range = **virtual** (not disconnect); the `VoiceManager` decides actual realness under
-  budget. This turns the Chrome `Suspended` hack into standard virtual-voice behavior.
-
----
-
-## 5. Key design decisions (incl. the 5 critique revisions)
-
-- **D1 — `fadeOutAndStop` must NOT hard-depend on `cancelAndHoldAtTime`.** It is unimplemented in
-  Firefox (and used nowhere in meep today). Feature-detect it; otherwise use the portable idiom:
-  read `param.value`, `cancelScheduledValues(now)`, `setValueAtTime(currentValue, now)`, then ramp.
-  Always ramp to an **epsilon, never 0** (exponential-ramp-to-0 throws / clicks), and schedule
-  `stop()` just after the gain reaches ~epsilon. Test the no-`cancelAndHoldAtTime` path with a mock.
-- **D2 — `playOneShot` owns a max-lifetime timeout (default 60s) AND releases on asset-load
-  failure.** `createSound` today is belt-and-suspenders (`on.ended` **and** `Sequence[Delay(60),Die]`).
-  A one-shot whose asset 404s must still release — the no-silent-catch sentinel path, not a hang.
-- **D3 — Virtualization revive uses the instance logical cursor, not `t % dur`.** `t % dur` is only
-  correct for a single looping leaf. For a `Sequence`/`Random`/one-shot, re-derive the active leaf(s)
-  and their offsets from the cursor at `currentTime`, then `start(when, leafOffset)` each.
-- **D4 — `PannerNode` + attenuation `GainNode` are per-`EventInstance` (shared by its leaf voices),
-  not per-`Voice`.** This matches today's per-emitter sharing (`buildNodes` builds one chain; all
-  tracks feed the single emitter volume node). Per-voice panners would multiply HRTF cost (the
-  dominant spatialization cost) on multi-track emitters — a regression for the dense scenes we care
-  about. Only the source node + trim gain are per-voice. Panner-type choice (HRTF / equalpower /
-  `StereoPanner` for 2D-UI / none) + distance/budget downgrade lives at the instance level.
-- **D5 — Random/Switch selection is network-deterministic (decided).** Seed `seededRandom` from a
-  replicated source (`entity id + fixedStepTick`), not `Math.random`. Because the seed depends on
-  `fixedStepTick` (which only advances in the fixed pass), a selection decision must be made in
-  `fixedUpdate(fixedStep)` **or** stamped with the `fixedStepTick` read once per frame — the
-  selection must never depend on the variable `update(dt)` cadence. Keep `setRandomSeed` on the
-  container voice (the `WeightedRandomBehavior` precedent) so tests are reproducible.
-- **D6 — Channel-volume facade stays linear end-to-end.** The settings sliders are `{min:0,max:1}`
-  linear and `Effects` defaults to **1.2** (above max). Store/return the raw linear gain the slider
-  expects; convert to dB only internally if a bus needs it. Preserve 1.2 / 0.1 exactly.
-- **D7 — Single owner of the `SoundAssetLoader` registration.** `AssetManager.registerLoader` throws
-  on duplicate type. The rewired `SoundEmitterSystem` already registers it; `SopraEngine` reuses it,
-  does not re-register. Make construction order in `makeMirEngineConfig` explicit.
-- **D8 — Clip-tree adapters model the behavior-tree spine, NOT the legacy `SoundEmitter` adapter.**
-  The legacy adapter hand-rolls track ser/de inline and is **not** polymorphic. New container
-  adapters extend `ObjectBasedClassSerializationAdapter` so children recurse by `typeName`.
-- **D9 — Resolve the dormant overlaps.** `material/` (weighted `SoundMaterialComposition` + terrain
-  splat detector) and `asset/SoundAssetPlaybackSpec` are dormant (zero usages/tests). Fold them into
-  `Switch`/weighted containers in P4; do not maintain three parallel spec hierarchies.
-- **D10 — Bus insert effects are live in v1 (per the scope decision).** Add an `AbstractAudioEffect`
-  base mirroring `AbstractAudioClip` style (`typeName`, `toJSON`/`fromJSON`, adapter, `compare`/
-  `equals`/`hash`/`clone`) with a `build(ctx) → { input, output }` contract, plus two concrete
-  effects for v1: `EqEffect` (`BiquadFilterNode`, automatable `frequency`/`Q`/`gain`) and
-  `CompressorEffect` (`DynamicsCompressorNode`). `BusGraph` wires each bus as
-  `input → effect[0] → … → effect[n] → output`; an empty `effects[]` is a direct `input === output`.
-  The existing **master** `DynamicsCompressor` (in `SoundEngine`) stays master-glue only — buses must
-  not double-compress by default. `WaveShaper`/occlusion-lowpass remain nice-to-have (P4+).
-
----
-
-## 6. Reuse map (reuse-over-micro-opt)
-
-| Existing meep code | Used for |
-|---|---|
-| `sound/SoundEngine.js` (AudioContext, master `Gain→Compressor→destination`, suspend/resume) | injected into `SopraEngine`; never a 2nd context |
-| `sound/ecs/SoundListener*.js` | listener pose, reused **verbatim** |
-| `core/bvh2/bvh3/*` + `BVHQueryIntersectsSphere` + `IncrementalDeltaSet` | hearing-range cull = virtualization trigger |
-| `core/model/object/ObjectPoolFactory.js` | voice trim-gain pool; `ParticlePool`/`BitSet` if fixed-capacity budget wanted |
-| `core/math/random/seededRandom.js` (Mulberry32) + `weightedRandomFromArray.js` | deterministic random/weighted selection; avoid-repeat ring |
-| `Signal`, `Vector1` (onChanged), `List`, `combine_hash`/`computeHashFloat`/`computeStringHash` | params, gains, child collections, voice `onended`, clip hashing |
-| `engine/asset/*` (`AssetManager`, `SoundAssetLoader`, `loadSoundTrackAsset` alias path, `AssetPreloader`) | `AssetManagerBufferProvider`; preload via existing asset manifests (no bank concept) |
-| `engine/animation/curve/AnimationCurve.js` + `Keyframe.js` | the curve type for RTPC automation **and** 3D distance attenuation (`EventDescription.attenuation`) — reused instead of a bespoke curve |
-| `core/math/physics/irradiance/interpolate_irradiance_*` | reference falloff shapes when authoring `AnimationCurve` attenuation presets (P2) |
-| `sound/volume2dB.js` + `dB2Volume.js` (**export them**) | dB↔linear at facade edges, gain randomization, ducking math |
-| `ecs/storage/binary/object/*` + `SequenceBehaviorSerializationAdapter` shape | polymorphic recursive clip-tree ser/de by `typeName` |
-| `intelligence/behavior/*` (`Behavior`, `CompositeBehavior`, `BehaviorSystem`) | definition node contract + system lifecycle shape (but split def/instance) |
-| `SoundEmitterComponentContext` discipline | runtime objects in `data[entity]`; `Suspended` plumbing → `VoiceManager` virtualization |
-
----
-
-## 7. Serialization plan
-
-- Each definition type gets a `typeName`, a `BinaryClassSerializationAdapter` at **version 0**, and a
-  parallel `toJSON`/`fromJSON`. Container adapters extend `ObjectBasedClassSerializationAdapter`.
-- Register all in `GameBinarySerializationRegistry.initializeGameBinarySerializationRegistry`
-  (`registerAdapters([...])`) **and** in `GameClassRegistry` — the single registration sites, called
-  before `config.apply` in `GameBootstrap`.
-- Design byte layouts to be **upgrade-friendly from day one** (varint-counted, append-only fields),
-  per the `SoundEmitterSerializationUpgrader_1_2` lesson (which just appends a default `volume`).
-- **The legacy `SoundEmitterSerializationAdapter` (v2) + upgraders `_0_1`/`_1_2` stay registered
-  verbatim** — old saves deserialize into a `SoundEmitter` exactly as today; the facade translates at
-  link time. No save-format migration in v1.
-
----
-
-## 8. Migration / back-compat (the four surfaces)
-
-Invariant: always exactly one renderer (sopra); legacy classes are translators.
-
-1. **`createSound`** (#1 fire-and-forget, ~7 high-traffic sites). Keep the signature
-   `{position, url|track, positioned, channel, volume, timeout}` and self-destruct contract
-   byte-for-byte. Reimplement the body to build an ad-hoc `EventDescription` (root =
-   `SampleAudioClip`, `busId = channel`, `is3D = positioned`, `gainDb = volume2dB(volume)`) and call
-   `playOneShot(desc, {position})`. **Preserve the full safety net** (D2). `GameSounds.js` named
-   tracks become named `EventDescription`s keeping their export names.
-2. **`SoundEmitter` + `fromJSON` + manual entity builds** (footsteps/voice/impacts, boss ambience,
-   music stems, title music, achievements, dialogue). v1: keep the exact component shape & `fromJSON`;
-   the rewired `SoundEmitterSystem.link` translates each `SoundTrack` → `SampleAudioClip` + a
-   persistent `EventInstance` on the channel-bus (attenuation enum → 3-point `AutomationCurve`).
-   `tracks.on.added/removed` spawn/stop instances so `emitter.tracks.add/addAll` keep working.
-   Direct AudioParam reaches get equivalents: `setVolumeOverTime`/`emitter.volume.onChanged` →
-   live voice gain; `resetSoundEmitterTracks` (`t.time=0`) → `instance.seek(0)` **and** write
-   `track.time` back from the live cursor so readers stay consistent; `hideEntityGracefully` 2.7s
-   fade / `SoundEmitterVolumeBehavior` → `instance.fadeOutAndStop`. `CombatEndMusicProcess` reads
-   `track.nodes.volume.gain` directly → expose a **temporary bridge GainNode** at
-   `SoundTrack.nodes.volume` during cut-over, then migrate it to a `bus.fadeTo`/voice-crossfade
-   primitive and drop the bridge in P4 (do not keep the bridge as steady state).
-3. **`SoundController`** (UnitMaker only). Keep its v0 adapter frozen in v1. P4: provide
-   `SopraEventTrigger` preserving the `{tracks, startEvent, stopEvent, loop, volume, channel}` rule
-   shape; migrate UnitMaker last.
-4. **Channels + settings UI** (must preserve). Seed default buses with the exact legacy mix; keep
-   `get/setChannelVolume` on the (rewired) `SoundEmitterSystem` proxying to bus gain **in the linear
-   domain** (D6). Sliders bind unchanged. **Editor** (`SoundEmitterController`, symbolic display,
-   reset-tracks) keeps working because the component shape is preserved.
-
----
-
-## 9. Phased plan
-
-> Each phase ships behind black-box `*.spec.js` run from `H:/git/moh` root. P0–P2 need **no ECS**.
-
-**P0 — Core skeleton + ser/de + bus inserts (no ECS).**
-Finish clip classes; add `SampleAudioClip`, `EventDescription`, `BusDefinition`,
-`ParameterDefinition` (3D attenuation reuses the existing `AnimationCurve`), and the effect hierarchy
-`AbstractAudioEffect`/`EqEffect`/`CompressorEffect`
-(D10); `BusGraph` (default buses at legacy mix, wiring each bus's `input→effects→output` insert
-chain); `EventInstance` + `Voice` (pooled gain); `SopraEngine.playEvent/playOneShot/createInstance/
-stop/bus`; `BufferProvider` + stub; **export `volume2dB`/`dB2Volume`**; `fadeOutAndStop` **with the
-Firefox fallback (D1)**; one adapter per definition + effect type registered.
-*Exit:* a `SampleAudioClip` event plays to the right bus at the right gain, **through a bus insert
-chain (EQ→Compressor) wired in the correct order**, **and** every definition + effect round-trips
-equal (binary + JSON) — in Jest with a mock `AudioContext`, no ECS. Firefox fade path tested. Legacy
-engine untouched and still active. **✅ DONE — 26 tests green (see §0).**
-
-**P1 — Timeline playback + containers + parameters. ✅ DONE — sopra suite 35 tests green.**
-A polymorphic `AbstractAudioClip.planTimeline()` (overridden per clip) deterministically flattens the clip graph to timed leaf plays (gain/pitch
-inheritance resolved once); `Random` (seeded + avoid-repeat ring via `SopraPlaybackContext`) and
-`Sequence` (cumulative offsets; `Silence` = offset arithmetic); `ParameterStore` + `AnimationCurve`
-bound to bus volume (same curve type used for 3D attenuation); per-trigger pitch/gain randomization.
-D5 resolved (deterministic). The pumping lookahead `Scheduler` was MOVED TO P2 (it's only needed for
-virtualization / indefinite content); P1 schedules finite timelines eagerly via WebAudio future
-`start(when)`.
-*Exit (met):* sequence schedules children back-to-back with no gap; random avoids last N for a fixed
-seed; `setParameter` observably moves a live gain — black-box, no ECS.
-
-**P2 — VoiceManager + spatialization + cursor scheduling. ✅ DONE — sopra suite 43 tests green.**
-Cursor-based per-instance scheduling realises the lookahead model (each frame
-`EventInstance.update(now, listener)` spawns leaves within a lookahead window) — a global priority
-queue is deferred to P4 as an optimization. `VoiceManager` with per-event `maxInstances` + priority +
-steal (oldest/quietest/none). **Cursor-based virtualization** (D3): out-of-range instances stop their
-voices, advance the cursor, and revive at the correct child + buffer-offset. Per-`EventInstance`
-`PannerNode` (rolloff=0) + attenuation `GainNode` driven by `attenuation.evaluate(distance)` (D4);
-`buildAttenuationCurve` authors legacy-equivalent curves from `interpolate_irradiance_*`;
-HRTF/EqualPower panner choice (StereoPanner / no-panner deferred to P4). Per-bus limits also deferred
-to P4 (per-event covers the exit criteria).
-*Exit (met):* over-limit steals the correct victim; a virtualized sequence revives at the correct
-child+offset; attenuation matches the legacy curve at sample distances. Default limits are a no-op /
-stealing is opt-in.
-*Exit:* over-limit steals the correct victim; a virtualized **sequence** (not just a loop) revives at
-the correct child+offset; attenuation matches the legacy curve at sample distances. **Default limits
-are a no-op / stealing is opt-in** (so dense scenes can't regress before measurement).
-
-**P3 — ECS binding + facade cut-over (zero call-site / save / settings / editor change).**
-`SopraEmitterSystem` (+ `playOneShot`); reuse `SoundListener*`; construct `SopraEngine` in
-`makeMirEngineConfig` from `sound.context/.destination`; **single loader owner (D7)**. Rewire
-`SoundEmitterSystem` to translate tracks→clips→persistent instances (same constructor); `createSound`
-→ `playOneShot` (D2); `GameSounds` as named events; `get/setChannelVolume` proxy (linear, D6);
-temporary `track.nodes.volume` bridge + `track.time` write-back. Legacy v2 adapter/upgraders +
-`SoundController`/`SoundListener` + editor untouched; remove old `SoundTrack` node-rendering once the
-regression suite is green.
-*Exit:* all ~25 call sites, saves, sliders, and the editor behave identically; sopra is the only
-renderer.
-
-**P4 — Native migration + FMOD/Wwise build-out (post-strangler).**
-
-> **DONE — Switch/Blend containers.** `SwitchContainerAudioClip` (discrete RTPC-keyed: rounds+clamps a
-> parameter to a child index) and `BlendContainerAudioClip` (per-child parameter→linear-gain curves;
-> every child with gain > 0 plays simultaneously, scaled). Parameter access added to the planTimeline
-> `env.getParameter` (read once at trigger). Full JSON+binary serialization + registry; supersedes the
-> dormant `material/` subsystem's surface-switch / composition concepts. **Limitation:** Blend is a
-> trigger-time snapshot — it does NOT re-blend live as the parameter later sweeps. **Live re-blend
-> follow-up:** have plays carry an optional `{gainParam, gainCurve}`, bind the spawned voice's trim
-> gain to the `ParameterStore` (needs an *unbind* on voice retire — ParameterStore.bind currently has
-> no removal). Also still dormant: delete the `material/` files + `asset/SoundAssetPlaybackSpec` once
-> confirmed unreferenced.
-
-> **DONE — Reverb / aux sends.** `BusGraph.build` now wires `BusDefinition.sends` (previously a
-> data-only shape): for each send it taps the source bus's output → a send-level `GainNode` →
-> `targetBus.input` (post-fader copy; the dry path to the parent is unchanged). Throws on an unknown
-> send target. `ReverbEffect` is a new `ConvolverNode` insert whose impulse response is generated
-> procedurally at build (decaying noise; params `decaySeconds`/`decayPower`) — so build stays
-> synchronous with no IR-asset dependency. A "reverb bus" = a bus with a `ReverbEffect` insert that
-> other buses send to. **Follow-ups:** live send-level control (sends are static at build); authored-IR
-> source from the BufferProvider (would make build async); pre-fader sends.
-
-**Native migration** (user naming: `AudioEmitter` [rename `SoundEmitter`→`LegacySoundEmitter`],
-`AudioEventTrigger` — keep "sopra" internal-only). Decided **additive-first**: `AudioEmitter` holds a
-full `EventDescription`.
-
-> **DONE — additive foundation (engine-level, not yet wired into the game).** `AudioEmitter`
-> (`engine/sound/ecs/audio/`) holds a full `EventDescription` + a live `volume` (Vector1) + `autoplay`;
-> serializable (JSON). `AudioEmitterSystem` shares the single sopra (`SoundEngine.createSopra` made
-> idempotent) + self-registers the `SoundAssetLoader` if absent (standalone-capable, guarded), autoplays
-> on link with `oneShot` derived from `event.rootClip.loops()` (finite events self-release at end,
-> looping events persist), plumbs `volume`→instance gain + `transform.position`→instance, and ticks
-> sopra + listener. Coexists with the untouched legacy `SoundEmitter`. Black-box tested.
-> **RENAME DROPPED (owner change of plans):** no `SoundEmitter`→`LegacySoundEmitter` rename. Instead
-> the legacy stack — `SoundEmitter`, `SoundEmitterSystem`, `SoundController`, `SoundControllerSystem` —
-> is annotated `@deprecated` (pointing at `AudioEmitter`/`AudioEmitterSystem`/the forthcoming
-> `AudioEventTrigger`). The classes keep their names; callers migrate organically.
-> **NOT yet done (own pass):** `AudioEventTrigger` (replaces `SoundController`); wiring `AudioEmitter`
-> into `GameClassRegistry` / `GameBinarySerializationRegistry` / the editor (`AudioEmitterController`,
-> symbolic display) / `makeMirEngineConfig`; consolidating the sopra tick to one owner once both systems
-> run together; migrating call sites to `AudioEmitter`.
->
-> **Post-review fixes landed (P4 review):** D1 — `oneShot` now derived from `event.rootClip.loops()`
-> (looping AudioEmitter events no longer die at the 60s lifetime backstop; added `loops()` to the clip
-> hierarchy). D2 (keystone) — `BusGraph` now keeps an authoritative per-bus `nominal` gain; `getVolume`/
-> `getVolumeDb` read it, `setVolume`/`rampVolume` write it, and `approachVolume` (ducking) deliberately
-> does NOT — so snapshot `captureSnapshot`, duck nominal-capture/restore, and settings read-back are
-> correct under automation (was: stale `gain.value`, which WebAudio never updates under ramps). IR2 —
-> `AudioEmitterSystem` self-registers the `SoundAssetLoader` (guarded). **Deferred (do at wiring time,
-> not band-aided):** IR1 single-owner sopra tick (the double-tick is idempotent-within-frame today and
-> only matters once both systems are in one config — **resolved**: the legacy system is gone and
-> `AudioEmitterSystem` is the single tick owner); D3 multi-ducker aggregation; ~~IR4 production
-> serialization wiring~~ (DONE); the remaining quick-fixes (D4–D9, C3).
-
-~~Flip call sites to `AudioEmitter`~~ (DONE); ~~`AudioEventTrigger` replaces `SoundController`~~
-(DONE); ~~`AudioEmitter` v0 adapter + save-translation path~~ (DONE — registered, plus
-`convertLegacySoundComponents`). Still open: migrate `CombatEndMusicProcess` to bus/voice crossfade and
-drop the bridge (game repo); an `AudioEmitterController` editor property panel (the symbolic display
-landed, the panel did not). Then the deferred features behind their own tests: **~~Snapshots/mixer-states~~ (DONE); ~~Blend/Switch containers~~ (DONE); additional bus insert
-effects (occlusion lowpass / `WaveShaper`) beyond the v1 EQ/Compressor; ~~reverb sends~~ (DONE);
-~~emulated ducking~~ (DONE); scatterer; adaptive-music timeline.**
-
-> **DONE — Emulated ducking.** `DuckingRule` definition (trigger/target bus, `duckDb`, `attack`,
-> `release`) + ser/de + registry. `SopraEngine.addDucker`/`clearDuckers`; evaluated each `update()`:
-> edge-triggered — when the trigger bus has ≥1 live instance the target ducks (`setTargetAtTime` toward
-> nominal+duckDb over attack; nominal captured at engage), restoring over release when the trigger goes
-> quiet. **Play-state** sidechain (active-instance count, NOT signal level — WebAudio has no native
-> sidechain) via the new `BusGraph.approachVolume`. Trigger match is by direct `instance.busId` (child
-> buses not counted in v1). Follow-up: true signal-following duck via `AudioWorklet`.
-
-> **DONE — Mixer snapshots.** `MixerSnapshot` definition (id + per-bus target `gainDb`) with full
-> ser/de + registry. `SopraEngine.applySnapshot(snapshot, {duration})` snaps (duration 0 →
-> `setVolume`) or click-safely ramps (`BusGraph.rampVolume` → shared `rampGain`) each listed bus to its
-> target — the FMOD mix-state blend. `captureSnapshot(id, busIds)` reads the current mix (for
-> save/restore). Throws on an unknown bus.
-
-> **Sound banks — DROPPED (not a feature).** A "bank" is FMOD/Wwise's catch-all for serialization +
-> load-unit + media package + by-id namespace, needed only because that middleware has no host data
-> model. meep already has every piece: `EventDescription`s are serializable definitions that live as
-> component / `EntityComponentDataset` data; load/unload is the scene/dataset boundary; media is the
-> `AssetManager`'s concern (cache + preload manifests). The only residual — shared "play by id" events
-> — is at most a small `AudioEventLibrary` *component* (id→`EventDescription` map), and even that is
-> optional since `playEvent` already accepts a description object directly.
-
----
-
-## 10. Testing strategy (black-box only)
-
-- **Layer 1 — ECS-free core** (the payoff of the agnostic design): inject a mock `AudioContext`
-  (records `createGain`/`createBufferSource`/`connect`/`start(when,offset,duration)`/gain
-  automation as an observable graph + schedule), a stub `BufferProvider` (fixed-duration buffers),
-  a deterministic clock, and a seeded RNG. Cover: definition round-trip; routing to the right bus at
-  the right dB; sequence gapless scheduling (`when` = prev `when` + prev `duration`); random
-  avoid-last-N **for a fixed seed (deterministic, D5)**; parameter moves gain; over-limit steals
-  correct victim; **virtualized sequence revives at correct child+offset**; attenuation matches
-  `interpolate_irradiance_*`; **a bus insert chain wires EQ→Compressor in order (empty `effects[]` is
-  pass-through; the master compressor is not double-applied)**; `fadeOutAndStop` never ramps to 0,
-  stops after ~epsilon, **and the no-`cancelAndHoldAtTime` fallback path**.
-- **Layer 2 — ECS binding**: an entity with `SopraEmitter+Transform` plays a 3D event, attenuates
-  with distance, goes virtual outside BVH range and revives on re-entry; sliders move bus gains.
-- **Layer 3 — back-compat regression** (the strangler safety net): `createSound` self-destructs on
-  end **and** on the timeout/asset-failure path; `SoundEmitter.fromJSON` is audibly equivalent;
-  `emitter.tracks.add` spawns a voice; `resetSoundEmitterTracks` restarts audibly; channel volume
-  round-trips at **1.2 / 0.1** through the linear proxy; an old save deserializes via the frozen v2
-  adapter and plays; single `SoundAssetLoader` registration when both engines are constructed.
-
-Determinism: seed `seededRandom` from the test (and, per D5, from a replicated source if
-network-deterministic audio is chosen).
-
----
-
-## 11. Risks
-
-| Risk | Sev | Mitigation |
-|---|---|---|
-| Game code pokes `track.nodes.volume.gain` directly (CombatEndMusicProcess) | high | temporary bridge GainNode in P3; migrate to bus/voice crossfade in P4; regression test |
-| `cancelAndHoldAtTime` absent in Firefox | high | D1 feature-detect + portable fallback + test the fallback |
-| One-shot leak on asset 404 | high | D2 max-lifetime timeout + release-on-failure sentinel |
-| Per-voice HRTF cost regression on multi-track emitters | high | D4 panner per-instance, shared across leaf voices |
-| Voice stealing silences sounds the old "play everything" engine played | med | default limits a no-op; stealing opt-in; measure densest scene first |
-| Scheduler/virtualization regresses loop sync or clicks | med | one fade primitive; absolute `when` off `currentTime`; revive-phase tests |
-| New ser/de drifts from conventions | med | D8 model on object adapter; version 0 + day-1 upgrader plan; P0 round-trip specs |
-| Uniform-flow flatten changes resolved gain/bus vs legacy | med | resolve once at instance creation; assert resolved bus/gain/pitch in tests |
-| Duplicate `audio` loader registration crash | low | D7 single owner |
-| `track.time` becomes dead state, breaks readers | med | write `track.time` back from the live cursor each frame |
-| Scope creep (reverb/ducking/snapshots in v1) | med | hard v1 line = spine + facades; ship effects[]/sends[] data shape only |
-
----
-
-## 12. Decisions
-
-**Locked by the owner:**
-1. **Migration aggressiveness — Facade-first strangler.** One renderer always; `SoundEmitter`/
-   `createSound`/channels become translators; sites migrate post-cut-over.
-2. **v1 scope — Spine + bus inserts.** Spine (split + buses + scheduler + voice manager + params +
-   random/sequence + spatialization + facades) **plus live EQ/Compressor insert effects on buses**
-   (`BiquadFilterNode` / `DynamicsCompressorNode`). Reverb sends / ducking / snapshots remain
-   P4 (banks dropped — see §9). (See D10 for the effect hierarchy and where it lands.)
-3. **Random/Switch selection — Network-deterministic.** Seed `seededRandom` from a replicated source
-   (entity id + `fixedStepTick`); selection is sampled where the fixed tick is stable (see D5).
-
-**Still the owner's call (defaults assumed; revisit any time):**
-4. **`SoundEmitter` endgame** — assume **keep as a frozen compat reader** through P3/P4; delete only
-   after full migration + a tested save-translation path. Removing a frozen ~80-line adapter is low value.
-5. **Voice budget defaults** — assume **high/no-op defaults + opt-in stealing**, measured in the
-   densest scene before enabling.
-6. **Bus tree source of truth** — assume **both**: code-seeded legacy default (1.2/0.1) overridable by
-   serialized scene data.
-
----
-
-## 13. FMOD/Wwise concept → sopra coverage
-
-**v1 (core):** definition/instance split · nestable bus tree · **bus insert effects (EQ/Compressor)** ·
-lookahead scheduler · parameters/RTPC + automation curves · voice manager
-(limits/priority/stealing/virtualization) · random + sequence containers · custom 3D attenuation
-curves · one-shot vs persistent · pitch/gain randomization · gapless loop regions
-(`loopStart/loopEnd`).
-
-**P4 / deferred (important):** ~~banks~~ (DROPPED — ECS data model covers it) ·
-~~snapshots/mixer-states~~ **DONE** · ~~blend + switch containers (fold in `material/`)~~ **DONE** ·
-~~reverb sends (`ConvolverNode`)~~ **DONE** · ~~emulated ducking~~ **DONE** · additional insert effects
-(occlusion lowpass / `WaveShaper`).
-
-**Nice-to-have:** scatterer/multi-spawn ambience · `AudioWorklet` (true sidechain + accurate meters)
-· `AnalyserNode` dev meters · `OfflineAudioContext` baking · adaptive-music timeline
-(transitions/stingers/sustain points).
-
----
-
-## 14. P3 detailed integration sub-plan — route `SoundEmitter` through sopra (real, not a veneer)
-
-Goal: the legacy `SoundEmitter` path genuinely renders through sopra. We do **not** keep 100%
-back-compat; instead we **deprecate-and-plumb** — the old public API stays as `@deprecated` members
-that translate into sopra (so call sites are unchanged), and is removed later. Where plumbing reaches
-private state, we rewrite the call site.
-
-### 14.1 Architecture — strangler at the existing spine
-`SoundEmitterSystem` is already the seam: it owns `this.sopra` and ticks `sopra.setListener` +
-`sopra.update` each frame (currently inert). Translation happens **there, at link time** — no new
-system. Per-entity runtime state lives in the (gutted) `SoundEmitterComponentContext`, repurposed from
-a WebAudio renderer into a **translation record**.
-
-- **link(emitter,transform,entity)** (sopra branch): translate the emitter to sopra
-  `EventDescription`s and `playEvent` a persistent `EventInstance` per persistent/looping track; store
-  them in a per-entity `Map<SoundTrack, EventInstance>`.
-- **tracks.on.added / on.removed** stay the hook: added → `playEvent` a new instance; removed →
-  `instance.stop()`. Preserves the live-mutation idiom (`SoundController`, `CombatEndMusicProcess`,
-  `injectMusic`, `StoryManager`).
-- **emitter.volume.onChanged** → `instance.setGainDb(volume2dB(v))`; **setVolumeOverTime /
-  fadeOutAllTracks** → `instance.fadeToGainDb` / `instance.fadeOutAndStop`.
-- **update()**: push `transform.position` into each owned instance (sopra already does distance
-  attenuation + panner + virtualization). The BVH stays as a cheap **far-cull pre-gate**.
-- **unlink** → stop all the entity's instances.
-- **createSound** (+ ~9 one-shot sites) → `sopra.playOneShot`, via a kept `@deprecated` facade that
-  still returns a destroyable `Entity` (so handle-dependent callers are unchanged) and wires
-  `instance.onEnded → builder.destroy`.
-
-**Component model:** `SoundEmitter`/`SoundTrack` are **kept as `@deprecated` data components**,
-translated at link time — lowest churn (editor, serialization adapters, `GameClassRegistry`, the 8
-`fromJSON` sites all keep working). No `SopraEmitter` component in v1. **One persistent `SoundTrack` →
-one `EventInstance`** (both already own an independent playhead/gain/loop/ended-signal); the emitter
-maps to a *set* of instances reconciled via the existing `on.added/on.removed` signals.
-
-### 14.2 Sopra gaps to fill first (engine-only, ECS-untouched)
-The engine is fire-and-forget today (content frozen at `#resolve`, no live gain/fade/seek; 2D voices
-route straight to the bus). Add the **live-control surface** without making content mutable:
-1. **`EventInstance` `#instanceGain`** — one always-on trim gain that *all* voices route through
-   (uniform 2D/3D chain head: `instanceGain → [panner if 3D] → bus`). Parity with the legacy
-   `nodes.volume`, not new cost. *(do first)*
-2. **`EventInstance.setGainDb(db)` / `get gainDb`** — composes with `#attenuationGain` (separate node)
-   so user volume × attenuation multiply.
-3. **`EventInstance.fadeToGainDb(target,dur,startAfter)` + public `fadeOutAndStop(dur,startAfter)`** —
-   refactor `fadeOutAndStop.js` into a shared `rampGain` helper; stop scheduled via an audio-clock
-   deadline checked in `update()` (not `setTimeout`).
-4. **`EventInstance.seek(seconds)` / `restart()`** — re-base `startedAt`, retire live voices so
-   `#evaluate` respawns at the new offset; **must not** reseed `playbackContext` (preserve avoid-repeat
-   determinism).
-5. **`SopraEngine.crossfade(oldInstance, idOrDesc, opts)`** — start new at epsilon, ramp up while
-   `old.fadeOutAndStop`.
-6. **Pure translators** in `sopra/legacy/`: `soundEmitterToEventDescriptions(emitter)` +
-   `attenuationFunctionToCurve(fn,min,max)` (dispatch `SoundAttenuationFunction` →
-   `interpolate_irradiance_*` → `buildAttenuationCurve`; `Attenuation` flag clear → flat-1 curve;
-   `is3D ← Spatialization`; `SoundPanningModelType → SopraPanningModel`).
-
-**Gain composition rule (as built):** the translator bakes **NO** gain (`description.gainDb = 0`); the
-per-instance `#instanceGain` carries the full live product `volume2dB(emitter.volume × track.volume)`,
-re-applied on `emitter.volume.onChanged` and on a live `track.volume` set (via the track's
-`__soundRuntime` back-ref); the **bus** carries the channel mix (the legacy 1.2/0.1 already lives on
-sopra buses). Baking the product into the description *and* the instance gain would double-count — so
-the description carries none.
-
-### 14.3 Phased sequence (bottom-up; the 47 sopra tests + 2 legacy specs stay green throughout)
-- **P3.2 — live-control primitives** *(risk: med)*: `#instanceGain`, `setGainDb`, `fadeToGainDb` +
-  public `fadeOutAndStop`, `seek`/`restart`, `SopraEngine.crossfade` + unit tests.
-- **P3.3 — pure translators** *(low)*: `soundEmitterToEventDescriptions` + `attenuationFunctionToCurve`
-  + unit tests (curves match `interpolate_irradiance_*` at sampled distances); not yet wired.
-- **P3.4 — one-shots** *(med)*: `GameSounds` → registered `EventDescription`s; `createSound` facade →
-  `playOneShot` returning a destroyable Entity; legacy path kept when sopra unreachable.
-- **P3.5 — persistent-emitter spine** *(high)*: rewire `SoundEmitterSystem.link` + gut
-  `SoundEmitterComponentContext` to a translation record; plumb volume/fade/stop; BVH far-cull kept;
-  `get/setChannelVolume` → bus proxies.
-- **P3.6 — hard live-mutation sites** *(med)*: `CombatEndMusicProcess.switchMusic` → `sopra.crossfade`;
-  `resetSoundEmitterTracks` → `restart()`; verify `SoundController`/`injectMusic`/`StoryManager` via the
-  add/remove plumb.
-- **P3.7 — listener convergence + cleanup** *(med)*: single sopra listener feeder; `@deprecated` JSDoc;
-  delete dead WebAudio in the sopra branch.
-
-### 14.4 Deletions vs retained-`@deprecated`
-- **Delete now (sopra branch):** `SoundEmitter.buildNodes`/`nodes`/`getTargetNode`/
-  `writeAttenuationVolume`/panner-half of `updatePosition`; `SoundEmitterComponentContext` WebAudio
-  body (connect/disconnect/suspend/resume); `SoundTrack.start`/`suspend`/`nodes`/`SoundTrackNodes`;
-  the per-track time-advance + `endTrack` loop; `CombatEndMusicProcess` hand-rolled crossfade;
-  `resetSoundEmitterTracks` `time=0` body.
-- **Retain `@deprecated`:** `SoundEmitter` + serializable fields, `SoundTrack`, `GameSounds` constants,
-  `SoundEmitterChannel`/`channels` (editor dropdown), `get/setChannelVolume`, `fadeOutAllTracks`/
-  `stopAllTracks`, `createSound`, `SoundController`/`System`, **both serialization adapters**
-  (save-compat — never delete at cutover).
-- **Later (dedicated change):** remove the `sopra === null` legacy WebAudio fallback once prototypes
-  are sound-free or sopra-capable; then retire `SoundEmitter` for a native sopra component.
-
-### 14.5 Testing & risks
-Black-box only; existing 47 sopra tests + `SoundEmitterSystem.spec` + `SoundEmitterSerializationAdapter.spec`
-(both exercise the `sopra === null` path) stay green every phase. New coverage per phase via
-`MockAudioContext` + `StubBufferProvider`. **Not unit-testable** (verify in-browser): AudioContext
-bootstrap, autoplay-resume, audible result, dat.gui editor.
-
-Top risks: **save-compat** (keep both adapters round-tripping — high); **gain composition** double-fold
-(one rule, dB↔linear round-trip test — med); **createSound handle** (return a real Entity that stops
-its instance on destroy — med); **`#instanceGain` topology change** perturbing the 47 tests (unity gain,
-re-run suite immediately — med); **`seek` reseeding RNG** (must not — med).
-
-### 14.6 Open decisions (recommendations in **bold**)
-1. Music crossfade ownership → **keep `CombatEndMusicProcess` locating the music emitter + calling
-   `sopra.crossfade`** (a `MusicDirector` is later scope).
-2. Prototypes → **keep the `sopra === null` branch** through P3 (strangler safety net); delete later.
-3. `createSound` return → **real `Entity`** (callers unchanged); revisit only if the UI-click path shows cost.
-4. Per-track volume fold → **`description.gainDb` per instance + `#instanceGain` for live volume**.
-5. `resetSoundEmitterTracks` → **`restart()`** (not stop+replay — preserves RNG/loading).
-6. `SoundController` → **keep the add/remove plumb** in v1 (single consumer: `UnitMaker`).
-
-### 14.7 LOCKED API contract + no-switch refinement (owner-directed; supersedes the above where they differ)
-
-**No switch.** There is no `sopra === null` fallback. `SoundEmitterSystem` ALWAYS routes through sopra.
-Constructor becomes `SoundEmitterSystem(assetManager, soundEngine)` (context/destination derived from
-it; it always `createSopra`s). All 11 construction sites pass the `SoundEngine` (the 10 prototypes/
-`testEffect` pass `sound`/`engine.sound`; the unit spec passes a `MockAudioContext`-backed stub whose
-`createSopra` builds a real `SopraEngine` on the mock + a `StubBufferProvider`). The legacy WebAudio
-renderer is **deleted outright**, not guarded: per-track time-advance loop, `SoundTrackNodes`,
-connect/disconnect virtualization, the channel `GainNode`s, `buildNodes`. (The two background-added
-`SoundEmitterSystem.spec` tests cover that deleted loop and are replaced by sopra-routing tests.)
-
-**Preserved public API — the whole contract. Everything else is removed or throws.**
-
-`SoundEmitter`:
-
-| member | plumbing into sopra |
-|---|---|
-| `tracks` (List) | add → `playEvent` + map; remove → `instance.stop()`; reconciled via `tracks.on.added/removed` |
-| `channel` (string) | `EventDescription.busId` (read at translation; `""` → `effects`) |
-| `volume` (Vector1) | `onChanged` → each owned `instance.setGainDb(volume2dB(emitter.volume × track.volume))` |
-| `flags` | `Spatialization` → `is3D`; `Attenuation` → attenuation curve (read at translation) |
-| `distanceMin` / `distanceMax` | `EventDescription.distanceMin/Max` |
-
-`SoundTrack`:
-
-| member | plumbing into sopra |
-|---|---|
-| `on.ended` (`{ended:Signal}`) | the track's `EventInstance.onEnded` → `on.ended.send1(track)` |
-| `flags` | `Loop` → `clip.loop`; `UsingAliasURL` → `clip.usingAlias`; `StartWhenReady` → autoplay |
-| `volume` (number) | NOT baked at translation; carried live in the owning instance gain (`emitter.volume × track.volume`), re-applied on a live set via `__soundRuntime` |
-| `time` (number) | written back from the instance playhead each frame; rewind via `restart()` (used by `resetSoundEmitterTracks`) |
-| `url` (string) | `SampleAudioClip.url` |
-
-**Node access → fail loud, explicitly NOT public API** (as built). The property getters
-`SoundEmitter.nodes` and `SoundTrack.nodes`, plus `SoundTrack.setVolumeOverTime`, are throwing stubs
-(`get nodes() { throw new Error("... sopra owns the audio graph"); }`) — these are the members external
-code could read. The internal builders that had **no external caller** (`buildNodes` / `getTargetNode` /
-`writeAttenuationVolume` / `start` / `suspend` / `initializeNodes`) and the `SoundTrackNodes` class were
-removed outright. Any straggler (e.g. `CombatEndMusicProcess` reaching `track.nodes.volume.gain`) breaks
-loudly → rewritten (it now uses `fadeOutAllTracks(1)` + `tracks.add`).
-
-**Kept as trivial `@deprecated` plumbing** (not in the contract, but behavioral with real callers, 1:1
-to instance ops): `SoundEmitter.fadeOutAllTracks` → `instance.fadeOutAndStop` per owned instance;
-`stopAllTracks` → owner `stopAll`. (Backs `hideEntityGracefully` / `AnimatedActions` unchanged.)
-
-**Kept for save-compat (data only, unchanged):** both serialization adapters + the component's
-serializable fields, including `isPositioned` (a thin `flags` wrapper retained for the editor +
-serialization). **Removed entirely** (callers migrated): the `SoundEmitterComponentContext` WebAudio
-body (gutted to a translation record), `endTrack`, `distanceRolloff`, the dead-but-unwritten
-`SoundTrack.duration` (dropped from the locked surface), and the rest of the non-contract surface.
-
-This also resolves §14.6 #2 (no `sopra === null` branch) and revises §14.4 (the node members move from
-"retained @deprecated" to "throwing stubs"; there is no legacy fallback to retain).
-
-## 15. P5 — spatial scaling to 100k emitters (BVH broadphase + live/dormant split)
-
-**Goal.** Support ~100,000 registered 3D `AudioEmitter`s with per-frame work and WebAudio node count
-bounded by a small audible budget `K`, **not** by the registered count. The fix is to decouple a
-*registered emitter* (cheap data + one BVH leaf) from a *live `EventInstance`* (WebAudio nodes): only
-emitters whose own audible sphere reaches the listener — capped to `K` — are ever live.
-
-### 15.1 Principle — broadphase / narrowphase (mirrors `PhysicsSystem`)
-- **Broadphase (new, cheap, ALL emitters):** a dynamic BVH of emitter audible-spheres; one point query
-  at the listener returns the emitters that *can possibly* be heard.
-- **Narrowphase (existing, ≤K live):** the current `EventInstance` per-frame exact
-  distance/attenuation + virtualization (`virtualThresholdDb`) decides which live instances actually
-  hold a source `Voice`. Unchanged.
-
-### 15.2 Three tiers
-
-| Tier | Count (island) | Cost each | Where |
-|---|---|---|---|
-| **Registered / dormant** | ~100k | 1 record + 1 BVH leaf — **no `EventInstance`, no nodes, no per-frame update** | `SpatialAudioIndex` |
-| **Live** | ≤ `K` (default **64**) | an `EventInstance` (panner chain), ticked each frame | sopra + the live set |
-| **Audible voice** | ≤ K, usually fewer | a `Voice` (source node) | existing virtualization |
-
-### 15.3 Reuse (this layer is thin — the BVH does the heavy lifting)
-- `core/bvh2/bvh3/BVH.js` + **`BvhClient`** (`link(tree,data)`/`unlink()`/`resize(x0..z1)`/`write_bounds`)
-  — one leaf per emitter; the same per-entity handle `RenderSystem`/`PhysicsSystem` already use.
-- `bvh_query_user_data_generic(out, 0, bvh, bvh.root, BVHQueryIntersectsSphere.from([lx,ly,lz, 0]))` —
-  the per-frame cull (point-in-leaf collect). `bvh_query_user_data_nearest_to_point` available if a
-  nearest-N selector is preferred over collect-then-select.
-- Existing `EventInstance` virtualization / `seek` / `fadeOutAndStop`, the `VOICE_POOL`, and
-  `SoundListener`+`Transform` — all unchanged.
-
-### 15.4 Key trick — leaf AABB = the emitter's OWN audible region (no global radius — owner-locked)
-Each emitter's leaf is sized to its audible sphere: `AABB = position ± event.distanceMax`. The cull is
-then a **point query at the listener**, returning exactly the emitters whose `distanceMax` reaches the
-listener — honoring each emitter's own range, with no hardcoded global radius.
-
-### 15.5 Reactive leaf maintenance (NO per-tick iteration — owner-locked)
-Everything in meep is dynamic; there is **no static/dynamic flag and no per-tick refit loop**. On
-`add`, the leaf subscribes to the emitter's `transform.position.onChanged` (the position channel of
-`Transform.subscribe`); the handler does `bvhClient.resize(position ± distanceMax)`. Unsubscribe on
-`remove`. Cost is proportional to *actual movement*, not emitter count: a forest of still trees refits
-zero leaves/frame; 100k handlers that never fire are just memory. (Live instances separately read the
-shared `position` Vector3 each frame for their panner — but only ≤K of those exist.)
-
-### 15.6 `SpatialAudioIndex` + `LiveEmitterSet` (two thin pieces) [as-built — the sketch's single class split in two]
-- **`SpatialAudioIndex`** (cull-only): owns the emitter `BVH` + records `{ entity, event, position,
-  bvhClient, onMove }`.
-  - `add(entity, event, position)` → record + `bvhClient.link(bvh, entity)` (leaf user_data = the entity
-    id, so queries return entity ids) + `resize(pos ± distanceMax)` + subscribe `position.onChanged`.
-  - `remove(entity)` → unsubscribe + `bvhClient.unlink()` + drop the record.
-  - `queryAudible(out, out_offset, listenerPosition)` → writes candidate entity ids into the caller's
-    reused buffer from `out_offset`, returns the match count (allocation-free; meep out-buffer convention).
-- **`LiveEmitterSet`** (the live/dormant lifecycle): wraps the index; owns the live map
-  `{ entity → EventInstance }` + per-emitter records `{ event, position, gainDb, playingSince }`; config
-  `{ budget = 64, liveStickiness = 0.8, fadeOutSeconds = 0.15 }`.
-  - `add(entity, event, position, gainDb)` → register with the index + record (dormant).
-  - `remove(entity)` → demote (hard cut) if live, then `index.remove`.
-  - `setGainDb(entity, gainDb)` → update the record + the live instance if any (survives re-promotion).
-  - `refresh(listenerPosition)` → cull + budget + diff, **every tick** (§15.7).
-
-Non-3D emitters (and finite-3D one-shots) skip the index entirely — the ECS layer plays them directly
-(§15.13 P5.6); only persistent looping 3D emitters are spatially managed.
-
-### 15.7 `LiveEmitterSet.refresh` — every tick [as-built]
-1. **Cull:** `queryAudible` point query → candidate entity ids (reused buffer); an exact spherical
-   refine then drops the conservative-cube corners (`distance > distanceMax`).
-2. **Budget select:** rank in-range candidates by **effective distance** — a live emitter competes as
-   `distance × liveStickiness` so it does not flicker promote/demote at the cutoff (rank hysteresis) —
-   and take the nearest `budget`. (The sketch's extra `event.priority` / attenuation-gain tie-breakers
-   were not needed; pure distance + stickiness.)
-3. **Diff** vs the current live set (`#live`) → **demote** leavers, **promote** entrants; at budget a
-   closer entrant steals the farthest live slot. The diff is re-derived from `#live` each call (so a
-   denied or self-ended promotion is retried automatically), with demote-before-promote ordering.
-4. `sopra.update(now)` — the caller's, right after `refresh` — ticks only the ≤budget live instances.
-
-**No throttle (§15.10):** this runs on every tick. The BVH query is microseconds and the diff is
-re-derived from `#live`, so there is nothing to gate; the scratch containers are reused so the per-tick
-diff is allocation-light apart from the rank entries.
-
-### 15.8 Promotion / demotion + voice slots (allocated at go-live — owner-confirmed)
-`K` is the voice-slot pool, allocated at promotion (the only moment WebAudio cost is incurred).
-- **promote:** `sopra.playEvent(event, { position, oneShot, startTime })` where `startTime = playingSince`
-  reconstructs the phase (§15.9 — via the `EventInstance.startTime` option, not a post-hoc `seek`), then
-  apply the emitter's `gainDb`, then store the instance.
-- **demote — two cases (owner-locked):**
-  - **culled out of range** (the emitter left its own audible sphere → already ~0 gain / virtual):
-    **hard cut** (`instance.stop()`). A fade is pointless/wrong — it is already inaudible.
-  - **contention / stolen** (a closer emitter evicts a still-in-range, audible live one): **fade**
-    (`fadeOutAndStop`) to avoid a click.
-- **stealing = distance priority:** at budget, a closer entrant demotes (steals the slot of) the
-  farthest live record.
-
-This sits *on top of*, not replacing, sopra's per-event `maxInstances` (polyphony among the live) and
-per-instance virtualization (source-voice gating). **Constraint (P5.2):** `budget` and `maxInstances`
-are independent composed caps. For content-equal ambience you want up to N copies of audible at once,
-that event's `maxInstances` must be ≥ N, else sopra gates the budget — `stealMode None` denies the
-promote (emitter stays dormant, retried next refresh) and `stealMode Oldest` makes the two layers fight
-(churn). Set managed ambience `maxInstances` high (P5.6 wiring).
-
-### 15.9 Phase reconstruction (continuous world clock — owner-decided; supersedes the entity-id phaseOffset idea)
-Dormant emitters don't simulate playback, but the loop conceptually keeps running on the world clock.
-Record `playingSince` (audio clock) **once at registration**; on promotion the instance starts with
-logical `startTime = playingSince`, so its playhead is `now − playingSince` and the looping voice's
-buffer offset wraps into the loop region. A bird you approach is mid-song (continuity); a re-promotion
-after a cull resumes at **total elapsed since link** (the loop kept running while you were away).
-Deterministic from real time — **no engine-invented random phase**. Decorrelation/variety is the content
-author's job (existing per-trigger pitch/gain randomization, RandomContainer), not an engine concern.
-(Rejected the earlier auto entity-id phaseOffset: opinionated/magic, and for sparse chirps the artifact
-is imperceptible; phase-lock matters mainly for tonal loops, which the author can vary.)
-
-### 15.10 Churn control (promotion has real cost)
-- **Hysteresis (as-built):** rank hysteresis via `liveStickiness` — a live emitter competes at
-  `distance × liveStickiness` (default 0.8), so a newcomer must be clearly closer to steal its slot; this
-  kills promote/demote flicker at the budget cutoff. (The sketch's leaf-AABB / `distanceMax + margin`
-  approach was not needed — range-edge churn is inaudible, gain ≈ 0 there; the audible flicker is at the
-  *budget* cutoff, which the rank discount handles.) Demote-by-cull is at exactly `distanceMax` (the
-  spherical refine).
-- **Cull every tick — NO throttling (owner-decided, P5.5 reverted).** `refresh()` runs the full cull
-  on every `update` tick. The BVH point-query is O(log n + candidates) (microseconds; the 100k stress
-  shows the whole per-frame `refresh + tick` is ~5 ms), and the promote/demote diff is re-derived from
-  `#live` each call, so there is no reason to throttle. A throttle was briefly added and removed — it was
-  unnecessary complexity (and introduced a contention-fade gap edge). The diff is allocation-light: the
-  scratch containers (`#ranked`, `#inRange`, `#target`, `#demoteScratch`, `#candidates`) are reused
-  across calls. (`IncrementalDeltaSet` was considered for the diff but does not fit: `#live` changes
-  out-of-band — instances self-end on asset failure, and promotions can be denied by polyphony caps — so
-  the diff must be re-derived from `#live` each frame, which a maintained delta set would fight.)
-- **Pool the per-instance output chain** (instanceGain → attenuationGain → panner) — **DEFERRED
-  (measure-first).** Original rationale was the "1000 live panners / panner not torn down on virtualize"
-  cost; the P5.1–P5.2 live/dormant model already bounds live panner chains to `budget` (≤64), and
-  hysteresis minimises promote/demote frequency, so this is now a constant-factor micro-opt on ≤64
-  chains churned only on genuine live-set changes. Per project guidance (reuse-over-micro-opt, measure
-  first, treat constant-factor diffs as noise) this is held until profiling shows promote/demote
-  node-churn is actually hot. AudioBufferSourceNodes are single-use and stay pooled via `VOICE_POOL`;
-  only Gain/Panner nodes would be poolable.
-
-### 15.11 What changes where
-- `SopraEngine` core: **unchanged**; its `update` is now O(K) (only live instances are active). No new
-  public surface (`playEvent`/`stop`/`seek` exist).
-- **New `SpatialAudioIndex`** (BVH cull + records, thin over the BVH + queries) and **`LiveEmitterSet`**
-  (the live/dormant lifecycle: budget + promote/demote/steal + per-emitter gain) layered on it.
-- `LiveEmitterSet.refresh` culls every tick (no throttling — §15.10), with reused scratch so the diff is
-  allocation-light. The per-instance output-chain pool is **deferred** (measure-first — §15.10): not
-  needed for the 100k target since live chains are already bounded to `budget`.
-- `AudioEmitterSystem` (DONE, P5.6): `link/unlink` → `liveSet.add/remove` for managed (looping 3D
-  autoplay) emitters; `update` → `liveSet.refresh(listener)` + `sopra.update`. 2D + finite-3D-one-shot
-  autoplay take the direct play path; non-autoplay is inert. No more unconditional autoplay-per-emitter.
-- `AudioEmitter`: **no** `dynamic` flag. `VoiceManager`: unchanged.
-
-### 15.12 Scorecard (target, 100k emitters)
-- Per frame: 1 BVH point query (O(log n + candidates)) + top-K select + O(K) live ticks. **Independent
-  of 100k.**
-- WebAudio: ≤K panner chains + ≤K voices.
-- Memory: 100k records + 100k BVH leaves (~a few MB, typed-array backed) + shared events/buffers. Leaf
-  refits ∝ movement, not count.
-
-### 15.13 Rollout (incremental, test-first; MockAudioContext + synthetic emitter field + movable mock listener)
-- **P5.1 — DONE** (meep `73f9becc1`). `SpatialAudioIndex` (`engine/sound/ecs/audio/SpatialAudioIndex.js`)
-  cull only: BVH add/remove + reactive `position.onChanged` refit + point query (`BVHQueryIntersectsSphere`
-  radius 0) → candidate entity ids; leaf user_data = entity id; leaf AABB = `position ± distanceMax`;
-  reused query object + result buffer. 12 black-box tests (in/out per-emitter range, reactive refit both
-  ways, removal+detach, boundary-inclusive on-axis, repeated-query buffer reuse, 1000-emitter cull). No
-  promotion yet.
-- **P5.2 — DONE** (meep `a39ecbbe6`). `LiveEmitterSet` (`engine/sound/ecs/audio/LiveEmitterSet.js`)
-  composes the index: `refresh(listener)` promotes nearest-in-range up to `budget` (64), demotes the
-  rest; distance-priority stealing; rank hysteresis via live-stickiness; exact spherical refine over the
-  conservative cube; demote-frees-before-promote-fills; zombie-safe demote (delete-before-stop) + self-
-  end cleanup. Hard cut on demote (fade-on-contention = P5.3). Documented budget↔maxInstances
-  dependency + pinned by a test. 12 black-box tests.
-- **P5.3 — DONE** (meep `1e0a0deee`). Demotion policy in `LiveEmitterSet`: refresh builds an `inRange`
-  set (exact distanceMax); a demoted live emitter still in range is faded (`fadeOutAndStop`,
-  `fadeOutSeconds` default 0.15) — audible, would click — while one that left range is hard-stopped
-  (already inaudible). `remove()` (unlink) hard-cuts. Slot frees immediately (delete-before-fade); the
-  onEnded `=== instance` guard makes re-promote-during-fade safe. Tests: cut-on-cull, fade-on-contention,
-  re-promote-during-fade no-clobber. Adversarial review → CLEAN.
-- **P5.4 — DONE** (meep `ad96e3a00`). Continuous-clock phase reconstruction (see §15.9, owner-decided —
-  no random phaseOffset). `EventInstance` gained a logical `startTime` option (playhead = now − startTime)
-  + a looping-voice buffer-offset wrap (also fixes long-dormant virtualization revival).
-  `LiveEmitterSet` records `playingSince` once at add and promotes with it, so a re-promotion after a
-  cull resumes at total elapsed since link. Zombie guard for a finite event whose play time already
-  elapsed (self-stops synchronously during start). Tests: resume-at-elapsed + offset-wrap,
-  continuity-across-cull, seek-wrap, finite-elapsed guard. Adversarial review → CLEAN.
-- **P5.5 — cull throttling ADDED then REVERTED** (added meep `8264bc328`, reverted later). A throttle
-  (`cullIntervalSeconds`/`cullMoveThreshold`) was briefly added, then removed at the owner's direction:
-  the BVH point-query is microseconds and the diff is re-derived from `#live` each call, so there is no
-  reason not to cull on every `update` tick (100k stress: ~5 ms per `refresh + tick`). What remains from
-  P5.5: `refresh()` culls every tick with an **allocation-light diff** — the scratch containers
-  (`#ranked`, `#inRange`, `#target`, `#demoteScratch`, `#candidates`) are reused across calls; the
-  comparator is module-static. `IncrementalDeltaSet` was considered for the diff but does not fit (`#live`
-  changes out-of-band: self-end on asset failure, denial by polyphony caps — the diff must re-derive from
-  `#live`). The +9 throttle tests were removed. **Output-chain pool still DEFERRED (measure-first)** —
-  see §15.10 (live/dormant already bounds panners to budget; held until profiling shows churn is hot).
-- **P5.6 — DONE** (meep `d4ba84cd4`). Wired `AudioEmitterSystem` to `LiveEmitterSet`. Routing fixed at
-  link: **managed** = `autoplay && is3D && rootClip.loops()` → `liveSet.add(entity, event, position,
-  volume2dB(volume))`, dormant until refresh; **direct** = any other autoplay (2D, or finite 3D one-shot)
-  → immediate `#play`; **inert** = non-autoplay. (Finite 3D one-shots are deliberately direct, not
-  managed — a dead one-shot would otherwise re-promote+self-stop every cull and occupy a budget slot:
-  the P5.6 review's main RISK.) `update` resolves the `SoundListener`, then refreshes the live set BEFORE
-  `sopra.update` (fresh promote spatializes same frame); a listener entity missing its `Transform` is
-  tolerated as "no listener" (guard) rather than throwing every frame. Per-emitter gain: `AudioEmitter.volume`
-  carried by `LiveEmitterSet` (`add` 4th arg + `setGainDb`), replayed on every promotion (survives
-  demote→re-promote). `instanceFor(entity)` exposes the active instance for either path; ctor takes
-  `liveEmitterSetOptions`. **100k stress (both `.skip`):** `AudioEmitterSystem.spec` proves only `budget`
-  hold a live instance (node count O(budget), not O(N)) + listener-walks-away frees all; `SpatialAudioIndex.spec`
-  proves the cull returns only the in-range candidates (~200), not N → per-frame work O(log N + k). 298
-  engine/sound green (34 suites), 2 skipped. Adversarial workflow review (6 dims / 21 agents): no
-  BUG-level defects; acted on the confirmed RISKs + doc fixes.
-- **Remaining (post-P5):** register `AudioEmitterSystem` in `makeMirEngineConfig` (production wiring; it
-  is currently constructed only in tests) and the standing background follow-ups (P5.5 output-chain pool
-  if profiling demands it; IR1/IR4; dormant-material cleanup).
-
-### 15.14 Locked decisions (owner)
-- Budget **K = 64** (live instances; virtualization trims actual voices further).
-- **No global radius** — cull by per-emitter `event.distanceMax` (leaf = `pos ± distanceMax`).
-- **No static/dynamic distinction** — everything is dynamic; leaves refit reactively via
-  `transform.position.onChanged`, never per-tick iteration.
-- **Demotion:** hard **cut** when culled out of range (already inaudible); **fade** only on contention
-  (stealing a still-audible live instance).