From 2fcbcc30029df5370e5a3f1e5ce1ed9713ba57db Mon Sep 17 00:00:00 2001
From: Hails <26784904+Hailey-Ross@users.noreply.github.com>
Date: Fri, 2 Oct 2026 22:58:17 -0600
Subject: [PATCH] New audio who dis

Native port of Skate 3's retail audio runtime (AEMS) behind SKATE_AEMS=1, plus the world audio work:
- skate-audio crate: formats, patch-program evaluator, voice graph, mixer, MixMap, granular rolling bed and its
  bus chain, Splice contacts, the buses (env reverb network, eEQChain, flanger returns, collision and footstep
  submixes, reverb zones) and the player components (rolling layers, seams on the console's 30 fps cadence,
  grinds, skids, squeaks, tricks, treatment, footsteps, clothing, hands on deck, wind, wheels, collision manager).
- game_audio host: native runtime, player audio state from our physics, world emitters from the maps' .ems files,
  random distant one-shots, zone ambience, state log, e2e render harness, timing.
- Setup: audio export of the banks, grains, MixMap, vault tuning and reverb zones.
- skate-core: per-wheel / per-part audio surfaces and seam patterns (additive).
- Docs: docs/hails-additions/11-audio.md and the PR plan.
---
 Cargo.lock                                    |    5 +
 Cargo.toml                                    |    2 +-
 crates/skate-audio/Cargo.toml                 |    6 +
 crates/skate-audio/examples/aems_list.rs      |   51 +
 crates/skate-audio/examples/aems_render.rs    |  129 ++
 crates/skate-audio/examples/aems_replay.rs    |  183 ++
 .../skate-audio/examples/board_mix_probe.rs   |   63 +
 crates/skate-audio/examples/effect_routes.rs  |   82 +
 .../examples/emitter_scene_probe.rs           |  199 ++
 .../skate-audio/examples/grain_bed_render.rs  |  161 ++
 .../skate-audio/examples/grain_chain_probe.rs |  255 +++
 crates/skate-audio/examples/mixmap_golden.rs  |   87 +
 crates/skate-audio/examples/pan_fold_probe.rs |   18 +
 crates/skate-audio/examples/post_probe.rs     |   68 +
 crates/skate-audio/examples/program_trace.rs  |  110 +
 .../skate-audio/examples/seam_pulse_probe.rs  |  135 ++
 .../skate-audio/examples/voice_load_probe.rs  |   61 +
 crates/skate-audio/src/be.rs                  |   82 +
 crates/skate-audio/src/bus/env.rs             |  587 ++++++
 crates/skate-audio/src/bus/eqchain.rs         |  152 ++
 crates/skate-audio/src/bus/flange.rs          |  239 +++
 crates/skate-audio/src/bus/mod.rs             |  111 +
 crates/skate-audio/src/bus/submix.rs          |  191 ++
 crates/skate-audio/src/bus/zones.rs           |  442 ++++
 crates/skate-audio/src/dsp/biquad.rs          |  217 ++
 crates/skate-audio/src/dsp/delay.rs           |  126 ++
 crates/skate-audio/src/dsp/fss.rs             |  278 +++
 crates/skate-audio/src/dsp/gain.rs            |   79 +
 crates/skate-audio/src/dsp/mod.rs             |   20 +
 crates/skate-audio/src/dsp/pan.rs             |  290 +++
 crates/skate-audio/src/dsp/peaking.rs         |  117 ++
 crates/skate-audio/src/dsp/resample.rs        |  138 ++
 crates/skate-audio/src/dsp/reverb.rs          |  230 ++
 crates/skate-audio/src/dsp/routes.rs          |   79 +
 crates/skate-audio/src/dsp/send.rs            |  116 +
 crates/skate-audio/src/dsp/shelf.rs           |  135 ++
 crates/skate-audio/src/eval/fmath.rs          |   61 +
 crates/skate-audio/src/eval/mod.rs            |  770 +++++++
 crates/skate-audio/src/eval/ops.rs            |  449 ++++
 crates/skate-audio/src/eval/ops/tests.rs      |  383 ++++
 crates/skate-audio/src/eval/rng.rs            |   59 +
 crates/skate-audio/src/eval/symbols.rs        |   97 +
 crates/skate-audio/src/eval/tests.rs          |  477 +++++
 crates/skate-audio/src/formats/abk.rs         |  256 +++
 crates/skate-audio/src/formats/csi.rs         |   52 +
 crates/skate-audio/src/formats/mod.rs         |   24 +
 crates/skate-audio/src/formats/snr.rs         |   63 +
 crates/skate-audio/src/grain/bed.rs           |  491 +++++
 crates/skate-audio/src/grain/board.rs         |  512 +++++
 crates/skate-audio/src/grain/chain.rs         |  539 +++++
 crates/skate-audio/src/grain/format.rs        |  229 ++
 crates/skate-audio/src/grain/mod.rs           |   17 +
 crates/skate-audio/src/grain/player.rs        |  610 ++++++
 crates/skate-audio/src/lib.rs                 |   47 +
 crates/skate-audio/src/mixer.rs               |  805 +++++++
 crates/skate-audio/src/mixmap/format.rs       |  255 +++
 crates/skate-audio/src/mixmap/keys.rs         |  116 +
 crates/skate-audio/src/mixmap/mod.rs          |  750 +++++++
 crates/skate-audio/src/mixmap/tables.rs       |  254 +++
 crates/skate-audio/src/mixmap/tests.rs        |  151 ++
 crates/skate-audio/src/player/clothing.rs     |  363 ++++
 crates/skate-audio/src/player/collision.rs    |  693 ++++++
 crates/skate-audio/src/player/components.rs   |  676 ++++++
 crates/skate-audio/src/player/contacts.rs     |  972 +++++++++
 crates/skate-audio/src/player/footsteps.rs    | 1153 ++++++++++
 crates/skate-audio/src/player/globals.rs      |   35 +
 crates/skate-audio/src/player/inputs.rs       |  189 ++
 crates/skate-audio/src/player/jitter.rs       |  126 ++
 crates/skate-audio/src/player/mod.rs          |   77 +
 crates/skate-audio/src/player/objpos.rs       |  159 ++
 crates/skate-audio/src/player/rolling.rs      |  859 ++++++++
 crates/skate-audio/src/player/seams.rs        |  660 ++++++
 crates/skate-audio/src/player/state.rs        |  277 +++
 crates/skate-audio/src/player/step_on.rs      |  184 ++
 crates/skate-audio/src/player/treatment.rs    |  243 +++
 crates/skate-audio/src/player/tricks.rs       |  338 +++
 crates/skate-audio/src/player/tricks/tests.rs |  192 ++
 crates/skate-audio/src/player/tuning.rs       |  227 ++
 crates/skate-audio/src/player/wheels.rs       |  203 ++
 crates/skate-audio/src/runtime.rs             |  242 +++
 crates/skate-audio/src/splice/format.rs       |  155 ++
 crates/skate-audio/src/splice/mod.rs          |  432 ++++
 crates/skate-audio/src/splice/tests.rs        |  139 ++
 crates/skate-audio/tests/disc_banks.rs        |  236 +++
 crates/skate-audio/tests/disc_grains.rs       |   39 +
 crates/skate-audio/tests/dsp_oracle.rs        |  248 +++
 crates/skate-audio/tests/offboard_levels.rs   |  405 ++++
 crates/skate-audio/tests/player_tricks.rs     |  651 ++++++
 crates/skate-audio/tests/rolling_banks.rs     |  604 ++++++
 crates/skate-core/src/physics/board_ground.rs |   13 +
 .../src/physics/tests/board_ground.rs         |    9 +
 crates/skate-game/Cargo.toml                  |    1 +
 crates/skate-game/src/game_audio/ambience.rs  |  249 ++-
 .../src/game_audio/crossfade_groups.rs        |   29 +
 crates/skate-game/src/game_audio/cues.rs      |   73 +-
 crates/skate-game/src/game_audio/e2e.rs       |  499 +++++
 crates/skate-game/src/game_audio/emitters.rs  |  269 ++-
 crates/skate-game/src/game_audio/grain_bed.rs |  447 ++++
 crates/skate-game/src/game_audio/library.rs   |  779 ++++++-
 crates/skate-game/src/game_audio/mod.rs       |   27 +-
 crates/skate-game/src/game_audio/native.rs    |  774 +++++++
 .../skate-game/src/game_audio/player_audio.rs |  961 +++++++++
 .../src/game_audio/random_programs.rs         |  121 ++
 .../skate-game/src/game_audio/random_sets.rs  |  329 +++
 .../skate-game/src/game_audio/skate_events.rs |  523 ++++-
 crates/skate-game/src/game_audio/state_log.rs |  176 ++
 crates/skate-game/src/game_audio/timing.rs    |   97 +
 crates/skate-game/src/game_audio/voices.rs    |  122 +-
 .../src/physics/foot_physical_output.rs       |    5 +
 docs/hails-additions/02-long-paths.md         |    4 +-
 docs/hails-additions/05-collision-volumes.md  |   54 +-
 docs/hails-additions/11-audio.md              | 1863 ++++++++++++++++-
 docs/hails-additions/PULL-REQUESTS.md         |    4 +-
 docs/hails-additions/README.md                |    4 +-
 tools/asset_pipeline/audio_export.py          |  845 +++++++-
 tools/asset_pipeline/audio_formats.py         |   62 +
 tools/asset_pipeline/test_audio_formats.py    |  248 +++
 117 files changed, 31947 insertions(+), 128 deletions(-)
 create mode 100644 crates/skate-audio/Cargo.toml
 create mode 100644 crates/skate-audio/examples/aems_list.rs
 create mode 100644 crates/skate-audio/examples/aems_render.rs
 create mode 100644 crates/skate-audio/examples/aems_replay.rs
 create mode 100644 crates/skate-audio/examples/board_mix_probe.rs
 create mode 100644 crates/skate-audio/examples/effect_routes.rs
 create mode 100644 crates/skate-audio/examples/emitter_scene_probe.rs
 create mode 100644 crates/skate-audio/examples/grain_bed_render.rs
 create mode 100644 crates/skate-audio/examples/grain_chain_probe.rs
 create mode 100644 crates/skate-audio/examples/mixmap_golden.rs
 create mode 100644 crates/skate-audio/examples/pan_fold_probe.rs
 create mode 100644 crates/skate-audio/examples/post_probe.rs
 create mode 100644 crates/skate-audio/examples/program_trace.rs
 create mode 100644 crates/skate-audio/examples/seam_pulse_probe.rs
 create mode 100644 crates/skate-audio/examples/voice_load_probe.rs
 create mode 100644 crates/skate-audio/src/be.rs
 create mode 100644 crates/skate-audio/src/bus/env.rs
 create mode 100644 crates/skate-audio/src/bus/eqchain.rs
 create mode 100644 crates/skate-audio/src/bus/flange.rs
 create mode 100644 crates/skate-audio/src/bus/mod.rs
 create mode 100644 crates/skate-audio/src/bus/submix.rs
 create mode 100644 crates/skate-audio/src/bus/zones.rs
 create mode 100644 crates/skate-audio/src/dsp/biquad.rs
 create mode 100644 crates/skate-audio/src/dsp/delay.rs
 create mode 100644 crates/skate-audio/src/dsp/fss.rs
 create mode 100644 crates/skate-audio/src/dsp/gain.rs
 create mode 100644 crates/skate-audio/src/dsp/mod.rs
 create mode 100644 crates/skate-audio/src/dsp/pan.rs
 create mode 100644 crates/skate-audio/src/dsp/peaking.rs
 create mode 100644 crates/skate-audio/src/dsp/resample.rs
 create mode 100644 crates/skate-audio/src/dsp/reverb.rs
 create mode 100644 crates/skate-audio/src/dsp/routes.rs
 create mode 100644 crates/skate-audio/src/dsp/send.rs
 create mode 100644 crates/skate-audio/src/dsp/shelf.rs
 create mode 100644 crates/skate-audio/src/eval/fmath.rs
 create mode 100644 crates/skate-audio/src/eval/mod.rs
 create mode 100644 crates/skate-audio/src/eval/ops.rs
 create mode 100644 crates/skate-audio/src/eval/ops/tests.rs
 create mode 100644 crates/skate-audio/src/eval/rng.rs
 create mode 100644 crates/skate-audio/src/eval/symbols.rs
 create mode 100644 crates/skate-audio/src/eval/tests.rs
 create mode 100644 crates/skate-audio/src/formats/abk.rs
 create mode 100644 crates/skate-audio/src/formats/csi.rs
 create mode 100644 crates/skate-audio/src/formats/mod.rs
 create mode 100644 crates/skate-audio/src/formats/snr.rs
 create mode 100644 crates/skate-audio/src/grain/bed.rs
 create mode 100644 crates/skate-audio/src/grain/board.rs
 create mode 100644 crates/skate-audio/src/grain/chain.rs
 create mode 100644 crates/skate-audio/src/grain/format.rs
 create mode 100644 crates/skate-audio/src/grain/mod.rs
 create mode 100644 crates/skate-audio/src/grain/player.rs
 create mode 100644 crates/skate-audio/src/lib.rs
 create mode 100644 crates/skate-audio/src/mixer.rs
 create mode 100644 crates/skate-audio/src/mixmap/format.rs
 create mode 100644 crates/skate-audio/src/mixmap/keys.rs
 create mode 100644 crates/skate-audio/src/mixmap/mod.rs
 create mode 100644 crates/skate-audio/src/mixmap/tables.rs
 create mode 100644 crates/skate-audio/src/mixmap/tests.rs
 create mode 100644 crates/skate-audio/src/player/clothing.rs
 create mode 100644 crates/skate-audio/src/player/collision.rs
 create mode 100644 crates/skate-audio/src/player/components.rs
 create mode 100644 crates/skate-audio/src/player/contacts.rs
 create mode 100644 crates/skate-audio/src/player/footsteps.rs
 create mode 100644 crates/skate-audio/src/player/globals.rs
 create mode 100644 crates/skate-audio/src/player/inputs.rs
 create mode 100644 crates/skate-audio/src/player/jitter.rs
 create mode 100644 crates/skate-audio/src/player/mod.rs
 create mode 100644 crates/skate-audio/src/player/objpos.rs
 create mode 100644 crates/skate-audio/src/player/rolling.rs
 create mode 100644 crates/skate-audio/src/player/seams.rs
 create mode 100644 crates/skate-audio/src/player/state.rs
 create mode 100644 crates/skate-audio/src/player/step_on.rs
 create mode 100644 crates/skate-audio/src/player/treatment.rs
 create mode 100644 crates/skate-audio/src/player/tricks.rs
 create mode 100644 crates/skate-audio/src/player/tricks/tests.rs
 create mode 100644 crates/skate-audio/src/player/tuning.rs
 create mode 100644 crates/skate-audio/src/player/wheels.rs
 create mode 100644 crates/skate-audio/src/runtime.rs
 create mode 100644 crates/skate-audio/src/splice/format.rs
 create mode 100644 crates/skate-audio/src/splice/mod.rs
 create mode 100644 crates/skate-audio/src/splice/tests.rs
 create mode 100644 crates/skate-audio/tests/disc_banks.rs
 create mode 100644 crates/skate-audio/tests/disc_grains.rs
 create mode 100644 crates/skate-audio/tests/dsp_oracle.rs
 create mode 100644 crates/skate-audio/tests/offboard_levels.rs
 create mode 100644 crates/skate-audio/tests/player_tricks.rs
 create mode 100644 crates/skate-audio/tests/rolling_banks.rs
 create mode 100644 crates/skate-game/src/game_audio/crossfade_groups.rs
 create mode 100644 crates/skate-game/src/game_audio/e2e.rs
 create mode 100644 crates/skate-game/src/game_audio/grain_bed.rs
 create mode 100644 crates/skate-game/src/game_audio/native.rs
 create mode 100644 crates/skate-game/src/game_audio/player_audio.rs
 create mode 100644 crates/skate-game/src/game_audio/random_programs.rs
 create mode 100644 crates/skate-game/src/game_audio/random_sets.rs
 create mode 100644 crates/skate-game/src/game_audio/state_log.rs
 create mode 100644 crates/skate-game/src/game_audio/timing.rs

diff --git a/Cargo.lock b/Cargo.lock
index 52561c16..20c3d1dd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4840,6 +4840,10 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
+[[package]]
+name = "skate-audio"
+version = "0.1.0"
+
 [[package]]
 name = "skate-core"
 version = "0.1.0"
@@ -4878,6 +4882,7 @@ dependencies = [
  "sdl3",
  "serde",
  "serde_json",
+ "skate-audio",
  "skate-core",
  "skate-data",
  "skate-dynamics",
diff --git a/Cargo.toml b/Cargo.toml
index e8a82a77..c9b8ba01 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-members = ["crates/skate-core", "crates/skate-data", "crates/skate-game", "crates/skate-dynamics", "crates/skate-mods", "crates/skate-net", "crates/skate-steam-relay"]
+members = ["crates/skate-core", "crates/skate-audio", "crates/skate-data", "crates/skate-game", "crates/skate-dynamics", "crates/skate-mods", "crates/skate-net", "crates/skate-steam-relay"]
 resolver = "3"
 
 [workspace.package]
diff --git a/crates/skate-audio/Cargo.toml b/crates/skate-audio/Cargo.toml
new file mode 100644
index 00000000..347e24ab
--- /dev/null
+++ b/crates/skate-audio/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "skate-audio"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+description = "Native port of Skate 3's AEMS patch-program evaluator and RenderWare-style voice graph (engine independent)"
diff --git a/crates/skate-audio/examples/aems_list.rs b/crates/skate-audio/examples/aems_list.rs
new file mode 100644
index 00000000..47bca200
--- /dev/null
+++ b/crates/skate-audio/examples/aems_list.rs
@@ -0,0 +1,51 @@
+//! List every bank's modules: bound class, capacity, payload words, players and the opcodes used.
+//!
+//! usage: aems_list <dir with the disc's .abk/.csi files> [name filter]
+use std::path::Path;
+
+use skate_audio::be::u8_at;
+use skate_audio::eval::Evaluator;
+use skate_audio::eval::symbols::SymRef;
+use skate_audio::formats::{Bank, Project};
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let dir = Path::new(&args[1]);
+    let filter = args.get(2).map(|s| s.to_ascii_lowercase());
+    let mut eval = Evaluator::new();
+    for name in std::fs::read_to_string(dir.join("csi_order.txt")).expect("csi_order.txt").lines() {
+        eval.install_project(&Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap());
+    }
+    let mut names: Vec<String> = std::fs::read_dir(dir)
+        .unwrap()
+        .filter_map(|e| e.ok()?.file_name().into_string().ok())
+        .filter(|n| n.to_ascii_lowercase().ends_with(".abk"))
+        .filter(|n| filter.as_ref().is_none_or(|f| n.to_ascii_lowercase().contains(f)))
+        .collect();
+    names.sort();
+    for name in names {
+        let bank = Bank::parse(&name, std::fs::read(dir.join(&name)).unwrap()).unwrap();
+        for (i, m) in bank.modules.iter().enumerate() {
+            let class = bank
+                .exports
+                .iter()
+                .find(|e| e.handle_offset == m.offset + 4)
+                .and_then(|e| eval.registry.lookup(e.kind, e.project, e.name_id, &e.name))
+                .and_then(|s| match s {
+                    SymRef::Class(c) => Some(eval.registry.classes[c].name.clone()),
+                    _ => None,
+                })
+                .unwrap_or_else(|| "?".into());
+            let payload = m.class_data_state.map(|o| u8_at(m.template(&bank.data), o as usize + 16));
+            let mut ops: Vec<u8> = m.program.iter().map(|o| o.opcode).collect();
+            ops.sort_unstable();
+            ops.dedup();
+            println!(
+                "{name} #{i} class={class} capacity={} payload={payload:?} players={} samples={} ops={ops:?}",
+                m.max_instances,
+                m.num_players,
+                bank.samples.len()
+            );
+        }
+    }
+}
diff --git a/crates/skate-audio/examples/aems_render.rs b/crates/skate-audio/examples/aems_render.rs
new file mode 100644
index 00000000..c8700c9a
--- /dev/null
+++ b/crates/skate-audio/examples/aems_render.rs
@@ -0,0 +1,129 @@
+//! Headless end-to-end render: install the projects, load banks with their decoded WAVs, post one
+//! message and render through the voice graph and the output stage's stereo fold. Prints per-second
+//! RMS / peak (dBFS), voice counts and the render speed; optionally writes a 48 kHz stereo WAV.
+//!
+//! usage: aems_render <banks dir (.abk/.csi + csi_order.txt)> <audio dir (has banks/<stem>/NNNN.wav)>
+//!        <bank stem[,stem…]> <class> <w0,w1,…> <seconds> [out.wav]
+//! The utility (`emitter_utility`) is always loaded and posted first, as at boot.
+//! `AEMS_FLANGE="a0,…,a8;b0,…,b8"` (the vault records of the FlangeSub returns by offset, from
+//! your install) enables the effect returns at the free-skate Reverb levels.
+use std::path::Path;
+use std::sync::Arc;
+use std::time::Instant;
+
+use skate_audio::formats::{Bank, Project};
+use skate_audio::mixer::Pcm;
+use skate_audio::runtime::Runtime;
+
+fn wav_pcm(bytes: &[u8]) -> Option<Pcm> {
+    let (mut channels, mut rate, mut bits) = (0usize, 0u32, 0u16);
+    let mut at = 12;
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().ok()?) as usize;
+        let body = at + 8;
+        match &bytes[at..at + 4] {
+            b"fmt " => {
+                channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+                rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().ok()?);
+                bits = u16::from_le_bytes([bytes[body + 14], bytes[body + 15]]);
+            }
+            b"data" if channels > 0 && bits == 16 => {
+                let data = &bytes[body..(body + size).min(bytes.len())];
+                let mut planar = vec![Vec::new(); channels];
+                for (i, s) in data.chunks_exact(2).enumerate() {
+                    planar[i % channels].push(f32::from(i16::from_le_bytes([s[0], s[1]])) / 32768.0);
+                }
+                return Some(Pcm { rate, channels: planar });
+            }
+            _ => {}
+        }
+        at = body + size + (size & 1);
+    }
+    None
+}
+
+fn db(v: f64) -> f64 {
+    20.0 * v.max(1e-9).log10()
+}
+
+fn main() {
+    let a: Vec<String> = std::env::args().collect();
+    if a.len() < 7 {
+        eprintln!("usage: aems_render <banks dir> <audio dir> <stems> <class> <payload> <seconds> [out.wav]");
+        std::process::exit(2);
+    }
+    let (dir, audio) = (Path::new(&a[1]), Path::new(&a[2]));
+    let payload: Vec<i32> = a[5].split(',').filter(|s| !s.is_empty()).map(|s| s.parse().unwrap()).collect();
+    let seconds: f64 = a[6].parse().unwrap();
+    let mut rt = Runtime::new();
+    for name in std::fs::read_to_string(dir.join("csi_order.txt")).unwrap().lines() {
+        rt.install_project(&Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap());
+    }
+    let mut stems: Vec<&str> = a[3].split(',').collect();
+    stems.insert(0, "emitter_utility");
+    for stem in stems {
+        let bank = Bank::parse(stem, std::fs::read(dir.join(format!("{stem}.abk"))).unwrap()).unwrap();
+        let pcm: Vec<Option<Arc<Pcm>>> = (0..bank.samples.len())
+            .map(|i| std::fs::read(audio.join(format!("banks/{stem}/{i:04}.wav"))).ok().and_then(|b| wav_pcm(&b)).map(Arc::new))
+            .collect();
+        let found = pcm.iter().filter(|p| p.is_some()).count();
+        println!("bank {stem}: {} samples, {found} with PCM", bank.samples.len());
+        rt.load_bank(bank, pcm);
+    }
+    if let Ok(v) = std::env::var("AEMS_FLANGE") {
+        use skate_audio::bus::flange::FlangePreset;
+        let rec = |s: &str| {
+            let v: Vec<f32> = s.split(',').map(|x| x.trim().parse().unwrap()).collect();
+            FlangePreset(v.try_into().expect("9 values"))
+        };
+        let (a, b) = v.split_once(';').expect("a;b");
+        rt.mixer.buses.flange.set_presets(rec(a), rec(b));
+        rt.mixer.buses.flange.frame([32692, 2313, 32692, 2313]);
+    }
+    let utility = rt.eval.class_id("c_emitter_utility").unwrap();
+    rt.post(utility, &[]);
+    let class = rt.eval.class_id(&a[4]).expect("class");
+    rt.post(class, &payload);
+    let frames = (seconds * 48000.0) as usize;
+    let mut out = vec![0.0f32; 2 * frames];
+    let started = Instant::now();
+    let mut max_voices = 0;
+    for chunk in out.chunks_mut(2 * 4800) {
+        rt.fill_stereo(chunk);
+        max_voices = max_voices.max(rt.mixer.voice_count());
+    }
+    let took = started.elapsed().as_secs_f64();
+    for (s, sec) in out.chunks(2 * 48000).enumerate() {
+        let rms = (sec.iter().map(|v| f64::from(*v).powi(2)).sum::<f64>() / sec.len() as f64).sqrt();
+        let peak = sec.iter().fold(0.0f64, |m, v| m.max(f64::from(v.abs())));
+        println!("{s:>3}s rms {:>7.1} dBFS peak {:>7.1} dBFS", db(rms), db(peak));
+    }
+    println!(
+        "rendered {seconds} s in {:.3} s ({:.0}x real time); voices max {max_voices}; opens refused {}; walks {}",
+        took,
+        seconds / took,
+        rt.mixer.refused,
+        rt.eval.walks
+    );
+    if let Some(path) = a.get(7) {
+        let mut w = Vec::new();
+        let data = (out.len() * 2) as u32;
+        w.extend(b"RIFF");
+        w.extend((36 + data).to_le_bytes());
+        w.extend(b"WAVEfmt ");
+        w.extend(16u32.to_le_bytes());
+        w.extend(1u16.to_le_bytes());
+        w.extend(2u16.to_le_bytes());
+        w.extend(48000u32.to_le_bytes());
+        w.extend((48000u32 * 4).to_le_bytes());
+        w.extend(4u16.to_le_bytes());
+        w.extend(16u16.to_le_bytes());
+        w.extend(b"data");
+        w.extend(data.to_le_bytes());
+        for v in &out {
+            w.extend(((v.clamp(-1.0, 1.0) * 32767.0).round() as i16).to_le_bytes());
+        }
+        std::fs::write(path, w).unwrap();
+        println!("wrote {path}");
+    }
+}
diff --git a/crates/skate-audio/examples/aems_replay.rs b/crates/skate-audio/examples/aems_replay.rs
new file mode 100644
index 00000000..dde2b51b
--- /dev/null
+++ b/crates/skate-audio/examples/aems_replay.rs
@@ -0,0 +1,183 @@
+//! Replay a post script through the native evaluator with the oracle's mock voice device and print
+//! every device call, in the same format as the local PoC probe (`.claude/skills/aems-port/tools/
+//! poc/aems_golden.rs`), so the two outputs can be diffed line by line
+//! (`.claude/skills/aems-port/tools/golden_compare.py`).
+//!
+//! usage: aems_replay <dir with the disc's .abk/.csi files> <script> [--trace]
+//! Script lines: `banks a.abk,b.abk` · `utility` · `global name=value` ·
+//! `post <block> <class> <w0,w1,...>` · `redeliver <block> <k> <words>` · `release <block> <k>` ·
+//! `blocks <n>`. The projects are installed in the order of `csi_order.txt` in that directory
+//! (the archive order), else alphabetically.
+//!
+//! Mock device: a voice lives while now < open + duration (frames / rate; loops forever); query
+//! remaining = trunc((end − now)·1000), elapsed = trunc((now − open)·1000), loops 1e9;
+//! now = block · f64(f32(256/48000)).
+use std::collections::HashMap;
+use std::path::Path;
+
+use skate_audio::eval::{Evaluator, NodeId, OpenRequest, VoiceHost, VoiceStatus};
+use skate_audio::formats::{Bank, Project, SampleHeader};
+
+struct Mock {
+    block: u64,
+    now: f64,
+    next: u32,
+    headers: HashMap<usize, Vec<Option<SampleHeader>>>,
+    live: HashMap<u32, (f64, f64)>,
+}
+
+impl VoiceHost for Mock {
+    fn open(&mut self, r: &OpenRequest) -> Option<u32> {
+        self.next += 1;
+        let header = self.headers.get(&r.bank).and_then(|h| h.get(r.slot as usize).copied().flatten());
+        let (duration, looping) = header.map_or((1.0, false), |h| (h.seconds(), h.loop_start.is_some()));
+        let az: Vec<String> = r.azimuth.iter().map(u8::to_string).collect();
+        println!(
+            "{} OPEN v{} slot={} level={} az={} stream={:x} n={}",
+            self.block,
+            self.next,
+            r.slot as i16,
+            r.level,
+            az.join(","),
+            r.stream_offset,
+            r.inputs.len()
+        );
+        let end = if looping { f64::INFINITY } else { self.now + duration };
+        self.live.insert(self.next, (self.now, end));
+        Some(self.next)
+    }
+    fn release(&mut self, voice: u32) {
+        println!("{} REL v{voice}", self.block);
+        self.live.remove(&voice);
+    }
+    fn pause(&mut self, voice: u32) {
+        println!("{} PAUSE v{voice}", self.block);
+    }
+    fn resume(&mut self, voice: u32) {
+        println!("{} RESUME v{voice}", self.block);
+    }
+    fn set(&mut self, voice: u32, id: u8, value: i32) {
+        println!("{} SET v{voice} {id} {value}", self.block);
+    }
+    fn set_azimuth(&mut self, voice: u32, value: i32) {
+        println!("{} AZ v{voice} {value}", self.block);
+    }
+    fn query(&mut self, voice: u32) -> VoiceStatus {
+        let Some(&(start, end)) = self.live.get(&voice) else { return VoiceStatus::default() };
+        let alive = self.now < end;
+        if !alive {
+            println!("{} END v{voice}", self.block);
+            return VoiceStatus::default();
+        }
+        let remaining = if end.is_finite() { (end - self.now).max(0.0) } else { 1.0e6 };
+        VoiceStatus { alive, remaining_ms: (remaining * 1000.0) as i32, elapsed_ms: ((self.now - start) * 1000.0) as i32 }
+    }
+}
+
+enum Action {
+    Post(String, Vec<i32>),
+    Redeliver(usize, Vec<i32>),
+    Release(usize),
+}
+
+fn words(s: &str) -> Vec<i32> {
+    s.split(',').filter(|s| !s.is_empty()).map(|s| s.trim().parse::<i64>().unwrap() as i32).collect()
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() < 3 {
+        eprintln!("usage: aems_replay <banks dir> <script> [--trace]");
+        std::process::exit(2);
+    }
+    let dir = Path::new(&args[1]);
+    let script = std::fs::read_to_string(&args[2]).expect("script");
+    let trace = args.iter().any(|a| a == "--trace");
+    let mut banks = Vec::new();
+    let mut utility = false;
+    let mut globals_set = Vec::new();
+    let mut actions: Vec<(u64, Action)> = Vec::new();
+    let mut blocks = 0u64;
+    for line in script.lines().map(str::trim).filter(|l| !l.is_empty() && !l.starts_with('#')) {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        match parts[0] {
+            "banks" => banks = parts[1].split(',').map(str::to_string).collect(),
+            "utility" => utility = true,
+            "global" => {
+                let (k, v) = parts[1].split_once('=').unwrap();
+                globals_set.push((k.to_string(), v.parse::<i64>().unwrap() as i32));
+            }
+            "post" => actions.push((parts[1].parse().unwrap(), Action::Post(parts[2].to_string(), words(parts.get(3).unwrap_or(&""))))),
+            "redeliver" => actions.push((parts[1].parse().unwrap(), Action::Redeliver(parts[2].parse().unwrap(), words(parts[3])))),
+            "release" => actions.push((parts[1].parse().unwrap(), Action::Release(parts[2].parse().unwrap()))),
+            "blocks" => blocks = parts[1].parse().unwrap(),
+            other => panic!("unknown script line {other}"),
+        }
+    }
+
+    let mut eval = Evaluator::new();
+    let order = std::fs::read_to_string(dir.join("csi_order.txt")).map(|s| s.lines().map(str::to_string).collect::<Vec<_>>()).unwrap_or_else(|_| {
+        let mut v: Vec<String> = std::fs::read_dir(dir)
+            .unwrap()
+            .filter_map(|e| e.ok()?.file_name().into_string().ok())
+            .filter(|n| n.ends_with(".csi"))
+            .collect();
+        v.sort();
+        v
+    });
+    for name in &order {
+        let bytes = std::fs::read(dir.join(name)).expect("csi");
+        eval.install_project(&Project::parse(name, &bytes).expect("csi parse"));
+        println!("# project {name}");
+    }
+    let mut mock = Mock { block: 0, now: 0.0, next: 0, headers: HashMap::new(), live: HashMap::new() };
+    for name in &banks {
+        let bytes = std::fs::read(dir.join(name)).unwrap_or_else(|e| panic!("{name}: {e}"));
+        let bank = Bank::parse(name, bytes).expect("bank parse");
+        let headers = bank.samples.iter().map(|s| s.1).collect();
+        let id = eval.load_bank(bank);
+        mock.headers.insert(id, headers);
+        println!("# bank {name}");
+    }
+    for (k, v) in &globals_set {
+        let g = eval.global_id(k).unwrap_or_else(|| panic!("no global {k}"));
+        eval.registry.globals[g].value = *v;
+    }
+    if utility {
+        let c = eval.class_id("c_emitter_utility").expect("c_emitter_utility");
+        eval.post(c, &[]);
+        println!("# utility posted");
+    }
+    if trace {
+        eval.trace = Some(Vec::new());
+    }
+    let mut nodes: Vec<NodeId> = Vec::new();
+    let delta = f64::from(256.0f32 / 48000.0f32);
+    for b in 0..blocks {
+        mock.block = b;
+        mock.now = b as f64 * delta;
+        for (at, action) in &actions {
+            if *at != b {
+                continue;
+            }
+            match action {
+                Action::Post(class, payload) => {
+                    let c = eval.class_id(class).unwrap_or_else(|| panic!("no class {class}"));
+                    nodes.push(eval.post(c, payload));
+                    println!("{b} POST {} {class}", nodes.len() - 1);
+                }
+                Action::Redeliver(k, payload) => eval.redeliver(nodes[*k], payload),
+                Action::Release(k) => {
+                    eval.release(nodes[*k]);
+                    println!("{b} RELEASE {k}");
+                }
+            }
+        }
+        eval.block(&mut mock);
+        if let Some(t) = &mut eval.trace {
+            for op in t.drain(..) {
+                println!("# op walk={} inst={} m={} op={} blk={} r={}", op.walk, op.instance, op.module, op.opcode, op.block, op.result);
+            }
+        }
+    }
+}
diff --git a/crates/skate-audio/examples/board_mix_probe.rs b/crates/skate-audio/examples/board_mix_probe.rs
new file mode 100644
index 00000000..28eee9f1
--- /dev/null
+++ b/crates/skate-audio/examples/board_mix_probe.rs
@@ -0,0 +1,63 @@
+//! The local player's board outputs from the retail MixMap over ground speed, with the inputs
+//! the game writes (`skate-game` `native::mixmap_frame`: free-skate globals, PlayerPhysics speed
+//! words, all four wheels down, both 3DObjPos blocks active at a camera distance), next to the
+//! retail capture medians of grain-player-spec §2.2 / §3.4 (grain pitch 3209 at rest, ~3500 at
+//! 1 m/s, ~4080 from ~5 m/s; gain A ≈ 0.06 at 5 km/h, 0.08–0.17 from 10 km/h up).
+//!
+//! PlayerPhysics.in9 is 0 for the local player (pass 32767 to see a remote player: the high-pass
+//! then sits at 1109 Hz and gain A drops ~2 dB).
+//!
+//! usage: cargo run -p skate-audio --release --example board_mix_probe -- <MixMapSK8.mxb> [camera m] [in9]
+use skate_audio::mixmap::{MixMap, keys};
+
+const SPEED_SCALES: [u32; 4] = [0x46B8_507A, 0x4575_C0A3, 0x4513_7395, 0x44D2_A51E];
+
+fn word(v: f32, bits: u32) -> i32 {
+    (v * f32::from_bits(bits)).clamp(0.0, 32767.0) as i32
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let bytes = std::fs::read(args.get(1).expect("usage: board_mix_probe <mxb> [camera m]")).expect("read mxb");
+    let camera: f32 = args.get(2).map_or(3.5, |a| a.parse().unwrap());
+    let in9: i32 = args.get(3).map_or(0, |a| a.parse().unwrap());
+    println!("camera {camera} m, PlayerPhysics.in9 {in9}; km/h, level(1) gainA, level(2), pitch(3)/4096, LP(11) Hz, HP(12) Hz, rocket level(5)");
+    for kmh in [0.0f32, 3.6, 5.0, 10.0, 15.0, 20.0, 30.0, 40.0, 50.0, 60.0] {
+        let mut m = MixMap::from_bytes(&bytes).expect("parse");
+        let v = kmh / 3.6;
+        for _ in 0..30 {
+            for id in 1..=4 {
+                m.set_input(keys::MASTER, id, 32767);
+            }
+            for id in [1, 2, 5] {
+                m.set_input(keys::MUSIC, id, 32767);
+            }
+            m.set_input(keys::REVERB, 5, 32767);
+            let p = keys::player_physics(0);
+            m.set_input(p, 0, word(v, SPEED_SCALES[0]));
+            m.set_input(p, 1, word(v, SPEED_SCALES[1]));
+            m.set_input(p, 7, word(v, SPEED_SCALES[2]));
+            m.set_input(p, 8, word(v, SPEED_SCALES[3]));
+            m.set_input(p, 14, word(v, SPEED_SCALES[3]));
+            m.set_input(p, 10, (4.0 * 8191.75) as i32);
+            m.set_input(p, 9, in9);
+            for key in [keys::obj_pos(0), keys::obj_pos2(0)] {
+                m.set_input_f32(key, keys::pos::DIST_SKATER, 0.0);
+                m.set_input_f32(key, keys::pos::DIST_CAMERA, camera);
+                m.set_input(key, keys::pos::FLAGS, 1);
+            }
+            m.tick(1.0 / 60.0);
+        }
+        let b = keys::skateboard(0);
+        println!(
+            "{kmh:5.1}  {:5} {:.3}  {:5}  {:.3}  {:5}  {:5}  {:5}",
+            m.level(b, 1),
+            m.level(b, 1) as f32 / 32767.0,
+            m.level(b, 2),
+            m.pitch_4096(b, 3) as f32 / 4096.0,
+            m.filter_hz(b, 11),
+            m.filter_hz(b, 12),
+            m.level(keys::sense_of_speed(0), 5)
+        );
+    }
+}
diff --git a/crates/skate-audio/examples/effect_routes.rs b/crates/skate-audio/examples/effect_routes.rs
new file mode 100644
index 00000000..d6dec4fa
--- /dev/null
+++ b/crates/skate-audio/examples/effect_routes.rs
@@ -0,0 +1,82 @@
+//! Census of the voice routing records (player input records with id ≥ 9) of every bank: which
+//! modules route their voices into the FlangeSub effect returns (values 4096 / 8192 / 16384, then
+//! an enable record and a level record), into an eEQChain bus (0–7, 10–17) or a fixed bus
+//! (512 / 2048). Template (authored) values; a program may overwrite the words at run time
+//! (the record's value word is then also an op output — flagged "dyn").
+//!
+//! usage: effect_routes <dir with the disc's .abk/.csi files> [name filter]
+use std::collections::BTreeMap;
+use std::path::Path;
+
+use skate_audio::be::{i32_at, u8_at};
+use skate_audio::eval::Evaluator;
+use skate_audio::eval::symbols::SymRef;
+use skate_audio::formats::{Bank, Project};
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let dir = Path::new(&args[1]);
+    let filter = args.get(2).map(|s| s.to_ascii_lowercase());
+    let mut eval = Evaluator::new();
+    for name in std::fs::read_to_string(dir.join("csi_order.txt")).expect("csi_order.txt").lines() {
+        eval.install_project(&Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap());
+    }
+    let mut names: Vec<String> = std::fs::read_dir(dir)
+        .unwrap()
+        .filter_map(|e| e.ok()?.file_name().into_string().ok())
+        .filter(|n| n.to_ascii_lowercase().ends_with(".abk"))
+        .filter(|n| filter.as_ref().is_none_or(|f| n.to_ascii_lowercase().contains(f)))
+        .collect();
+    names.sort();
+    let mut totals: BTreeMap<i32, usize> = BTreeMap::new();
+    for name in names {
+        let bank = Bank::parse(&name, std::fs::read(dir.join(&name)).unwrap()).unwrap();
+        for (i, m) in bank.modules.iter().enumerate() {
+            let class = bank
+                .exports
+                .iter()
+                .find(|e| e.handle_offset == m.offset + 4)
+                .and_then(|e| eval.registry.lookup(e.kind, e.project, e.name_id, &e.name))
+                .and_then(|s| match s {
+                    SymRef::Class(c) => Some(eval.registry.classes[c].name.clone()),
+                    _ => None,
+                })
+                .unwrap_or_else(|| "?".into());
+            let t = m.template(&bank.data);
+            // Every instance offset some op writes to (op outputs: the second word of each pair).
+            let outputs: Vec<i32> = m.program.iter().flat_map(|o| o.pairs.iter().map(move |p| o.block as i32 + p.1)).collect();
+            for (p, &b) in m.players().iter().enumerate() {
+                let b = b as usize;
+                if b + 28 > t.len() {
+                    continue;
+                }
+                let n = u8_at(t, b + 14) as usize;
+                let recs: Vec<(u8, i32, bool)> = (0..n)
+                    .filter(|k| b + 36 + 12 * k + 4 <= t.len())
+                    .map(|k| {
+                        let at = b + 28 + 12 * k;
+                        (u8_at(t, at), i32_at(t, at + 8), outputs.contains(&((at + 8) as i32)))
+                    })
+                    .collect();
+                let routing: Vec<String> = recs
+                    .iter()
+                    .filter(|r| r.0 >= 9)
+                    .map(|r| format!("{}={}{}", r.0, r.1, if r.2 { "(dyn)" } else { "" }))
+                    .collect();
+                if routing.is_empty() {
+                    continue;
+                }
+                for r in recs.iter().filter(|r| r.0 >= 9) {
+                    *totals.entry(r.1).or_default() += 1;
+                }
+                let fx = recs.iter().any(|r| r.0 >= 9 && matches!(r.1, 4096 | 8192 | 16384));
+                println!(
+                    "{}{name} #{i} player {p} class={class} n={n} routing [{}]",
+                    if fx { "FX " } else { "   " },
+                    routing.join(" ")
+                );
+            }
+        }
+    }
+    println!("totals by value: {totals:?}");
+}
diff --git a/crates/skate-audio/examples/emitter_scene_probe.rs b/crates/skate-audio/examples/emitter_scene_probe.rs
new file mode 100644
index 00000000..dfcbb8e1
--- /dev/null
+++ b/crates/skate-audio/examples/emitter_scene_probe.rs
@@ -0,0 +1,199 @@
+//! Headless world-emitter scene: load several banks, post one `c_emitter` payload per emitter (as
+//! `game_audio/emitters.rs` does), redeliver them every 60 Hz frame and log every voice's life
+//! (open, end) with its bank, slot, gain and pitch, plus per-second RMS and the most voices per
+//! bank that sounded at once. For listening reports like "doubling or restarting".
+//!
+//! usage: emitter_scene_probe <banks dir> <audio dir> <stem[,stem…]> <seconds> <payload>[;<payload>…]
+//! A payload is `w0,w1,…,w8`; `@T` after it (`…,347@12.5`) releases that post at T seconds and
+//! `+T` posts it only from T seconds (a re-entry). The utility is loaded and posted first.
+use std::collections::HashMap;
+use std::path::Path;
+use std::sync::Arc;
+
+use skate_audio::formats::{Bank, Project};
+use skate_audio::mixer::Pcm;
+use skate_audio::runtime::Runtime;
+
+fn wav_pcm(bytes: &[u8]) -> Option<Pcm> {
+    let (mut channels, mut rate, mut bits) = (0usize, 0u32, 0u16);
+    let mut at = 12;
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().ok()?) as usize;
+        let body = at + 8;
+        match &bytes[at..at + 4] {
+            b"fmt " => {
+                channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+                rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().ok()?);
+                bits = u16::from_le_bytes([bytes[body + 14], bytes[body + 15]]);
+            }
+            b"data" if channels > 0 && bits == 16 => {
+                let data = &bytes[body..(body + size).min(bytes.len())];
+                let mut planar = vec![Vec::new(); channels];
+                for (i, s) in data.chunks_exact(2).enumerate() {
+                    planar[i % channels].push(f32::from(i16::from_le_bytes([s[0], s[1]])) / 32768.0);
+                }
+                return Some(Pcm { rate, channels: planar });
+            }
+            _ => {}
+        }
+        at = body + size + (size & 1);
+    }
+    None
+}
+
+struct Post {
+    words: Vec<i32>,
+    from: f64,
+    until: f64,
+    node: Option<skate_audio::eval::NodeId>,
+}
+
+fn main() {
+    let a: Vec<String> = std::env::args().collect();
+    if a.len() < 6 {
+        eprintln!("usage: emitter_scene_probe <banks dir> <audio dir> <stems> <seconds> <payload>[;…]");
+        std::process::exit(2);
+    }
+    let (dir, audio) = (Path::new(&a[1]), Path::new(&a[2]));
+    let seconds: f64 = a[4].parse().unwrap();
+    let mut posts: Vec<Post> = a[5]
+        .split(';')
+        .map(|p| {
+            let (mut words, mut from, mut until) = (p.to_string(), 0.0, f64::INFINITY);
+            if let Some((w, t)) = words.clone().split_once('@') {
+                until = t.parse().unwrap();
+                words = w.to_string();
+            }
+            if let Some((w, t)) = words.clone().split_once('+') {
+                from = t.parse().unwrap();
+                words = w.to_string();
+            }
+            Post { words: words.split(',').map(|s| s.trim().parse().unwrap()).collect(), from, until, node: None }
+        })
+        .collect();
+    let mut rt = Runtime::new();
+    for name in std::fs::read_to_string(dir.join("csi_order.txt")).unwrap().lines() {
+        rt.install_project(&Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap());
+    }
+    let mut names: HashMap<usize, String> = HashMap::new();
+    let mut stems: Vec<&str> = a[3].split(',').collect();
+    stems.insert(0, "emitter_utility");
+    for stem in stems {
+        let bank = Bank::parse(stem, std::fs::read(dir.join(format!("{stem}.abk"))).unwrap()).unwrap();
+        let pcm: Vec<Option<Arc<Pcm>>> = (0..bank.samples.len())
+            .map(|i| std::fs::read(audio.join(format!("banks/{stem}/{i:04}.wav"))).ok().and_then(|b| wav_pcm(&b)).map(Arc::new))
+            .collect();
+        // The op-8 shuffle bags as authored (template): range, avoid flag, min, number set.
+        let bytes = std::fs::read(dir.join(format!("{stem}.abk"))).unwrap();
+        for (mi, m) in bank.modules.iter().enumerate() {
+            let t = m.template(&bytes);
+            for op in m.program.iter().filter(|op| op.opcode == 8) {
+                let b = op.block as usize;
+                let wide = t[b + 2] != 1;
+                let range = u16::from_be_bytes([t[b + 10], t[b + 11]]) as usize;
+                let set: Vec<u16> = (0..range)
+                    .map(|k| if wide { u16::from_be_bytes([t[b + 16 + 2 * k], t[b + 17 + 2 * k]]) } else { u16::from(t[b + 16 + k]) })
+                    .collect();
+                println!(
+                    "{stem} module {mi} shuffle @{b}: range {range}, avoid {}, min {}, index {}, set {set:?}",
+                    t[b + 3] as i8,
+                    i32::from_be_bytes(t[b + 4..b + 8].try_into().unwrap()),
+                    u16::from_be_bytes([t[b + 8], t[b + 9]])
+                );
+            }
+        }
+        for (i, (_, h)) in bank.samples.iter().enumerate() {
+            if let Some(h) = h {
+                let seam = pcm[i].as_ref().zip(h.loop_start).map(|(p, l)| {
+                    let c = &p.channels[0];
+                    (c.last().copied().unwrap_or(0.0), c.get(l as usize).copied().unwrap_or(0.0))
+                });
+                println!("{stem} slot {i}: {} frames @ {} Hz, loop {:?}, wrap (last, loop start) {seam:?}", h.frames, h.rate, h.loop_start);
+            }
+        }
+        let id = rt.load_bank(bank, pcm);
+        names.insert(id, stem.to_string());
+    }
+    let utility = rt.eval.class_id("c_emitter_utility").unwrap();
+    rt.post(utility, &[]);
+    let class = rt.eval.class_id("c_emitter").expect("c_emitter");
+    if std::env::var("PROBE_SHUFFLES").is_ok_and(|v| v == "1") {
+        rt.eval.trace = Some(Vec::new());
+    }
+    let mut shuffles: HashMap<(u32, u32), i32> = HashMap::new();
+
+    let block_s = skate_audio::BLOCK as f64 / 48000.0;
+    let blocks = (seconds / block_s) as usize;
+    let mut stereo = vec![0.0f32; 2 * skate_audio::BLOCK];
+    let mut live: HashMap<u32, (f64, String, u16, f32, f32)> = HashMap::new();
+    let mut most: HashMap<String, usize> = HashMap::new();
+    let mut sec_sum = 0.0f64;
+    let mut sec_n = 0usize;
+    let mut next_frame = 0.0f64;
+    for b in 0..blocks {
+        let t = b as f64 * block_s;
+        if t >= next_frame {
+            next_frame += 1.0 / 60.0;
+            for p in &mut posts {
+                match p.node {
+                    None if t >= p.from && t < p.until => p.node = Some(rt.post(class, &p.words)),
+                    Some(n) if t >= p.until => {
+                        rt.release(n);
+                        p.node = None;
+                        p.until = f64::INFINITY;
+                        p.from = f64::INFINITY;
+                    }
+                    Some(n) => rt.redeliver(n, &p.words),
+                    None => {}
+                }
+            }
+        }
+        rt.fill_stereo(&mut stereo);
+        // PROBE_SHUFFLES=1: every change of a shuffle's output (a new draw) with its walk.
+        if let Some(trace) = rt.eval.trace.as_mut() {
+            for e in trace.drain(..) {
+                if e.opcode == 8 && names.get(&e.bank).is_some_and(|n| n != "emitter_utility") {
+                    let last = shuffles.entry((e.instance, e.block)).or_insert(i32::MIN);
+                    if *last != e.result {
+                        println!("{t:8.3}s DRAW  walk {} instance {} shuffle @{} = {}", e.walk, e.instance, e.block, e.result);
+                        *last = e.result;
+                    }
+                }
+            }
+        }
+        sec_sum += stereo.iter().map(|v| f64::from(*v).powi(2)).sum::<f64>();
+        sec_n += stereo.len();
+        let snap = rt.mixer.snapshot();
+        let mut per: HashMap<String, usize> = HashMap::new();
+        for v in &snap {
+            let name = names.get(&v.bank).cloned().unwrap_or_else(|| format!("bank{}", v.bank));
+            *per.entry(name.clone()).or_default() += 1;
+            live.entry(v.id).or_insert_with(|| {
+                println!("{t:8.3}s OPEN  v{:<5} {name} slot {} gain {:.3} pitch {:.3}", v.id, v.slot, v.gain, v.pitch);
+                (t, name, v.slot, v.gain, v.pitch)
+            });
+            if let Some(e) = live.get_mut(&v.id) {
+                e.3 = v.gain;
+                e.4 = v.pitch;
+            }
+        }
+        for (k, n) in per {
+            let m = most.entry(k).or_default();
+            *m = (*m).max(n);
+        }
+        let ids: Vec<u32> = snap.iter().map(|v| v.id).collect();
+        live.retain(|id, (t0, name, slot, gain, pitch)| {
+            let keep = ids.contains(id);
+            if !keep {
+                println!("{t:8.3}s END   v{id:<5} {name} slot {slot} after {:.3} s (gain {gain:.3} pitch {pitch:.3})", t - *t0);
+            }
+            keep
+        });
+        if sec_n >= 2 * 48000 {
+            println!("{:8.3}s rms {:.1} dBFS", t, 10.0 * (sec_sum / sec_n as f64).max(1e-18).log10());
+            sec_sum = 0.0;
+            sec_n = 0;
+        }
+    }
+    println!("most voices at once per bank: {most:?}");
+}
diff --git a/crates/skate-audio/examples/grain_bed_render.rs b/crates/skate-audio/examples/grain_bed_render.rs
new file mode 100644
index 00000000..3c5db8b4
--- /dev/null
+++ b/crates/skate-audio/examples/grain_bed_render.rs
@@ -0,0 +1,161 @@
+//! Whole-bed check, headless: the retail MixMap + the grain bed on `concrete_rough_hard` at
+//! constant speeds, through the runtime's block clock and stereo output stage. Prints per speed:
+//! grain starts per second (both players), the most voices at once, the record (gain A, position
+//! A/B, pitch) and the stereo RMS / peak in dBFS — next to retail's numbers (grain-player-spec
+//! §2.4: ~6 starts/s for one sounding truck; §3.4: rolling bed −22.9 dBFS in PR #4's 6-ch capture,
+//! position A 0.12 at 10 km/h → 0.63 at 40 km/h). Optional `--wav out.wav` writes the 30 km/h run.
+//!
+//! The member's tuning is concrete_rough_hard's vault values (max 60 km/h, P1 0.0345, P2 0.9138;
+//! GrainParams A 0.1/0.2/0.1/1.6/0.05, B 0.2/0.1/0.2/1.5/0.05), staged by
+//! `.claude/skills/aems-port/tools/stage_grain_mixmap.py`.
+//!
+//! usage: cargo run -p skate-audio --release --example grain_bed_render -- <assets/private/audio> <MixMapSK8.mxb> [--wav out.wav]
+use std::sync::Arc;
+
+use skate_audio::grain::board::{self, BoardInputs, PushTuning, SurfaceTuning};
+use skate_audio::grain::{GrainFile, GrainParams, GrainSource};
+use skate_audio::mixer::Pcm;
+use skate_audio::mixmap::{MixMap, keys};
+use skate_audio::runtime::Runtime;
+
+const SPEED_SCALES: [u32; 4] = [0x46B8_507A, 0x4575_C0A3, 0x4513_7395, 0x44D2_A51E];
+
+fn wav_mono(bytes: &[u8]) -> Pcm {
+    let mut at = 12;
+    let (mut rate, mut channels) = (0u32, 1usize);
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().unwrap()) as usize;
+        let body = at + 8;
+        if &bytes[at..at + 4] == b"fmt " {
+            channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+            rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().unwrap());
+        } else if &bytes[at..at + 4] == b"data" {
+            let data = &bytes[body..(body + size).min(bytes.len())];
+            let mono = data.chunks_exact(2 * channels).map(|f| f32::from(i16::from_le_bytes([f[0], f[1]])) / 32768.0).collect();
+            return Pcm { rate, channels: vec![mono] };
+        }
+        at = body + size + (size & 1);
+    }
+    panic!("not a PCM16 WAV");
+}
+
+fn word(v: f32, bits: u32) -> i32 {
+    (v * f32::from_bits(bits)).clamp(0.0, 32767.0) as i32
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let audio = std::path::Path::new(args.get(1).expect("usage: grain_bed_render <audio dir> <mxb> [--wav out]"));
+    let mxb = std::fs::read(args.get(2).expect("mxb")).expect("read mxb");
+    let wav_out = args.iter().position(|a| a == "--wav").and_then(|i| args.get(i + 1));
+    let header = GrainFile::parse(&std::fs::read(audio.join("grains/concrete_rough_hard.grain")).expect("grain")).expect("parse grain");
+    let pcm = wav_mono(&std::fs::read(audio.join("grains/concrete_rough_hard.wav")).expect("wav"));
+    assert_eq!(pcm.rate, header.stream.rate);
+    let source = Arc::new(GrainSource { name: "concrete_rough_hard".into(), duration: header.duration, pcm: Arc::new(pcm) });
+    let a = GrainParams { attack: 0.1, sustain: 0.2, release: 0.1, window: 1.6, drift: 0.05 };
+    let b = GrainParams { attack: 0.2, sustain: 0.1, release: 0.2, window: 1.5, drift: 0.05 };
+    let tuning = SurfaceTuning {
+        max_kmh: 60.0,
+        bezier: [0, 0x3D0D_3DCB, 0x3F69_EE58, 0x3F80_0000].map(f32::from_bits),
+        params: [a, b],
+        turn_cap: 0.6,
+        turn_rise_step: 0.06,
+        turn_fall_step: 0.06,
+        special_gain: 0.65,
+        special_shift_hz: 150.0,
+        b_slope_gain: 2.0,
+        b_slope_ramp_kmh: 10.0,
+        a_shift_per_slope_hz: -100.0,
+        b_base_shift_hz: -10.0,
+        b_shift_per_slope_hz: 50.0,
+        slope_divisors: (-10.0, 10.0),
+        push: PushTuning { ramp_kmh: 45.0, scale_low: 1.4, scale_high: 1.1, shift_low_hz: -52.0, shift_high_hz: -20.0, scale_ms: [35.0, 200.0, 600.0], shift_ms: [30.0, 200.0, 600.0] },
+    };
+    println!("km/h  starts/s  max voices  gainA   posA    posB    pitch   RMS dBFS  peak dBFS");
+    for kmh in [5.0f32, 10.0, 20.0, 30.0, 40.0] {
+        let v = kmh / 3.6;
+        let mut m = MixMap::from_bytes(&mxb).expect("mxb");
+        let mut rt = Runtime::new();
+        let seconds = 10.0f32;
+        let frames = (seconds * 60.0) as usize;
+        let mut stereo = vec![0.0f32; 2 * 800];
+        let mut out = Vec::with_capacity(2 * 48000 * seconds as usize);
+        let mut max_voices = 0;
+        let mut rec = Default::default();
+        for f in 0..frames {
+            for id in 1..=4 {
+                m.set_input(keys::MASTER, id, 32767);
+            }
+            for id in [1, 2, 5] {
+                m.set_input(keys::MUSIC, id, 32767);
+            }
+            m.set_input(keys::REVERB, 5, 32767);
+            let p = keys::player_physics(0);
+            for (id, s) in [(0, 0), (1, 1), (7, 2), (8, 3), (14, 3)] {
+                m.set_input(p, id, word(v, SPEED_SCALES[s]));
+            }
+            m.set_input(p, 10, (4.0 * 8191.75) as i32);
+            for key in [keys::obj_pos(0), keys::obj_pos2(0)] {
+                m.set_input_f32(key, keys::pos::DIST_CAMERA, 3.5);
+                m.set_input(key, keys::pos::FLAGS, 1);
+            }
+            m.tick(1.0 / 60.0);
+            let o = keys::skateboard(0);
+            let records = board::records(&tuning, &BoardInputs {
+                speed: v, speed_scale: None, level_a: m.level(o, 1), level_b: m.level(o, 2), pitch: m.pitch_4096(o, 3),
+                turn: 0.0, brake: 0.0, special: false, downhill: 0.0, seam: None,
+            });
+            rec = records;
+            if f == 0 {
+                rt.grains.bind_truck(0, source.clone(), [a, b], records);
+            } else {
+                rt.grains.set_records(0, records);
+            }
+            let chain = skate_audio::grain::ChainValues {
+                highpass_hz: m.filter_hz(o, 12) as f32,
+                lowpass_hz: m.filter_hz(o, 11) as f32,
+                pan_degrees: m.raw(o, 0) as f32 * (360.0 / 65535.0),
+                level: 1.0,
+                ..Default::default()
+            };
+            rt.grains.set_chains(0, [chain; 2]);
+            rt.fill_stereo(&mut stereo);
+            out.extend_from_slice(&stereo);
+            max_voices = max_voices.max(rt.grains.voices());
+        }
+        let starts: u64 = rt.grains.trucks[0].players.iter().map(|p| p.starts).sum();
+        let tail = &out[out.len() / 5..];
+        let rms = (tail.iter().map(|s| s * s).sum::<f32>() / tail.len() as f32).sqrt();
+        let peak = tail.iter().fold(0.0f32, |m, s| m.max(s.abs()));
+        println!(
+            "{kmh:4.0}  {:8.2}  {max_voices:10}  {:.4}  {:.4}  {:.4}  {:.4}  {:8.1}  {:9.1}",
+            starts as f32 / seconds,
+            rec[0].gain,
+            rec[0].position,
+            rec[1].position,
+            rec[0].pitch,
+            20.0 * rms.max(1e-9).log10(),
+            20.0 * peak.max(1e-9).log10()
+        );
+        if let (Some(path), true) = (wav_out, kmh == 30.0) {
+            let mut w = Vec::new();
+            let data_len = (out.len() * 2) as u32;
+            w.extend_from_slice(b"RIFF");
+            w.extend_from_slice(&(36 + data_len).to_le_bytes());
+            w.extend_from_slice(b"WAVEfmt ");
+            w.extend_from_slice(&16u32.to_le_bytes());
+            w.extend_from_slice(&1u16.to_le_bytes());
+            w.extend_from_slice(&2u16.to_le_bytes());
+            w.extend_from_slice(&48000u32.to_le_bytes());
+            w.extend_from_slice(&(48000u32 * 4).to_le_bytes());
+            w.extend_from_slice(&4u16.to_le_bytes());
+            w.extend_from_slice(&16u16.to_le_bytes());
+            w.extend_from_slice(b"data");
+            w.extend_from_slice(&data_len.to_le_bytes());
+            for s in &out {
+                w.extend_from_slice(&((s.clamp(-1.0, 1.0) * 32767.0) as i16).to_le_bytes());
+            }
+            std::fs::write(path, w).expect("write wav");
+        }
+    }
+}
diff --git a/crates/skate-audio/examples/grain_chain_probe.rs b/crates/skate-audio/examples/grain_chain_probe.rs
new file mode 100644
index 00000000..83428230
--- /dev/null
+++ b/crates/skate-audio/examples/grain_chain_probe.rs
@@ -0,0 +1,255 @@
+//! The grain bus chain headless (spec `.claude/notes/aems-grain-chain-spec.md` §6): the retail
+//! MixMap + the bed on `concrete_rough_hard` through the runtime, a 12 s run — 30 km/h with a
+//! manual (special latch) from 2 to 4 s, a ramp to 85 km/h (graph-3 send, wobble, level ramp),
+//! back down to 35 km/h (the level hold) — with a push every 1.5 s.
+//!
+//! - `--mode old`: `chain_extras` off and the older chain values (level 1.0): must be bit-identical
+//!   to the same run of the code before the full chain (`baseline` copy, same file).
+//! - `--mode full` (default): the full chain with the owner state machines (`grain::chain`).
+//! - `--raw out.f32`: the interleaved stereo output; prints an FNV-1a hash of the output bits and
+//!   the per-block render time (p50 / p99 / max µs; real time = 5333 µs), plus per-phase RMS and
+//!   the bed's spectral centroid.
+//!
+//! usage: cargo run --release --example grain_chain_probe -- <assets/private/audio> <MixMapSK8.mxb> [--mode old|full] [--raw out.f32]
+#![allow(unexpected_cfgs)] // `--cfg baseline` builds this file against the code before the full chain.
+use std::sync::Arc;
+use std::time::Instant;
+
+use skate_audio::BLOCK;
+use skate_audio::dsp::routes::output_stereo;
+use skate_audio::grain::board::{self, BoardInputs, PushTuning, SurfaceTuning};
+use skate_audio::grain::{GrainFile, GrainParams, GrainSource};
+use skate_audio::mixer::Pcm;
+use skate_audio::mixmap::{MixMap, keys};
+use skate_audio::runtime::Runtime;
+
+const SPEED_SCALES: [u32; 4] = [0x46B8_507A, 0x4575_C0A3, 0x4513_7395, 0x44D2_A51E];
+
+fn wav_mono(bytes: &[u8]) -> Pcm {
+    let mut at = 12;
+    let (mut rate, mut channels) = (0u32, 1usize);
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().unwrap()) as usize;
+        let body = at + 8;
+        if &bytes[at..at + 4] == b"fmt " {
+            channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+            rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().unwrap());
+        } else if &bytes[at..at + 4] == b"data" {
+            let data = &bytes[body..(body + size).min(bytes.len())];
+            let mono = data.chunks_exact(2 * channels).map(|f| f32::from(i16::from_le_bytes([f[0], f[1]])) / 32768.0).collect();
+            return Pcm { rate, channels: vec![mono] };
+        }
+        at = body + size + (size & 1);
+    }
+    panic!("not a PCM16 WAV");
+}
+
+fn word(v: f32, bits: u32) -> i32 {
+    (v * f32::from_bits(bits)).clamp(0.0, 32767.0) as i32
+}
+
+fn kmh_at(t: f32) -> f32 {
+    if t < 4.0 {
+        30.0
+    } else if t < 8.0 {
+        30.0 + (t - 4.0) / 4.0 * 55.0
+    } else if t < 10.0 {
+        85.0 - (t - 8.0) / 2.0 * 50.0
+    } else {
+        35.0
+    }
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let audio = std::path::Path::new(args.get(1).expect("usage: grain_chain_probe <audio dir> <mxb> [--mode old|full] [--raw out]"));
+    let mxb = std::fs::read(args.get(2).expect("mxb")).expect("read mxb");
+    let opt = |name: &str| args.iter().position(|a| a == name).and_then(|i| args.get(i + 1)).cloned();
+    let full = opt("--mode").as_deref() != Some("old");
+    let header = GrainFile::parse(&std::fs::read(audio.join("grains/concrete_rough_hard.grain")).expect("grain")).expect("parse grain");
+    let pcm = wav_mono(&std::fs::read(audio.join("grains/concrete_rough_hard.wav")).expect("wav"));
+    let source = Arc::new(GrainSource { name: "concrete_rough_hard".into(), duration: header.duration, pcm: Arc::new(pcm) });
+    let a = GrainParams { attack: 0.1, sustain: 0.2, release: 0.1, window: 1.6, drift: 0.05 };
+    let b = GrainParams { attack: 0.2, sustain: 0.1, release: 0.2, window: 1.5, drift: 0.05 };
+    let tuning = SurfaceTuning {
+        max_kmh: 60.0,
+        bezier: [0, 0x3D0D_3DCB, 0x3F69_EE58, 0x3F80_0000].map(f32::from_bits),
+        params: [a, b],
+        turn_cap: 0.6,
+        turn_rise_step: 0.06,
+        turn_fall_step: 0.06,
+        special_gain: 0.65,
+        special_shift_hz: 150.0,
+        b_slope_gain: 2.0,
+        b_slope_ramp_kmh: 10.0,
+        a_shift_per_slope_hz: -100.0,
+        b_base_shift_hz: -10.0,
+        b_shift_per_slope_hz: 50.0,
+        slope_divisors: (-10.0, 10.0),
+        push: PushTuning { ramp_kmh: 45.0, scale_low: 1.4, scale_high: 1.1, shift_low_hz: -52.0, shift_high_hz: -20.0, scale_ms: [35.0, 200.0, 600.0], shift_ms: [30.0, 200.0, 600.0] },
+    };
+    let mut m = MixMap::from_bytes(&mxb).expect("mxb");
+    let mut rt = Runtime::new();
+    rt.grains.chain_extras = full;
+    let mut owner = OwnerSide::default();
+    let frames = 12 * 60;
+    let mut out: Vec<f32> = Vec::with_capacity(2 * 48000 * 12);
+    let mut stereo = vec![0.0f32; 2 * BLOCK];
+    let mut times = Vec::new();
+    let mut rendered = 0usize;
+    let mut push = board::PushEnvelope::default();
+    for f in 0..frames {
+        let t = f as f32 / 60.0;
+        let v = kmh_at(t) / 3.6;
+        let special = (2.0..4.0).contains(&t);
+        let pushed = f % 90 == 45 && v < 40.0 / 3.6;
+        for id in 1..=4 {
+            m.set_input(keys::MASTER, id, 32767);
+        }
+        for id in [1, 2, 5] {
+            m.set_input(keys::MUSIC, id, 32767);
+        }
+        m.set_input(keys::REVERB, 5, 32767);
+        let p = keys::player_physics(0);
+        for (id, s) in [(0, 0), (1, 1), (7, 2), (8, 3), (14, 3)] {
+            m.set_input(p, id, word(v, SPEED_SCALES[s]));
+        }
+        m.set_input(p, 10, (4.0 * 8191.75) as i32);
+        for key in [keys::obj_pos(0), keys::obj_pos2(0)] {
+            m.set_input_f32(key, keys::pos::DIST_CAMERA, 3.5);
+            m.set_input(key, keys::pos::FLAGS, 1);
+        }
+        m.tick(1.0 / 60.0);
+        let o = keys::skateboard(0);
+        if pushed {
+            let (scale, _) = board::push_peaks(&tuning.push, v);
+            push.trigger(scale, 1.0, tuning.push.scale_ms);
+        }
+        push.advance(1.0 / 60.0);
+        let records = board::records(&tuning, &BoardInputs {
+            speed: v, speed_scale: push.value(), level_a: m.level(o, 1), level_b: m.level(o, 2), pitch: m.pitch_4096(o, 3),
+            turn: 0.0, brake: 0.0, special, downhill: 0.0, seam: None,
+        });
+        if f == 0 {
+            owner.rebuilt();
+            rt.grains.bind_truck(0, source.clone(), [a, b], records);
+        } else {
+            rt.grains.set_records(0, records);
+        }
+        let chains = if full {
+            owner.frame(&tuning, &m, v, special, pushed, 1.0 / 60.0)
+        } else {
+            let c = skate_audio::grain::ChainValues {
+                highpass_hz: m.filter_hz(o, 12) as f32,
+                lowpass_hz: m.filter_hz(o, 11) as f32,
+                pan_degrees: m.raw(o, 0) as f32 * (360.0 / 65535.0),
+                level: 1.0,
+                ..Default::default()
+            };
+            [c; 2]
+        };
+        if full && [60, 180, 450, 540, 660].contains(&f) {
+            let [ca, cb] = chains;
+            println!(
+                "t {t:5.2}s {:5.1} km/h  FSS A {:7.2} B {:7.2} Hz  g1 A {:.4} B {:.4}  g3 A {:.4} B {:.4}  send3 {:.3}  env {:.4}  flange A {:.4} B {:.4}",
+                v * 3.6, ca.fss_hz, cb.fss_hz, ca.level, cb.level, ca.graph3_gain, cb.graph3_gain, ca.graph3_send, ca.env_send, ca.flange_send, cb.flange_send
+            );
+        }
+        rt.grains.set_chains(0, chains);
+        let needed = (f + 1) * 800;
+        while rendered < needed {
+            let start = Instant::now();
+            let bus = *rt.render_block();
+            times.push(start.elapsed().as_secs_f64() * 1e6);
+            output_stereo(&bus, &mut stereo);
+            out.extend_from_slice(&stereo);
+            rendered += BLOCK;
+        }
+    }
+    let mut hash = 0xCBF2_9CE4_8422_2325u64;
+    for s in &out {
+        for byte in s.to_bits().to_le_bytes() {
+            hash = (hash ^ u64::from(byte)).wrapping_mul(0x0100_0000_01B3);
+        }
+    }
+    times.sort_by(f64::total_cmp);
+    let q = |p: f64| times[((times.len() - 1) as f64 * p) as usize];
+    println!("mode {}  blocks {}  hash {hash:016X}", if full { "full" } else { "old" }, times.len());
+    println!("render µs/block: p50 {:.1}  p99 {:.1}  max {:.1}", q(0.5), q(0.99), q(1.0));
+    for (name, from, to) in [("30 km/h", 0.5f32, 2.0f32), ("30 km/h manual", 2.2, 4.0), ("60-85 km/h", 6.5, 8.0), ("35 km/h after", 10.5, 12.0)] {
+        let (i, j) = ((from * 48000.0) as usize * 2, (to * 48000.0) as usize * 2);
+        let seg = &out[i..j.min(out.len())];
+        let rms = (seg.iter().map(|s| s * s).sum::<f32>() / seg.len() as f32).sqrt();
+        println!("{name:16} RMS {:7.2} dBFS  centroid {:7.0} Hz", 20.0 * rms.max(1e-9).log10(), centroid(seg));
+    }
+    if let Some(path) = opt("--raw") {
+        let bytes: Vec<u8> = out.iter().flat_map(|s| s.to_le_bytes()).collect();
+        std::fs::write(path, bytes).expect("write raw");
+    }
+}
+
+/// Spectral centroid (Hz) of the left channel: mean of 4096-point DFT magnitudes (naive, Hann).
+fn centroid(seg: &[f32]) -> f32 {
+    let n = 4096;
+    let left: Vec<f32> = seg.iter().step_by(2).copied().collect();
+    let (mut num, mut den) = (0.0f64, 0.0f64);
+    for start in (0..left.len().saturating_sub(n)).step_by(n * 4) {
+        let w: Vec<f64> = (0..n).map(|k| left[start + k] as f64 * (0.5 - 0.5 * (std::f64::consts::TAU * k as f64 / n as f64).cos())).collect();
+        for bin in (1..n / 2).step_by(4) {
+            let (mut re, mut im) = (0.0, 0.0);
+            let dw = std::f64::consts::TAU * bin as f64 / n as f64;
+            for (k, x) in w.iter().enumerate() {
+                re += x * (dw * k as f64).cos();
+                im -= x * (dw * k as f64).sin();
+            }
+            let mag = (re * re + im * im).sqrt();
+            num += mag * bin as f64 * 48000.0 / n as f64;
+            den += mag;
+        }
+    }
+    (num / den.max(1e-30)) as f32
+}
+
+/// The host side of the full chain: the owner's chain state, the push shift and the FSS values.
+#[derive(Default)]
+struct OwnerSide {
+    #[cfg(not(baseline))]
+    state: skate_audio::grain::chain::ChainState,
+    #[cfg(not(baseline))]
+    shift: skate_audio::grain::chain::PushShift,
+    rng: Option<skate_audio::eval::rng::Rng>,
+}
+
+impl OwnerSide {
+    fn rebuilt(&mut self) {
+        #[cfg(not(baseline))]
+        self.state.rebuilt(0);
+    }
+
+    #[allow(unused_variables)]
+    fn frame(&mut self, t: &SurfaceTuning, m: &MixMap, v: f32, special: bool, pushed: bool, dt: f32) -> [skate_audio::grain::ChainValues; 2] {
+        #[cfg(not(baseline))]
+        {
+            use skate_audio::grain::chain::{self, ChainFrame, ChainTuning};
+            let rng = self.rng.get_or_insert_with(|| skate_audio::eval::rng::Rng::new(skate_audio::grain::GrainBed::SEED));
+            if pushed {
+                let (_, peak) = board::push_peaks(&t.push, v);
+                self.shift.trigger(peak, t.push.shift_ms);
+            }
+            self.shift.advance(dt);
+            self.state.frame(&ChainTuning::default(), v, dt, [true, false], || rng.draw());
+            let o = keys::skateboard(0);
+            let frame = ChainFrame {
+                highpass_hz: m.filter_hz(o, 12) as f32,
+                lowpass_hz: m.filter_hz(o, 11) as f32,
+                pan_degrees: m.raw(o, 0) as f32 * chain::DEGREES_PER_RAW,
+                env_send: m.level(o, 13) as f32 * chain::PER_LEVEL,
+                flange_send: [m.level(o, 21) as f32 * chain::PER_LEVEL, m.level(o, 22) as f32 * chain::PER_LEVEL],
+                fss_hz: chain::fss_shifts(t, t, special, self.shift.value(), 0.0),
+            };
+            self.state.values(0, &frame)
+        }
+        #[cfg(baseline)]
+        unreachable!()
+    }
+}
diff --git a/crates/skate-audio/examples/mixmap_golden.rs b/crates/skate-audio/examples/mixmap_golden.rs
new file mode 100644
index 00000000..1a33156d
--- /dev/null
+++ b/crates/skate-audio/examples/mixmap_golden.rs
@@ -0,0 +1,87 @@
+//! Run a MixMap golden script through the native port and write the watched outputs per
+//! evaluation as CSV — the same script format and CSV as the PoC's `mixmap_golden` example and
+//! our reference `mxb_tool.py eval` (spec `.claude/notes/mixmap-spec.md` §9.1), so the three can
+//! be diffed with `mxb_diff.py` / `.claude/skills/aems-port/tools/mixmap_compare.py`.
+//!
+//! Script lines: `dt <s>` | `dtat <eval> <s>` | `frames <n>` | `watch <key hex> <id> level|raw|pitch`
+//! | `set <eval> <key hex> <id> <int|0xhex|f:float>`.
+//!
+//! usage: cargo run -p skate-audio --release --example mixmap_golden -- <MixMapSK8.mxb> <script> <out.csv>
+use std::collections::BTreeMap;
+use std::fmt::Write as _;
+
+use skate_audio::mixmap::MixMap;
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() != 4 {
+        eprintln!("usage: mixmap_golden <MixMapSK8.mxb> <script> <out.csv>");
+        std::process::exit(2);
+    }
+    let bytes = std::fs::read(&args[1]).expect("read mxb");
+    let script = std::fs::read_to_string(&args[2]).expect("read script");
+    let mut dt = 1.0f64 / 60.0;
+    let mut frames = 0usize;
+    let mut dtat = BTreeMap::new();
+    let mut watch: Vec<(u32, usize, String)> = Vec::new();
+    let mut sets: Vec<(usize, u32, usize, u32)> = Vec::new();
+    for line in script.lines() {
+        let t: Vec<&str> = line.split_whitespace().collect();
+        if t.is_empty() || t[0].starts_with('#') {
+            continue;
+        }
+        let hex = |s: &str| u32::from_str_radix(s, 16).expect("hex key");
+        match t[0] {
+            "dt" => dt = t[1].parse().unwrap(),
+            "dtat" => {
+                dtat.insert(t[1].parse::<usize>().unwrap(), t[2].parse::<f64>().unwrap());
+            }
+            "frames" => frames = t[1].parse().unwrap(),
+            "watch" => watch.push((hex(t[1]), t[2].parse().unwrap(), t[3].to_owned())),
+            "set" => {
+                let v = t[4];
+                let value = if let Some(f) = v.strip_prefix("f:") {
+                    f.parse::<f32>().unwrap().to_bits()
+                } else if let Some(h) = v.strip_prefix("0x") {
+                    u32::from_str_radix(h, 16).unwrap()
+                } else {
+                    v.parse::<i64>().unwrap() as u32
+                };
+                sets.push((t[1].parse().unwrap(), hex(t[2]), t[3].parse().unwrap(), value));
+            }
+            _ => {}
+        }
+    }
+    sets.sort_by_key(|s| s.0);
+    let mut m = MixMap::from_bytes(&bytes).expect("parse mxb");
+    let mut out = String::from("frame");
+    for (k, i, how) in &watch {
+        write!(out, ",{k:x}:{i}:{how}").unwrap();
+    }
+    out.push('\n');
+    let mut si = 0;
+    for frame in 0..frames {
+        if let Some(&d) = dtat.get(&frame) {
+            dt = d;
+        }
+        while si < sets.len() && sets[si].0 <= frame {
+            let (_, key, id, value) = sets[si];
+            m.set_input(key, id, value as i32);
+            si += 1;
+        }
+        // The script's dt is a double; the evaluator takes it as f32 like retail.
+        m.tick(dt as f32);
+        write!(out, "{frame}").unwrap();
+        for (k, i, how) in &watch {
+            let v = match how.as_str() {
+                "level" => m.level(*k, *i),
+                "raw" => m.raw(*k, *i),
+                _ => m.pitch_4096(*k, *i),
+            };
+            write!(out, ",{v}").unwrap();
+        }
+        out.push('\n');
+    }
+    std::fs::write(&args[3], out).expect("write csv");
+    println!("wrote {} ({frames} frames, {} watched outputs)", args[3], watch.len());
+}
diff --git a/crates/skate-audio/examples/pan_fold_probe.rs b/crates/skate-audio/examples/pan_fold_probe.rs
new file mode 100644
index 00000000..b36254bc
--- /dev/null
+++ b/crates/skate-audio/examples/pan_fold_probe.rs
@@ -0,0 +1,18 @@
+//! The stereo gain a mono voice gets through Pan2D1 and the output stage's stereo fold, by
+//! azimuth (degrees): what the native host does to a voice of per-voice gain 1.
+//! usage: cargo run -p skate-audio --release --example pan_fold_probe
+use skate_audio::dsp::pan::{ANGLE, Pan2D};
+
+fn main() {
+    const G707: f32 = std::f32::consts::FRAC_1_SQRT_2;
+    println!("azimuth  L  C  R  Ls  Rs  ->  left  right  (power sum dB)");
+    for az in [0.0f32, 30.0, 60.0, 90.0, 135.0, 180.0, -90.0] {
+        let mut p = Pan2D::new(1);
+        p.params[ANGLE] = az;
+        let m = p.matrix()[0];
+        let l = G707 * m[0] + 0.5 * m[1] + 0.5 * m[3];
+        let r = G707 * m[2] + 0.5 * m[1] + 0.5 * m[4];
+        let db = 10.0 * (l * l + r * r).log10();
+        println!("{az:6.0}  {:.3} {:.3} {:.3} {:.3} {:.3}  ->  {l:.3} {r:.3}  ({db:+.1} dB vs a mono g on both channels {:+.1} dB)", m[0], m[1], m[2], m[3], m[4], db - 10.0 * 2.0f32.log10());
+    }
+}
diff --git a/crates/skate-audio/examples/post_probe.rs b/crates/skate-audio/examples/post_probe.rs
new file mode 100644
index 00000000..bdd9018a
--- /dev/null
+++ b/crates/skate-audio/examples/post_probe.rs
@@ -0,0 +1,68 @@
+//! Post one class with a payload through the evaluator (every project + the named banks loaded)
+//! and print what reaches the voice host: the open requests' input records (routing ids ≥ 9) and
+//! every property set, per block. A headless check of what a component's words do to its voices.
+//!
+//! usage: post_probe <banks dir> <bank stem[,stem…]> <class> <w0,w1,…> [blocks] [redeliver words]
+use std::path::Path;
+
+use skate_audio::eval::{Evaluator, OpenRequest, VoiceHost, VoiceStatus};
+use skate_audio::formats::{Bank, Project};
+
+struct Log {
+    block: usize,
+    next: u32,
+}
+
+impl VoiceHost for Log {
+    fn open(&mut self, r: &OpenRequest) -> Option<u32> {
+        self.next += 1;
+        println!("b{:<4} open v{} bank {} slot {} inputs {:?}", self.block, self.next, r.bank, r.slot, r.inputs);
+        Some(self.next)
+    }
+    fn release(&mut self, v: u32) {
+        println!("b{:<4} release v{v}", self.block);
+    }
+    fn pause(&mut self, _: u32) {}
+    fn resume(&mut self, _: u32) {}
+    fn set(&mut self, v: u32, id: u8, value: i32) {
+        println!("b{:<4} set v{v} id {id} = {value}", self.block);
+    }
+    fn set_azimuth(&mut self, v: u32, value: i32) {
+        println!("b{:<4} azimuth v{v} = {value}", self.block);
+    }
+    fn query(&mut self, _: u32) -> VoiceStatus {
+        VoiceStatus { alive: true, remaining_ms: 10_000, elapsed_ms: 0 }
+    }
+}
+
+fn words(s: &str) -> Vec<i32> {
+    s.split(',').filter(|w| !w.is_empty()).map(|w| w.trim().parse().unwrap()).collect()
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let dir = Path::new(&args[1]);
+    let mut eval = Evaluator::new();
+    for name in std::fs::read_to_string(dir.join("csi_order.txt")).expect("csi_order.txt").lines() {
+        eval.install_project(&Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap());
+    }
+    for stem in args[2].split(',') {
+        let file = format!("{stem}.abk");
+        eval.load_bank(Bank::parse(&file, std::fs::read(dir.join(&file)).unwrap()).unwrap());
+    }
+    let class = eval.class_id(&args[3]).expect("class");
+    let payload = words(&args[4]);
+    let blocks: usize = args.get(5).map_or(60, |b| b.parse().unwrap());
+    let again = args.get(6).map(|s| words(s));
+    let node = eval.post(class, &payload);
+    let mut host = Log { block: 0, next: 0 };
+    for b in 0..blocks {
+        host.block = b;
+        if b == blocks / 2 {
+            if let Some(w) = &again {
+                eval.redeliver(node, w);
+            }
+        }
+        eval.block(&mut host);
+    }
+}
diff --git a/crates/skate-audio/examples/program_trace.rs b/crates/skate-audio/examples/program_trace.rs
new file mode 100644
index 00000000..0d510f12
--- /dev/null
+++ b/crates/skate-audio/examples/program_trace.rs
@@ -0,0 +1,110 @@
+//! Dump one class's program (op, data block, copy pairs) and trace it while a held packet is
+//! redelivered with a toggling trigger word: every op's result per walk and every voice open.
+//! A headless look at how a program turns packet words into sample choices.
+//!
+//! usage: program_trace <banks dir> <bank stem> <class> <w0,w1,…> [trigger word] [walks] [period]
+//! The trigger word (default 7) alternates 1 / 2 every `period` walks (default 2), 0 in between.
+use std::path::Path;
+
+use skate_audio::eval::symbols::SymRef;
+use skate_audio::eval::{Evaluator, OpenRequest, VoiceHost, VoiceStatus};
+use skate_audio::formats::{Bank, Project};
+
+struct Log {
+    walk: usize,
+    next: u32,
+}
+
+impl VoiceHost for Log {
+    fn open(&mut self, r: &OpenRequest) -> Option<u32> {
+        self.next += 1;
+        println!("w{:<4} OPEN v{} slot {} inputs {:?}", self.walk, self.next, r.slot, r.inputs);
+        Some(self.next)
+    }
+    fn release(&mut self, _: u32) {}
+    fn pause(&mut self, _: u32) {}
+    fn resume(&mut self, _: u32) {}
+    fn set(&mut self, _: u32, _: u8, _: i32) {}
+    fn set_azimuth(&mut self, _: u32, _: i32) {}
+    fn query(&mut self, _: u32) -> VoiceStatus {
+        VoiceStatus { alive: true, remaining_ms: 10_000, elapsed_ms: 0 }
+    }
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let dir = Path::new(&args[1]);
+    let mut eval = Evaluator::new();
+    for name in std::fs::read_to_string(dir.join("csi_order.txt")).expect("csi_order.txt").lines() {
+        eval.install_project(&Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap());
+    }
+    if args[2] == "-classes" {
+        for (i, c) in eval.registry.classes.iter().enumerate() {
+            println!("class {i:3} {}", c.name);
+        }
+        for name in std::fs::read_to_string(dir.join("csi_order.txt")).unwrap().lines() {
+            let p = Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap();
+            for (t, table) in p.tables.iter().enumerate() {
+                for (k, s) in table.iter().enumerate() {
+                    println!("project {} ({}) table {t} #{k} id {} {}", p.name, p.id, s.name_id, s.name);
+                }
+            }
+        }
+        return;
+    }
+    let file = format!("{}.abk", args[2]);
+    let bank = Bank::parse(&file, std::fs::read(dir.join(&file)).unwrap()).unwrap();
+    for (i, m) in bank.modules.iter().enumerate() {
+        println!("module {i}: {} ops", m.program.len());
+        for e in &bank.exports {
+            if e.handle_offset >= m.template_offset && e.handle_offset < m.template_offset + m.data_size {
+                let sym = eval.registry.lookup(e.kind, e.project, e.name_id, &e.name);
+                let name = match sym {
+                    Some(SymRef::Global(g)) => format!("global {}", eval.registry.globals[g].name),
+                    Some(SymRef::Function(f)) => format!("function {}", eval.registry.functions[f].name),
+                    Some(SymRef::Class(c)) => format!("class {}", eval.registry.classes[c].name),
+                    _ => format!("? {}", e.name),
+                };
+                println!("  handle @{} = {name}", e.handle_offset - m.template_offset);
+            }
+        }
+        for (k, op) in m.program.iter().enumerate() {
+            println!("  #{k:3} op {:2} block {:5} pairs {:?}", op.opcode, op.block, op.pairs);
+        }
+    }
+    eval.load_bank(bank);
+    // PRE=stem:class,… loads more banks and posts those classes first (boot utilities).
+    if let Ok(pre) = std::env::var("PRE") {
+        let mut host = Log { walk: 0, next: 1000 };
+        for item in pre.split(',').filter(|s| !s.is_empty()) {
+            let (stem, class) = item.split_once(':').expect("stem:class");
+            let file = format!("{stem}.abk");
+            eval.load_bank(Bank::parse(&file, std::fs::read(dir.join(&file)).unwrap()).unwrap());
+            eval.post(eval.class_id(class).expect("pre class"), &[]);
+        }
+        eval.walk(&mut host);
+    }
+    let class = eval.class_id(&args[3]).expect("class");
+    let mut w: Vec<i32> = args[4].split(',').filter(|s| !s.is_empty()).map(|s| s.trim().parse().unwrap()).collect();
+    let tw: usize = args.get(5).map_or(7, |v| v.parse().unwrap());
+    let walks: usize = args.get(6).map_or(12, |v| v.parse().unwrap());
+    let period: usize = args.get(7).map_or(2, |v| v.parse().unwrap());
+    eval.trace = Some(Vec::new());
+    let node = eval.post(class, &w);
+    let mut host = Log { walk: 0, next: 0 };
+    let mut toggle = false;
+    for k in 0..walks {
+        host.walk = k;
+        w[tw] = if k % period == 0 {
+            toggle = !toggle;
+            if toggle { 1 } else { 2 }
+        } else {
+            0
+        };
+        eval.redeliver(node, &w);
+        eval.walk(&mut host);
+        for t in eval.trace.as_mut().unwrap().drain(..) {
+            println!("w{k:<4} i{} m{} op {:2} @{:5} = {}", t.instance, t.module, t.opcode, t.block, t.result);
+        }
+    }
+}
diff --git a/crates/skate-audio/examples/seam_pulse_probe.rs b/crates/skate-audio/examples/seam_pulse_probe.rs
new file mode 100644
index 00000000..01db9744
--- /dev/null
+++ b/crates/skate-audio/examples/seam_pulse_probe.rs
@@ -0,0 +1,135 @@
+//! Which Seams_Bank samples the Class_Seams program opens for a given sequence of the trigger word
+//! w7 as the held packet carries it, one value per 256-frame block (5.33 ms; the evaluator walks
+//! every 6 blocks and sees the latest value). Real runtime with the decoded samples, so voice
+//! lifetimes are the samples' own. Headless.
+//!
+//! usage: seam_pulse_probe <banks dir> <audio dir> <w0,w1,…,w19> <w7 per block, e.g. 2,0,0> [seconds]
+//!        seam_pulse_probe <banks dir> <audio dir> <words> model:<calls per 60 Hz step>:<hit p>:<double p> [seconds]
+//! The model form simulates the host: the physics state steps at 60 Hz, the component's process
+//! runs `calls` times per step (1 = our 60 Hz host; the recomp ~5), a step has a hit with
+//! probability p (on its first call only), a hit fires twice (both axes: w7 toggles back) with
+//! probability q, and every call clears w7 first; each block sees the latest call's value.
+//! The banks dir is `aems-port/tools/bank_layout_check.py --extract`'s; the audio dir holds
+//! `banks/<stem>/NNNN.wav` (the install's `assets/private/audio`). Boots `c_emitter_utility` and
+//! `Common.abk`'s `Start_up_Play_ctl` (the seams' sample shuffle) first. Prints voice starts per
+//! second and by eight-sample block.
+use std::collections::{BTreeMap, HashSet};
+use std::path::Path;
+use std::sync::Arc;
+
+use skate_audio::formats::{Bank, Project};
+use skate_audio::mixer::Pcm;
+use skate_audio::runtime::Runtime;
+
+fn wav_pcm(bytes: &[u8]) -> Option<Pcm> {
+    let (mut channels, mut rate, mut bits) = (0usize, 0u32, 0u16);
+    let mut at = 12;
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().ok()?) as usize;
+        let body = at + 8;
+        match &bytes[at..at + 4] {
+            b"fmt " => {
+                channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+                rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().ok()?);
+                bits = u16::from_le_bytes([bytes[body + 14], bytes[body + 15]]);
+            }
+            b"data" if channels > 0 && bits == 16 => {
+                let data = &bytes[body..(body + size).min(bytes.len())];
+                let mut planar = vec![Vec::new(); channels];
+                for (i, s) in data.chunks_exact(2).enumerate() {
+                    planar[i % channels].push(f32::from(i16::from_le_bytes([s[0], s[1]])) / 32768.0);
+                }
+                return Some(Pcm { rate, channels: planar });
+            }
+            _ => {}
+        }
+        at = body + size + (size & 1);
+    }
+    None
+}
+
+fn main() {
+    let a: Vec<String> = std::env::args().collect();
+    let (dir, audio) = (Path::new(&a[1]), Path::new(&a[2]));
+    let mut w: Vec<i32> = a[3].split(',').map(|s| s.trim().parse().unwrap()).collect();
+    let seq: Vec<i32> = if a[4].starts_with("model:") { Vec::new() } else { a[4].split(',').map(|s| s.trim().parse().unwrap()).collect() };
+    let seconds: f64 = a.get(5).map_or(10.0, |v| v.parse().unwrap());
+    let mut rt = Runtime::new();
+    for name in std::fs::read_to_string(dir.join("csi_order.txt")).expect("csi_order.txt").lines() {
+        rt.install_project(&Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap());
+    }
+    let mut seams = 0;
+    for stem in ["emitter_utility", "Seams_Bank", "Common"] {
+        let bank = Bank::parse(stem, std::fs::read(dir.join(format!("{stem}.abk"))).unwrap()).unwrap();
+        let pcm: Vec<Option<Arc<Pcm>>> = (0..bank.samples.len())
+            .map(|i| std::fs::read(audio.join(format!("banks/{stem}/{i:04}.wav"))).ok().and_then(|b| wav_pcm(&b)).map(Arc::new))
+            .collect();
+        let id = rt.load_bank(bank, pcm);
+        if stem == "Seams_Bank" {
+            seams = id;
+        }
+    }
+    rt.post(rt.eval.class_id("c_emitter_utility").unwrap(), &[]);
+    rt.post(rt.eval.class_id("Start_up_Play_ctl").expect("utility"), &[]);
+    let node = rt.post(rt.eval.class_id("Class_Seams").expect("class"), &w);
+    let blocks = (seconds * 48000.0 / 256.0) as usize;
+    // model:<calls>:<p>:<q> → the per-block sequence from the host model (fixed-seed LCG).
+    let seq: Vec<i32> = match a[4].strip_prefix("model:") {
+        None => seq,
+        Some(m) => {
+            let f: Vec<f64> = m.split(':').map(|x| x.parse().unwrap()).collect();
+            let (calls, p, q) = (f[0], f[1], f[2]);
+            let mut rng = 0x2545_F491_4F6C_DD1Du64;
+            let mut next = || {
+                rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+                (rng >> 11) as f64 / (1u64 << 53) as f64
+            };
+            let (step, call) = (1.0 / 60.0, 1.0 / 60.0 / calls);
+            let mut toggle = true;
+            let (mut t_call, mut value) = (0.0f64, 0);
+            let mut out = Vec::with_capacity(blocks);
+            for b in 0..blocks {
+                let t = b as f64 * 256.0 / 48000.0;
+                while t_call <= t {
+                    let first = (t_call / step).fract() < call / step * 0.5 || (t_call / step).fract() > 1.0 - 1e-9;
+                    value = 0;
+                    if first && next() < p {
+                        let fires = if next() < q { 2 } else { 1 };
+                        for _ in 0..fires {
+                            value = if toggle { 1 } else { 2 };
+                            toggle = !toggle;
+                        }
+                    }
+                    t_call += call;
+                }
+                out.push(value);
+            }
+            out
+        }
+    };
+    let mut seen = HashSet::new();
+    let mut by_block: BTreeMap<u16, u32> = BTreeMap::new();
+    let mut pulses = 0;
+    let mut prev = 0;
+    for b in 0..blocks {
+        let v = seq[b % seq.len()];
+        pulses += usize::from(v != 0 && v != prev);
+        prev = v;
+        w[7] = v;
+        rt.redeliver(node, &w);
+        rt.render_block();
+        for vi in rt.mixer.snapshot() {
+            if vi.bank == seams && seen.insert(vi.id) {
+                *by_block.entry(vi.slot / 8 * 8).or_default() += 1;
+            }
+        }
+    }
+    let n: u32 = by_block.values().sum();
+    let base: u32 = by_block.iter().filter(|(k, _)| **k < 48).map(|(_, v)| v).sum();
+    println!(
+        "{seconds} s: {:.1} pulses/s (value changes to non-zero), {:.1} voices/s, base share {:.0}%, by block {by_block:?}",
+        pulses as f64 / seconds,
+        f64::from(n) / seconds,
+        100.0 * f64::from(base) / f64::from(n.max(1))
+    );
+}
diff --git a/crates/skate-audio/examples/voice_load_probe.rs b/crates/skate-audio/examples/voice_load_probe.rs
new file mode 100644
index 00000000..3d4afa9f
--- /dev/null
+++ b/crates/skate-audio/examples/voice_load_probe.rs
@@ -0,0 +1,61 @@
+//! Render cost of the mixer under load: N looping voices (mono and stereo) with filters on and the
+//! azimuth / cutoff changing every 6 blocks (an evaluator tick), as world emitters do. Prints the
+//! per-block render time (p50 / p99 / max, µs; real time = 5333 µs per 256-frame block).
+//! usage: cargo run -p skate-audio --release --example voice_load_probe [voices] [blocks] [fx]
+//! `fx`: the FlangeSub returns enabled and every voice routed into one (A / B alternating, Send B
+//! 0.05) — the cost of Send B and the returns.
+use std::sync::Arc;
+use std::time::Instant;
+
+use skate_audio::BLOCK;
+use skate_audio::eval::{OpenRequest, VoiceHost};
+use skate_audio::formats::SampleHeader;
+use skate_audio::mixer::{Mixer, Pcm};
+
+fn main() {
+    let a: Vec<String> = std::env::args().collect();
+    let n: usize = a.get(1).and_then(|v| v.parse().ok()).unwrap_or(96);
+    let blocks: usize = a.get(2).and_then(|v| v.parse().ok()).unwrap_or(2000);
+    let fx = a.get(3).is_some_and(|v| v == "fx");
+    let frames = 44_100 * 4;
+    let mono = Arc::new(Pcm { rate: 44_100, channels: vec![(0..frames).map(|i| (i as f32 * 0.03).sin() * 0.3).collect()] });
+    let stereo = Arc::new(Pcm { rate: 44_100, channels: vec![mono.channels[0].clone(), mono.channels[0].clone()] });
+    let header = |channels| SampleHeader { codec: 3, channels, rate: 44_100, frames: frames as u32, loop_start: Some(0) };
+    let mut m = Mixer::new();
+    m.max_voices = n.max(1);
+    m.add_bank(0, vec![Some(header(1)), Some(header(2))], vec![Some(mono), Some(stereo)]);
+    if fx {
+        use skate_audio::bus::flange::FlangePreset;
+        m.buses.flange.set_presets(
+            FlangePreset([20.0, 0.3, 0.2, 0.1, 1500.0, 0.002, 0.5, 0.9, 0.03]),
+            FlangePreset([1.7, 0.3, 0.0, 1.0, 250.0, 0.0005, 0.25, 0.6, 0.11]),
+        );
+        m.buses.flange.frame([32692, 2313, 32692, 2313]);
+    }
+    let routes = [[(9u8, 4096i32), (10, 1), (11, 1638)], [(9u8, 16384i32), (10, 1), (11, 1638)]];
+    let ids: Vec<u32> = (0..n)
+        .filter_map(|k| {
+            let inputs: &[(u8, i32)] = if fx { &routes[k % 2] } else { &[] };
+            m.open(&OpenRequest { bank: 0, slot: (k % 2) as u16, level: 100, azimuth: [224, 32, 0, 0, 0, 0], stream_offset: u32::MAX, inputs })
+        })
+        .collect();
+    let mut bus = [[0.0f32; BLOCK]; 6];
+    let mut times = Vec::with_capacity(blocks);
+    for b in 0..blocks {
+        if b % 6 == 0 {
+            for (k, &v) in ids.iter().enumerate() {
+                m.set_azimuth(v, ((b * 37 + k * 911) % 65536) as i32);
+                m.set(v, 6, 2000 + ((b + k * 13) % 20000) as i32);
+                m.set(v, 7, 77);
+                m.set(v, 2, 20000);
+                m.set(v, 0, 4096 + ((b + k) % 400) as i32);
+            }
+        }
+        let t = Instant::now();
+        m.render(&mut bus);
+        times.push(t.elapsed().as_secs_f64() * 1e6);
+    }
+    times.sort_by(f64::total_cmp);
+    let q = |p: f64| times[((times.len() - 1) as f64 * p) as usize];
+    println!("{} voices: render per block p50 {:.0} us, p99 {:.0} us, max {:.0} us (real time 5333 us)", ids.len(), q(0.5), q(0.99), q(1.0));
+}
diff --git a/crates/skate-audio/src/be.rs b/crates/skate-audio/src/be.rs
new file mode 100644
index 00000000..16ff7807
--- /dev/null
+++ b/crates/skate-audio/src/be.rs
@@ -0,0 +1,82 @@
+//! Big-endian word access on byte buffers (banks, projects and instance memory are all big-endian,
+//! as on the Xbox 360). Out-of-range reads return 0 and writes are dropped, so a malformed program
+//! can never panic the audio thread; bank loading validates layouts up front.
+
+#[inline]
+pub fn u8_at(d: &[u8], at: usize) -> u8 {
+    d.get(at).copied().unwrap_or(0)
+}
+
+#[inline]
+pub fn i8_at(d: &[u8], at: usize) -> i8 {
+    u8_at(d, at) as i8
+}
+
+#[inline]
+pub fn u16_at(d: &[u8], at: usize) -> u16 {
+    match d.get(at..at + 2) {
+        Some(b) => u16::from_be_bytes([b[0], b[1]]),
+        None => 0,
+    }
+}
+
+#[inline]
+pub fn i16_at(d: &[u8], at: usize) -> i16 {
+    u16_at(d, at) as i16
+}
+
+#[inline]
+pub fn u32_at(d: &[u8], at: usize) -> u32 {
+    match d.get(at..at + 4) {
+        Some(b) => u32::from_be_bytes([b[0], b[1], b[2], b[3]]),
+        None => 0,
+    }
+}
+
+#[inline]
+pub fn i32_at(d: &[u8], at: usize) -> i32 {
+    u32_at(d, at) as i32
+}
+
+#[inline]
+pub fn f32_at(d: &[u8], at: usize) -> f32 {
+    f32::from_bits(u32_at(d, at))
+}
+
+#[inline]
+pub fn put_u8(d: &mut [u8], at: usize, v: u8) {
+    if let Some(b) = d.get_mut(at) {
+        *b = v;
+    }
+}
+
+#[inline]
+pub fn put_u16(d: &mut [u8], at: usize, v: u16) {
+    if let Some(b) = d.get_mut(at..at + 2) {
+        b.copy_from_slice(&v.to_be_bytes());
+    }
+}
+
+#[inline]
+pub fn put_u32(d: &mut [u8], at: usize, v: u32) {
+    if let Some(b) = d.get_mut(at..at + 4) {
+        b.copy_from_slice(&v.to_be_bytes());
+    }
+}
+
+#[inline]
+pub fn put_i32(d: &mut [u8], at: usize, v: i32) {
+    put_u32(d, at, v as u32);
+}
+
+#[inline]
+pub fn put_f32(d: &mut [u8], at: usize, v: f32) {
+    put_u32(d, at, v.to_bits());
+}
+
+/// NUL-terminated Latin-1 string at `at`.
+pub fn cstr(d: &[u8], at: usize) -> String {
+    let tail = d.get(at..).unwrap_or(&[]);
+    let end = tail.iter().position(|&b| b == 0).unwrap_or(tail.len());
+    tail[..end].iter().map(|&b| b as char).collect()
+}
diff --git a/crates/skate-audio/src/bus/env.rs b/crates/skate-audio/src/bus/env.rs
new file mode 100644
index 00000000..f749c7a6
--- /dev/null
+++ b/crates/skate-audio/src/bus/env.rs
@@ -0,0 +1,587 @@
+//! The environment (reverb) network (spec `.claude/notes/aems-env-bus-spec.md`): the mono
+//! "EnvSendSub" bus every standard voice's Send A feeds, split into two sides A / B (for preset
+//! crossfades), each = EnvSub (gain → PeakingIir2) → RvrbSub (pre-delay → ReverbModel1 → gain →
+//! two filtered outputs panned 270° / 90° with LFE 0.5) + two echo taps (delay → HPF → LPF → gain
+//! → panner, delay and pan swept by the per-block LFO task), all into SFX Master.
+//!
+//! Presets: vault class `204CAC1FD77088B8` (`aud_reverb/reverbNN`, 44 values by record offset,
+//! applied as `sub_8248DD18` posts them); a preset change loads the new preset on the other side
+//! with weight 0 and crossfades the two side weights linearly over 1.0 s of game time
+//! (`sub_824DE548` timed fade, re-posted per frame).
+//!
+//! The reverb-zone emitters (type 5: zone fades, zone-to-zone, the pan rotation toward the zone)
+//! and retail's frame order are in [`super::zones`] ([`EnvNetwork::update`]); the global env-send
+//! scale from the Reverb owner in [`EnvNetwork::scale_frame`]; the FlangeSub returns in
+//! [`super::flange`].
+//!
+//! Not modelled (UNCERTAIN in the spec): the non-voice contributors other than the owner one-shot
+//! buses and the Collision SubMix, the module timer delay before a new reverb configuration is
+//! heard (applied at the next block here).
+use crate::BLOCK;
+use crate::dsp::biquad::{Iir2, Kind};
+use crate::dsp::delay::Delay;
+use crate::dsp::gain::Gain;
+use crate::dsp::pan::{self, Pan2D};
+use crate::dsp::peaking::PeakingIir2;
+use crate::dsp::reverb::ReverbModel1;
+use crate::dsp::send::RAMP_STEP;
+
+/// Block time step (256/48000 as f32, 0x3BAEC33E).
+const DT: f32 = BLOCK as f32 / 48000.0;
+/// 2π as the image holds it (0x820B411C).
+const TWO_PI: f32 = 6.283_185_5;
+/// The global env-send scale (manager +104) as the constructor writes it; per frame
+/// `sub_824DF220` rewrites it from the MixMap Reverb owner's out4 ([`EnvNetwork::scale_frame`]).
+pub const ENV_SCALE: f32 = 1.0;
+/// The crossfade length (s) between presets (0x8231A844).
+pub const FADE: f32 = 1.0;
+
+/// One preset: the 44 record values in offset order (offset = 4 × index).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Preset(pub [f32; 44]);
+
+impl Preset {
+    fn at(&self, offset: usize) -> f32 {
+        self.0[offset / 4]
+    }
+}
+
+/// A send level with Sen0's ramp: 64 samples to 64/65 of the way, flat after.
+#[derive(Clone, Copy, Debug)]
+pub struct Level {
+    pub target: f32,
+    current: f32,
+    started: bool,
+}
+
+impl Level {
+    pub fn new(target: f32) -> Self {
+        Self { target, current: target, started: false }
+    }
+
+    /// dst[k] += level(k) · src[k].
+    pub fn add(&mut self, src: &[f32], dst: &mut [f32]) {
+        if !self.started {
+            self.current = self.target;
+            self.started = true;
+        }
+        let (from, to) = (self.current, self.target);
+        if from == to {
+            if to != 0.0 {
+                for (d, &s) in dst.iter_mut().zip(src) {
+                    *d += to * s;
+                }
+            }
+        } else {
+            let step = (to - from) * RAMP_STEP;
+            let flat = from + 64.0 * step;
+            for (k, (d, &s)) in dst.iter_mut().zip(src).enumerate() {
+                *d += if k < 64 { from + k as f32 * step } else { flat } * s;
+            }
+        }
+        self.current = to;
+    }
+
+    pub fn silent(&self) -> bool {
+        self.target == 0.0 && self.current == 0.0
+    }
+}
+
+/// One LFO record (`sub_82490B60`): out = centre + depth · amount · sin(2π · phase / period).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Lfo {
+    pub period: f32,
+    pub phase: f32,
+    pub amount: f32,
+    pub centre: f32,
+    pub depth: f32,
+}
+
+impl Lfo {
+    fn template(centre: f32) -> Self {
+        Self { period: 1.0, phase: 0.0, amount: 0.5, centre, depth: centre }
+    }
+
+    /// One block: advance the phase (truncating fmod) and return the output.
+    pub fn step(&mut self) -> f32 {
+        let p = self.phase + DT;
+        self.phase = if self.period > 0.0 { p - (p / self.period).trunc() * self.period } else { 0.0 };
+        let x = if self.period > 0.0 { TWO_PI * self.phase / self.period } else { 0.0 };
+        self.centre + self.depth * self.amount * (x as f64).sin() as f32
+    }
+}
+
+fn period(rate: f32, min: f32) -> f32 {
+    if rate >= min { 1.0 / rate } else { 10.0 }
+}
+
+/// A filtered, panned output (rvrbfiltsub / the tail of rvrbdelaysub).
+#[derive(Clone, Debug)]
+struct Out {
+    hpf: Iir2,
+    lpf: Iir2,
+    gain: Gain,
+    pan: Pan2D,
+}
+
+impl Out {
+    fn new(azimuth: f32) -> Self {
+        let mut pan = Pan2D::new(1);
+        pan.params[pan::ANGLE] = azimuth;
+        pan.params[pan::DISTANCE] = 1.0;
+        pan.params[pan::LFE] = 0.5;
+        Self { hpf: Iir2::new(Kind::HighPass), lpf: Iir2::new(Kind::LowPass), gain: Gain::default(), pan }
+    }
+
+    fn set(&mut self, lpf: f32, hpf: f32, gain: f32) {
+        self.lpf.cutoff = lpf;
+        self.hpf.cutoff = hpf;
+        self.gain.target = gain;
+    }
+
+    /// Filter, gain, pan the mono block and add it into SFX Master.
+    fn render(&mut self, x: &mut [f32; BLOCK], master: &mut [[f32; BLOCK]; 6]) {
+        {
+            let mut planes: [&mut [f32]; 1] = [&mut x[..]];
+            self.hpf.process(&mut planes, 48000.0);
+            self.lpf.process(&mut planes, 48000.0);
+            self.gain.process(&mut planes);
+        }
+        let mut six = [[0.0f32; BLOCK]; 6];
+        self.pan.process(&[&x[..]], &mut six);
+        for (m, s) in master.iter_mut().zip(six.iter()) {
+            for (a, b) in m.iter_mut().zip(s.iter()) {
+                *a += b;
+            }
+        }
+    }
+}
+
+/// One side: EnvSub, RvrbSub with its two outputs, two echo taps, and its LFO records.
+#[derive(Clone, Debug)]
+pub struct Side {
+    /// EnvSendSub's Sen0 to this side (the crossfade weight).
+    pub weight: Level,
+    g_in: Gain,
+    eq: PeakingIir2,
+    s_rev: Level,
+    s_tap: [Level; 2],
+    predelay: Delay,
+    reverb: ReverbModel1,
+    g_rev: Gain,
+    outs: [Out; 2],
+    taps: [(Delay, Out); 2],
+    /// LFO records: EQ frequency, tap 1 / tap 2 delay, tap 1 / tap 2 azimuth.
+    pub lfo: [Lfo; 5],
+    pub preset: Option<u64>,
+}
+
+impl Side {
+    fn new(weight: f32) -> Self {
+        Self {
+            weight: Level::new(weight),
+            g_in: Gain::default(),
+            eq: PeakingIir2::default(),
+            s_rev: Level::new(1.0),
+            s_tap: [Level::new(1.0); 2],
+            predelay: Delay::new(0.16, 1),
+            reverb: ReverbModel1::default(),
+            g_rev: Gain::default(),
+            outs: [Out::new(270.0), Out::new(90.0)],
+            taps: [(Delay::new(0.46, 1), Out::new(270.0)), (Delay::new(0.46, 1), Out::new(90.0))],
+            lfo: [Lfo::template(1.0), Lfo::template(0.3), Lfo::template(0.3), Lfo::template(0.3), Lfo::template(0.3)],
+            preset: None,
+        }
+    }
+
+    /// The three EnvSub sends (→ reverb, → tap 1, → tap 2) of a preset, before the scale.
+    pub(crate) fn sends(p: &Preset) -> [f32; 3] {
+        [p.at(52), p.at(60), p.at(56)]
+    }
+
+    fn set_sends(&mut self, sends: [f32; 3], scale: f32) {
+        self.s_rev.target = sends[0] * scale;
+        self.s_tap[0].target = sends[1] * scale;
+        self.s_tap[1].target = sends[2] * scale;
+    }
+
+    /// `sub_8248DD18`: post a preset's values (the side weight is set by the caller); the sends
+    /// × the global env scale (manager +104).
+    pub fn apply(&mut self, key: u64, p: &Preset) {
+        self.apply_scaled(key, p, ENV_SCALE);
+    }
+
+    pub(crate) fn apply_scaled(&mut self, key: u64, p: &Preset, scale: f32) {
+        self.preset = Some(key);
+        self.g_in.target = p.at(84);
+        let f_eq = p.at(80);
+        self.eq.freq = f_eq;
+        let g = p.at(76);
+        self.eq.gain = if (0.1..=20.0).contains(&g) { g } else { 0.1 };
+        let q = p.at(64);
+        self.eq.q = if (0.2..=20.0).contains(&q) { q } else { 0.2 };
+        self.lfo[0] = Lfo { period: period(p.at(68), 0.1), phase: 0.0, amount: p.at(72), centre: f_eq, depth: f_eq };
+        self.set_sends(Self::sends(p), scale);
+        self.predelay.delay = p.at(12);
+        self.predelay.feedback = p.at(16);
+        self.reverb.time = p.at(20);
+        self.reverb.size = p.at(24);
+        self.reverb.brightness = p.at(32);
+        self.g_rev.target = p.at(28);
+        self.outs[0].set(p.at(36), p.at(40), p.at(44));
+        self.outs[1].set(p.at(0), p.at(4), p.at(8));
+        // Pn21 p0 of the two reverb outputs: the code constants 270 / 90 (a zone blend rotates
+        // them, `sub_824DEEF0`).
+        self.outs[0].pan.params[pan::ANGLE] = 270.0;
+        self.outs[1].pan.params[pan::ANGLE] = 90.0;
+        // Tap 1: delay +168, fb +172, delay LFO depth +156 / rate +152, LPF +148, HPF +160, gain +164.
+        let (d1, d2) = (p.at(168), p.at(128));
+        self.taps[0].0.delay = d1;
+        self.taps[0].0.feedback = p.at(172);
+        self.taps[0].1.set(p.at(148), p.at(160), p.at(164));
+        self.lfo[1] = Lfo { period: period(p.at(152), 0.01), phase: 0.0, amount: p.at(156), centre: d1, depth: d1 };
+        // Tap 2: delay +128, fb +132, depth +116 / rate +112, LPF +108, HPF +120, gain +124.
+        self.taps[1].0.delay = d2;
+        self.taps[1].0.feedback = p.at(132);
+        self.taps[1].1.set(p.at(108), p.at(120), p.at(124));
+        self.lfo[2] = Lfo { period: period(p.at(112), 0.01), phase: 0.0, amount: p.at(116), centre: d2, depth: d2 };
+        // The echo pans: rate +88, depth +92; tap 2 swings in the opposite phase.
+        let pan_period = period(p.at(88), 0.01);
+        self.lfo[3] = Lfo { period: pan_period, phase: 0.0, amount: p.at(92), centre: 270.0, depth: 90.0 };
+        self.lfo[4] = Lfo { period: pan_period, phase: pan_period / 2.0, amount: p.at(92), centre: 90.0, depth: 90.0 };
+    }
+
+    /// `sub_824DE400` → `sub_8248D770`: the per-frame re-post of a side's blend weight and its
+    /// reverb outputs' azimuths (the EQ frequency, tap delays and tap pans it also posts are
+    /// overwritten by the LFO task within the block).
+    pub(crate) fn post(&mut self, weight: f32, pans: [f32; 2]) {
+        self.weight.target = weight;
+        self.outs[0].pan.params[pan::ANGLE] = pans[0];
+        self.outs[1].pan.params[pan::ANGLE] = pans[1];
+    }
+
+    /// The reverb outputs' azimuths (filt L, filt R).
+    pub fn pans(&self) -> [f32; 2] {
+        [self.outs[0].pan.params[pan::ANGLE], self.outs[1].pan.params[pan::ANGLE]]
+    }
+
+    fn render(&mut self, input: &[f32; BLOCK], master: &mut [[f32; BLOCK]; 6]) {
+        // The LFO task runs every block whether or not anything sounds.
+        self.eq.freq = self.lfo[0].step();
+        self.taps[0].0.delay = self.lfo[1].step();
+        self.taps[1].0.delay = self.lfo[2].step();
+        self.taps[0].1.pan.params[pan::ANGLE] = self.lfo[3].step();
+        self.taps[1].1.pan.params[pan::ANGLE] = self.lfo[4].step();
+        let mut x = [0.0f32; BLOCK];
+        self.weight.add(input, &mut x);
+        {
+            let mut planes: [&mut [f32]; 1] = [&mut x[..]];
+            self.g_in.process(&mut planes);
+            self.eq.process(&mut planes, 48000.0);
+        }
+        let mut rev = [0.0f32; BLOCK];
+        self.s_rev.add(&x, &mut rev);
+        {
+            let mut planes: [&mut [f32]; 1] = [&mut rev[..]];
+            self.predelay.process(&mut planes);
+        }
+        self.reverb.process(&mut rev);
+        {
+            let mut planes: [&mut [f32]; 1] = [&mut rev[..]];
+            self.g_rev.process(&mut planes);
+        }
+        for out in &mut self.outs {
+            let mut copy = rev;
+            out.render(&mut copy, master);
+        }
+        for (k, (delay, out)) in self.taps.iter_mut().enumerate() {
+            let mut tap = [0.0f32; BLOCK];
+            self.s_tap[k].add(&x, &mut tap);
+            {
+                let mut planes: [&mut [f32]; 1] = [&mut tap[..]];
+                delay.process(&mut planes);
+            }
+            out.render(&mut tap, master);
+        }
+    }
+}
+
+/// The whole network plus the preset selection.
+#[derive(Clone, Debug)]
+pub struct EnvNetwork {
+    pub sides: [Side; 2],
+    pub presets: std::collections::HashMap<u64, Preset>,
+    /// The side currently in use, and the running fade (target side, elapsed s).
+    pub current: usize,
+    pub fade: Option<(usize, f32)>,
+    /// Manager +104, the global env-send scale (1.0 until [`EnvNetwork::scale_frame`]).
+    pub scale: f32,
+    /// The sends of the last applied preset (the parameter block at manager +868 + 32..40).
+    pub(crate) last_sends: Option<[f32; 3]>,
+    /// `SFXObj_Reverb`'s retail state machine ([`EnvNetwork::update`]); unused by the
+    /// `request` / `frame` path.
+    pub selector: super::zones::Selector,
+}
+
+impl Default for EnvNetwork {
+    fn default() -> Self {
+        Self { sides: [Side::new(1.0), Side::new(0.0)], presets: Default::default(), current: 0, fade: None, scale: ENV_SCALE, last_sends: None, selector: Default::default() }
+    }
+}
+
+/// `sub_824DF390`'s jump table (`0x824DF3D0`): a preset's number (record `+48`, the NN of
+/// reverbNN, 1..24) → the MixMap Reverb input `sub_824DF468` raises to 32767 (the other six are
+/// written 0 the same frame); 0 or > 24 → none.
+pub fn reverb_input(number: i32) -> Option<usize> {
+    match number {
+        1..=5 => Some(4),
+        6..=8 => Some(0),
+        9 | 13 | 14 | 17 | 18 => Some(1),
+        10 => Some(2),
+        21 => Some(3),
+        11 | 12 | 15 | 16 | 22 => Some(5),
+        19 | 20 | 23 | 24 => Some(6),
+        _ => None,
+    }
+}
+
+/// reverb01, the preset when the region layer gives none (`A2782D75A971CC8C`).
+pub const DEFAULT_PRESET: u64 = 0xA278_2D75_A971_CC8C;
+
+impl EnvNetwork {
+    /// Presets loaded: the network renders; without any it stays silent (no wet path).
+    pub fn enabled(&self) -> bool {
+        !self.presets.is_empty()
+    }
+
+    /// The preset key in use (or being faded to).
+    pub fn key(&self) -> Option<u64> {
+        match self.fade {
+            Some((t, _)) => self.sides[t].preset,
+            None => self.sides[self.current].preset,
+        }
+    }
+
+    /// Ask for a preset (per game frame): starts a 1 s fade on the other side when it differs from
+    /// the current one and no fade runs (`sub_824DE548` / `sub_824DE468`). The very first preset
+    /// is applied at once on the current side.
+    pub fn request(&mut self, key: u64) {
+        let key = if self.presets.contains_key(&key) { key } else { DEFAULT_PRESET };
+        let Some(p) = self.presets.get(&key).copied() else { return };
+        if self.fade.is_some() || self.sides[self.current].preset == Some(key) {
+            return;
+        }
+        self.last_sends = Some(Side::sends(&p));
+        if self.sides[self.current].preset.is_none() {
+            self.sides[self.current].apply_scaled(key, &p, self.scale);
+            return;
+        }
+        let target = 1 - self.current;
+        self.sides[target].apply_scaled(key, &p, self.scale);
+        self.sides[target].weight.target = 0.0;
+        self.fade = Some((target, 0.0));
+    }
+
+    /// The per-frame fade step (`sub_824DE850`): weights new = x, old = 1 − x, x = elapsed / 1 s.
+    pub fn frame(&mut self, dt: f32) {
+        let Some((target, elapsed)) = self.fade else { return };
+        let elapsed = elapsed + dt;
+        let x = (elapsed / FADE).min(1.0);
+        self.sides[target].weight.target = x;
+        self.sides[1 - target].weight.target = 1.0 - x;
+        if x >= 1.0 {
+            self.current = target;
+            self.fade = None;
+        } else {
+            self.fade = Some((target, elapsed));
+        }
+    }
+
+    /// The preset on the side being faded to (`+420`; the current one when no fade runs): what
+    /// `sub_824DF390` reads.
+    pub fn target_key(&self) -> Option<u64> {
+        let side = if self.selector.active() { self.selector.target_side() } else { self.fade.map_or(self.current, |(t, _)| t) };
+        self.sides[side].preset
+    }
+
+    /// `sub_824DF468` (first step of `SFXObj_Reverb`'s update `sub_824DE548`, before the MixMap
+    /// tick): Reverb.in0..in6 = 0, then the input of the target side's preset number
+    /// ([`reverb_input`]) = 32767. All 0 without presets.
+    pub fn reverb_inputs(&self) -> [i32; 7] {
+        let mut v = [0; 7];
+        let number = self.target_key().and_then(|k| self.presets.get(&k)).map(|p| p.at(48) as i32);
+        if let Some(i) = number.and_then(reverb_input) {
+            v[i] = 32767;
+        }
+        v
+    }
+
+    /// `sub_824DF220` → `sub_8248DB78`, per game frame after the MixMap tick: the global scale =
+    /// the Reverb owner's out4 / 32767, and the EnvSub sends of the side being faded to and of the
+    /// current side are re-posted as the *last applied* preset's sends × the scale (during a fade
+    /// the old side takes the new preset's sends: retail keeps one parameter block). Optional: a
+    /// host that never calls it keeps the constructor's 1.0 and the per-side sends.
+    pub fn scale_frame(&mut self, out4: i32) {
+        self.scale = out4 as f32 * crate::dsp::INV_32767;
+        let Some(sends) = self.last_sends else { return };
+        let (target, current) = if self.selector.active() {
+            (self.selector.target_side(), self.current)
+        } else {
+            (self.fade.map_or(self.current, |(t, _)| t), self.current)
+        };
+        self.sides[target].set_sends(sends, self.scale);
+        if target != current {
+            self.sides[current].set_sends(sends, self.scale);
+        }
+    }
+
+    /// Render one block of the mono env input into SFX Master.
+    pub fn render(&mut self, input: &[f32; BLOCK], master: &mut [[f32; BLOCK]; 6]) {
+        if !self.enabled() {
+            return;
+        }
+        for side in &mut self.sides {
+            if side.preset.is_some() {
+                side.render(input, master);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn reverb01() -> Preset {
+        // reverb01's values by offset (the user's vault; only the first preset, for the test).
+        Preset([
+            4000.0, 600.0, 1.0, 0.08, 0.0, 1.5, 70.0, 1.0, 0.7, 4000.0, 500.0, 1.0, 1.0, 0.25, 1.0, 1.0, 3.0, 0.1, 0.34, 1.0, 1161.0,
+            0.5, 0.2, 0.6, 1.0, 1.0, 270.0, 5000.0, 0.5, 0.45, 500.0, 0.75, 0.3, 0.3, 1.0, 1.0, 90.0, 5000.0, 0.51, 0.5, 500.0, 0.75,
+            0.28, 0.25,
+        ])
+    }
+
+    #[test]
+    fn an_impulse_comes_back_as_a_wet_tail_on_the_sides() {
+        let mut env = EnvNetwork::default();
+        env.presets.insert(DEFAULT_PRESET, reverb01());
+        env.request(0x1234); // unknown → reverb01
+        assert_eq!(env.key(), Some(DEFAULT_PRESET));
+        let mut first = true;
+        let mut energy = [0.0f32; 6];
+        for _ in 0..200 {
+            let mut input = [0.0f32; BLOCK];
+            if first {
+                input[0] = 1.0;
+                first = false;
+            }
+            let mut master = [[0.0f32; BLOCK]; 6];
+            env.render(&input, &mut master);
+            for (e, ch) in energy.iter_mut().zip(master.iter()) {
+                *e += ch.iter().map(|v| v * v).sum::<f32>();
+            }
+        }
+        // The reverb and echoes sit left and right (Ls/L, Rs/R); LFE gets 0.5 of each.
+        assert!(energy[3] > 0.0 && energy[4] > 0.0 && energy[5] > 0.0, "{energy:?}");
+        assert!(energy[3] > energy[1] * 10.0, "centre stays (nearly) dry: {energy:?}");
+    }
+
+    #[test]
+    fn the_reverb_owner_scales_the_sends_of_the_last_applied_preset() {
+        let mut env = EnvNetwork::default();
+        let mut other = reverb01();
+        other.0[13] = 0.5; // +52 s_rev
+        env.presets.insert(DEFAULT_PRESET, reverb01());
+        env.presets.insert(7, other);
+        env.request(DEFAULT_PRESET);
+        assert_eq!(env.sides[0].s_rev.target, 0.25);
+        env.scale_frame(32730);
+        let scale = 32730.0 * crate::dsp::INV_32767;
+        assert_eq!(env.sides[0].s_rev.target, 0.25 * scale);
+        // A fade to preset 7: the new side is applied at the current scale, and the per-frame
+        // re-post gives both sides preset 7's sends.
+        env.request(7);
+        assert_eq!(env.sides[1].s_rev.target, 0.5 * scale);
+        assert_eq!(env.sides[0].s_rev.target, 0.25 * scale);
+        env.scale_frame(32730);
+        assert_eq!(env.sides[0].s_rev.target, 0.5 * scale);
+        assert_eq!(env.sides[0].s_tap[0].target, 1.0 * scale);
+    }
+
+    #[test]
+    fn the_reverb_inputs_follow_the_preset_being_faded_to() {
+        let mut env = EnvNetwork::default();
+        assert_eq!(env.reverb_inputs(), [0; 7], "no presets: nothing raised");
+        let mut eleven = reverb01();
+        eleven.0[12] = 11.0; // reverb11 (the zones' BEEFC8E3DE04FBAE)
+        let mut nine = reverb01();
+        nine.0[12] = 9.0;
+        env.presets.insert(DEFAULT_PRESET, reverb01());
+        env.presets.insert(11, eleven);
+        env.presets.insert(9, nine);
+        env.request(DEFAULT_PRESET);
+        assert_eq!(env.reverb_inputs(), [0, 0, 0, 0, 32767, 0, 0], "reverb01 → in4");
+        env.request(11);
+        assert_eq!(env.reverb_inputs(), [0, 0, 0, 0, 0, 32767, 0], "the target side's preset, from the fade's start");
+        for _ in 0..61 {
+            env.frame(1.0 / 60.0);
+        }
+        assert_eq!(env.reverb_inputs()[5], 32767, "committed");
+        env.request(9);
+        assert_eq!(env.reverb_inputs(), [0, 32767, 0, 0, 0, 0, 0]);
+        let table: Vec<Option<usize>> = (0..=25).map(reverb_input).collect();
+        assert_eq!(table[0], None);
+        assert_eq!(table[25], None);
+        assert_eq!((1..=24).filter(|&n| reverb_input(n) == Some(5)).collect::<Vec<_>>(), vec![11, 12, 15, 16, 22]);
+    }
+
+    #[test]
+    fn a_new_preset_fades_in_over_one_second() {
+        let mut env = EnvNetwork::default();
+        let mut other = reverb01();
+        other.0[5] = 1.04;
+        env.presets.insert(DEFAULT_PRESET, reverb01());
+        env.presets.insert(7, other);
+        env.request(DEFAULT_PRESET);
+        env.request(7);
+        assert_eq!(env.fade, Some((1, 0.0)));
+        env.request(DEFAULT_PRESET); // ignored while fading
+        for _ in 0..30 {
+            env.frame(1.0 / 60.0);
+        }
+        assert!((env.sides[1].weight.target - 0.5).abs() < 1e-3);
+        for _ in 0..31 {
+            env.frame(1.0 / 60.0);
+        }
+        assert_eq!((env.current, env.fade), (1, None));
+        assert_eq!(env.sides[0].weight.target, 0.0);
+        let mut lfo = Lfo { period: 1.0, phase: 0.0, amount: 0.5, centre: 1.0, depth: 1.0 };
+        let first = lfo.step();
+        assert!((first - (1.0 + 0.5 * (TWO_PI * DT).sin())).abs() < 1e-6);
+    }
+}
+
+#[cfg(test)]
+mod timing {
+    use super::*;
+
+    #[test]
+    #[ignore = "timing print"]
+    fn first_blocks_cost() {
+        let mut env = EnvNetwork::default();
+        env.presets.insert(DEFAULT_PRESET, Preset([
+            4000.0, 600.0, 1.0, 0.08, 0.0, 1.5, 70.0, 1.0, 0.7, 4000.0, 500.0, 1.0, 1.0, 0.25, 1.0, 1.0, 3.0, 0.1, 0.34, 1.0, 1161.0,
+            0.5, 0.2, 0.6, 1.0, 1.0, 270.0, 5000.0, 0.5, 0.45, 500.0, 0.75, 0.3, 0.3, 1.0, 1.0, 90.0, 5000.0, 0.51, 0.5, 500.0, 0.75,
+            0.28, 0.25,
+        ]));
+        let t = std::time::Instant::now();
+        env.request(DEFAULT_PRESET);
+        println!("request {:?}", t.elapsed());
+        for b in 0..5 {
+            let t = std::time::Instant::now();
+            let mut master = [[0.0f32; BLOCK]; 6];
+            env.render(&[0.1; BLOCK], &mut master);
+            println!("block {b}: {:?}", t.elapsed());
+        }
+    }
+}
diff --git a/crates/skate-audio/src/bus/eqchain.rs b/crates/skate-audio/src/bus/eqchain.rs
new file mode 100644
index 00000000..6063e8fe
--- /dev/null
+++ b/crates/skate-audio/src/bus/eqchain.rs
@@ -0,0 +1,152 @@
+//! The eight eEQChain ("material") buses (spec `.claude/notes/aems-eqchain-buses-spec.md`): per bus
+//! `Sub0 → DCl0 → PeakingIir2 → PeakingIir2 → Sen0 (→ SFX Master)`, 6 channels, order 253.
+//!
+//! - Buses with the record's enable flag (0–4): the first create-flagged resolve after a clear
+//!   re-rolls the six EQ values (`sub_824916E8`): each = b + (k·(a − b))·0.1 with k = r mod 11 from
+//!   the title generator (no draw when a == b), in the order PI20#1 freq, gain, Q, PI20#2 freq,
+//!   gain, Q, then the clip level.
+//! - Buses without it (5–7): every clear posts the shared jitter walk's values (`sub_82491180`):
+//!   freq clamped 0..96000, gain 0.1..20, Q 0.2..20, clip 0..1000.
+//! - The clear (`sub_82491180`) runs on every second game frame (both halves on frames longer than
+//!   20 ms) and resets every created flag.
+//! - Index 8 = SFX Master (no EQ).
+use crate::BLOCK;
+use crate::dsp::peaking::{PeakingIir2, clip};
+use crate::eval::rng::Rng;
+
+/// One bus's vault record (class `AA801D9FC0ADBBBF`, collection from the image table 0x8224DC78).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct EqRecord {
+    pub enabled: bool,
+    pub clip: f32,
+    /// (a, b) per value: PI20#1 freq, gain, Q, PI20#2 freq, gain, Q.
+    pub ranges: [[f32; 2]; 6],
+}
+
+#[derive(Clone, Debug)]
+pub struct EqBus {
+    pub record: Option<EqRecord>,
+    pub created: bool,
+    pub level: f32,
+    pub eq: [PeakingIir2; 2],
+}
+
+impl Default for EqBus {
+    fn default() -> Self {
+        Self { record: None, created: false, level: 100.0, eq: [PeakingIir2::default(), PeakingIir2::default()] }
+    }
+}
+
+/// `sub_82491DF0`: one value on the 11-point grid between b and a.
+pub fn pick(a: f32, b: f32, rng: &mut Rng) -> f32 {
+    if a == b {
+        return b;
+    }
+    let k = (rng.draw() % 11) as f32;
+    (k * (a - b)).mul_add(f32::from_bits(0x3DCC_CCCD), b)
+}
+
+pub struct EqBuses {
+    pub buses: [EqBus; 8],
+    pub rng: Rng,
+    /// Re-rolls so far (diagnostics).
+    pub rolls: u64,
+}
+
+impl Default for EqBuses {
+    fn default() -> Self {
+        // Our own instance of the title generator, seeded like the evaluator's.
+        Self { buses: Default::default(), rng: Rng::new([0x0F1E_2D3C, 0x4B5A_6978, 0x8796_A5B4, 0xC3D2_E1F0, 0x1357_9BDF, 0x2468_ACE0]), rolls: 0 }
+    }
+}
+
+impl EqBuses {
+    pub fn set_records(&mut self, records: &[EqRecord]) {
+        for (bus, r) in self.buses.iter_mut().zip(records) {
+            bus.record = Some(*r);
+        }
+    }
+
+    /// `sub_82491108`: a voice or owner resolves bus `idx`; `create` re-rolls a fresh preset on the
+    /// first use since the last clear.
+    pub fn resolve(&mut self, idx: u8, create: bool) {
+        let Some(bus) = self.buses.get_mut(usize::from(idx)) else { return };
+        if !create || bus.created {
+            return;
+        }
+        bus.created = true;
+        let Some(r) = bus.record.filter(|r| r.enabled) else { return };
+        let v: Vec<f32> = r.ranges.iter().map(|[a, b]| pick(*a, *b, &mut self.rng)).collect();
+        for (k, eq) in bus.eq.iter_mut().enumerate() {
+            eq.freq = v[3 * k];
+            eq.gain = v[3 * k + 1];
+            eq.q = v[3 * k + 2];
+        }
+        bus.level = r.clip;
+        self.rolls += 1;
+    }
+
+    /// `sub_82491180` (every second game frame): post the jitter values (PI20#1 freq, gain, Q,
+    /// PI20#2 freq, gain, Q) to the buses without the enable flag, then clear every created flag.
+    pub fn clear(&mut self, jitter: Option<[f32; 6]>) {
+        for bus in &mut self.buses {
+            if let (Some(r), Some(j)) = (bus.record, jitter) {
+                if !r.enabled {
+                    for (k, eq) in bus.eq.iter_mut().enumerate() {
+                        eq.freq = j[3 * k].clamp(0.0, 96_000.0);
+                        eq.gain = j[3 * k + 1].clamp(0.1, 20.0);
+                        eq.q = j[3 * k + 2].clamp(0.2, 20.0);
+                    }
+                    bus.level = r.clip.clamp(0.0, 1000.0);
+                }
+            }
+            bus.created = false;
+        }
+    }
+
+    /// Process the eight bus inputs and add them into SFX Master.
+    pub fn render(&mut self, inputs: &mut [[[f32; BLOCK]; 6]; 8], master: &mut [[f32; BLOCK]; 6]) {
+        for (bus, input) in self.buses.iter_mut().zip(inputs.iter_mut()) {
+            {
+                let mut planes: Vec<&mut [f32]> = input.iter_mut().map(|c| &mut c[..]).collect();
+                clip(&mut planes, bus.level);
+                bus.eq[0].process(&mut planes, 48000.0);
+                bus.eq[1].process(&mut planes, 48000.0);
+            }
+            for (m, s) in master.iter_mut().zip(input.iter()) {
+                for (a, b) in m.iter_mut().zip(s.iter()) {
+                    *a += b;
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rerolls_sit_on_the_11_point_grid_once_per_clear() {
+        let mut eq = EqBuses::default();
+        let bus0 = EqRecord { enabled: true, clip: 100.0, ranges: [[450.0, 150.0], [1.5, 0.75], [3.0, 0.25], [5000.0, 1500.0], [1.25, 0.9], [2.0, 0.25]] };
+        let jittered = EqRecord { enabled: false, ..bus0 };
+        eq.set_records(&[bus0, bus0, bus0, bus0, bus0, jittered, jittered, jittered]);
+        for _ in 0..50 {
+            eq.resolve(0, true);
+            let f = eq.buses[0].eq[0].freq;
+            let k = (f - 150.0) / 30.0;
+            assert!((k - k.round()).abs() < 1e-4 && (0.0..=10.0).contains(&k), "{f}");
+            let before = eq.buses[0].eq[0].freq;
+            eq.resolve(0, true);
+            assert_eq!(eq.buses[0].eq[0].freq, before, "one roll per clear");
+            eq.clear(None);
+        }
+        assert_eq!(eq.rolls, 50);
+        eq.resolve(1, false);
+        assert_eq!(eq.buses[1].eq[0].gain, 1.0, "no create: class defaults (bypass)");
+        eq.clear(Some([5000.0, 30.0, 0.1, 2000.0, 1.75, 3.0]));
+        assert_eq!((eq.buses[5].eq[0].freq, eq.buses[5].eq[0].gain, eq.buses[5].eq[0].q), (5000.0, 20.0, 0.2));
+        assert_eq!(eq.buses[0].eq[0].gain, eq.buses[0].eq[0].gain);
+    }
+}
diff --git a/crates/skate-audio/src/bus/flange.rs b/crates/skate-audio/src/bus/flange.rs
new file mode 100644
index 00000000..20c877bd
--- /dev/null
+++ b/crates/skate-audio/src/bus/flange.rs
@@ -0,0 +1,239 @@
+//! The two "FlangeSub" effect returns (spec `.claude/notes/aems-bus-leftovers-spec.md` §1; builder
+//! `sub_82490270`, presets `sub_824DDF58` → `sub_8248FE68`, levels `sub_824DF220` → `sub_8248FFF8`,
+//! sweeps by the LFO task `sub_82490B60` records 11–14).
+//!
+//! Per return (graph order 150, mono): `Sub0 → Del0 (max 15 ms) → PI20 → Sen0 (→ env bus) → Gai0 →
+//! Pn21 (1 → 6) → Sen0 (→ SFX Master)`.
+//! - Voices whose routing records hold 4096 / 8192 (return A) or 16384 (return B) followed by an
+//!   enable record of 1 get a Send B after their Gain: the post-gain channels summed to mono
+//!   (routes N → 1 at unity, LFE dropped) at property 11 / 32767 (posted 0 at open).
+//! - Del0's delay is swept every block: d(t) = d₀ + d₀·depth·sin(2π·t·rate) (record fields +20,
+//!   +28, +24), whole samples with Del0's 128-sample tap crossfade; feedback stays at the class
+//!   default 0 (nothing posts it). Retail's dry voice plus this short, moving copy is a flanger.
+//! - PI20's frequency is swept the same way (+16, +8, +4) but its gain is never posted: class
+//!   default 1.0 = bypass.
+//! - Levels per game frame from the MixMap's Reverb owner (`0x40050000`): A gain = out0, A env
+//!   send = out1, B gain = out2, B env send = out3 (each / 32767). Class defaults (1.0 / 1.0)
+//!   until the first frame.
+//! - Pn21: parameter 0 posted from manager +124 / +160, which nothing we found writes (zeroed
+//!   allocation assumed): azimuth 0 on the speaker circle, i.e. the centre. UNCERTAIN.
+//! - A return renders only in blocks where some voice sends into it (retail's trace shows return
+//!   A's modules processed only in bursts); its LFO records advance every block regardless.
+use crate::BLOCK;
+use crate::bus::env::{Level, Lfo};
+use crate::dsp::delay::Delay;
+use crate::dsp::gain::Gain;
+use crate::dsp::pan::Pan2D;
+use crate::dsp::peaking::PeakingIir2;
+
+/// 1/32767 (0x822F8898).
+const INV_32767: f32 = crate::dsp::INV_32767;
+
+/// One return's vault record (class `4CDD7CDC1A955D5C`; collection `C6290FFCB9E84CD9` = return A
+/// (type 12288), `DFDFFAD67CCBA322` = return B (16384)): the nine values by record offset 0..32.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct FlangePreset(pub [f32; 9]);
+
+impl FlangePreset {
+    fn at(&self, offset: usize) -> f32 {
+        self.0[offset / 4]
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct FlangeReturn {
+    delay: Delay,
+    eq: PeakingIir2,
+    /// LFO records 11/13 (Del0 p0) and 12/14 (PI20 p0).
+    pub lfo_delay: Lfo,
+    pub lfo_eq: Lfo,
+    /// Sen0 → env bus (Reverb out1 / out3).
+    pub env: Level,
+    /// Gai0 (Reverb out0 / out2).
+    gain: Gain,
+    pan: Pan2D,
+    pub preset: Option<FlangePreset>,
+}
+
+impl Default for FlangeReturn {
+    fn default() -> Self {
+        // `sub_824907D8` templates: period 1 s, amount 0.5, centre = depth (6 ms / 1.0).
+        let template = |centre| Lfo { period: 1.0, phase: 0.0, amount: 0.5, centre, depth: centre };
+        Self {
+            delay: Delay::new(0.015, 1),
+            eq: PeakingIir2::default(),
+            lfo_delay: template(0.006),
+            lfo_eq: template(1.0),
+            env: Level::new(1.0),
+            gain: Gain::default(),
+            pan: Pan2D::new(1),
+            preset: None,
+        }
+    }
+}
+
+impl FlangeReturn {
+    /// `sub_8248FE68`: the LFO records from the preset (periods 1/rate, phase 0).
+    pub fn apply(&mut self, p: &FlangePreset) {
+        self.preset = Some(*p);
+        self.lfo_delay = Lfo { period: 1.0 / p.at(24), phase: 0.0, amount: p.at(28), centre: p.at(20), depth: p.at(20) };
+        self.lfo_eq = Lfo { period: 1.0 / p.at(4), phase: 0.0, amount: p.at(8), centre: p.at(16), depth: p.at(16) };
+    }
+
+    /// `sub_8248FFF8`: the per-frame levels (Q15 words of the Reverb owner).
+    pub fn set_levels(&mut self, gain: i32, env: i32) {
+        self.gain.target = gain as f32 * INV_32767;
+        self.env.target = env as f32 * INV_32767;
+    }
+
+    /// One block: the LFO task's posts, then (when `active`) the graph on `input` (mono), adding
+    /// its env send into `env_in` and its panned output into SFX Master.
+    pub fn render(&mut self, input: &mut [f32; BLOCK], active: bool, env_in: &mut [f32; BLOCK], master: &mut [[f32; BLOCK]; 6]) {
+        self.delay.delay = self.lfo_delay.step();
+        self.eq.freq = self.lfo_eq.step();
+        if !active {
+            return;
+        }
+        {
+            let mut planes: [&mut [f32]; 1] = [&mut input[..]];
+            self.delay.process(&mut planes);
+            self.eq.process(&mut planes, 48000.0);
+        }
+        self.env.add(&input[..], &mut env_in[..]);
+        {
+            let mut planes: [&mut [f32]; 1] = [&mut input[..]];
+            self.gain.process(&mut planes);
+        }
+        let mut six = [[0.0f32; BLOCK]; 6];
+        self.pan.process(&[&input[..]], &mut six);
+        for (m, s) in master.iter_mut().zip(six.iter()) {
+            for (a, b) in m.iter_mut().zip(s.iter()) {
+                *a += b;
+            }
+        }
+    }
+}
+
+/// Both returns. Disabled (no presets) = no Send B anywhere: renders stay as without the returns.
+#[derive(Clone, Debug, Default)]
+pub struct FlangeReturns {
+    pub returns: [FlangeReturn; 2],
+    enabled: bool,
+}
+
+impl FlangeReturns {
+    /// Load the two presets (A, B) and enable the returns.
+    pub fn set_presets(&mut self, a: FlangePreset, b: FlangePreset) {
+        self.returns[0].apply(&a);
+        self.returns[1].apply(&b);
+        self.enabled = true;
+    }
+
+    pub fn enabled(&self) -> bool {
+        self.enabled
+    }
+
+    /// `sub_824DF220` (SFXObj_Reverb's update, after the MixMap tick): the Reverb owner's outputs
+    /// 0..3 (A gain, A env send, B gain, B env send).
+    pub fn frame(&mut self, reverb: [i32; 4]) {
+        self.returns[0].set_levels(reverb[0], reverb[1]);
+        self.returns[1].set_levels(reverb[2], reverb[3]);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The user's vault values by offset (for the tests only).
+    pub(crate) const A: FlangePreset = FlangePreset([20.0, 0.3, 0.2, 0.1, 1500.0, 0.002, 0.5, 0.9, 0.03]);
+    pub(crate) const B: FlangePreset = FlangePreset([1.7, 0.3, 0.0, 1.0, 250.0, 0.0005, 0.25, 0.6, 0.11]);
+
+    #[test]
+    fn the_delay_sweeps_between_the_preset_bounds_and_the_output_is_centred() {
+        let mut fx = FlangeReturns::default();
+        fx.set_presets(A, B);
+        fx.frame([32692, 2313, 32692, 2313]);
+        let (mut lo, mut hi) = (f32::MAX, f32::MIN);
+        let mut env_total = 0.0f32;
+        let mut energy = [0.0f32; 6];
+        for b in 0..400 {
+            let mut input = [0.0f32; BLOCK];
+            input[0] = if b % 8 == 0 { 1.0 } else { 0.0 };
+            let mut env_in = [0.0f32; BLOCK];
+            let mut master = [[0.0f32; BLOCK]; 6];
+            fx.returns[0].render(&mut input, true, &mut env_in, &mut master);
+            lo = lo.min(fx.returns[0].delay.delay);
+            hi = hi.max(fx.returns[0].delay.delay);
+            env_total += env_in.iter().map(|v| v.abs()).sum::<f32>();
+            for (e, ch) in energy.iter_mut().zip(master.iter()) {
+                *e += ch.iter().map(|v| v * v).sum::<f32>();
+            }
+        }
+        // 2 ms ± 90 % at 0.5 Hz (400 blocks = 2.1 s covers a whole period).
+        assert!((lo - 0.0002).abs() < 2e-5 && (hi - 0.0038).abs() < 2e-5, "{lo} {hi}");
+        assert!(env_total > 0.0);
+        assert!(energy[1] > 0.0 && energy.iter().enumerate().all(|(i, &e)| i == 1 || e == 0.0), "{energy:?}");
+    }
+
+    #[test]
+    fn the_reverb_owner_gives_the_retail_free_skate_levels() {
+        use crate::mixmap::{MixMap, keys};
+        let bytes = std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/private/audio/aems/MixMapSK8.mxb"));
+        let Ok(bytes) = bytes else { return eprintln!("skipped: no MixMap") };
+        let levels = |in5: i32| {
+            let mut m = MixMap::from_bytes(&bytes).unwrap();
+            for _ in 0..30 {
+                for id in 1..=4 {
+                    m.set_input(keys::MASTER, id, 32767);
+                }
+                for id in [1, 2, 5] {
+                    m.set_input(keys::MUSIC, id, 32767);
+                }
+                m.set_input(keys::REVERB, 5, in5);
+                m.tick(1.0 / 60.0);
+            }
+            (0..5).map(|k| m.level(keys::REVERB, k)).collect::<Vec<i32>>()
+        };
+        // Retail (all_20261002_163809): return B gain 0.9977 outside pauses, return env sends
+        // 0.0706, EnvSub sends = preset × 0.9989 (manager +104 = out4 = 0 mB).
+        let out = levels(0);
+        assert_eq!(out, vec![32692, 2313, 32692, 2313, 32730]);
+        assert!((out[0] as f32 * INV_32767 - 0.9977).abs() < 1e-4 && (out[1] as f32 * INV_32767 - 0.0706).abs() < 1e-4);
+        // With Reverb.in5 = 32767 (what the hosts write today, from PR #4's capture statistics)
+        // F213 holds out4 at −400 mB: the env scale would be 0.63, which the retail trace rules out.
+        assert_eq!(levels(32767)[4], 20603);
+    }
+
+    #[test]
+    fn an_impulse_comes_back_delayed_by_whole_samples() {
+        let mut r = FlangeReturn::default();
+        r.apply(&B);
+        r.set_levels(32767, 0);
+        let mut input = [0.0f32; BLOCK];
+        input[0] = 1.0;
+        let mut env_in = [0.0f32; BLOCK];
+        let mut master = [[0.0f32; BLOCK]; 6];
+        r.render(&mut input, true, &mut env_in, &mut master);
+        let d = (r.delay.delay * 48000.0).round() as usize;
+        assert!((10..=38).contains(&d), "{d}");
+        let peak = master[1].iter().position(|&v| v != 0.0).unwrap();
+        assert_eq!(peak, d);
+        assert!((master[1][d] - 1.0).abs() < 1e-6);
+        assert!(env_in.iter().all(|&v| v == 0.0), "env send 0");
+    }
+
+    #[test]
+    fn an_inactive_return_only_advances_its_sweeps() {
+        let mut r = FlangeReturn::default();
+        r.apply(&A);
+        let before = r.lfo_delay.phase;
+        let mut input = [1.0f32; BLOCK];
+        let mut env_in = [0.0f32; BLOCK];
+        let mut master = [[0.0f32; BLOCK]; 6];
+        r.render(&mut input, false, &mut env_in, &mut master);
+        assert_ne!(r.lfo_delay.phase, before);
+        assert!(master.iter().all(|c| c.iter().all(|&v| v == 0.0)));
+        assert!(env_in.iter().all(|&v| v == 0.0));
+    }
+}
diff --git a/crates/skate-audio/src/bus/mod.rs b/crates/skate-audio/src/bus/mod.rs
new file mode 100644
index 00000000..46b8ee7b
--- /dev/null
+++ b/crates/skate-audio/src/bus/mod.rs
@@ -0,0 +1,111 @@
+//! The buses behind the voices (specs `.claude/notes/aems-env-bus-spec.md`,
+//! `.claude/notes/aems-eqchain-buses-spec.md`): per block, voices add into the mono environment
+//! input (their pre-gain Send A, and the owner one-shot buses' env send), into one of the eight
+//! eEQChain buses or straight into SFX Master; then the environment network (orders 199–202) and
+//! the eEQChain buses (253) render into SFX Master (254: gain 1, filters open — an identity in
+//! retail's traces), which the output stage folds. Voices with an effect routing record also feed
+//! one of the two FlangeSub returns (order 150, [`flange`]), which send on into the env input and
+//! SFX Master.
+pub mod env;
+pub mod eqchain;
+pub mod flange;
+pub mod submix;
+pub mod zones;
+
+use crate::BLOCK;
+
+/// Where a voice's final 6-channel Send goes.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Output {
+    /// SFX Master (eEQChain 8, the default bus).
+    #[default]
+    Master,
+    /// eEQChain bus 0..7.
+    Eq(u8),
+    /// A FootStep SubMix graph ([`submix`]; mono: route it with [`Route::mono`]). It sends on into
+    /// the env bus and SFX Master. Falls back to SFX Master when the graph was never built.
+    Submix(u8),
+}
+
+/// How a direct (Splice / stream) voice is routed: its output bus, whether resolving it may
+/// re-roll the bus's EQ (`create`), and the env send of the owner one-shot bus it plays through
+/// (`sub_82488DD0`: Sub0 → Sen0 env at the owner's level → Sen0 to the eEQChain bus), 0 = none.
+/// `mono`: that bus is mono (the collision manager's per-voice "Collision SubMix",
+/// `sub_824D25E0`): the voice's six channels sum into it (routes 6 → 1, LFE dropped) and it sends
+/// on into its bus's centre (1 → 6).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Route {
+    pub output: Output,
+    pub create: bool,
+    pub owner_env: f32,
+    pub mono: bool,
+}
+
+pub struct Buses {
+    pub env_in: Box<[f32; BLOCK]>,
+    pub eq_in: Box<[[[f32; BLOCK]; 6]; 8]>,
+    pub env: env::EnvNetwork,
+    pub eq: eqchain::EqBuses,
+    /// The FlangeSub returns' mono inputs (A, B) and whether any voice sent into them this block.
+    pub flange_in: Box<[[f32; BLOCK]; 2]>,
+    pub flange_active: [bool; 2],
+    pub flange: flange::FlangeReturns,
+    /// The FootStep SubMix graphs (`player::footsteps`).
+    pub submix: submix::FootSubmixes,
+}
+
+impl Default for Buses {
+    fn default() -> Self {
+        Self {
+            env_in: Box::new([0.0; BLOCK]),
+            eq_in: Box::new([[[0.0; BLOCK]; 6]; 8]),
+            env: env::EnvNetwork::default(),
+            eq: eqchain::EqBuses::default(),
+            flange_in: Box::new([[0.0; BLOCK]; 2]),
+            flange_active: [false; 2],
+            flange: flange::FlangeReturns::default(),
+            submix: submix::FootSubmixes::default(),
+        }
+    }
+}
+
+impl Buses {
+    pub fn clear_inputs(&mut self) {
+        self.env_in.fill(0.0);
+        for bus in self.eq_in.iter_mut() {
+            for ch in bus.iter_mut() {
+                ch.fill(0.0);
+            }
+        }
+        if self.flange.enabled() {
+            for ch in self.flange_in.iter_mut() {
+                ch.fill(0.0);
+            }
+            self.flange_active = [false; 2];
+        }
+    }
+
+    /// The 6-channel input a voice's final Send adds into.
+    pub fn target<'a>(&'a mut self, output: Output, master: &'a mut [[f32; BLOCK]; 6]) -> &'a mut [[f32; BLOCK]; 6] {
+        match output {
+            Output::Eq(i) if i < 8 => &mut self.eq_in[usize::from(i)],
+            Output::Submix(i) if self.submix.graphs.get(usize::from(i)).is_some_and(Option::is_some) => {
+                self.submix.input(i).expect("built graph")
+            }
+            _ => master,
+        }
+    }
+
+    /// Render the FootStep SubMix graphs (when built), the FlangeSub returns (when enabled), the env network and the eEQChain buses into
+    /// SFX Master.
+    pub fn render(&mut self, master: &mut [[f32; BLOCK]; 6]) {
+        self.submix.render(&mut self.env_in, master);
+        if self.flange.enabled() {
+            for (k, r) in self.flange.returns.iter_mut().enumerate() {
+                r.render(&mut self.flange_in[k], self.flange_active[k], &mut self.env_in, master);
+            }
+        }
+        self.env.render(&self.env_in, master);
+        self.eq.render(&mut self.eq_in, master);
+    }
+}
diff --git a/crates/skate-audio/src/bus/submix.rs b/crates/skate-audio/src/bus/submix.rs
new file mode 100644
index 00000000..1fbb691f
--- /dev/null
+++ b/crates/skate-audio/src/bus/submix.rs
@@ -0,0 +1,191 @@
+//! The FootStep SubMix (`sub_82494188`, spec `.claude/notes/aems-offboard-clothing-spec.md` §2.5):
+//! one mono graph per foot sound slot of `SFXObj_OffBoard` (two feet × four slots), built once
+//! for the owner's life (`sub_82494A68`):
+//!
+//! `Sub0 → HI20 → LI20 → PI20 → Sen0 (→ the env bus input) → Pn21 (1 → 6) → Sen0 (→ SFX Master)`.
+//!
+//! The slot's Splice voices play into Sub0 (their 6-channel final Send sums L, C, R, Ls, Rs into
+//! the mono input, LFE dropped, as the Collision SubMix's). At each start of the slot's sound
+//! `sub_82494550` posts HI20 = slot +4, LI20 = slot +8, PI20 centre / gain / Q = slot +12 / +16 /
+//! +20, Sen0 #1 = the holder's env level (OffBoard level(8) / 32767 as of the last update) and Pn21
+//! p0 = the holder's azimuth × 360/65536: the graph keeps those values (and its filter history,
+//! send ramps and panner matrix) until the slot's next start.
+//!
+//! UNCERTAIN (spec §8): Sen0 #2's level is never posted (constructor default 1.0); Pn21 keeps its
+//! class defaults except the azimuth (distance 1, on the speaker circle).
+use super::env::Level;
+use crate::dsp::biquad::{Iir2, Kind};
+use crate::dsp::pan::{self, Pan2D};
+use crate::dsp::peaking::PeakingIir2;
+use crate::dsp::routes::to_six;
+use crate::dsp::send::{Mode, Send};
+use crate::{BLOCK, MIX_RATE};
+
+/// The graphs of one owner: foot A slots 0..3, foot B slots 4..7.
+pub const GRAPHS: usize = 8;
+
+/// What `sub_82494550` posts at a slot's start.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SubmixParams {
+    /// HI20 / LI20 cutoffs (Hz).
+    pub high_pass: f32,
+    pub low_pass: f32,
+    /// PI20 centre (Hz), linear gain and Q.
+    pub peak_freq: f32,
+    pub peak_gain: f32,
+    pub peak_q: f32,
+    /// Sen0 #1 (→ env bus) level.
+    pub env: f32,
+    /// Pn21 azimuth (degrees).
+    pub azimuth: f32,
+}
+
+/// One built graph.
+#[derive(Clone, Debug)]
+pub struct FootSubmix {
+    /// Sub0: the voices' Send adds into channel 1 (centre) of this 6-channel buffer (the mono
+    /// route of [`super::Route::mono`]); the other channels stay 0.
+    pub input: Box<[[f32; BLOCK]; 6]>,
+    hpf: Iir2,
+    lpf: Iir2,
+    peak: PeakingIir2,
+    env: Level,
+    pan: Pan2D,
+    send: Send,
+}
+
+impl Default for FootSubmix {
+    fn default() -> Self {
+        Self {
+            input: Box::new([[0.0; BLOCK]; 6]),
+            hpf: Iir2::new(Kind::HighPass),
+            lpf: Iir2::new(Kind::LowPass),
+            peak: PeakingIir2::default(),
+            // Sen0 posts 0 at build; `sub_82494550` sets it before the first sound.
+            env: Level::new(0.0),
+            pan: Pan2D::new(1),
+            send: Send::default(),
+        }
+    }
+}
+
+impl FootSubmix {
+    fn set(&mut self, p: &SubmixParams) {
+        self.hpf.cutoff = p.high_pass;
+        self.lpf.cutoff = p.low_pass;
+        self.peak.freq = p.peak_freq;
+        self.peak.gain = p.peak_gain;
+        self.peak.q = p.peak_q;
+        self.env.target = p.env;
+        self.pan.params[pan::ANGLE] = p.azimuth;
+    }
+
+    /// One block: filter the mono input, send it to the env bus, pan it into SFX Master; the
+    /// input is cleared for the next block.
+    fn render(&mut self, env_in: &mut [f32; BLOCK], master: &mut [[f32; BLOCK]; 6]) {
+        let mut mono = self.input[1];
+        self.input[1] = [0.0; BLOCK];
+        {
+            let mut planes: [&mut [f32]; 1] = [&mut mono[..]];
+            self.hpf.process(&mut planes, MIX_RATE as f32);
+            self.lpf.process(&mut planes, MIX_RATE as f32);
+            self.peak.process(&mut planes, MIX_RATE as f32);
+        }
+        self.env.add(&mono, &mut env_in[..]);
+        let mut six = [[0.0f32; BLOCK]; 6];
+        self.pan.process(&[&mono[..]], &mut six);
+        let outs: Vec<&[f32]> = six.iter().map(|c| &c[..]).collect();
+        self.send.process(&outs, to_six(6), master, Mode::Normal);
+    }
+}
+
+/// The FootStep SubMix graphs (built on first use, rendered every block from then on).
+#[derive(Clone, Debug, Default)]
+pub struct FootSubmixes {
+    /// Off: hosts keep the old direct route (SFX Master with the owner env tap).
+    pub enabled: bool,
+    pub graphs: Vec<Option<FootSubmix>>,
+}
+
+impl FootSubmixes {
+    /// `sub_82494A68` (build when missing) + `sub_82494550` (post the start's parameters).
+    pub fn set(&mut self, graph: u8, p: &SubmixParams) {
+        let i = usize::from(graph);
+        if i >= GRAPHS {
+            return;
+        }
+        if self.graphs.len() < GRAPHS {
+            self.graphs.resize_with(GRAPHS, || None);
+        }
+        self.graphs[i].get_or_insert_with(FootSubmix::default).set(p);
+    }
+
+    /// The input a voice routed to `graph` adds into (None when the graph was never built).
+    pub fn input(&mut self, graph: u8) -> Option<&mut [[f32; BLOCK]; 6]> {
+        self.graphs.get_mut(usize::from(graph))?.as_mut().map(|g| &mut *g.input)
+    }
+
+    pub fn render(&mut self, env_in: &mut [f32; BLOCK], master: &mut [[f32; BLOCK]; 6]) {
+        for g in self.graphs.iter_mut().flatten() {
+            g.render(env_in, master);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tone(f: f32, k0: usize) -> [f32; BLOCK] {
+        std::array::from_fn(|k| (std::f32::consts::TAU * f * (k0 + k) as f32 / MIX_RATE as f32).sin() * 0.5)
+    }
+
+    const OPEN: SubmixParams =
+        SubmixParams { high_pass: 0.0, low_pass: 96_000.0, peak_freq: 96_000.0, peak_gain: 1.0, peak_q: 3.0, env: 0.1, azimuth: 0.0 };
+
+    #[test]
+    fn an_open_graph_passes_the_mono_input_to_the_centre_and_taps_the_env_send() {
+        let mut s = FootSubmixes::default();
+        s.set(2, &OPEN);
+        assert!(s.input(0).is_none(), "only built graphs take input");
+        let x = tone(440.0, 0);
+        s.input(2).unwrap()[1] = x;
+        let (mut env, mut master) = ([0.0; BLOCK], [[0.0; BLOCK]; 6]);
+        s.render(&mut env, &mut master);
+        for k in 0..BLOCK {
+            assert!((master[1][k] - x[k]).abs() < 1e-6, "centre carries the input at unity");
+            assert!((env[k] - 0.1 * x[k]).abs() < 1e-7, "env send at the posted level");
+        }
+        assert!([0, 2, 3, 4, 5].iter().all(|&c| master[c].iter().all(|&v| v == 0.0)));
+        // The input was consumed.
+        let (mut env, mut master) = ([0.0; BLOCK], [[0.0; BLOCK]; 6]);
+        s.render(&mut env, &mut master);
+        assert!(master.iter().all(|c| c.iter().all(|&v| v == 0.0)));
+    }
+
+    #[test]
+    fn the_eq_record_filters_and_the_azimuth_pans() {
+        let mut s = FootSubmixes::default();
+        // Footstep id 959's record: HPF 200, LPF 7000, PI20 5200 Hz × 0.1, Q 0.5.
+        let p = SubmixParams { high_pass: 200.0, low_pass: 7000.0, peak_freq: 5200.0, peak_gain: 0.1, peak_q: 0.5, env: 0.0, azimuth: 90.0 };
+        s.set(0, &p);
+        let rms = |f: f32| {
+            let mut s2 = s.clone();
+            let mut acc = 0.0f32;
+            for b in 0..40 {
+                s2.input(0).unwrap()[1] = tone(f, b * BLOCK);
+                let (mut env, mut master) = ([0.0; BLOCK], [[0.0; BLOCK]; 6]);
+                s2.render(&mut env, &mut master);
+                if b >= 20 {
+                    acc += master.iter().flat_map(|c| c.iter()).map(|v| v * v).sum::<f32>();
+                    assert!(env.iter().all(|&v| v == 0.0));
+                    assert!(master[1].iter().all(|v| v.abs() < 1e-3), "panned right of centre");
+                }
+            }
+            acc.sqrt()
+        };
+        let (low, mid, peak) = (rms(50.0), rms(1000.0), rms(5200.0));
+        assert!(low < 0.2 * mid, "high-passed: {low} vs {mid}");
+        assert!(peak < 0.3 * mid, "the PI20 cut at 5.2 kHz: {peak} vs {mid}");
+    }
+}
diff --git a/crates/skate-audio/src/bus/zones.rs b/crates/skate-audio/src/bus/zones.rs
new file mode 100644
index 00000000..edc3edc7
--- /dev/null
+++ b/crates/skate-audio/src/bus/zones.rs
@@ -0,0 +1,442 @@
+//! `SFXObj_Reverb`'s preset selection with the reverb-zone emitters (spec
+//! `.claude/notes/aems-bus-leftovers-spec.md` §4): the per-frame update `sub_824DE548` and its
+//! mode handlers — timed fade `sub_824DE850` (0), zone fade `sub_824DE970` (1), zone-to-zone
+//! `sub_824DEAE8` (2) — the start `sub_824DE468`, the snap `sub_824DEDD8` and the zone blend with
+//! the reverb outputs' rotation toward the zone `sub_824DEEF0`.
+//!
+//! The host hands in, per game frame, the active `.ems` nodes whose attribute type is 5 in the
+//! emitter manager's list order ([`Zone`]: node identity, attribute key `+24`, the attribute's
+//! preset key, the normalised distance `+12` — 0 inside the inner core, 1 at the edge — and the
+//! zone position), the `audio_reverb` region key at the skater, and the camera (`*(0x83083C38) +
+//! 0x2F078`: position `+48`, forward `+64`).
+//!
+//! [`EnvNetwork::update`] replaces [`EnvNetwork::request`] + [`EnvNetwork::frame`] for a host that
+//! has zones (with none it is the same timed fade, but in retail's order: the frame that starts a
+//! fade does not advance it, and the network starts on reverb01 on both sides as `sub_824DDE50`
+//! sets it up, so the first region preset fades in over 1 s).
+use super::env::{DEFAULT_PRESET, EnvNetwork, FADE};
+
+/// The reverb outputs' azimuths outside a zone blend (0x82063B20 / 0x82256FD8).
+const PANS: [f32; 2] = [270.0, 90.0];
+/// 180 (0x821DE7BC), 1/π (0x822F8610), 360 (0x820B4118).
+const DEG_180: f32 = 180.0;
+const INV_PI: f32 = 0.318_309_87;
+const DEG_360: f32 = 360.0;
+
+/// One reverb-zone emitter node this frame.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Zone {
+    /// The node's identity (retail compares node pointers).
+    pub id: u64,
+    /// Node `+24`: the attribute record key (two nodes of one attribute count as one zone).
+    pub attribute: u64,
+    /// The attribute record's reverb preset key (`sub_8248CDC8` → `sub_8248CE30`, `+8`).
+    pub preset: u64,
+    /// Node `+12`: the normalised distance (0 = inner core, 1 = edge).
+    pub d: f32,
+    /// The zone position (x, z) the blend rotates toward (node record `+8` / `+16`).
+    pub position: [f32; 2],
+    /// `sub_82488278`'s vfunc92 check on the attribute: a failing first candidate ends the query.
+    pub enabled: bool,
+}
+
+/// The camera as `sub_824DEEF0` reads it (world position and forward; x, z are used).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Camera {
+    pub position: [f32; 3],
+    pub forward: [f32; 3],
+}
+
+/// Retail's selection state: keys `+400` / `+408`, sides `+416` / `+420`, the zone side `+424`,
+/// the zone nodes `+428` / `+432` and per side the mode `+128` and timer `+204`.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Selector {
+    started: bool,
+    pub current_key: u64,
+    pub target_key: u64,
+    pub current: usize,
+    pub target: usize,
+    pub zone_side: usize,
+    pub nodes: [Option<Zone>; 2],
+    pub modes: [u8; 2],
+    pub timers: [f32; 2],
+}
+
+impl Selector {
+    pub fn active(&self) -> bool {
+        self.started
+    }
+
+    pub fn target_side(&self) -> usize {
+        self.target
+    }
+}
+
+/// `sub_82488278(mgr, skip)`: the first zone in list order that is not `skip`, if its attribute
+/// passes the check (else none: the query does not look further).
+pub fn query(zones: &[Zone], skip: Option<u64>) -> Option<Zone> {
+    let z = zones.iter().find(|z| Some(z.id) != skip)?;
+    z.enabled.then_some(*z)
+}
+
+impl EnvNetwork {
+    /// `sub_824DDE50`: both sides on reverb01, side 0 at weight 1, side 1 at 0.
+    fn init_selector(&mut self) {
+        let key = if self.presets.contains_key(&DEFAULT_PRESET) { DEFAULT_PRESET } else { return };
+        let p = self.presets[&key];
+        self.last_sends = Some(super::env::Side::sends(&p));
+        for (k, side) in self.sides.iter_mut().enumerate() {
+            side.apply_scaled(key, &p, self.scale);
+            side.weight.target = if k == 0 { 1.0 } else { 0.0 };
+        }
+        self.selector = Selector { started: true, current_key: key, target_key: key, ..Default::default() };
+        self.sync();
+    }
+
+    /// Mirror the selector into `current` / `fade` (for [`EnvNetwork::key`] and diagnostics).
+    fn sync(&mut self) {
+        let s = &self.selector;
+        self.current = s.current;
+        self.fade = (s.current_key != s.target_key).then_some((s.target, s.timers[s.target]));
+    }
+
+    /// `sub_824DE468`: load `key` on the other side at weight 0 in `mode`.
+    fn start(&mut self, key: u64, mode: u8) {
+        let key = if self.presets.contains_key(&key) { key } else { DEFAULT_PRESET };
+        let Some(p) = self.presets.get(&key).copied() else { return };
+        let s = &mut self.selector;
+        s.target_key = key;
+        s.target = 1 - s.current;
+        let t = s.target;
+        s.modes[t] = mode;
+        s.timers[t] = 0.0;
+        self.last_sends = Some(super::env::Side::sends(&p));
+        self.sides[t].apply_scaled(key, &p, self.scale);
+        self.sides[t].weight.target = 0.0;
+    }
+
+    fn post(&mut self, side: usize, weight: f32, pans: [f32; 2]) {
+        self.sides[side].post(weight, pans);
+    }
+
+    /// `sub_824DEDD8`: leave the zone blend at once.
+    fn snap(&mut self) {
+        let (cur, tgt) = (self.selector.current, self.selector.target);
+        if self.selector.zone_side == cur {
+            self.post(cur, 0.0, PANS);
+            self.post(tgt, 1.0, PANS);
+            self.selector.current = tgt;
+            self.selector.current_key = self.selector.target_key;
+        } else {
+            self.post(tgt, 0.0, PANS);
+            self.post(cur, 1.0, PANS);
+            self.selector.target = cur;
+            self.selector.target_key = self.selector.current_key;
+        }
+        self.selector.nodes = [None, None];
+    }
+
+    /// `sub_824DEEF0`: blend `side` (1 − d) against the other side (d) and turn `side`'s reverb
+    /// outputs toward the zone. Without a camera retail calls the object's vfunc 28 (UNCERTAIN,
+    /// not modelled: nothing changes).
+    fn blend(&mut self, side: usize, zone: &Zone, camera: Option<&Camera>) {
+        let Some(cam) = camera else { return };
+        let d = self.selector.timers[side];
+        let (fx, fz) = (cam.forward[0], cam.forward[2]);
+        let (dx, dz) = (zone.position[0] - cam.position[0], zone.position[1] - cam.position[2]);
+        let nf = 1.0 / (fx * fx + fz * fz).sqrt();
+        let nd = 1.0 / (dx * dx + dz * dz).sqrt();
+        let (fx, fz, dx, dz) = (fx * nf, fz * nf, dx * nd, dz * nd);
+        let c = (dx * fx + dz * fz).clamp(-1.0, 1.0);
+        let cross = dx * fz - dz * fx;
+        // The vector acos (`sub_82453298`) → degrees: θ ∈ [0, 180], unsigned.
+        let theta = INV_PI * (c.acos() * DEG_180);
+        let (mut left, right) = (theta - 270.0, 90.0 - theta);
+        if !(cross > 0.0) && theta < 90.0 {
+            left = theta + 90.0;
+        }
+        let wrap = |mut a: f32| {
+            if a > DEG_360 {
+                a -= DEG_360;
+            }
+            if a < 0.0 {
+                a += DEG_360;
+            }
+            a
+        };
+        let r = wrap(-d.mul_add(right, -90.0));
+        let l = wrap(d.mul_add(left, 270.0));
+        self.post(side, 1.0 - d, [l, r]);
+        self.post(1 - side, d, PANS);
+    }
+
+    /// `sub_824DE548`, once per game frame (`dt` s): pick the preset from the reverb zones or the
+    /// region key (0 = reverb01) and run the fade in progress.
+    pub fn update(&mut self, dt: f32, region: u64, zones: &[Zone], camera: Option<&Camera>) {
+        if !self.enabled() {
+            return;
+        }
+        if !self.selector.started {
+            self.init_selector();
+            if !self.selector.started {
+                return;
+            }
+        }
+        let region = if region == 0 { DEFAULT_PRESET } else { region };
+        let s = self.selector.clone();
+        if s.current_key == s.target_key {
+            match query(zones, None) {
+                None => {
+                    self.selector.nodes = [None, None];
+                    if s.current_key != region {
+                        self.start(region, 0);
+                    }
+                }
+                Some(z1) if s.nodes[0].is_none() => {
+                    self.selector.nodes[0] = Some(z1);
+                    self.start(z1.preset, 1);
+                    self.selector.zone_side = self.selector.target;
+                }
+                Some(z1) => match query(zones, Some(z1.id)) {
+                    Some(z2) => {
+                        let (k1, k2) = (z1.preset, z2.preset);
+                        if k1 == k2 && s.current_key == k1 {
+                            self.selector.target = s.current;
+                        } else if k1 != k2 && s.current_key == k1 {
+                            self.start(k2, 2);
+                            self.selector.nodes[1] = Some(z2);
+                        } else {
+                            self.start(k1, 2);
+                            self.selector.nodes[1] = Some(z1);
+                        }
+                    }
+                    None => {
+                        // The held node's distance as it is now (its record; the stored copy if it
+                        // left the list).
+                        let n0 = s.nodes[0].map(|n| zones.iter().find(|z| z.id == n.id).copied().unwrap_or(n));
+                        if n0.is_some_and(|n| n.d > 0.0) && s.zone_side == s.current {
+                            self.start(region, 1);
+                            self.selector.zone_side = s.current;
+                        }
+                    }
+                },
+            }
+        } else {
+            match s.modes[s.target] {
+                0 => self.timed(dt),
+                1 => self.zone_fade(zones, camera),
+                2 => self.zone_to_zone(zones, camera),
+                _ => self.selector.target = s.current,
+            }
+        }
+        if let Some(n) = &mut self.selector.nodes[0] {
+            if let Some(z) = zones.iter().find(|z| z.id == n.id) {
+                *n = *z;
+            }
+        }
+        if let Some(n) = &mut self.selector.nodes[1] {
+            if let Some(z) = zones.iter().find(|z| z.id == n.id) {
+                *n = *z;
+            }
+        }
+        self.sync();
+    }
+
+    /// `sub_824DE850`: the linear 1 s fade.
+    fn timed(&mut self, dt: f32) {
+        let (cur, tgt) = (self.selector.current, self.selector.target);
+        self.selector.timers[tgt] += dt;
+        let mut w = self.selector.timers[tgt] / FADE;
+        let other = if w >= 1.0 {
+            w = 1.0;
+            0.0
+        } else {
+            1.0 - w
+        };
+        self.post(tgt, w, PANS);
+        self.post(cur, other, PANS);
+        if w >= 1.0 {
+            self.selector.current = tgt;
+            self.selector.current_key = self.selector.target_key;
+        }
+    }
+
+    /// `sub_824DE970`: blend by the zone's distance; commit (or cancel) at d = 0.
+    fn zone_fade(&mut self, zones: &[Zone], camera: Option<&Camera>) {
+        let z1 = query(zones, None);
+        let z2 = z1.and_then(|z| query(zones, Some(z.id)));
+        let Some(z1) = z1 else { return self.snap() };
+        let Some(held) = self.selector.nodes[0] else { return self.snap() };
+        if held.id != z1.id {
+            match z2 {
+                None if held.attribute == z1.attribute => self.selector.nodes[0] = Some(z1),
+                Some(z2) if held.id == z2.id => {}
+                _ => return self.snap(),
+            }
+        }
+        let node = self.selector.nodes[0].map(|n| zones.iter().find(|z| z.id == n.id).copied().unwrap_or(n)).unwrap();
+        let side = self.selector.zone_side;
+        self.selector.timers[side] = node.d;
+        if node.d != 0.0 {
+            return self.blend(side, &node, camera);
+        }
+        let s = &mut self.selector;
+        if s.target == side {
+            s.current = s.target;
+            s.current_key = s.target_key;
+        } else {
+            s.target_key = s.current_key;
+            s.target = s.current;
+        }
+        let cur = s.current;
+        self.post(cur, 1.0, PANS);
+        self.post(1 - cur, 0.0, PANS);
+    }
+
+    /// `sub_824DEAE8`: between two overlapping zones of different presets.
+    fn zone_to_zone(&mut self, zones: &[Zone], camera: Option<&Camera>) {
+        let z1 = query(zones, None);
+        let z2 = z1.and_then(|z| query(zones, Some(z.id)));
+        // No zone: retail calls the object's vfunc 28 (UNCERTAIN); we leave the blend as the snap does.
+        let Some(z1) = z1 else { return self.snap() };
+        let (cur, tgt) = (self.selector.current, self.selector.target);
+        let Some(z2) = z2 else {
+            if self.selector.nodes[0].map(|n| n.id) != Some(z1.id) {
+                self.selector.nodes[0] = self.selector.nodes[1];
+            }
+            let Some(held) = self.selector.nodes[0] else { return self.snap() };
+            if self.selector.current_key == held.preset {
+                self.post(cur, 1.0, PANS);
+                self.post(tgt, 0.0, PANS);
+            } else {
+                self.post(tgt, 1.0, PANS);
+                self.post(cur, 0.0, PANS);
+            }
+            let s = &mut self.selector;
+            s.nodes[1] = None;
+            s.target = s.current;
+            s.target_key = s.current_key;
+            s.zone_side = s.current;
+            return;
+        };
+        let ids = [z1.id, z2.id];
+        let (Some(a), Some(b)) = (self.selector.nodes[0], self.selector.nodes[1]) else { return self.snap() };
+        if !ids.contains(&a.id) || !ids.contains(&b.id) {
+            return self.snap();
+        }
+        if a.attribute == b.attribute {
+            self.post(cur, 1.0, PANS);
+            self.post(tgt, 0.0, PANS);
+            let s = &mut self.selector;
+            s.zone_side = s.current;
+            s.target = s.current;
+            s.target_key = s.current_key;
+            return;
+        }
+        let b = zones.iter().find(|z| z.id == b.id).copied().unwrap_or(b);
+        if b.d == 0.0 {
+            self.post(cur, 0.0, PANS);
+            self.post(tgt, 1.0, PANS);
+            let s = &mut self.selector;
+            s.current = s.target;
+            s.zone_side = s.target;
+            s.current_key = s.target_key;
+            s.nodes = [Some(b), None];
+            return;
+        }
+        self.selector.timers[tgt] = b.d;
+        self.blend(tgt, &b, camera);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::bus::env::Preset;
+
+    fn net() -> EnvNetwork {
+        let mut env = EnvNetwork::default();
+        let mut p = Preset([1.0; 44]);
+        p.0[5] = 1.5;
+        env.presets.insert(DEFAULT_PRESET, p);
+        env.presets.insert(7, Preset([0.5; 44]));
+        env.presets.insert(9, Preset([0.25; 44]));
+        env
+    }
+
+    fn zone(id: u64, preset: u64, d: f32) -> Zone {
+        Zone { id, attribute: id * 100, preset, d, position: [10.0, 0.0], enabled: true }
+    }
+
+    const CAM: Camera = Camera { position: [0.0, 1.5, 0.0], forward: [1.0, 0.0, 0.0] };
+
+    #[test]
+    fn without_zones_the_region_preset_fades_in_from_reverb01() {
+        let mut env = net();
+        env.update(1.0 / 60.0, 7, &[], Some(&CAM));
+        // Started this frame on side 1 at weight 0; the fade advances from the next frame.
+        assert_eq!((env.selector.target, env.selector.target_key, env.selector.modes[1]), (1, 7, 0));
+        assert_eq!(env.sides[1].weight.target, 0.0);
+        for _ in 0..30 {
+            env.update(1.0 / 60.0, 7, &[], Some(&CAM));
+        }
+        assert!((env.sides[1].weight.target - 0.5).abs() < 1e-3);
+        for _ in 0..31 {
+            env.update(1.0 / 60.0, 7, &[], Some(&CAM));
+        }
+        assert_eq!((env.selector.current, env.selector.current_key), (1, 7));
+        assert_eq!(env.key(), Some(7));
+    }
+
+    #[test]
+    fn a_zone_blends_by_distance_turns_the_reverb_toward_it_and_commits_at_the_core() {
+        let mut env = net();
+        env.update(1.0 / 60.0, 0, &[], Some(&CAM)); // reverb01, nothing to do
+        assert_eq!(env.selector.current_key, DEFAULT_PRESET);
+        let z = |d| [zone(1, 9, d)];
+        env.update(1.0 / 60.0, 0, &z(0.8), Some(&CAM));
+        assert_eq!((env.selector.target_key, env.selector.zone_side, env.selector.modes[1]), (9, 1, 1));
+        env.update(1.0 / 60.0, 0, &z(0.75), Some(&CAM));
+        // Zone side weight 1 − d, the other d; the zone straight ahead (θ = 0) pulls both
+        // outputs toward 0°: L = 270 + 0.75·(90 − 0)... = 337.5, R = 90 − 0.75·90 = 22.5.
+        assert!((env.sides[1].weight.target - 0.25).abs() < 1e-6);
+        assert!((env.sides[0].weight.target - 0.75).abs() < 1e-6);
+        let [l, r] = env.sides[1].pans();
+        assert!((l - 337.5).abs() < 0.05 && (r - 22.5).abs() < 0.05, "{l} {r}");
+        assert_eq!(env.sides[0].pans(), PANS);
+        env.update(1.0 / 60.0, 0, &z(0.0), Some(&CAM));
+        assert_eq!((env.selector.current, env.selector.current_key), (1, 9));
+        assert_eq!((env.sides[1].weight.target, env.sides[0].weight.target), (1.0, 0.0));
+        assert_eq!(env.sides[1].pans(), PANS);
+        // Leaving: the region preset loads on the other side (mode 1) and the zone side fades out
+        // with d; outside the zone the snap commits to the region preset.
+        env.update(1.0 / 60.0, 0, &z(0.4), Some(&CAM));
+        assert_eq!((env.selector.target, env.selector.target_key, env.selector.zone_side), (0, DEFAULT_PRESET, 1));
+        env.update(1.0 / 60.0, 0, &z(0.6), Some(&CAM));
+        assert!((env.sides[1].weight.target - 0.4).abs() < 1e-6);
+        env.update(1.0 / 60.0, 0, &[], Some(&CAM));
+        assert_eq!((env.selector.current, env.selector.current_key), (0, DEFAULT_PRESET));
+        assert_eq!((env.sides[0].weight.target, env.sides[1].weight.target), (1.0, 0.0));
+        assert_eq!(env.selector.nodes, [None, None]);
+    }
+
+    #[test]
+    fn the_rotation_unwraps_by_the_side_of_the_zone() {
+        let mut env = net();
+        env.update(1.0 / 60.0, 0, &[], Some(&CAM));
+        env.selector.timers[1] = 1.0;
+        // Zone 90° off the forward axis on either side: θ = 90 (unsigned); full blend (d = 1)
+        // puts both outputs on θ.
+        for z in [[0.0, 10.0], [0.0, -10.0]] {
+            env.blend(1, &Zone { position: z, ..zone(1, 9, 1.0) }, Some(&CAM));
+            let [l, r] = env.sides[1].pans();
+            assert!((l - 90.0).abs() < 0.05 && (r - 90.0).abs() < 0.05, "{z:?}: {l} {r}");
+        }
+        // 45° (θ = 45): the cross sign picks L's unwrap (θ − 270 + 270 = 45, or θ + 90 + 270 → 45).
+        for z in [[10.0, 10.0], [10.0, -10.0]] {
+            env.blend(1, &Zone { position: z, ..zone(1, 9, 1.0) }, Some(&CAM));
+            let [l, r] = env.sides[1].pans();
+            assert!((l - 45.0).abs() < 0.05 && (r - 45.0).abs() < 0.05, "{z:?}: {l} {r}");
+        }
+    }
+}
diff --git a/crates/skate-audio/src/dsp/biquad.rs b/crates/skate-audio/src/dsp/biquad.rs
new file mode 100644
index 00000000..2de76481
--- /dev/null
+++ b/crates/skate-audio/src/dsp/biquad.rs
@@ -0,0 +1,217 @@
+//! HighPassIir2 / LowPassIir2 (spec §4.4, §4.5): RBJ cookbook biquads at fixed Q = 1, single
+//! precision, Direct Form I with a 1e-18 denormal bias. The cutoff is raw Hz; the filter bypasses
+//! (bit-exact pass-through) outside 24 Hz … 0.999·Nyquist, so a raw 25000 Hz low-pass is "open"
+//! because it lies past 0.999·Nyquist, not because of a special case.
+
+/// 2π as f32 (6.2831855).
+pub const TWO_PI: f32 = std::f32::consts::TAU;
+/// ω floor π/1000 (≈ 24 Hz at 48 kHz) and ceiling 0.999π (≈ 23976 Hz), image constants.
+pub const FLOOR: f32 = 0.003_141_593;
+pub const CEIL: f32 = 3.138_451_1;
+/// Denormal guard added to the feed-forward sum (cell 0x822F87B0).
+pub const BIAS: f32 = 1e-18;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+    LowPass,
+    HighPass,
+}
+
+/// Normalised coefficients {a1, a2, b0, b1, b2}.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Coefficients {
+    pub a1: f32,
+    pub a2: f32,
+    pub b0: f32,
+    pub b1: f32,
+    pub b2: f32,
+}
+
+/// RBJ low/high-pass at Q = 1 from ω, every step in f32 (sin/cos in f64, rounded once).
+pub fn coefficients(kind: Kind, omega: f32) -> Coefficients {
+    let s = (omega as f64).sin() as f32;
+    let c = (omega as f64).cos() as f32;
+    let alpha = 0.5 * s;
+    let a0 = 1.0 + alpha;
+    let inv = 1.0 / a0;
+    let a1 = (-2.0 * c) * inv;
+    let a2 = (1.0 - alpha) * inv;
+    let (n, sign) = match kind {
+        Kind::LowPass => (1.0 - c, 1.0f32),
+        Kind::HighPass => (1.0 + c, -1.0f32),
+    };
+    let b0 = n / (2.0 * a0);
+    Coefficients { a1, a2, b0, b1: sign * (n * inv), b2: b0 }
+}
+
+/// ω for a cutoff at the block rate: f32(f32(fc / fs) × 2π).
+pub fn omega(cutoff: f32, rate: f32) -> f32 {
+    (cutoff / rate) * TWO_PI
+}
+
+#[derive(Clone, Debug)]
+pub struct Iir2 {
+    pub kind: Kind,
+    /// Parameter 0: cutoff in Hz.
+    pub cutoff: f32,
+    cached: f32,
+    coefficients: Coefficients,
+    /// Per channel {x1, x2, y1, y2}.
+    history: [[f32; 4]; 8],
+    filtering: bool,
+}
+
+impl Iir2 {
+    /// Class defaults: HPF 0 Hz, LPF 96000 Hz (both bypass).
+    pub fn new(kind: Kind) -> Self {
+        let cutoff = match kind {
+            Kind::LowPass => 96_000.0,
+            Kind::HighPass => 0.0,
+        };
+        // The constructor caches the raw Hz, so the first filtering block always rebuilds.
+        Self { kind, cutoff, cached: cutoff, coefficients: Coefficients::default(), history: [[0.0; 4]; 8], filtering: false }
+    }
+
+    /// True when this block will pass through untouched.
+    pub fn bypassed(&self, rate: f32) -> bool {
+        let w = omega(self.cutoff, rate);
+        match self.kind {
+            Kind::LowPass => w.is_nan() || w >= CEIL,
+            Kind::HighPass => w.is_nan() || w <= FLOOR,
+        }
+    }
+
+    /// Process one block in place (planar channels).
+    pub fn process(&mut self, channels: &mut [&mut [f32]], rate: f32) {
+        let w = omega(self.cutoff, rate);
+        let bypass = match self.kind {
+            Kind::LowPass => w.is_nan() || w >= CEIL,
+            Kind::HighPass => w.is_nan() || w <= FLOOR,
+        };
+        if bypass {
+            if self.filtering {
+                self.history = [[0.0; 4]; 8];
+            }
+            self.filtering = false;
+            self.cached = w;
+            return;
+        }
+        let w = match self.kind {
+            Kind::LowPass => w.max(FLOOR),
+            Kind::HighPass => w.min(CEIL),
+        };
+        if w.to_bits() != self.cached.to_bits() || !self.filtering && self.coefficients == Coefficients::default() {
+            self.coefficients = coefficients(self.kind, w);
+            self.cached = w;
+        }
+        self.filtering = true;
+        for (ch, samples) in channels.iter_mut().enumerate().take(8) {
+            kernel(&self.coefficients, &mut self.history[ch], samples);
+        }
+    }
+}
+
+/// Direct Form I in place over one block of one channel, history {x1, x2, y1, y2}.
+///
+/// Feed-forward b0·x + b1·x1 + b2·x2 + 1e-18 and feedback y = (t − a1·y1) − a2·y2 in single
+/// precision. Retail processes 8 samples at a time and associates the feed-forward sum by the
+/// sample's position in its group of 8 (groups aligned to the block start). The order below was
+/// fitted black-box against the PoC's replay-verified kernel (`tests/dsp_oracle.rs`
+/// `fit_biquad_association`: every position 100 % bit-exact) — the innermost product is a plain
+/// multiply plus the bias, the outer two are fused multiply-adds:
+/// - position 0: b1·x1 + (b2·x2 + (b0·x + bias));
+/// - position 1: b2·x2 + (b1·x1 + (b0·x + bias));
+/// - positions 2..7: b0·x + (b2·x2 + (b1·x1 + bias));
+/// - feedback: two fused negative multiply-subtracts, a1 first.
+pub fn kernel(k: &Coefficients, history: &mut [f32; 4], samples: &mut [f32]) {
+    let [mut x1, mut x2, mut y1, mut y2] = *history;
+    for (n, s) in samples.iter_mut().enumerate() {
+        let x = *s;
+        let t = match n % 8 {
+            0 => k.b1.mul_add(x1, k.b2.mul_add(x2, k.b0 * x + BIAS)),
+            1 => k.b2.mul_add(x2, k.b1.mul_add(x1, k.b0 * x + BIAS)),
+            _ => k.b0.mul_add(x, k.b2.mul_add(x2, k.b1 * x1 + BIAS)),
+        };
+        let y = (-k.a2).mul_add(y2, (-k.a1).mul_add(y1, t));
+        x2 = x1;
+        x1 = x;
+        y2 = y1;
+        y1 = y;
+        *s = y;
+    }
+    *history = [x1, x2, y1, y2];
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn close(a: f32, b: f32) -> bool {
+        (a - b).abs() <= 2.0 * f32::EPSILON * b.abs().max(1.0)
+    }
+
+    #[test]
+    fn worked_coefficients_from_the_spec() {
+        for (kind, fc, want) in [
+            (Kind::LowPass, 5000.0, [-1.2164445, 0.53329474, 0.079212569, 0.15842514]),
+            (Kind::LowPass, 1000.0, [-1.8614084, 0.87747043, 0.0040154932, 0.0080309864]),
+            (Kind::HighPass, 77.0, [-1.9898703, 0.98997140, 0.99496043, -1.9899209]),
+        ] {
+            let c = coefficients(kind, omega(fc, 48000.0));
+            for (got, want) in [c.a1, c.a2, c.b0, c.b1].into_iter().zip(want) {
+                assert!(close(got, want), "{kind:?} {fc}: {got} vs {want}");
+            }
+            assert_eq!(c.b0, c.b2);
+        }
+        assert_eq!(omega(5000.0, 48000.0), 0.654_498_46);
+    }
+
+    #[test]
+    fn bypass_edges() {
+        let mut lpf = Iir2::new(Kind::LowPass);
+        for (fc, bypass) in [(25000.0, true), (23976.0, true), (23975.0, false), (96000.0, true)] {
+            lpf.cutoff = fc;
+            assert_eq!(lpf.bypassed(48000.0), bypass, "LPF {fc}");
+        }
+        let mut hpf = Iir2::new(Kind::HighPass);
+        for (fc, bypass) in [(0.0, true), (24.0, true), (25.0, false), (77.0, false)] {
+            hpf.cutoff = fc;
+            assert_eq!(hpf.bypassed(48000.0), bypass, "HPF {fc}");
+        }
+        // Bypass is a bit-exact pass-through.
+        let mut x: Vec<f32> = (0..256).map(|i| (i as f32 * 0.1).sin()).collect();
+        let before = x.clone();
+        lpf.cutoff = 25000.0;
+        lpf.process(&mut [&mut x[..]], 48000.0);
+        assert_eq!(x, before);
+    }
+
+    #[test]
+    fn low_pass_attenuates_above_cutoff_and_passes_below() {
+        let rms = |fc: f32, f: f32| {
+            let mut lpf = Iir2::new(Kind::LowPass);
+            lpf.cutoff = fc;
+            let mut x: Vec<f32> = (0..48000).map(|i| (std::f32::consts::TAU * f * i as f32 / 48000.0).sin()).collect();
+            for chunk in x.chunks_mut(256) {
+                lpf.process(&mut [chunk], 48000.0);
+            }
+            let tail = &x[24000..];
+            (tail.iter().map(|v| v * v).sum::<f32>() / tail.len() as f32).sqrt() * std::f32::consts::SQRT_2
+        };
+        // 0 dB at fc for Q = 1 (RBJ), strong cut two octaves above, flat well below.
+        assert!((rms(1000.0, 1000.0) - 1.0).abs() < 0.02);
+        assert!(rms(1000.0, 4000.0) < 0.08);
+        assert!((rms(1000.0, 100.0) - 1.0).abs() < 0.02);
+    }
+
+    #[test]
+    fn history_clears_when_switching_to_bypass() {
+        let mut lpf = Iir2::new(Kind::LowPass);
+        lpf.cutoff = 1000.0;
+        let mut x = vec![1.0f32; 256];
+        lpf.process(&mut [&mut x[..]], 48000.0);
+        lpf.cutoff = 25000.0;
+        lpf.process(&mut [&mut x[..]], 48000.0);
+        assert_eq!(lpf.history[0], [0.0; 4]);
+    }
+}
diff --git a/crates/skate-audio/src/dsp/delay.rs b/crates/skate-audio/src/dsp/delay.rs
new file mode 100644
index 00000000..eed7adf8
--- /dev/null
+++ b/crates/skate-audio/src/dsp/delay.rs
@@ -0,0 +1,126 @@
+//! Delay (Del0, process `sub_82B222D8`; spec `aems-env-bus-spec.md` §8.1, §8.3): a whole-sample
+//! feedback delay, wet only. p0 = delay (s; 0 = off: the module is skipped and the signal passes
+//! undelayed), p1 = feedback (clamped to ±0.99). D = round-half-away(p0 · 48000).
+//! w[n] = x[n] + fb·w[n−D]; y[n] = w[n−D]. A change of D crossfades the old and new taps over 128
+//! samples (r = 127/128 … 0): y = (1−r)·t_new + r·t_old, w = x + (1−r)·fb_new·t_new + r·fb_old·t_old.
+//! A feedback change outside a crossfade applies at once. Mono or multichannel (one line each).
+//!
+//! UNCERTAIN (spec): the output while the line first fills (we read the zeroed line, i.e. silence
+//! until D samples have passed) and whether a resize clears the line (we keep its contents).
+
+#[derive(Clone, Debug)]
+pub struct Delay {
+    /// p0 (s) and p1.
+    pub delay: f32,
+    pub feedback: f32,
+    lines: Vec<Vec<f32>>,
+    write: usize,
+    taps: usize,
+    fb: f32,
+    /// 0 = bypass, 1 = running.
+    state: u8,
+}
+
+impl Delay {
+    /// `max` = the constructor's maximum delay (s): the line length.
+    pub fn new(max: f32, channels: usize) -> Self {
+        let len = (max * 48000.0).round().max(1.0) as usize + 1;
+        Self { delay: 0.0, feedback: 0.0, lines: vec![vec![0.0; len]; channels.max(1)], write: 0, taps: 0, fb: 0.0, state: 0 }
+    }
+
+    fn samples(delay: f32) -> usize {
+        let d = delay * 48000.0;
+        if d.is_nan() || d <= 0.0 { 0 } else { d.round() as usize }
+    }
+
+    fn grow(&mut self, d: usize) {
+        if d + 1 > self.lines[0].len() {
+            let len = self.lines[0].len();
+            for line in &mut self.lines {
+                // Keep the ring order: unwrap it so `write` stays valid.
+                line.rotate_left(self.write);
+                line.resize(d + 1, 0.0);
+            }
+            self.write = len;
+            self.write %= self.lines[0].len();
+        }
+    }
+
+    pub fn process(&mut self, channels: &mut [&mut [f32]]) {
+        let d = Self::samples(self.delay);
+        let fb_new = if self.feedback.is_nan() { self.feedback } else { self.feedback.clamp(-0.99, 0.99) };
+        if d == 0 {
+            self.state = 0;
+            return;
+        }
+        self.grow(d);
+        if self.state == 0 {
+            for line in &mut self.lines {
+                line.fill(0.0);
+            }
+            self.write = 0;
+            self.taps = d;
+            self.fb = fb_new;
+            self.state = 1;
+        }
+        let len = self.lines[0].len();
+        let (old_d, old_fb) = (self.taps, self.fb);
+        let fade = old_d != d;
+        for (ch, samples) in channels.iter_mut().enumerate().take(self.lines.len()) {
+            let line = &mut self.lines[ch];
+            let mut w = self.write;
+            for (k, s) in samples.iter_mut().enumerate() {
+                let t_new = line[(w + len - d) % len];
+                let (y, wv) = if fade && k < 128 {
+                    let r = (127 - k) as f32 * (1.0 / 128.0);
+                    let t_old = line[(w + len - old_d) % len];
+                    ((1.0 - r) * t_new + r * t_old, *s + (1.0 - r) * fb_new * t_new + r * old_fb * t_old)
+                } else {
+                    (t_new, *s + fb_new * t_new)
+                };
+                line[w] = wv;
+                *s = y;
+                w = (w + 1) % len;
+            }
+        }
+        self.write = (self.write + channels.first().map_or(0, |c| c.len())) % len;
+        self.taps = d;
+        self.fb = fb_new;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn delays_by_whole_samples_with_feedback_and_bypasses_at_zero() {
+        let mut dl = Delay::new(0.01, 1);
+        let mut x = vec![0.0f32; 256];
+        x[0] = 1.0;
+        let before = x.clone();
+        dl.process(&mut [&mut x[..]]);
+        assert_eq!(x, before, "delay 0 = bypass");
+        dl.delay = 100.0 / 48000.0;
+        dl.feedback = 0.5;
+        let mut x = vec![0.0f32; 256];
+        x[0] = 1.0;
+        dl.process(&mut [&mut x[..]]);
+        assert_eq!(x[100], 1.0);
+        assert_eq!(x[200], 0.5);
+        assert!(x.iter().enumerate().all(|(i, &v)| i == 100 || i == 200 || v == 0.0));
+    }
+
+    #[test]
+    fn a_new_delay_crossfades_over_128_samples() {
+        let mut dl = Delay::new(0.01, 1);
+        dl.delay = 10.0 / 48000.0;
+        let mut x = vec![1.0f32; 256];
+        dl.process(&mut [&mut x[..]]);
+        dl.delay = 20.0 / 48000.0;
+        let mut x = vec![1.0f32; 256];
+        dl.process(&mut [&mut x[..]]);
+        // Both taps read a constant 1.0 line: the crossfade is seamless.
+        assert!(x.iter().all(|&v| (v - 1.0).abs() < 1e-6));
+    }
+}
diff --git a/crates/skate-audio/src/dsp/fss.rs b/crates/skate-audio/src/dsp/fss.rs
new file mode 100644
index 00000000..b284f476
--- /dev/null
+++ b/crates/skate-audio/src/dsp/fss.rs
@@ -0,0 +1,278 @@
+//! FrequencyShiftSsb (`FSS0`, process `sub_82B22898`, constructor `sub_82B22770`, size
+//! `sub_82B22738`; spec `.claude/notes/aems-grain-chain-spec.md` §1): a single-sideband frequency
+//! shifter, mono.
+//!
+//! Per 256-frame block:
+//! 1. Two cascades of two allpass biquads (image tables at `0x82FCE2B0` / `0x82FCE2C4` → I and
+//!    `0x82FCE2D8` / `0x82FCE2EC` → Q; fixed constants, never recomputed) form a Hilbert pair, run
+//!    through the shared biquad kernel `sub_82B43AF8` ([`super::biquad::kernel`]).
+//! 2. A phase φ (state `+260`) advances by Δ = f32(f32(shift / rate) · 2π) per sample; the lanes of
+//!    each group of four are {φ, φ + Δ, φ + 2Δ, φ + 3Δ} and the group advances by 4Δ (`vaddfp`).
+//! 3. out = I · cos φ − Q · sin φ, with the XNA-style polynomial `XMVectorSin` / `XMVectorCos`
+//!    (`sub_824531C8` / `sub_82473930`: round(x / 2π) reduction, 11 odd / even Taylor terms).
+//! 4. Block end: φ' = (φ + 256·Δ) − trunc((φ + 256·Δ) / 2π) · 2π.
+//!
+//! The shift (parameter 0, `+52`, range ±96000 Hz) applies from the next block; there is no
+//! smoothing and no bypass: at 0 Hz the output is the I path, a phase-shifted (allpass) copy.
+//! The class's optional 64-tap band-limiting FIR (`sub_82B42510` / `sub_82B41D58`, active when the
+//! construction parameter is 1.0) is off in the board chain (`sub_824C8878` passes 0.0), so it is
+//! not ported.
+use super::biquad::{Coefficients, TWO_PI, kernel};
+
+/// The four allpass sections {a1, a2, b0, b1, b2} (I = 0, 1; Q = 2, 3), image `0x82FCE2B0`.
+pub const SECTIONS: [Coefficients; 4] = [
+    allpass(0xBFF6_20C5, 0x3F6C_7469),
+    allpass(0xBECD_B811, 0xBE5A_43B1),
+    allpass(0xBFFB_DFCD, 0x3F77_C5D9),
+    allpass(0xBFA1_A207, 0x3EB1_E001),
+];
+
+const fn allpass(a1: u32, a2: u32) -> Coefficients {
+    let (a1, a2) = (f32::from_bits(a1), f32::from_bits(a2));
+    Coefficients { a1, a2, b0: a2, b1: a1, b2: 1.0 }
+}
+
+/// 1/2π as the image holds it (`0x822F8904` for the wrap, lane 3 of `0x822F9850` for the trig).
+pub const INV_TWO_PI: f32 = f32::from_bits(0x3E22_F983);
+
+/// `XMVectorSin` coefficients for V³ … V²³ (`0x822F97C4` … `0x822F97EC`).
+const SIN: [u32; 11] = [
+    0xBE2A_AAAB, 0x3C08_8889, 0xB950_0D01, 0x3638_EF1D, 0xB2D7_322B, 0x2F30_9231, 0xAB57_3F9F, 0x274A_963C, 0xA317_A4DA, 0x1EB8_DC78,
+    0x9A3B_0DA1,
+];
+/// `XMVectorCos` coefficients for V² … V²² (`0x822F97F4` … `0x822F981C`).
+const COS: [u32; 11] = [
+    0xBF00_0000, 0x3D2A_AAAB, 0xBAB6_0B61, 0x37D0_0D01, 0xB493_F27E, 0x310F_76C8, 0xAD49_CBA5, 0x2957_3F9F, 0xA534_13C3, 0x20F2_A15D,
+    0x9C86_71CB,
+];
+
+fn c(table: &[u32; 11], k: usize) -> f32 {
+    f32::from_bits(table[k])
+}
+
+/// x − 2π · round(x / 2π) (`vrfin` = nearest, ties to even; fused `vnmsubfp`).
+fn reduce(x: f32) -> f32 {
+    let n = (x * INV_TWO_PI).round_ties_even();
+    (-TWO_PI).mul_add(n, x)
+}
+
+/// `XMVectorSin` per lane: powers by repeated ×V², terms accumulated with fused multiply-adds in
+/// ascending order. Retail's VMX flushes denormals; here a power that underflows stays denormal,
+/// which can only matter for |V| < 1e-30.
+pub fn sin(x: f32) -> f32 {
+    let v = reduce(x);
+    let v2 = v * v;
+    let mut p = v2 * v;
+    let mut r = c(&SIN, 0).mul_add(p, v);
+    for k in 1..11 {
+        p *= v2;
+        r = c(&SIN, k).mul_add(p, r);
+    }
+    r
+}
+
+/// `XMVectorCos` per lane. The powers come in retail's pairing (V⁴ = V²·V², V⁶ = V⁴·V², V⁸ = V⁴·V⁴,
+/// V¹⁰ = V⁶·V⁴, V¹² = V⁶·V⁶, V¹⁴ = V⁸·V⁶, V¹⁶ = V⁸·V⁸, V¹⁸ = V¹⁰·V⁸, V²⁰ = V¹⁰·V¹⁰, V²² = V¹²·V¹⁰);
+/// the terms are summed from 1 upwards with fused multiply-adds.
+pub fn cos(x: f32) -> f32 {
+    let v = reduce(x);
+    let v2 = v * v;
+    let v4 = v2 * v2;
+    let v6 = v4 * v2;
+    let v8 = v4 * v4;
+    let v10 = v6 * v4;
+    let v12 = v6 * v6;
+    let v14 = v8 * v6;
+    let v16 = v8 * v8;
+    let v18 = v10 * v8;
+    let v20 = v10 * v10;
+    let v22 = v12 * v10;
+    let powers = [v2, v4, v6, v8, v10, v12, v14, v16, v18, v20, v22];
+    let mut r = 1.0f32;
+    for (k, p) in powers.into_iter().enumerate() {
+        r = c(&COS, k).mul_add(p, r);
+    }
+    r
+}
+
+#[derive(Clone, Debug)]
+pub struct FrequencyShift {
+    /// Parameter 0: the shift in Hz (positive = up).
+    pub shift_hz: f32,
+    /// Oscillator phase (`+260`, radians, kept in (−2π, 2π) by the block-end wrap).
+    phase: f32,
+    /// Allpass histories {x1, x2, y1, y2} (`+56`, `+72`, `+88`, `+104`).
+    history: [[f32; 4]; 4],
+}
+
+impl Default for FrequencyShift {
+    fn default() -> Self {
+        Self { shift_hz: 0.0, phase: 0.0, history: [[0.0; 4]; 4] }
+    }
+}
+
+impl FrequencyShift {
+    pub fn phase(&self) -> f32 {
+        self.phase
+    }
+
+    /// Process one block in place (mono; `samples.len()` a multiple of 4, retail's is 256).
+    pub fn process(&mut self, samples: &mut [f32], rate: f32) {
+        let n = samples.len();
+        let mut i = [0.0f32; crate::BLOCK];
+        let mut q = [0.0f32; crate::BLOCK];
+        let (i, q) = (&mut i[..n], &mut q[..n]);
+        i.copy_from_slice(samples);
+        q.copy_from_slice(samples);
+        let [h0, h1, h2, h3] = &mut self.history;
+        kernel(&SECTIONS[0], h0, i);
+        kernel(&SECTIONS[1], h1, i);
+        kernel(&SECTIONS[2], h2, q);
+        kernel(&SECTIONS[3], h3, q);
+        let delta = (self.shift_hz / rate) * TWO_PI;
+        let phi = self.phase;
+        let mut lanes = [phi, phi + delta, delta.mul_add(2.0, phi), delta.mul_add(3.0, phi)];
+        let step = delta * 4.0;
+        for (g, out) in samples.chunks_exact_mut(4).enumerate() {
+            for (k, s) in out.iter_mut().enumerate() {
+                let at = 4 * g + k;
+                *s = i[at] * cos(lanes[k]) - q[at] * sin(lanes[k]);
+            }
+            for l in &mut lanes {
+                *l += step;
+            }
+        }
+        let end = delta.mul_add(n as f32, phi);
+        let turns = ((end * INV_TWO_PI) as i32) as f32;
+        self.phase = (-turns).mul_add(TWO_PI, end);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const RATE: f32 = 48000.0;
+
+    fn tone(f: f32, n: usize) -> Vec<f32> {
+        (0..n).map(|k| ((std::f64::consts::TAU * f as f64 * k as f64 / RATE as f64).sin() * 0.5) as f32).collect()
+    }
+
+    /// Amplitude of the component at `f` (single-bin DFT, f64).
+    fn amplitude(x: &[f32], f: f32) -> f64 {
+        let w = std::f64::consts::TAU * f as f64 / RATE as f64;
+        let (mut re, mut im) = (0.0f64, 0.0f64);
+        for (k, &s) in x.iter().enumerate() {
+            re += s as f64 * (w * k as f64).cos();
+            im -= s as f64 * (w * k as f64).sin();
+        }
+        2.0 * (re * re + im * im).sqrt() / x.len() as f64
+    }
+
+    fn shift(input: &[f32], hz: f32) -> Vec<f32> {
+        let mut fss = FrequencyShift { shift_hz: hz, ..Default::default() };
+        let mut x = input.to_vec();
+        for block in x.chunks_mut(crate::BLOCK) {
+            fss.process(block, RATE);
+        }
+        x
+    }
+
+    #[test]
+    fn coefficients_are_the_image_allpasses() {
+        assert_eq!(SECTIONS[0].a1, -1.922_875_0);
+        assert_eq!(SECTIONS[0].a2, 0.923_651_3);
+        assert_eq!(SECTIONS[1].a2, -0.213_148_85);
+        assert_eq!(SECTIONS[3].a1, -1.262_757_2);
+        for s in SECTIONS {
+            assert_eq!((s.b0, s.b1, s.b2), (s.a2, s.a1, 1.0));
+        }
+    }
+
+    #[test]
+    fn polynomial_trig_tracks_libm() {
+        let mut worst = (0.0f32, 0.0f32);
+        for k in -20000..=20000 {
+            let x = k as f32 * 0.000_7;
+            let es = (sin(x) - (x as f64).sin() as f32).abs();
+            let ec = (cos(x) - (x as f64).cos() as f32).abs();
+            worst = (worst.0.max(es), worst.1.max(ec));
+        }
+        assert!(worst.0 < 1e-6 && worst.1 < 1e-6, "{worst:?}");
+        assert_eq!(cos(0.0), 1.0);
+        assert_eq!(sin(0.0), 0.0);
+    }
+
+    #[test]
+    fn each_path_is_an_allpass_and_the_pair_is_in_quadrature() {
+        // Steady state of a tone through I and Q alone: unit magnitude; the phase difference is a
+        // quarter turn across the band the bed uses.
+        for f in [100.0f32, 300.0, 1000.0, 3000.0, 8000.0, 15000.0] {
+            let x = tone(f, 48000);
+            let mut i = x.clone();
+            let mut q = x.clone();
+            let mut h = [[0.0f32; 4]; 4];
+            for (bi, bq) in i.chunks_mut(256).zip(q.chunks_mut(256)) {
+                kernel(&SECTIONS[0], &mut h[0], bi);
+                kernel(&SECTIONS[1], &mut h[1], bi);
+                kernel(&SECTIONS[2], &mut h[2], bq);
+                kernel(&SECTIONS[3], &mut h[3], bq);
+            }
+            let (ai, aq) = (amplitude(&i[24000..], f), amplitude(&q[24000..], f));
+            assert!((ai - 0.5).abs() < 2e-3 && (aq - 0.5).abs() < 2e-3, "{f} Hz: |I| {ai}, |Q| {aq}");
+            // Quadrature: I² + Q² is flat (a 90° pair) — its ripple measures the phase error.
+            let env: Vec<f64> = i[24000..].iter().zip(&q[24000..]).map(|(&a, &b)| (a as f64).hypot(b as f64)).collect();
+            let (lo, hi) = env.iter().fold((f64::MAX, 0.0f64), |(l, h), &e| (l.min(e), h.max(e)));
+            let error_deg = ((hi - lo) / (hi + lo)).asin().to_degrees() * 2.0;
+            // The image pair's design (f64 response of the sections): within 0.6° from 100 Hz to
+            // 1 kHz, 6.1° at 8 kHz, 10° at 15 kHz; −47 / −74 / −25 dB image at 100 Hz / 1 kHz / 8 kHz.
+            let allowed = if f <= 1000.0 { 1.0 } else if f <= 8000.0 { 7.0 } else { 12.0 };
+            assert!(error_deg < allowed, "{f} Hz: quadrature error ≈ {error_deg:.2}°");
+        }
+    }
+
+    #[test]
+    fn a_tone_moves_by_the_shift() {
+        let x = tone(1000.0, 48000);
+        // Shifts on whole cycles of the 0.5 s analysis window (no DFT leakage between the bins).
+        for hz in [150.0f32, -52.0, 38.0] {
+            let y = shift(&x, hz);
+            let wanted = amplitude(&y[24000..], 1000.0 + hz);
+            let image = amplitude(&y[24000..], 1000.0 - hz);
+            let left = amplitude(&y[24000..], 1000.0);
+            assert!((wanted - 0.5).abs() < 5e-3, "{hz}: shifted tone {wanted}");
+            // −60 dB: the pair's −74 dB image at 1 kHz plus the oscillator's f32 phase noise.
+            assert!(image < 0.5e-3 && left < 0.5e-3, "{hz}: image {image}, carrier {left}");
+        }
+    }
+
+    #[test]
+    fn zero_hz_is_the_allpass_not_a_bypass() {
+        let x = tone(440.0, 4096);
+        let y = shift(&x, 0.0);
+        assert_ne!(x, y, "never a bypass");
+        let mut i = x.clone();
+        let mut h = [[0.0f32; 4]; 2];
+        for b in i.chunks_mut(256) {
+            kernel(&SECTIONS[0], &mut h[0], b);
+            kernel(&SECTIONS[1], &mut h[1], b);
+        }
+        // cos 0 = 1, sin 0 = 0: exactly the I path.
+        assert_eq!(y, i);
+    }
+
+    #[test]
+    fn phase_wraps_per_block_and_stays_bounded() {
+        let mut fss = FrequencyShift { shift_hz: 1234.5, ..Default::default() };
+        let mut x = [0.0f32; crate::BLOCK];
+        for _ in 0..10_000 {
+            fss.process(&mut x, RATE);
+            assert!(fss.phase().abs() < TWO_PI);
+        }
+        let mut fss = FrequencyShift { shift_hz: -150.0, ..Default::default() };
+        fss.process(&mut x, RATE);
+        let d = (-150.0f32 / RATE) * TWO_PI;
+        let end = d.mul_add(256.0, 0.0);
+        assert_eq!(fss.phase(), end, "less than a turn: no wrap, sign kept");
+    }
+}
diff --git a/crates/skate-audio/src/dsp/gain.rs b/crates/skate-audio/src/dsp/gain.rs
new file mode 100644
index 00000000..63a30d4f
--- /dev/null
+++ b/crates/skate-audio/src/dsp/gain.rs
@@ -0,0 +1,79 @@
+//! Gain (Gai0, spec §4.6): a 64-sample linear de-click on every target change, then flat.
+//! On the graph's first block the applied gain jumps to the target (no ramp).
+
+#[derive(Clone, Debug)]
+pub struct Gain {
+    /// Parameter 0: target gain (linear amplitude).
+    pub target: f32,
+    applied: f32,
+    started: bool,
+}
+
+impl Default for Gain {
+    fn default() -> Self {
+        Self { target: 1.0, applied: 1.0, started: false }
+    }
+}
+
+impl Gain {
+    pub fn applied(&self) -> f32 {
+        self.applied
+    }
+
+    pub fn process(&mut self, channels: &mut [&mut [f32]]) {
+        if !self.started {
+            self.applied = self.target;
+            self.started = true;
+        }
+        let start = self.applied;
+        // Two roundings, never fused.
+        let step = (self.target - start) * (1.0 / 64.0);
+        if step == 0.0 {
+            if start != 1.0 {
+                for ch in channels.iter_mut() {
+                    for s in ch.iter_mut() {
+                        *s *= start;
+                    }
+                }
+            }
+        } else {
+            for ch in channels.iter_mut() {
+                ramp(ch, start, step);
+            }
+        }
+        self.applied = self.target;
+    }
+}
+
+/// The de-click kernel: samples 0..63 × a gain ramping from `start` by `step`, the rest ×
+/// (start + 64·step). Lanes are built per group of 8 as (start + 8g·step) + m·step with plain
+/// (unfused) single-precision operations. Against the PoC's replay-verified kernel
+/// (tests/dsp_oracle.rs): the flat part and power-of-two steps are bit-exact; with an irregular
+/// step 11 of 64 ramp samples differ by 1 ulp (the exact lane arithmetic is not recovered).
+pub fn ramp(samples: &mut [f32], start: f32, step: f32) {
+    let flat = start + 64.0 * step;
+    for (k, s) in samples.iter_mut().enumerate() {
+        *s *= if k < 64 { (start + (8 * (k / 8)) as f32 * step) + (k % 8) as f32 * step } else { flat };
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn first_block_jumps_then_changes_ramp_over_64_samples() {
+        let mut g = Gain { target: 0.5, ..Gain::default() };
+        let mut x = vec![1.0f32; 256];
+        g.process(&mut [&mut x[..]]);
+        assert!(x.iter().all(|&v| v == 0.5));
+        g.target = 0.0;
+        let mut x = vec![1.0f32; 256];
+        g.process(&mut [&mut x[..]]);
+        assert_eq!(x[0], 0.5);
+        assert_eq!(x[32], 0.5 + 32.0 * (-0.5 / 64.0));
+        assert_eq!(x[63], (0.5 + 56.0 * (-0.5 / 64.0)) + 7.0 * (-0.5 / 64.0));
+        assert!(x[64..].iter().all(|&v| v == 0.0));
+        assert_eq!(g.applied(), 0.0);
+    }
+}
diff --git a/crates/skate-audio/src/dsp/mod.rs b/crates/skate-audio/src/dsp/mod.rs
new file mode 100644
index 00000000..d379e14c
--- /dev/null
+++ b/crates/skate-audio/src/dsp/mod.rs
@@ -0,0 +1,20 @@
+//! Voice-graph modules (spec: `.claude/notes/aems-voice-graph-spec.md` §4, §6).
+//!
+//! Each module processes one 256-frame block of planar f32 channels at the block's rate.
+pub mod biquad;
+pub mod delay;
+pub mod fss;
+pub mod gain;
+pub mod pan;
+pub mod peaking;
+pub mod resample;
+pub mod reverb;
+pub mod routes;
+pub mod send;
+pub mod shelf;
+
+/// 1/32767 as the retail cell holds it (0x822F8898): converts 15-bit levels to linear gain.
+pub const INV_32767: f32 = 0.000_030_518_509;
+
+/// Degrees per azimuth unit (65536 = 360°), cell 0x822F88E8.
+pub const DEGREES_PER_UNIT: f32 = 360.0 / 65536.0;
diff --git a/crates/skate-audio/src/dsp/pan.rs b/crates/skate-audio/src/dsp/pan.rs
new file mode 100644
index 00000000..0710a98f
--- /dev/null
+++ b/crates/skate-audio/src/dsp/pan.rs
@@ -0,0 +1,290 @@
+//! Pan2D1 (Pn21, spec §4.9): places 1, 2, 4 or 6 source channels on the 6-channel layout
+//! L (+30°), C (0°), R (−30°), Ls (+110°), Rs (−110°), LFE in internal angles; the azimuth
+//! parameter is in degrees, positive = to the right, internal angle θ = −A.
+//!
+//! On the speaker circle (distance 1): constant-power pairwise panning with centre extraction in
+//! the front sector. Inside the circle: a distance spread blended with the angular term and
+//! renormalised. A parameter change ramps every matrix cell over 64 samples.
+//!
+//! Computed in f64 and stored as f32: not bit-exact with retail's single-precision code (its
+//! constructor and speaker tables are unverified), checked against the spec's worked gains.
+
+/// Parameter indices.
+pub const ANGLE: usize = 0;
+pub const DISTANCE: usize = 1;
+pub const RADIUS: usize = 2;
+pub const TURN: usize = 3;
+pub const FOCUS: usize = 4;
+pub const LEVEL: usize = 5;
+pub const LFE: usize = 6;
+pub const SPREAD1: usize = 7;
+pub const SPREAD2: usize = 8;
+pub const SPREAD3: usize = 9;
+
+/// Class defaults.
+pub const DEFAULTS: [f32; 10] = [0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 30.0, 110.0, 150.0];
+
+/// Speaker angles (internal degrees) of the 5 full-range outputs L, C, R, Ls, Rs.
+const SPEAKERS: [f64; 5] = [30.0, 0.0, -30.0, 110.0, -110.0];
+
+#[derive(Clone, Debug)]
+pub struct Pan2D {
+    pub params: [f32; 10],
+    sources: usize,
+    /// Law gain: voices open with law 0 → 1.0.
+    law: f32,
+    /// Row = source (up to 6), column = output (6).
+    matrix: [[f32; 6]; 6],
+    cache: Option<[f32; 10]>,
+}
+
+impl Pan2D {
+    pub fn new(sources: usize) -> Self {
+        Self { params: DEFAULTS, sources: sources.clamp(1, 6), law: 1.0, matrix: [[0.0; 6]; 6], cache: None }
+    }
+
+    pub fn sources(&self) -> usize {
+        self.sources
+    }
+
+    /// The current gain matrix (row = source, column = output), rebuilt from the parameters.
+    pub fn matrix(&mut self) -> [[f32; 6]; 6] {
+        if self.cache.map(|c| c.iter().zip(&self.params).any(|(a, b)| a.to_bits() != b.to_bits())).unwrap_or(true) {
+            self.matrix = build(&self.params, self.sources, self.law);
+        }
+        self.matrix
+    }
+
+    /// Pan one block: `src` planar (self.sources channels) → `out` 6 planar channels (overwritten).
+    pub fn process(&mut self, src: &[&[f32]], out: &mut [[f32; crate::BLOCK]; 6]) {
+        let changed = self.cache.is_none_or(|c| c.iter().zip(&self.params).any(|(a, b)| a.to_bits() != b.to_bits() || b.is_nan()));
+        let first = self.cache.is_none();
+        let old = self.matrix;
+        if changed {
+            self.matrix = build(&self.params, self.sources, self.law);
+            self.cache = Some(self.params);
+        }
+        let new = self.matrix;
+        for d in 0..6 {
+            out[d] = [0.0; crate::BLOCK];
+        }
+        for (s, input) in src.iter().enumerate().take(self.sources) {
+            for d in 0..6 {
+                let (from, to) = (old[s][d], new[s][d]);
+                let o = &mut out[d];
+                if !changed || first || from == to {
+                    if to != 0.0 {
+                        for (k, &x) in input.iter().enumerate() {
+                            o[k] += to * x;
+                        }
+                    }
+                } else {
+                    let delta = (to - from) / 64.0;
+                    for (k, &x) in input.iter().enumerate() {
+                        let g = if k < 64 { from + k as f32 * delta } else { to };
+                        o[k] += g * x;
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Clamp a position to the unit disc: r² > 1 → normalised; 0.999 < r² < 1 → r² treated as 1.
+fn clamp(x: f64, y: f64) -> (f64, f64, f64) {
+    let r2 = x * x + y * y;
+    if r2 > 1.0 {
+        let r = r2.sqrt();
+        (x / r, y / r, 1.0)
+    } else if r2 > 0.999 {
+        (x, y, 1.0)
+    } else {
+        (x, y, r2)
+    }
+}
+
+/// Gains on L, C, R, Ls, Rs for a point source at (x, y) (internal frame, x forward, y left).
+pub fn point_gains(x: f64, y: f64, focus: f64) -> [f64; 5] {
+    let (x, y, r2) = clamp(x, y);
+    let mut g = [0.0f64; 5];
+    if r2 < 1.0 {
+        let w: Vec<f64> = SPEAKERS
+            .iter()
+            .map(|a| {
+                let (sx, sy) = (a.to_radians().cos(), a.to_radians().sin());
+                1.0 - 0.5 * ((sx - x).powi(2) + (sy - y).powi(2)).sqrt()
+            })
+            .collect();
+        let mut front = 0.5 * (x + 1.0);
+        let mut back = 1.0 - front;
+        if front < 5e-4 {
+            front = 0.0;
+        }
+        if back < 5e-4 {
+            back = 0.0;
+        }
+        let wc = w[1] * focus;
+        let fd = w[0] * w[0] + w[2] * w[2] + wc * wc;
+        let f = if fd > 0.0 { (front / fd).sqrt() } else { 0.0 };
+        let bd = w[3] * w[3] + w[4] * w[4];
+        let b = if bd > 0.0 { (back / bd).sqrt() } else { 0.0 };
+        let fade = (1.0 - r2 * r2).sqrt();
+        g = [f * w[0] * fade, f * wc * fade, f * w[2] * fade, b * w[3] * fade, b * w[4] * fade];
+    }
+    if r2 > 0.0 {
+        let mut theta = y.atan2(x).to_degrees();
+        if theta < -30.0 {
+            theta += 360.0;
+        }
+        // Sectors: [−30, 30) R–L, [30, 110) L–Ls, [110, 250) Ls–Rs, [250, 330) Rs–R.
+        let (ia, alpha, ib, beta) = if theta < 30.0 {
+            (2, -30.0, 0, 30.0)
+        } else if theta < 110.0 {
+            (0, 30.0, 3, 110.0)
+        } else if theta < 250.0 {
+            (3, 110.0, 4, 250.0)
+        } else {
+            (4, 250.0, 2, 330.0)
+        };
+        let span = ((beta - alpha) as f64).to_radians().sin();
+        let mut a = ((beta - theta) as f64).to_radians().sin() / span;
+        let mut b = ((theta - alpha) as f64).to_radians().sin() / span;
+        let mut angular = [0.0f64; 5];
+        if ia == 2 && ib == 0 {
+            // Front sector: extract the shared part into the centre.
+            let share = a.min(b) * focus;
+            a -= share;
+            b -= share;
+            angular[1] = 3f64.sqrt() * share;
+        }
+        angular[ia] += a;
+        angular[ib] += b;
+        let norm = angular.iter().map(|v| v * v).sum::<f64>().sqrt();
+        if norm > 0.0 {
+            for (gk, ak) in g.iter_mut().zip(angular) {
+                *gk += ak * r2 / norm;
+            }
+        }
+    }
+    if r2 < 1.0 {
+        let norm = g.iter().map(|v| v * v).sum::<f64>().sqrt();
+        if norm > 0.0 {
+            for gk in &mut g {
+                *gk /= norm;
+            }
+        }
+    }
+    g
+}
+
+fn build(p: &[f32; 10], sources: usize, law: f32) -> [[f32; 6]; 6] {
+    let deg = |v: f32| f64::from(v).to_radians();
+    let focus = f64::from(p[FOCUS]);
+    let scale = f64::from(p[LEVEL]) * f64::from(law);
+    let mut m = [[0.0f32; 6]; 6];
+    let row = |x: f64, y: f64| -> [f32; 6] {
+        let g = point_gains(x, y, focus);
+        [(g[0] * scale) as f32, (g[1] * scale) as f32, (g[2] * scale) as f32, (g[3] * scale) as f32, (g[4] * scale) as f32, 0.0]
+    };
+    let d = f64::from(p[DISTANCE]);
+    let theta = -deg(p[ANGLE]);
+    if sources == 1 {
+        m[0] = row(d * theta.cos(), d * theta.sin());
+        m[0][5] = p[LFE];
+        return m;
+    }
+    // Multichannel: entries around the layout centre.
+    let (cx, cy) = (d * theta.cos(), d * theta.sin());
+    let radius = f64::from(p[RADIUS]);
+    let base = -deg(p[ANGLE] + p[TURN]);
+    let (s1, s2) = (deg(p[SPREAD1]), deg(p[SPREAD2]));
+    let offsets: &[Option<f64>] = match sources {
+        2 => &[Some(s1), Some(-s1)],
+        4 => &[Some(s1), Some(-s1), Some(s2), Some(-s2)],
+        6 => &[Some(s1), Some(0.0), Some(-s1), Some(s2), Some(-s2), None],
+        _ => &[],
+    };
+    for (s, offset) in offsets.iter().enumerate() {
+        match offset {
+            Some(o) => {
+                let a = base + o;
+                m[s] = row(cx + radius * a.cos(), cy + radius * a.sin());
+                if sources != 6 {
+                    m[s][5] = p[LFE];
+                }
+            }
+            None => m[s][5] = p[LFE],
+        }
+    }
+    m
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Spec worked gains (mono, focus = level = 1): A (deg), D, focus → L, C, R, Ls, Rs.
+    #[test]
+    fn worked_gains_from_the_spec() {
+        let cases: &[(f32, f32, f32, [f32; 5])] = &[
+            (0.0, 1.0, 1.0, [0.0, 1.0, 0.0, 0.0, 0.0]),
+            (-30.0, 1.0, 1.0, [1.0, 0.0, 0.0, 0.0, 0.0]),
+            (30.0, 1.0, 1.0, [0.0, 0.0, 1.0, 0.0, 0.0]),
+            (-15.0, 1.0, 1.0, [0.7071, 0.7071, 0.0, 0.0, 0.0]),
+            (-15.0, 1.0, 0.0, [0.9391, 0.0, 0.3437, 0.0, 0.0]),
+            (-90.0, 1.0, 1.0, [0.3673, 0.0, 0.0, 0.9301, 0.0]),
+            (90.0, 1.0, 1.0, [0.0, 0.0, 0.3673, 0.0, 0.9301]),
+            (180.0, 1.0, 1.0, [0.0, 0.0, 0.0, 0.7071, 0.7071]),
+            (-150.0, 1.0, 1.0, [0.0, 0.0, 0.0, 0.8374, 0.5466]),
+            (0.0, 0.5, 1.0, [0.4196, 0.6791, 0.4196, 0.3055, 0.3055]),
+            (-90.0, 0.5, 1.0, [0.4927, 0.3226, 0.2477, 0.7437, 0.1970]),
+            (180.0, 0.5, 1.0, [0.2411, 0.2211, 0.2411, 0.6461, 0.6461]),
+            (47.0, 0.0, 1.0, [0.4082, 0.4082, 0.4082, 0.5, 0.5]),
+        ];
+        for &(a, d, focus, want) in cases {
+            let mut p = Pan2D::new(1);
+            p.params[ANGLE] = a;
+            p.params[DISTANCE] = d;
+            p.params[FOCUS] = focus;
+            let m = p.matrix();
+            for k in 0..5 {
+                assert!((m[0][k] - want[k]).abs() < 1.5e-4, "A {a} D {d} focus {focus}: {:?} vs {want:?}", &m[0][..5]);
+            }
+            assert_eq!(m[0][5], 0.0);
+        }
+    }
+
+    #[test]
+    fn multichannel_defaults_land_each_channel_on_its_speaker() {
+        // The open's defaults: distance 0, radius 1, spreads = speaker angles.
+        let mut p = Pan2D::new(6);
+        p.params[DISTANCE] = 0.0;
+        let m = p.matrix();
+        for s in 0..5 {
+            for d in 0..5 {
+                let want = if s == d { 1.0 } else { 0.0 };
+                assert!((m[s][d] - want).abs() < 1e-5, "{s}->{d}: {}", m[s][d]);
+            }
+        }
+        // Stereo pair at ±45° (bank descriptors 224/32 → −45°/+45°): channel 0 leans left.
+        let mut p = Pan2D::new(2);
+        p.params[DISTANCE] = 0.0;
+        p.params[SPREAD1] = 45.0;
+        let m = p.matrix();
+        assert!(m[0][0] > m[0][2] && m[1][2] > m[1][0]);
+    }
+
+    #[test]
+    fn parameter_change_ramps_over_64_samples() {
+        let mut p = Pan2D::new(1);
+        let x = vec![1.0f32; crate::BLOCK];
+        let mut out = [[0.0f32; crate::BLOCK]; 6];
+        p.process(&[&x], &mut out);
+        assert!(out[1].iter().all(|&v| (v - 1.0).abs() < 1e-6));
+        p.params[ANGLE] = -30.0;
+        p.process(&[&x], &mut out);
+        assert!((out[1][0] - 1.0).abs() < 1e-6 && out[0][0].abs() < 1e-6);
+        assert!((out[1][32] - 0.5).abs() < 1e-3 && (out[0][32] - 0.5).abs() < 1e-3);
+        assert!(out[1][64].abs() < 1e-6 && (out[0][64] - 1.0).abs() < 1e-6);
+    }
+}
diff --git a/crates/skate-audio/src/dsp/peaking.rs b/crates/skate-audio/src/dsp/peaking.rs
new file mode 100644
index 00000000..a15e7cab
--- /dev/null
+++ b/crates/skate-audio/src/dsp/peaking.rs
@@ -0,0 +1,117 @@
+//! PeakingIir2 (PI20, `sub_82B2C658`; spec `aems-voice-graph-spec.md` §4.10): an RBJ peaking EQ.
+//! Parameters: 0 = centre (Hz), 1 = linear gain, 2 = Q. Class defaults 96000 Hz / 1.0 / 3.0. The
+//! module bypasses (pass-through, history cleared once) only when the gain is exactly 1.0; ω is
+//! clamped to [FLOOR, CEIL] and Q to 0.2..20 for the coefficients. Same Direct Form I kernel as
+//! the high/low-pass ([`super::biquad::kernel`]). Not bit-exact against retail (no replay vectors:
+//! the coefficient arithmetic is RBJ in f32 with libm trig, UNCERTAIN to the ulp).
+use super::biquad::{CEIL, Coefficients, FLOOR, kernel, omega};
+
+#[derive(Clone, Debug)]
+pub struct PeakingIir2 {
+    pub freq: f32,
+    pub gain: f32,
+    pub q: f32,
+    cached: Option<[u32; 3]>,
+    coefficients: Coefficients,
+    history: [[f32; 4]; 8],
+    filtering: bool,
+}
+
+impl Default for PeakingIir2 {
+    fn default() -> Self {
+        Self { freq: 96_000.0, gain: 1.0, q: 3.0, cached: None, coefficients: Coefficients::default(), history: [[0.0; 4]; 8], filtering: false }
+    }
+}
+
+/// RBJ peaking coefficients (A = √gain, α = sin ω / 2Q), normalised by a0, in f32.
+pub fn coefficients(freq: f32, gain: f32, q: f32, rate: f32) -> Coefficients {
+    let w = omega(freq, rate);
+    let w = if w.is_nan() { CEIL } else { w.clamp(FLOOR, CEIL) };
+    let q = q.clamp(0.2, 20.0);
+    let a = gain.max(0.0).sqrt();
+    let s = (w as f64).sin() as f32;
+    let c = (w as f64).cos() as f32;
+    let alpha = s / (2.0 * q);
+    let a0 = 1.0 + alpha / a;
+    let inv = 1.0 / a0;
+    Coefficients {
+        b0: (1.0 + alpha * a) * inv,
+        b1: (-2.0 * c) * inv,
+        b2: (1.0 - alpha * a) * inv,
+        a1: (-2.0 * c) * inv,
+        a2: (1.0 - alpha / a) * inv,
+    }
+}
+
+impl PeakingIir2 {
+    pub fn bypassed(&self) -> bool {
+        self.gain == 1.0
+    }
+
+    pub fn process(&mut self, channels: &mut [&mut [f32]], rate: f32) {
+        if self.gain == 1.0 {
+            if self.filtering {
+                self.history = [[0.0; 4]; 8];
+            }
+            self.filtering = false;
+            return;
+        }
+        let key = [self.freq.to_bits(), self.gain.to_bits(), self.q.to_bits()];
+        if self.cached != Some(key) {
+            self.coefficients = coefficients(self.freq, self.gain, self.q, rate);
+            self.cached = Some(key);
+        }
+        self.filtering = true;
+        for (ch, samples) in channels.iter_mut().enumerate().take(8) {
+            kernel(&self.coefficients, &mut self.history[ch], samples);
+        }
+    }
+}
+
+/// DCl0 (`sub_82B22678`): hard clip to ±level; bypass when level ≥ 100 or NaN.
+pub fn clip(channels: &mut [&mut [f32]], level: f32) {
+    if level.is_nan() || level >= 100.0 {
+        return;
+    }
+    for ch in channels.iter_mut() {
+        for s in ch.iter_mut() {
+            *s = s.clamp(-level, level);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tone_gain(eq: &mut PeakingIir2, f: f32) -> f32 {
+        let mut x: Vec<f32> = (0..48000).map(|i| (std::f32::consts::TAU * f * i as f32 / 48000.0).sin()).collect();
+        for chunk in x.chunks_mut(256) {
+            eq.process(&mut [chunk], 48000.0);
+        }
+        let tail = &x[24000..];
+        (tail.iter().map(|v| v * v).sum::<f32>() / tail.len() as f32).sqrt() * std::f32::consts::SQRT_2
+    }
+
+    #[test]
+    fn peak_gain_at_the_centre_and_flat_far_away() {
+        let mut eq = PeakingIir2 { freq: 1000.0, gain: 2.0, q: 1.0, ..Default::default() };
+        assert!((tone_gain(&mut eq, 1000.0) - 2.0).abs() < 0.02);
+        let mut eq = PeakingIir2 { freq: 1000.0, gain: 0.25, q: 1.0, ..Default::default() };
+        assert!((tone_gain(&mut eq, 1000.0) - 0.25).abs() < 0.01);
+        assert!((tone_gain(&mut eq, 20.0) - 1.0).abs() < 0.03);
+    }
+
+    #[test]
+    fn gain_one_is_a_bit_exact_bypass() {
+        let mut eq = PeakingIir2 { freq: 500.0, ..Default::default() };
+        let mut x: Vec<f32> = (0..256).map(|i| (i as f32 * 0.3).sin()).collect();
+        let before = x.clone();
+        eq.process(&mut [&mut x[..]], 48000.0);
+        assert_eq!(x, before);
+        let mut c = vec![0.5f32, -0.2, 0.09];
+        clip(&mut [&mut c[..]], 0.1);
+        assert_eq!(c, vec![0.1, -0.1, 0.09]);
+        clip(&mut [&mut c[..]], 100.0);
+    }
+}
diff --git a/crates/skate-audio/src/dsp/resample.rs b/crates/skate-audio/src/dsp/resample.rs
new file mode 100644
index 00000000..749bbdd7
--- /dev/null
+++ b/crates/skate-audio/src/dsp/resample.rs
@@ -0,0 +1,138 @@
+//! Resample (Rsp0): linear interpolation with a 16.16 phase, no anti-alias filter (spec §4.3).
+//!
+//! ratio = f32(f32(source rate / 48000) × pitch scale); step = ratio·65536 rounded half away from
+//! zero, at most 2^18 (4×). Each output is a + (b − a)·(frac·W) as one fused multiply-add, with
+//! W = f32 0x377FFC9C (not exactly 1/65536). The block structure of retail's pull (carried tail,
+//! look-ahead) only splits the same continuous stream, so we interpolate the stream directly.
+
+/// The interpolation weight constant (≈ 1/65536, about one part in 2^21 off).
+pub const WEIGHT: f32 = f32::from_bits(0x377F_FC9C);
+/// Step ceiling: 2^18 = ratio 4.0 (MAX_RESAMPLE_RATIO).
+pub const MAX_STEP: u32 = 1 << 18;
+
+/// The resample ratio for a source rate and pitch scale (two single roundings).
+pub fn ratio(source_rate: u32, scale: f32) -> f32 {
+    (source_rate as f32 / crate::MIX_RATE as f32) * scale
+}
+
+/// 16.16 step for a ratio: rounded half away from zero, clamped to [0, 2^18].
+pub fn step(ratio: f32) -> u32 {
+    let x = ratio * 65536.0;
+    if x.is_nan() || x <= 0.0 {
+        return 0;
+    }
+    let s = (x + 0.5) as u64; // positive: half away from zero
+    s.min(u64::from(MAX_STEP)) as u32
+}
+
+#[derive(Clone, Debug)]
+pub struct Resampler {
+    /// Source frame index of the left interpolation point.
+    pub position: u64,
+    /// Fraction (low 16 bits used).
+    pub frac: u32,
+    pub step: u32,
+    cached_ratio: f32,
+}
+
+impl Default for Resampler {
+    fn default() -> Self {
+        Self { position: 0, frac: 0, step: 65536, cached_ratio: f32::NAN }
+    }
+}
+
+impl Resampler {
+    /// Recompute the step when the ratio changes (exact compare, as retail).
+    pub fn set_ratio(&mut self, ratio: f32) {
+        if ratio.to_bits() != self.cached_ratio.to_bits() {
+            self.cached_ratio = ratio;
+            self.step = step(ratio);
+        }
+    }
+
+    /// Render `out.len()` frames of one channel from `frame(index)`. Returns nothing; call
+    /// [`Resampler::advance`] once per block after all channels.
+    pub fn render(&self, out: &mut [f32], mut frame: impl FnMut(u64) -> f32) {
+        let (mut position, mut frac) = (self.position, self.frac);
+        let mut a = frame(position);
+        let mut b = frame(position + 1);
+        for o in out.iter_mut() {
+            let w = frac as f32 * WEIGHT;
+            *o = (b - a).mul_add(w, a);
+            frac += self.step;
+            let carry = u64::from(frac >> 16);
+            frac &= 0xFFFF;
+            if carry > 0 {
+                position += carry;
+                if carry == 1 {
+                    a = b;
+                } else {
+                    a = frame(position);
+                }
+                b = frame(position + 1);
+            }
+        }
+    }
+
+    /// Advance the phase by `frames` output frames.
+    pub fn advance(&mut self, frames: usize) {
+        let total = u64::from(self.frac) + u64::from(self.step) * frames as u64;
+        self.position += total >> 16;
+        self.frac = (total & 0xFFFF) as u32;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ratio_and_step_rules() {
+        // Measured in the recomp trace: 44100 Hz at scale 0.9749 → ratio 0.8956.
+        let r = ratio(44100, 0.9749);
+        assert!((r - 0.8956).abs() < 1e-4);
+        assert_eq!(step(1.0), 65536);
+        assert_eq!(step(0.5), 32768);
+        assert_eq!(step(4.0), MAX_STEP);
+        assert_eq!(step(7.5), MAX_STEP);
+        assert_eq!(step(0.0), 0);
+        // Half away from zero: 1.5/65536 → 2.
+        assert_eq!(step(1.5 / 65536.0), 2);
+    }
+
+    #[test]
+    fn unity_pitch_is_an_exact_copy() {
+        let src: Vec<f32> = (0..600).map(|i| (i as f32 * 0.37).sin()).collect();
+        let mut r = Resampler::default();
+        r.set_ratio(ratio(48000, 1.0));
+        let mut out = vec![0.0; 256];
+        r.render(&mut out, |i| src.get(i as usize).copied().unwrap_or(0.0));
+        assert_eq!(&out[..], &src[..256]);
+        r.advance(256);
+        r.render(&mut out, |i| src.get(i as usize).copied().unwrap_or(0.0));
+        assert_eq!(&out[..], &src[256..512]);
+    }
+
+    #[test]
+    fn half_rate_interpolates_with_the_retail_weight() {
+        let src = [0.0f32, 1.0, 0.0, -1.0, 0.0];
+        let mut r = Resampler::default();
+        r.set_ratio(0.5);
+        let mut out = vec![0.0; 6];
+        r.render(&mut out, |i| src.get(i as usize).copied().unwrap_or(0.0));
+        let half = (32768.0f32 * WEIGHT) * 1.0;
+        assert_eq!(out, vec![0.0, half, 1.0, 1.0 - half, 0.0, -half]);
+        // WEIGHT is just below 1/65536.
+        assert!(half < 0.5 && half > 0.4999);
+    }
+
+    #[test]
+    fn advance_matches_render_position() {
+        let mut r = Resampler::default();
+        r.set_ratio(ratio(44100, 1.1478));
+        let step = u64::from(r.step);
+        r.advance(256);
+        assert_eq!(r.position, (step * 256) >> 16);
+        assert_eq!(u64::from(r.frac), (step * 256) & 0xFFFF);
+    }
+}
diff --git a/crates/skate-audio/src/dsp/reverb.rs b/crates/skate-audio/src/dsp/reverb.rs
new file mode 100644
index 00000000..53f1ea84
--- /dev/null
+++ b/crates/skate-audio/src/dsp/reverb.rs
@@ -0,0 +1,230 @@
+//! ReverbModel1 (RM10, process `sub_82B2F8C0`; spec `aems-env-bus-spec.md` §8.2, §8.3): mono in,
+//! six parallel Moorer combs (a one-pole low-pass in each feedback loop) into one all-pass, wet
+//! only. p0 = reverb time T60 (s; ≤ 0 → silence, else at least 0.366 s), p1 = space size (m,
+//! clamped 2 … 83.3), p2 = brightness.
+//!
+//! - Distances: near = 0.8·S, far = 1.5·near (far > 100 → far 100, near 66.666664); six evenly
+//!   spaced from near to far. Delay of comb i = the first prime strictly above 48000·dᵢ/344.8,
+//!   the search continuing from the previous comb's prime.
+//! - g1ᵢ (damping) = linear interpolation over the distance knots 0, 12.5, …, 100 of
+//!   0.08·row25k + 0.92·row50k (image tables 0x8211621C / 0x82116264). Brightness quirk: only when
+//!   p2 differs from the last applied brightness (constructor 1.0): b = max(p2, g1[5] + 0.001),
+//!   every g1 /= b and the comb states are zeroed.
+//! - g2ᵢ = (1 − g1ᵢ)·(1 − 0.366/T).
+//! - Comb: s[n] = x[n] + g2·s[n−D] + g1·s[n−1]; out = (s[n−D] − g1·s[n−D−1]) / 6.
+//! - All-pass: a[n] = c[n] − 0.7·a[n−288]; y[n] = 2·(0.7·a[n] + a[n−288]).
+//!
+//! UNCERTAIN (spec §8.3): the tap alignment (n−D vs n−D−1), how many blocks retail waits before a
+//! new configuration is heard (its module timer; we apply it at the next block), whether resizes
+//! clear the lines (we zero them), the f32 association of the vectorised kernels.
+
+const SPEED_OF_SOUND_INV: f32 = 0.002_900_232_1;
+const KNOTS: [f32; 9] = [0.0, 12.5, 25.0, 37.5, 50.0, 62.5, 75.0, 87.5, 100.0];
+const ROW_25K: [f32; 9] = [0.0, 0.12, 0.23, 0.30, 0.35, 0.40, 0.43, 0.46, 0.50];
+const ROW_50K: [f32; 9] = [0.0, 0.31, 0.45, 0.53, 0.57, 0.61, 0.64, 0.67, 0.70];
+const MIN_TIME: f32 = 0.366;
+const ALLPASS_GAIN: f32 = 0.7;
+const ALLPASS_DELAY: usize = 288;
+
+/// The primes 2 … 13999 (the image's table at 0x821147D0 holds these 1652 values as floats).
+fn primes() -> &'static [u32] {
+    static PRIMES: std::sync::OnceLock<Vec<u32>> = std::sync::OnceLock::new();
+    PRIMES.get_or_init(|| {
+        let n = 14_000usize;
+        let mut sieve = vec![true; n];
+        sieve[0] = false;
+        sieve[1] = false;
+        let mut i = 2;
+        while i * i < n {
+            if sieve[i] {
+                let mut j = i * i;
+                while j < n {
+                    sieve[j] = false;
+                    j += i;
+                }
+            }
+            i += 1;
+        }
+        (0..n as u32).filter(|&k| sieve[k as usize]).collect()
+    })
+}
+
+#[derive(Clone, Debug, Default)]
+struct Comb {
+    line: Vec<f32>,
+    at: usize,
+    delay: usize,
+    g1: f32,
+    g2: f32,
+    last: f32,
+}
+
+#[derive(Clone, Debug)]
+pub struct ReverbModel1 {
+    pub time: f32,
+    pub size: f32,
+    pub brightness: f32,
+    applied: Option<[u32; 3]>,
+    applied_size: Option<u32>,
+    last_brightness: f32,
+    combs: [Comb; 6],
+    allpass: Vec<f32>,
+    ap_at: usize,
+}
+
+impl Default for ReverbModel1 {
+    fn default() -> Self {
+        Self {
+            time: 0.0,
+            size: 0.0,
+            brightness: 1.0,
+            applied: None,
+            applied_size: None,
+            last_brightness: 1.0,
+            combs: Default::default(),
+            allpass: vec![0.0; ALLPASS_DELAY],
+            ap_at: 0,
+        }
+    }
+}
+
+/// The six comb distances (m) for a space size.
+pub fn distances(size: f32) -> [f32; 6] {
+    let s = size.clamp(2.0, 83.3);
+    let mut near = 0.8 * s;
+    let mut far = 1.5 * near;
+    if far > 100.0 {
+        far = 100.0;
+        near = 66.666_664;
+    }
+    let mut d = [0.0; 6];
+    for (k, v) in d.iter_mut().enumerate() {
+        *v = if k == 5 { far } else { near + k as f32 * 0.2 * (far - near) };
+    }
+    d
+}
+
+/// The six comb delays (samples): successive primes above 48000·d/344.8.
+pub fn delays(distances: &[f32; 6]) -> [usize; 6] {
+    let p = primes();
+    let mut from = 0;
+    let mut out = [0; 6];
+    for (o, &d) in out.iter_mut().zip(distances) {
+        let x = 48000.0 * d * SPEED_OF_SOUND_INV;
+        while from < p.len() && p[from] as f32 <= x {
+            from += 1;
+        }
+        let k = from.min(p.len() - 1);
+        *o = p[k] as usize;
+        from = k + 1;
+    }
+    out
+}
+
+/// g1 at a distance: the knot interpolation of 0.08·row25k + 0.92·row50k.
+pub fn damping(distance: f32) -> f32 {
+    let row = |i: usize| 0.08 * ROW_25K[i] + 0.92 * ROW_50K[i];
+    let d = distance.clamp(0.0, 100.0);
+    let i = ((d / 12.5) as usize).min(7);
+    let t = (d - KNOTS[i]) / 12.5;
+    row(i) + t * (row(i + 1) - row(i))
+}
+
+impl ReverbModel1 {
+    fn configure(&mut self) {
+        let size_bits = self.size.to_bits();
+        if self.applied_size != Some(size_bits) {
+            let d = distances(self.size);
+            let delays = delays(&d);
+            for (k, c) in self.combs.iter_mut().enumerate() {
+                c.delay = delays[k];
+                c.line = vec![0.0; delays[k] + 3];
+                c.at = 0;
+                c.last = 0.0;
+                c.g1 = damping(d[k]);
+            }
+            self.applied_size = Some(size_bits);
+        }
+        if self.brightness.to_bits() != self.last_brightness.to_bits() {
+            let b = self.brightness.max(self.combs[5].g1 + 0.001);
+            for c in &mut self.combs {
+                c.g1 *= 1.0 / b;
+                c.line.fill(0.0);
+                c.last = 0.0;
+            }
+            self.last_brightness = self.brightness;
+        }
+        let t = self.time.max(MIN_TIME);
+        for c in &mut self.combs {
+            c.g2 = (1.0 - c.g1) * (1.0 - MIN_TIME / t);
+        }
+    }
+
+    /// One mono block in place.
+    pub fn process(&mut self, x: &mut [f32]) {
+        if self.time.is_nan() || self.time <= 0.0 {
+            x.fill(0.0);
+            return;
+        }
+        let key = [self.time.to_bits(), self.size.to_bits(), self.brightness.to_bits()];
+        if self.applied != Some(key) {
+            self.configure();
+            self.applied = Some(key);
+        }
+        for s in x.iter_mut() {
+            let input = *s;
+            let mut sum = 0.0f32;
+            for c in &mut self.combs {
+                let len = c.line.len();
+                let delayed = c.line[(c.at + len - c.delay) % len];
+                let before = c.line[(c.at + len - c.delay - 1) % len];
+                let v = input + c.g2 * delayed + c.g1 * c.last;
+                c.line[c.at] = v;
+                c.last = v;
+                c.at = (c.at + 1) % len;
+                sum += (delayed - c.g1 * before) * (1.0 / 6.0);
+            }
+            let old = self.allpass[self.ap_at];
+            let a = sum - ALLPASS_GAIN * old;
+            self.allpass[self.ap_at] = a;
+            self.ap_at = (self.ap_at + 1) % ALLPASS_DELAY;
+            *s = 2.0 * (ALLPASS_GAIN * a + old);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn comb_delays_match_the_spec_examples() {
+        assert_eq!(primes().len(), 1652);
+        assert_eq!(delays(&distances(70.0)), [7817, 8581, 9371, 10139, 10937, 11699]);
+        assert_eq!(delays(&distances(8.3))[0], 929);
+        assert_eq!(delays(&distances(8.3))[5], 1399);
+    }
+
+    #[test]
+    fn an_impulse_rings_and_decays() {
+        let mut rv = ReverbModel1 { time: 1.5, size: 70.0, brightness: 0.7, ..Default::default() };
+        let mut energy = Vec::new();
+        for b in 0..(48000 * 3 / 256) {
+            let mut x = vec![0.0f32; 256];
+            if b == 0 {
+                x[0] = 1.0;
+            }
+            rv.process(&mut x);
+            energy.push(x.iter().map(|v| v * v).sum::<f32>());
+        }
+        let window = |s: f32| energy[(s * 48000.0 / 256.0) as usize..((s + 0.2) * 48000.0 / 256.0) as usize].iter().sum::<f32>();
+        let drop = 10.0 * (window(0.4) / window(1.9)).log10();
+        // The loop gain per round trip is g2/(1 − g1) = 1 − 0.366/T (0.756 at 1.5 s): with 70 m
+        // combs (≈ 0.2 s per trip) that is ≈ 12 dB/s, not a 60 dB T60 (retail's formula, spec §8.3).
+        assert!(window(0.4) > 0.0 && drop > 10.0 && drop < 40.0, "{drop}");
+        let mut silent = ReverbModel1::default();
+        let mut x = vec![1.0f32; 256];
+        silent.process(&mut x);
+        assert!(x.iter().all(|&v| v == 0.0), "T60 0 = silence");
+    }
+}
diff --git a/crates/skate-audio/src/dsp/routes.rs b/crates/skate-audio/src/dsp/routes.rs
new file mode 100644
index 00000000..92f3a2dc
--- /dev/null
+++ b/crates/skate-audio/src/dsp/routes.rs
@@ -0,0 +1,79 @@
+//! Channel routes (spec §6.1) and the output stage's downmix tables (spec §6.3).
+//!
+//! Internal 6-channel order: L, C, R, Ls, Rs, LFE. The 0.707 gain is the f32 nearest to 0.707
+//! (0.7070000172), not 1/√2.
+
+pub const G707: f32 = 0.707;
+
+/// One route: (source channel, destination channel, gain).
+pub type Route = (usize, usize, f32);
+
+/// Routes converting a `src`-channel signal into 6 channels (the voice-graph Send into a 6-channel
+/// bus). Unlisted gains are 1. Counts 3, 5 and 7 have no routes (retail executes garbage there).
+pub fn to_six(src: usize) -> &'static [Route] {
+    match src {
+        1 => &[(0, 1, 1.0)],                                  // centre only
+        2 => &[(0, 0, 1.0), (1, 2, 1.0)],                     // L→L, R→R
+        4 => &[(0, 0, 1.0), (1, 2, 1.0), (2, 3, 1.0), (3, 4, 1.0)], // FL, FR, SL, SR
+        6 => &[(0, 0, 1.0), (1, 1, 1.0), (2, 2, 1.0), (3, 3, 1.0), (4, 4, 1.0), (5, 5, 1.0)],
+        _ => &[],
+    }
+}
+
+/// The output stage's stereo table (N = 2) applied to the 6 planes we keep (L, C, R, Ls, Rs,
+/// LFE; Lx/Rx are empty in our mix): Lo = 0.707·L + 0.5·C + 0.5·Ls, Ro mirrored, LFE dropped.
+/// Every sample is then clamped to ±1 (NaN passes), with no master gain.
+pub fn output_stereo(six: &[[f32; crate::BLOCK]; 6], out: &mut [f32]) {
+    for k in 0..crate::BLOCK {
+        let l = G707 * six[0][k] + 0.5 * six[1][k] + 0.5 * six[3][k];
+        let r = G707 * six[2][k] + 0.5 * six[1][k] + 0.5 * six[4][k];
+        out[2 * k] = clamp(l);
+        out[2 * k + 1] = clamp(r);
+    }
+}
+
+/// The recomp host's capture conversion (rex): Lc = 0.4·(FL + SL + 0.5·C), Rc mirrored. Only for
+/// comparing levels with `SKATE3_AUDIO_CAPTURE` recordings; not the game's own fold.
+pub fn capture_stereo(six: &[[f32; crate::BLOCK]; 6], out: &mut [f32]) {
+    for k in 0..crate::BLOCK {
+        out[2 * k] = 0.4 * (six[0][k] + six[3][k] + 0.5 * six[1][k]);
+        out[2 * k + 1] = 0.4 * (six[2][k] + six[4][k] + 0.5 * six[1][k]);
+    }
+}
+
+/// Clamp out-of-range values to ±1; NaN passes through as retail.
+#[inline]
+pub fn clamp(v: f32) -> f32 {
+    if v > 1.0 {
+        1.0
+    } else if v < -1.0 {
+        -1.0
+    } else {
+        v
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn stereo_fold_and_clamp() {
+        let mut six = [[0.0f32; crate::BLOCK]; 6];
+        six[1][0] = 1.0; // centre
+        six[0][1] = 1.0; // left
+        six[3][2] = 1.0; // left surround
+        six[5][3] = 1.0; // LFE dropped
+        six[0][4] = 3.0; // clipped
+        six[0][5] = f32::NAN;
+        let mut out = vec![0.0f32; 2 * crate::BLOCK];
+        output_stereo(&six, &mut out);
+        assert_eq!(&out[0..2], &[0.5, 0.5]);
+        assert_eq!(&out[2..4], &[G707, 0.0]);
+        assert_eq!(&out[4..6], &[0.5, 0.0]);
+        assert_eq!(&out[6..8], &[0.0, 0.0]);
+        assert_eq!(out[8], 1.0);
+        assert!(out[10].is_nan());
+        assert_eq!(G707.to_bits(), 0.707f32.to_bits());
+    }
+}
diff --git a/crates/skate-audio/src/dsp/send.rs b/crates/skate-audio/src/dsp/send.rs
new file mode 100644
index 00000000..8e39562c
--- /dev/null
+++ b/crates/skate-audio/src/dsp/send.rs
@@ -0,0 +1,116 @@
+//! Send (Sen0, spec §4.8): a tap that adds the signal into a bus through the route table. A level
+//! change ramps over 64 samples to 64/65 of the way (step = Δ·(1/65)) and the next block jumps
+//! the last 1/65 (retail arithmetic). A removed voice leaves its last contributed values, which
+//! the bus fades into its next block's first 16 samples (taps 16/17 … 1/17).
+use super::routes::Route;
+
+/// 1/65 as the retail cell holds it (0x822F8A00).
+pub const RAMP_STEP: f32 = 0.015_384_615;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Mode {
+    /// Ramp current → target (or flat).
+    Normal,
+    /// Ramp current → 0 (fade out).
+    FadeOut,
+    /// Ramp 0 → target (fade in).
+    FadeIn,
+}
+
+#[derive(Clone, Debug)]
+pub struct Send {
+    pub target: f32,
+    current: f32,
+    started: bool,
+    /// Per bus channel: the last sample contributed (for the release de-click).
+    pub last: [f32; 6],
+}
+
+impl Default for Send {
+    fn default() -> Self {
+        Self { target: 1.0, current: 1.0, started: false, last: [0.0; 6] }
+    }
+}
+
+impl Send {
+    /// Add `src` (planar) into `bus` through `routes`.
+    pub fn process(&mut self, src: &[&[f32]], routes: &[Route], bus: &mut [[f32; crate::BLOCK]; 6], mode: Mode) {
+        if !self.started {
+            self.current = self.target;
+            self.started = true;
+        }
+        let (from, to) = match mode {
+            Mode::Normal => (self.current, self.target),
+            Mode::FadeOut => (self.current, 0.0),
+            Mode::FadeIn => (0.0, self.target),
+        };
+        self.last = [0.0; 6];
+        for &(s, d, g) in routes {
+            let Some(input) = src.get(s) else { continue };
+            let out = &mut bus[d];
+            if from == to {
+                let level = g * to;
+                for (o, &x) in out.iter_mut().zip(input.iter()) {
+                    *o += level * x;
+                }
+            } else {
+                let start = g * from;
+                let step = g * (to - from) * RAMP_STEP;
+                let flat = start + 64.0 * step;
+                for (k, (o, &x)) in out.iter_mut().zip(input.iter()).enumerate() {
+                    *o += if k < 64 { start + k as f32 * step } else { flat } * x;
+                }
+            }
+            if let Some(&x) = input.last() {
+                self.last[d] += g * to * x;
+            }
+        }
+        self.current = to;
+    }
+}
+
+/// Fold a removed contributor's last values into the first 16 samples of a bus block.
+pub fn fold_release(bus: &mut [[f32; crate::BLOCK]; 6], last: &[f32; 6]) {
+    for (ch, &v) in last.iter().enumerate() {
+        if v != 0.0 {
+            for k in 0..16 {
+                bus[ch][k] += v * ((16 - k) as f32 / 17.0);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::dsp::routes::to_six;
+
+    #[test]
+    fn ramp_lands_at_64_of_65() {
+        let mut s = Send::default();
+        let x = vec![1.0f32; crate::BLOCK];
+        let mut bus = [[0.0f32; crate::BLOCK]; 6];
+        s.process(&[&x], to_six(1), &mut bus, Mode::Normal);
+        assert!(bus[1].iter().all(|&v| v == 1.0));
+        s.target = 0.0;
+        let mut bus = [[0.0f32; crate::BLOCK]; 6];
+        s.process(&[&x], to_six(1), &mut bus, Mode::Normal);
+        assert_eq!(bus[1][0], 1.0);
+        let landed = 1.0 + 64.0 * (-RAMP_STEP);
+        assert_eq!(bus[1][200], landed);
+        assert!((landed - 1.0 / 65.0).abs() < 1e-6);
+        // Next block: flat at the target.
+        let mut bus = [[0.0f32; crate::BLOCK]; 6];
+        s.process(&[&x], to_six(1), &mut bus, Mode::Normal);
+        assert!(bus[1].iter().all(|&v| v == 0.0));
+    }
+
+    #[test]
+    fn release_fold_taps() {
+        let mut bus = [[0.0f32; crate::BLOCK]; 6];
+        fold_release(&mut bus, &[0.0, 1.7, 0.0, 0.0, 0.0, 0.0]);
+        assert_eq!(bus[1][0], 1.7 * 16.0 / 17.0);
+        assert_eq!(bus[1][15], 1.7 / 17.0);
+        assert_eq!(bus[1][16], 0.0);
+    }
+}
diff --git a/crates/skate-audio/src/dsp/shelf.rs b/crates/skate-audio/src/dsp/shelf.rs
new file mode 100644
index 00000000..9be59f23
--- /dev/null
+++ b/crates/skate-audio/src/dsp/shelf.rs
@@ -0,0 +1,135 @@
+//! HighShelfIir2 (`HS20`, process `sub_82B26740`, coefficients `sub_82B43D78`; voice-graph spec
+//! §4.10): an RBJ high shelf, slope S = 1. Parameters: 0 = corner (Hz, `+52`), 1 = linear gain
+//! (`+60`; the plateau above the corner, A = √gain). Used in the board grain chain's graph 3
+//! (5000 Hz × 0.65) and the stream bus.
+//!
+//! Per block: ω = f32(f32(fc / rate) · 2π). It filters only while ω < CEIL **and** gain ≠ 1.0;
+//! otherwise it passes the block through and clears the histories once (when it was filtering).
+//! While filtering ω is raised to FLOOR, and the coefficients are rebuilt when ω or the gain differ
+//! from the cached pair (`+216` / `+220`; the bypass path caches its unclamped ω too). The kernel is
+//! the shared biquad kernel `sub_82B43AF8` ([`super::biquad::kernel`]).
+use super::biquad::{CEIL, Coefficients, FLOOR, TWO_PI, kernel};
+
+/// α = sin ω × this (`0x822F8E50`, not exactly 1/√2).
+pub const ALPHA_SCALE: f32 = f32::from_bits(0x3F35_04EF);
+
+/// `sub_82B43D78` in its own operation order (single precision; sin/cos in double, rounded once).
+pub fn coefficients(omega: f32, gain: f32) -> Coefficients {
+    let s = (omega as f64).sin() as f32;
+    let c = (omega as f64).cos() as f32;
+    let a = gain.sqrt();
+    let root = a.sqrt();
+    let plus = a + 1.0;
+    let minus = a - 1.0;
+    let alpha = s * ALPHA_SCALE;
+    let ra = root * alpha;
+    // a0 = (A+1) − (A−1)cos + 2√A·α.
+    let a0 = ra.mul_add(2.0, (-minus).mul_add(c, plus));
+    let inv = 1.0 / a0;
+    let b0_sum = ra.mul_add(2.0, minus * c) + plus;
+    let b1_sum = plus.mul_add(c, minus);
+    let b2_sum = (-ra).mul_add(2.0, minus.mul_add(c, plus));
+    let a1_sum = (-plus).mul_add(c, minus);
+    let a2_sum = (-ra).mul_add(2.0, (-minus).mul_add(c, plus));
+    Coefficients {
+        a1: (a1_sum * inv) * 2.0,
+        a2: a2_sum * inv,
+        b0: (b0_sum * inv) * a,
+        b1: ((b1_sum * inv) * a) * -2.0,
+        b2: (b2_sum * inv) * a,
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct HighShelfIir2 {
+    pub freq: f32,
+    pub gain: f32,
+    cached: Option<(f32, f32)>,
+    coefficients: Coefficients,
+    history: [[f32; 4]; 8],
+    filtering: bool,
+}
+
+impl HighShelfIir2 {
+    pub fn new(freq: f32, gain: f32) -> Self {
+        Self { freq, gain, cached: None, coefficients: Coefficients::default(), history: [[0.0; 4]; 8], filtering: false }
+    }
+
+    pub fn bypassed(&self, rate: f32) -> bool {
+        let w = (self.freq / rate) * TWO_PI;
+        w >= CEIL || self.gain == 1.0
+    }
+
+    pub fn process(&mut self, channels: &mut [&mut [f32]], rate: f32) {
+        let w = (self.freq / rate) * TWO_PI;
+        // Float compares as retail's `fcmpu` (a NaN ω filters, at FLOOR).
+        if w >= CEIL || self.gain == 1.0 {
+            if self.filtering {
+                self.history = [[0.0; 4]; 8];
+                self.filtering = false;
+            }
+            self.cached = Some((w, self.gain));
+            return;
+        }
+        self.filtering = true;
+        let w = if w >= FLOOR { w } else { FLOOR };
+        let key = (w, self.gain);
+        if self.cached.is_none_or(|c| c != key) {
+            self.coefficients = coefficients(w, self.gain);
+            self.cached = Some(key);
+        }
+        for (ch, samples) in channels.iter_mut().enumerate().take(8) {
+            kernel(&self.coefficients, &mut self.history[ch], samples);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tone_gain(eq: &mut HighShelfIir2, f: f32) -> f32 {
+        let mut x: Vec<f32> = (0..48000).map(|i| (std::f32::consts::TAU * f * i as f32 / 48000.0).sin()).collect();
+        for chunk in x.chunks_mut(256) {
+            eq.process(&mut [chunk], 48000.0);
+        }
+        let tail = &x[24000..];
+        (tail.iter().map(|v| v * v).sum::<f32>() / tail.len() as f32).sqrt() * std::f32::consts::SQRT_2
+    }
+
+    #[test]
+    fn the_board_shelf_cuts_the_top_to_the_gain() {
+        let mut eq = HighShelfIir2::new(5000.0, 0.65);
+        assert!((tone_gain(&mut eq, 100.0) - 1.0).abs() < 0.01);
+        // Plateau = gain (A² with A = √gain); −1.87 dB at 20 kHz, about half way at the corner.
+        assert!((tone_gain(&mut eq, 20000.0) - 0.65).abs() < 0.02);
+        let mid = tone_gain(&mut HighShelfIir2::new(5000.0, 0.65), 5000.0);
+        assert!((mid - 0.65f32.sqrt()).abs() < 0.03, "{mid}");
+    }
+
+    #[test]
+    fn rbj_reference_and_bypass() {
+        // Against the textbook RBJ high shelf in f64 (S = 1).
+        let w = (5000.0f32 / 48000.0) * TWO_PI;
+        let k = coefficients(w, 0.65);
+        let (a, cs, sn) = (0.65f64.sqrt(), (w as f64).cos(), (w as f64).sin());
+        let alpha = sn / 2.0 * 2.0f64.sqrt();
+        let a0 = (a + 1.0) - (a - 1.0) * cs + 2.0 * a.sqrt() * alpha;
+        let want = [
+            2.0 * ((a - 1.0) - (a + 1.0) * cs) / a0,
+            ((a + 1.0) - (a - 1.0) * cs - 2.0 * a.sqrt() * alpha) / a0,
+            a * ((a + 1.0) + (a - 1.0) * cs + 2.0 * a.sqrt() * alpha) / a0,
+            -2.0 * a * ((a - 1.0) + (a + 1.0) * cs) / a0,
+            a * ((a + 1.0) + (a - 1.0) * cs - 2.0 * a.sqrt() * alpha) / a0,
+        ];
+        for (got, want) in [k.a1, k.a2, k.b0, k.b1, k.b2].into_iter().zip(want) {
+            assert!((got as f64 - want).abs() < 1e-6, "{got} vs {want}");
+        }
+        let mut eq = HighShelfIir2::new(5000.0, 1.0);
+        let mut x: Vec<f32> = (0..256).map(|i| (i as f32 * 0.3).sin()).collect();
+        let before = x.clone();
+        eq.process(&mut [&mut x[..]], 48000.0);
+        assert_eq!(x, before);
+        assert!(HighShelfIir2::new(24000.0, 0.5).bypassed(48000.0));
+    }
+}
diff --git a/crates/skate-audio/src/eval/fmath.rs b/crates/skate-audio/src/eval/fmath.rs
new file mode 100644
index 00000000..14ddfb29
--- /dev/null
+++ b/crates/skate-audio/src/eval/fmath.rs
@@ -0,0 +1,61 @@
+//! Single-precision helpers with the retail rounding rules (spec §3 "Float semantics").
+
+/// Float → int as the evaluator's `round`: add ±0.5 in f32, then truncate toward zero, saturating
+/// like PPC `fctiwz` (NaN and values below −2³¹ → i32::MIN, above 2³¹−1 → i32::MAX).
+#[inline]
+pub fn round(x: f32) -> i32 {
+    let v = if x < 0.0 { x - 0.5 } else { x + 0.5 };
+    trunc(v)
+}
+
+/// Truncate toward zero with `fctiwz` saturation (Rust's `as` maps NaN to 0, retail to i32::MIN).
+#[inline]
+pub fn trunc(v: f32) -> i32 {
+    if v.is_nan() { i32::MIN } else { v as i32 }
+}
+
+/// One-rounding a·b + c (PPC `fmadds`).
+#[inline]
+pub fn fused(a: f32, b: f32, c: f32) -> f32 {
+    a.mul_add(b, c)
+}
+
+/// The quarter-sine table used by the Oscillator (257 entries): T[i] = min(65535,
+/// floor(65536·sin(i·π/512))). Generated from the formula; it equals the retail table on all 257
+/// entries (checked with `tools/re/aems_image_consts.py`).
+pub fn quarter_sine() -> &'static [u16; 257] {
+    use std::sync::OnceLock;
+    static TABLE: OnceLock<[u16; 257]> = OnceLock::new();
+    TABLE.get_or_init(|| {
+        let mut t = [0u16; 257];
+        for (i, v) in t.iter_mut().enumerate() {
+            let s = (65536.0 * (i as f64 * std::f64::consts::PI / 512.0).sin()).floor();
+            *v = s.min(65535.0) as u16;
+        }
+        t
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rounding_matches_fctiwz_rules() {
+        assert_eq!(round(1.5), 2);
+        assert_eq!(round(-1.5), -2);
+        assert_eq!(round(0.49), 0);
+        assert_eq!(round(-0.5), -1);
+        assert_eq!(round(f32::NAN), i32::MIN);
+        assert_eq!(round(3.0e10), i32::MAX);
+        assert_eq!(round(-3.0e10), i32::MIN);
+    }
+
+    #[test]
+    fn sine_table_endpoints() {
+        let t = quarter_sine();
+        assert_eq!(t[0], 0);
+        assert_eq!(t[256], 65535);
+        assert_eq!(t[128], (65536.0 * (std::f64::consts::PI / 4.0).sin()).floor() as u16);
+    }
+}
diff --git a/crates/skate-audio/src/eval/mod.rs b/crates/skate-audio/src/eval/mod.rs
new file mode 100644
index 00000000..fc4a96d7
--- /dev/null
+++ b/crates/skate-audio/src/eval/mod.rs
@@ -0,0 +1,770 @@
+//! The AEMS patch-program evaluator (spec: `.claude/notes/aems-evaluator-spec.md`).
+//!
+//! - Csis projects are installed first ([`Evaluator::install_project`]), then banks
+//!   ([`Evaluator::load_bank`]): every export is resolved and each module registers as a constructor
+//!   of its class.
+//! - A post to a class ([`Evaluator::post`]) creates one instance per bound module (newest bank
+//!   first, capacity permitting) and copies the payload into each instance's ClassData. The game
+//!   keeps the returned node, redelivers new payloads and releases it.
+//! - [`Evaluator::block`] is called once per 256-frame block; every 6th call walks the instance list
+//!   (newest first) and runs each program over its own copy of the module's template.
+//! - Instance memory is a byte copy of the template, read and written as big-endian words at the
+//!   same offsets as retail, so programs run untranslated.
+//! - Voices are driven through [`VoiceHost`] (the mixer in the game, a mock in tests).
+pub mod fmath;
+pub mod ops;
+pub mod rng;
+pub mod symbols;
+
+use std::collections::{HashMap, VecDeque};
+use std::sync::Arc;
+
+use crate::be::*;
+use crate::formats::abk::{InterfaceKind, Op};
+use crate::formats::{Bank, FormatError};
+use rng::Rng;
+use symbols::{Client, Registry, SymRef};
+
+/// What the evaluator hands the voice layer when a Player opens a voice (spec §5.2).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct OpenRequest<'a> {
+    pub bank: usize,
+    /// S10A slot (the sample group entry's sample index).
+    pub slot: u16,
+    /// Sample group entry byte 2 (%). Meaning UNCERTAIN (voice-graph spec §3.4): not applied as gain.
+    pub level: u8,
+    /// Sample group entry bytes 3..8 as retail hands them over, each `<< 8` into 65536 = 360°.
+    /// Bytes 3..7 are per-channel azimuths (stereo banks hold 224/32 = −45°/+45°, quad 224/32/160/96);
+    /// byte 8 is the first byte of the stream-offset word at +8 (hence the `…, FF` seen on in-memory
+    /// samples), so only the first five are angles.
+    pub azimuth: [u8; 6],
+    /// Sample group entry +8: stream offset (`FFFFFFFF` = in-memory sample).
+    pub stream_offset: u32,
+    /// The Player's input records (type id, value) in record order; ids ≥ 9 carry routing codes.
+    pub inputs: &'a [(u8, i32)],
+}
+
+/// A voice's state as the Player op queries it (spec §5.3). Times are ms of source time.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct VoiceStatus {
+    pub alive: bool,
+    pub remaining_ms: i32,
+    pub elapsed_ms: i32,
+}
+
+/// The voice device the Player op drives. Voice handles are non-zero.
+pub trait VoiceHost {
+    fn open(&mut self, request: &OpenRequest) -> Option<u32>;
+    fn release(&mut self, voice: u32);
+    fn pause(&mut self, voice: u32);
+    fn resume(&mut self, voice: u32);
+    /// A voice property (PLAYER_INPUT id, spec §1.6), already clamped by the setter. Never id 3.
+    fn set(&mut self, voice: u32, id: u8, value: i32);
+    /// Property 3 (AZIMUTH), through the alternate setter: 65536 = 360°.
+    fn set_azimuth(&mut self, voice: u32, value: i32);
+    fn query(&mut self, voice: u32) -> VoiceStatus;
+}
+
+/// A post (Csis class instance) the game or a ControlClass op holds.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct NodeId(pub u32);
+
+/// Evaluator errors at load time.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum LoadError {
+    Format(FormatError),
+}
+
+impl From<FormatError> for LoadError {
+    fn from(e: FormatError) -> Self {
+        Self::Format(e)
+    }
+}
+
+/// One executed op, for golden comparisons ([`Evaluator::trace`]).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct OpTrace {
+    pub walk: u64,
+    pub instance: u32,
+    pub bank: usize,
+    pub module: usize,
+    pub opcode: u8,
+    pub block: u32,
+    pub result: i32,
+}
+
+struct LoadedModule {
+    program: Arc<[Op]>,
+    class: Option<usize>,
+    /// Handles inside the template: instance offset → symbol.
+    handles: HashMap<u32, SymRef>,
+    live: i16,
+}
+
+struct LoadedBank {
+    bank: Arc<Bank>,
+    modules: Vec<LoadedModule>,
+}
+
+struct Instance {
+    bank: usize,
+    module: usize,
+    node: u32,
+    mem: Vec<u8>,
+}
+
+struct Node {
+    class: usize,
+    refcount: u32,
+    class_data: Vec<Client>,
+    destructors: Vec<Client>,
+}
+
+/// Blocks per walk with δ = f32(256/48000) and D = 30 (spec §2.6).
+pub const BLOCKS_PER_WALK: u32 = 6;
+
+/// The tick scale retail computes for that period: f32(f32(f32(6)·δ)·1000) = 31.999998 ms.
+pub fn tick_scale() -> f32 {
+    let delta = 256.0f32 / 48000.0f32;
+    (BLOCKS_PER_WALK as f32 * delta) * 1000.0
+}
+
+pub struct Evaluator {
+    pub registry: Registry,
+    banks: Vec<Option<LoadedBank>>,
+    instances: Vec<Option<Instance>>,
+    free: Vec<u32>,
+    /// Instance ids, newest first (the timer client list).
+    order: VecDeque<u32>,
+    nodes: HashMap<u32, Node>,
+    next_node: u32,
+    pub rng: Rng,
+    tick: f32,
+    countdown: u32,
+    /// Completed walks.
+    pub walks: u64,
+    /// When Some, every executed op is appended (tests and golden runs).
+    pub trace: Option<Vec<OpTrace>>,
+}
+
+impl Default for Evaluator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[inline]
+fn word(m: &[u8], at: u32) -> i32 {
+    i32_at(m, at as usize)
+}
+
+impl Evaluator {
+    pub fn new() -> Self {
+        Self {
+            registry: Registry::default(),
+            banks: Vec::new(),
+            instances: Vec::new(),
+            free: Vec::new(),
+            order: VecDeque::new(),
+            nodes: HashMap::new(),
+            next_node: 1,
+            rng: Rng::default(),
+            tick: tick_scale(),
+            countdown: BLOCKS_PER_WALK,
+            walks: 0,
+            trace: None,
+        }
+    }
+
+    pub fn tick_scale(&self) -> f32 {
+        self.tick
+    }
+
+    pub fn install_project(&mut self, project: &crate::formats::Project) {
+        self.registry.install(project);
+    }
+
+    /// Install a bank: resolve its exports and register its modules on their classes. Projects
+    /// must be installed first. Returns the bank id.
+    pub fn load_bank(&mut self, bank: Bank) -> usize {
+        let bank = Arc::new(bank);
+        let id = self.banks.len();
+        let mut modules: Vec<LoadedModule> = bank
+            .modules
+            .iter()
+            .map(|m| LoadedModule { program: m.program.clone().into(), class: None, handles: HashMap::new(), live: 0 })
+            .collect();
+        for e in &bank.exports {
+            let Some(sym) = self.registry.lookup(e.kind, e.project, e.name_id, &e.name) else { continue };
+            for (m, module) in bank.modules.iter().enumerate() {
+                if e.handle_offset == module.offset + 4 && e.kind == InterfaceKind::Class {
+                    if let SymRef::Class(c) = sym {
+                        modules[m].class = Some(c);
+                    }
+                } else if (module.template_offset..module.template_offset + module.data_size).contains(&e.handle_offset) {
+                    modules[m].handles.insert(e.handle_offset - module.template_offset, sym);
+                }
+            }
+        }
+        for (m, module) in modules.iter().enumerate() {
+            if let Some(c) = module.class {
+                self.registry.classes[c].constructors.push((id, m));
+            }
+        }
+        self.banks.push(Some(LoadedBank { bank, modules }));
+        id
+    }
+
+    /// Remove a bank: its live instances are destroyed (voices released) and its modules stop
+    /// answering posts.
+    pub fn unload_bank(&mut self, id: usize, host: &mut dyn VoiceHost) {
+        let doomed: Vec<u32> = self.order.iter().copied().filter(|&i| self.instance(i).is_some_and(|x| x.bank == id)).collect();
+        for i in doomed {
+            self.destroy(i, host);
+        }
+        for class in &mut self.registry.classes {
+            class.constructors.retain(|&(b, _)| b != id);
+        }
+        if let Some(slot) = self.banks.get_mut(id) {
+            *slot = None;
+        }
+    }
+
+    pub fn bank(&self, id: usize) -> Option<&Arc<Bank>> {
+        self.banks.get(id)?.as_ref().map(|b| &b.bank)
+    }
+
+    pub fn class_id(&self, name: &str) -> Option<usize> {
+        self.registry.by_name(InterfaceKind::Class, name)
+    }
+
+    pub fn function_id(&self, name: &str) -> Option<usize> {
+        self.registry.by_name(InterfaceKind::Function, name)
+    }
+
+    pub fn global_id(&self, name: &str) -> Option<usize> {
+        self.registry.by_name(InterfaceKind::GlobalVariable, name)
+    }
+
+    /// Live instances, newest first: (instance id, bank, module).
+    pub fn instances(&self) -> Vec<(u32, usize, usize)> {
+        self.order.iter().filter_map(|&i| self.instance(i).map(|x| (i, x.bank, x.module))).collect()
+    }
+
+    /// An instance's memory (tests, debugging).
+    pub fn instance_memory(&self, id: u32) -> Option<&[u8]> {
+        self.instance(id).map(|i| &i.mem[..])
+    }
+
+    /// The class a live post was made to.
+    pub fn node_class(&self, node: NodeId) -> Option<usize> {
+        self.nodes.get(&node.0).map(|n| n.class)
+    }
+
+    /// Live posts (class instances), including ControlClass children.
+    pub fn node_count(&self) -> usize {
+        self.nodes.len()
+    }
+
+    pub fn node_refcount(&self, node: NodeId) -> Option<u32> {
+        self.nodes.get(&node.0).map(|n| n.refcount)
+    }
+
+    fn instance(&self, id: u32) -> Option<&Instance> {
+        self.instances.get(id as usize)?.as_ref()
+    }
+
+    fn instance_mut(&mut self, id: u32) -> Option<&mut Instance> {
+        self.instances.get_mut(id as usize)?.as_mut()
+    }
+
+    // ---- posting (spec §2.2–2.5) -------------------------------------------------------------
+
+    /// Post to a class: create the bound modules' instances (newest bank first) and deliver the
+    /// payload. Succeeds even when nothing was created, like retail.
+    pub fn post(&mut self, class: usize, payload: &[i32]) -> NodeId {
+        let id = self.next_node;
+        self.next_node = self.next_node.wrapping_add(1).max(1);
+        self.nodes.insert(id, Node { class, refcount: 1, class_data: Vec::new(), destructors: Vec::new() });
+        let constructors: Vec<(usize, usize)> =
+            self.registry.classes.get(class).map(|c| c.constructors.iter().rev().copied().collect()).unwrap_or_default();
+        for (bank, module) in constructors {
+            self.create_instance(id, bank, module);
+        }
+        self.redeliver(NodeId(id), payload);
+        NodeId(id)
+    }
+
+    /// Rewrite the payload of a held post (SetMemberData): only its ClassData clients rerun.
+    pub fn redeliver(&mut self, node: NodeId, payload: &[i32]) {
+        let Some(n) = self.nodes.get(&node.0) else { return };
+        for (inst, off) in n.class_data.clone() {
+            if let Some(i) = self.instance_mut(inst) {
+                let count = u8_at(&i.mem, off as usize + 16) as usize;
+                for k in 0..count {
+                    put_i32(&mut i.mem, off as usize + 20 + 4 * k, payload.get(k).copied().unwrap_or(0));
+                }
+            }
+        }
+    }
+
+    /// Release a post: its instances see the ClassDestructor pulse; the poster's reference drops.
+    pub fn release(&mut self, node: NodeId) {
+        let Some(n) = self.nodes.get_mut(&node.0) else { return };
+        let destructors = n.destructors.clone();
+        for (inst, off) in destructors {
+            if let Some(i) = self.instance_mut(inst) {
+                put_i32(&mut i.mem, off as usize + 16, 1);
+            }
+        }
+        self.unref(node.0);
+    }
+
+    fn unref(&mut self, node: u32) {
+        if let Some(n) = self.nodes.get_mut(&node) {
+            n.refcount = n.refcount.saturating_sub(1);
+            if n.refcount == 0 {
+                self.nodes.remove(&node);
+            }
+        }
+    }
+
+    fn create_instance(&mut self, node: u32, bank: usize, module: usize) {
+        let Some(Some(lb)) = self.banks.get(bank) else { return };
+        let m = &lb.bank.modules[module];
+        if lb.modules[module].live >= m.max_instances {
+            return;
+        }
+        let mem = m.template(&lb.bank.data).to_vec();
+        let destructor = m.destructor_state;
+        let class_data = m.class_data_state;
+        let globals: Vec<(u32, Option<usize>)> = m
+            .global_states
+            .iter()
+            .map(|&o| (o, match lb.modules[module].handles.get(&o) { Some(SymRef::Global(g)) => Some(*g), _ => None }))
+            .collect();
+        let functions: Vec<(u32, Option<usize>)> = m
+            .function_states
+            .iter()
+            .map(|&o| (o, match lb.modules[module].handles.get(&o) { Some(SymRef::Function(f)) => Some(*f), _ => None }))
+            .collect();
+        let id = match self.free.pop() {
+            Some(id) => id,
+            None => {
+                self.instances.push(None);
+                (self.instances.len() - 1) as u32
+            }
+        };
+        self.instances[id as usize] = Some(Instance { bank, module, node, mem });
+        if let Some(Some(lb)) = self.banks.get_mut(bank) {
+            lb.modules[module].live += 1;
+        }
+        let n = self.nodes.get_mut(&node).expect("post node");
+        if let Some(off) = destructor {
+            n.destructors.push((id, off));
+            n.refcount += 1;
+        }
+        if let Some(off) = class_data {
+            n.class_data.push((id, off));
+            n.refcount += 1;
+        }
+        for (off, global) in globals {
+            if let Some(g) = global {
+                self.registry.globals[g].subscribers.push((id, off));
+                let value = self.registry.globals[g].value;
+                put_i32(&mut self.instances[id as usize].as_mut().unwrap().mem, off as usize + 24, value);
+            }
+        }
+        for (off, function) in functions {
+            if let Some(f) = function {
+                self.registry.functions[f].subscribers.push((id, off));
+            }
+        }
+        self.order.push_front(id);
+    }
+
+    fn destroy(&mut self, id: u32, host: &mut dyn VoiceHost) {
+        let Some(inst) = self.instances.get_mut(id as usize).and_then(Option::take) else { return };
+        self.free.push(id);
+        self.order.retain(|&i| i != id);
+        if let Some(n) = self.nodes.get_mut(&inst.node) {
+            let before = n.destructors.len() + n.class_data.len();
+            n.destructors.retain(|c| c.0 != id);
+            n.class_data.retain(|c| c.0 != id);
+            let dropped = before - n.destructors.len() - n.class_data.len();
+            for _ in 0..dropped {
+                self.unref(inst.node);
+            }
+        }
+        for g in &mut self.registry.globals {
+            g.subscribers.retain(|c| c.0 != id);
+        }
+        for f in &mut self.registry.functions {
+            f.subscribers.retain(|c| c.0 != id);
+        }
+        let Some(Some(lb)) = self.banks.get_mut(inst.bank) else { return };
+        lb.modules[inst.module].live -= 1;
+        let module = &lb.bank.modules[inst.module];
+        let players: Vec<u32> = module.players().to_vec();
+        let controllers: Vec<u32> = module.controllers().to_vec();
+        for p in players {
+            let voice = u32_at(&inst.mem, p as usize + 8);
+            if voice != 0 {
+                host.release(voice);
+            }
+        }
+        for c in controllers {
+            let child = u32_at(&inst.mem, c as usize + 8);
+            if child != 0 {
+                self.release(NodeId(child));
+            }
+        }
+    }
+
+    /// CallFunction (op 5, or game code): every subscriber copies its own number of parameters and
+    /// sees the trigger at its next op 37. Returns −4 when nobody subscribes.
+    pub fn call_function(&mut self, function: usize, params: &[i32]) -> i32 {
+        let Some(f) = self.registry.functions.get(function) else { return -6 };
+        if f.subscribers.is_empty() {
+            return -4;
+        }
+        for (inst, off) in f.subscribers.clone() {
+            if let Some(i) = self.instance_mut(inst) {
+                let off = off as usize;
+                let count = u8_at(&i.mem, off + 24) as usize;
+                for k in 0..count {
+                    put_i32(&mut i.mem, off + 28 + 4 * k, params.get(k).copied().unwrap_or(0));
+                }
+                put_u8(&mut i.mem, off + 25, 1);
+            }
+        }
+        0
+    }
+
+    /// SetGlobalVariable (op 39 after its clamp, or game code): subscribers are told only when the
+    /// stored value changes.
+    pub fn set_global(&mut self, global: usize, value: i32) {
+        let Some(g) = self.registry.globals.get_mut(global) else { return };
+        if g.value == value {
+            return;
+        }
+        g.value = value;
+        for (inst, off) in g.subscribers.clone() {
+            if let Some(i) = self.instance_mut(inst) {
+                put_i32(&mut i.mem, off as usize + 24, value);
+            }
+        }
+    }
+
+    pub fn global(&self, global: usize) -> Option<i32> {
+        self.registry.globals.get(global).map(|g| g.value)
+    }
+
+    // ---- the tick (spec §2.6, §3) --------------------------------------------------------------
+
+    /// One 256-frame audio block. Every 6th call walks the instances. Returns true on a walk.
+    pub fn block(&mut self, host: &mut dyn VoiceHost) -> bool {
+        self.countdown -= 1;
+        if self.countdown > 0 {
+            return false;
+        }
+        self.countdown = BLOCKS_PER_WALK;
+        self.walk(host);
+        true
+    }
+
+    /// Run every instance's program once, newest first.
+    pub fn walk(&mut self, host: &mut dyn VoiceHost) {
+        let order: Vec<u32> = self.order.iter().copied().collect();
+        for id in order {
+            if self.instance(id).is_some() {
+                self.run(id, host);
+            }
+        }
+        self.walks += 1;
+    }
+
+    fn run(&mut self, id: u32, host: &mut dyn VoiceHost) {
+        let (bank, module) = match self.instance(id) {
+            Some(i) => (i.bank, i.module),
+            None => return,
+        };
+        let program = match &self.banks[bank] {
+            Some(lb) => lb.modules[module].program.clone(),
+            None => return,
+        };
+        for op in program.iter() {
+            let result = self.exec(id, bank, module, op, host);
+            if let Some(trace) = &mut self.trace {
+                trace.push(OpTrace { walk: self.walks, instance: id, bank, module, opcode: op.opcode, block: op.block, result });
+            }
+            let Some(inst) = self.instance_mut(id) else { return }; // destroyed by op 4
+            let m = &mut inst.mem;
+            for &(src, dst) in &op.pairs {
+                let to = op.block as i64 + i64::from(dst);
+                let value = if src == -1 { result } else { i32_at(m, (op.block as i64 + i64::from(src)) as usize) };
+                if to >= 0 {
+                    put_i32(m, to as usize, value);
+                }
+            }
+        }
+    }
+
+    fn exec(&mut self, id: u32, bank: usize, module: usize, op: &Op, host: &mut dyn VoiceHost) -> i32 {
+        let b = op.block;
+        match op.opcode {
+            // ClassDestructor: the release pulse, read once.
+            0 => self.take_word(id, b + 16),
+            // ClassData: values[0]; programs fan out the other words with copy pairs.
+            1 => self.instance(id).map_or(0, |i| word(&i.mem, b + 20)),
+            // GlobalVariable: the subscribed value.
+            2 => self.instance(id).map_or(0, |i| word(&i.mem, b + 24)),
+            // Create: 1 on the first walk only.
+            3 => self.take_word(id, b),
+            // Destroy: the last op; ends the instance in this walk when triggered.
+            4 => {
+                if self.instance(id).is_some_and(|i| word(&i.mem, b + 12) != 0) {
+                    self.destroy(id, host);
+                }
+                0
+            }
+            5 => self.call_function_op(id, bank, module, b),
+            27 => self.player(id, bank, b, host),
+            // Function: the call pulse, read once; programs copy the parameters out.
+            37 => {
+                let Some(i) = self.instance_mut(id) else { return 0 };
+                let t = u8_at(&i.mem, b as usize + 25);
+                put_u8(&mut i.mem, b as usize + 25, 0);
+                i32::from(t)
+            }
+            38 => self.control_class(id, bank, module, b),
+            39 => {
+                let Some(i) = self.instance_mut(id) else { return 0 };
+                let (min, max, prev, value) = (word(&i.mem, b + 8), word(&i.mem, b + 12), word(&i.mem, b + 16), word(&i.mem, b + 20));
+                if value != prev {
+                    put_i32(&mut i.mem, b as usize + 16, value);
+                    if let Some(SymRef::Global(g)) = self.handle(bank, module, b) {
+                        self.set_global(g, value.max(min).min(max));
+                    }
+                }
+                0
+            }
+            opcode => {
+                let Evaluator { banks, instances, rng, tick, .. } = self;
+                let (Some(Some(lb)), Some(Some(inst))) = (banks.get(bank), instances.get_mut(id as usize)) else { return 0 };
+                let mut ctx = ops::Ctx { bank: &lb.bank.data, rng, tick: *tick };
+                ops::run(opcode, &mut inst.mem, b as usize, &mut ctx).unwrap_or(0)
+            }
+        }
+    }
+
+    fn handle(&self, bank: usize, module: usize, at: u32) -> Option<SymRef> {
+        self.banks.get(bank)?.as_ref()?.modules[module].handles.get(&at).copied()
+    }
+
+    /// Read a word and clear it.
+    fn take_word(&mut self, id: u32, at: u32) -> i32 {
+        let Some(i) = self.instance_mut(id) else { return 0 };
+        let v = word(&i.mem, at);
+        put_i32(&mut i.mem, at as usize, 0);
+        v
+    }
+
+    /// Clamp `n` parameters at `params` in place to the {min, max} pairs at `ranges`.
+    fn clamp_params(mem: &mut [u8], ranges: u32, params: u32, n: u32) {
+        for k in 0..n {
+            let (min, max) = (word(mem, ranges + 8 * k), word(mem, ranges + 8 * k + 4));
+            let v = word(mem, params + 4 * k);
+            put_i32(mem, (params + 4 * k) as usize, v.max(min).min(max));
+        }
+    }
+
+    /// The words from `at` to the end of the instance (a callee may read more parameters than the
+    /// caller declares; retail then reads on into the caller's block).
+    fn words_from(mem: &[u8], at: u32) -> Vec<i32> {
+        (at as usize..mem.len()).step_by(4).map(|o| i32_at(mem, o)).collect()
+    }
+
+    /// Op 5 CallFunction: +0 function handle, +8 u8 clamp flag, +9 u8 n, +12 ranges (if flag),
+    /// then {trigger, params[n]}. The trigger is not cleared.
+    fn call_function_op(&mut self, id: u32, bank: usize, module: usize, b: u32) -> i32 {
+        let target = self.handle(bank, module, b);
+        let Some(i) = self.instance_mut(id) else { return 0 };
+        let flag = u8_at(&i.mem, b as usize + 8) != 0;
+        let n = u32::from(u8_at(&i.mem, b as usize + 9));
+        let inputs = b + 12 + if flag { 8 * n } else { 0 };
+        if flag {
+            Self::clamp_params(&mut i.mem, b + 12, inputs + 4, n);
+        }
+        if word(&i.mem, inputs) != 0 {
+            let params = Self::words_from(&i.mem, inputs + 4);
+            if let Some(SymRef::Function(f)) = target {
+                self.call_function(f, &params);
+            }
+        }
+        0
+    }
+
+    /// Op 38 ControlClass: owns a child post (spec §4.6). +0 class handle, +8 node, +12 u8 clamp
+    /// flag, +13 u8 n, +16 ranges (if flag), then {construct, destruct, params[n]}.
+    fn control_class(&mut self, id: u32, bank: usize, module: usize, b: u32) -> i32 {
+        let class = self.handle(bank, module, b);
+        let Some(i) = self.instance_mut(id) else { return 0 };
+        let mut node = u32_at(&i.mem, b as usize + 8);
+        let flag = u8_at(&i.mem, b as usize + 12) != 0;
+        let n = u32::from(u8_at(&i.mem, b as usize + 13));
+        let inputs = b + 16 + if flag { 8 * n } else { 0 };
+        let (construct, destruct) = (word(&i.mem, inputs), word(&i.mem, inputs + 4));
+        if destruct != 0 {
+            if node != 0 {
+                self.release(NodeId(node));
+                node = 0;
+            }
+        } else if construct != 0 {
+            if node == 0 {
+                if flag {
+                    Self::clamp_params(&mut i.mem, b + 16, inputs + 8, n);
+                }
+                let params = Self::words_from(&i.mem, inputs + 8);
+                if let Some(SymRef::Class(c)) = class {
+                    node = self.post(c, &params).0;
+                }
+            }
+        } else if node != 0 {
+            if flag {
+                Self::clamp_params(&mut i.mem, b + 16, inputs + 8, n);
+            }
+            let params = Self::words_from(&i.mem, inputs + 8);
+            self.redeliver(NodeId(node), &params);
+        }
+        if let Some(i) = self.instance_mut(id) {
+            put_u32(&mut i.mem, b as usize + 8, node);
+        }
+        if node == 0 { 0 } else { self.nodes.get(&node).map_or(0, |n| n.refcount as i32) }
+    }
+
+    /// Op 27 Player (spec §5.1). Layout: +4 sample group, +8 voice, +12/+13 previous play
+    /// controls, +14 u8 input count, +15 u8 update outputs, +20 sample select, +24 play control,
+    /// +28 inputs {u8 id, …, +4 applied, +8 value}, then {time left, time current}.
+    fn player(&mut self, id: u32, bank: usize, b: u32, host: &mut dyn VoiceHost) -> i32 {
+        let Evaluator { banks, instances, .. } = self;
+        let (Some(Some(lb)), Some(Some(inst))) = (banks.get(bank), instances.get_mut(id as usize)) else { return 0 };
+        let data = &lb.bank.data[..];
+        let m = &mut inst.mem;
+        let b = b as usize;
+        let control = i32_at(m, b + 24).clamp(0, 2);
+        let (prev0, prev1) = (i32::from(i8_at(m, b + 12)), i32::from(i8_at(m, b + 13)));
+        let mut voice = u32_at(m, b + 8);
+        let n = u8_at(m, b + 14) as usize;
+        let update = u8_at(m, b + 15) != 0;
+        let extra = u8_at(m, b + 17) != 0;
+        let outputs = b + 28 + 12 * n;
+        let clear = |m: &mut [u8]| {
+            if update {
+                for k in 0..(2 + if extra { 8 } else { 0 }) {
+                    put_i32(m, outputs + 4 * k, 0);
+                }
+            }
+        };
+        let push = |m: &mut [u8], voice: u32, k: usize, host: &mut dyn VoiceHost| {
+            let at = b + 28 + 12 * k;
+            let (kind, value) = (u8_at(m, at), i32_at(m, at + 8));
+            set_property(host, voice, kind, value);
+            put_i32(m, at + 4, value);
+        };
+        if control != prev0 {
+            match control {
+                0 => {
+                    if voice != 0 {
+                        host.release(voice);
+                        voice = 0;
+                        clear(m);
+                    }
+                }
+                1 => {
+                    if voice != 0 {
+                        host.resume(voice);
+                    } else if !(prev0 == 2 && prev1 == 1) {
+                        let group = u32_at(m, b + 4) as usize;
+                        let count = u32_at(data, group) as i32;
+                        let k = i32_at(m, b + 20).clamp(0, (count - 1).max(0)) as usize;
+                        let entry = group + 4 + 12 * k;
+                        let slot = u16_at(data, entry);
+                        if count <= 0 || slot == 0xFFFF {
+                            clear(m);
+                        } else {
+                            let inputs: Vec<(u8, i32)> =
+                                (0..n).map(|k| (u8_at(m, b + 28 + 12 * k), i32_at(m, b + 36 + 12 * k))).collect();
+                            let mut azimuth = [0u8; 6];
+                            azimuth.copy_from_slice(&data[entry + 3..entry + 9]);
+                            let request = OpenRequest {
+                                bank,
+                                slot,
+                                level: u8_at(data, entry + 2),
+                                azimuth,
+                                stream_offset: u32_at(data, entry + 8),
+                                inputs: &inputs,
+                            };
+                            match host.open(&request) {
+                                Some(v) => {
+                                    voice = v;
+                                    // Open applies the full input set.
+                                    for k in 0..n {
+                                        push(m, voice, k, host);
+                                    }
+                                }
+                                None => clear(m),
+                            }
+                        }
+                    }
+                }
+                _ => {
+                    if voice != 0 {
+                        host.pause(voice);
+                    }
+                }
+            }
+            put_u8(m, b + 13, prev0 as u8);
+            put_u8(m, b + 12, control as u8);
+        }
+        let mut result = match (voice != 0, control) {
+            (true, 1) => 1,
+            (true, 2) => 2,
+            _ => 0,
+        };
+        if control == 1 && voice != 0 {
+            for k in 0..n {
+                let at = b + 28 + 12 * k;
+                if i32_at(m, at + 8) != i32_at(m, at + 4) {
+                    push(m, voice, k, host);
+                }
+            }
+            let status = host.query(voice);
+            if !status.alive {
+                host.release(voice);
+                voice = 0;
+                clear(m);
+                result = 0;
+            } else if update {
+                put_i32(m, outputs, status.remaining_ms);
+                put_i32(m, outputs + 4, status.elapsed_ms);
+            }
+        }
+        put_u32(m, b + 8, voice);
+        result
+    }
+}
+
+/// The property setter (`sub_82B1BE30`): clamp by id, then hand to the voice. Id 3 goes to the
+/// alternate (azimuth) setter.
+pub fn set_property(host: &mut dyn VoiceHost, voice: u32, id: u8, value: i32) {
+    match id {
+        3 => host.set_azimuth(voice, value),
+        0 | 6 | 7 => host.set(voice, id, value.clamp(0, 65535)),
+        2 | 5 | 8 => host.set(voice, id, value.clamp(0, 32767)),
+        _ => host.set(voice, id, value),
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/skate-audio/src/eval/ops.rs b/crates/skate-audio/src/eval/ops.rs
new file mode 100644
index 00000000..c7d94019
--- /dev/null
+++ b/crates/skate-audio/src/eval/ops.rs
@@ -0,0 +1,449 @@
+//! The self-contained opcodes: everything that only reads and writes its own block (plus the bank's
+//! tables, the shared RNG and the tick scale). Behaviour per `.claude/notes/aems-evaluator-spec.md`
+//! §4; the ops that touch other objects (0–5, 27, 37–39) live in `eval/mod.rs`.
+//!
+//! Every word is an i32 with wrapping arithmetic; floats are f32 with one rounding per operation.
+use super::fmath::{fused, quarter_sine, round, trunc};
+use super::rng::Rng;
+use crate::be::*;
+
+pub struct Ctx<'a> {
+    /// The bank's bytes (TABLE pointers are bank offsets).
+    pub bank: &'a [u8],
+    pub rng: &'a mut Rng,
+    /// Tick length in ms (f32 31.999998 in play).
+    pub tick: f32,
+}
+
+#[inline]
+fn w(m: &[u8], at: usize) -> i32 {
+    i32_at(m, at)
+}
+
+/// Run a self-contained op on the block at `b`; None for the opcodes handled by the evaluator.
+pub fn run(opcode: u8, m: &mut [u8], b: usize, ctx: &mut Ctx) -> Option<i32> {
+    Some(match opcode {
+        6 => counter(m, b),
+        7 => random(m, b, ctx),
+        8 => shuffle(m, b, ctx),
+        9 => weighted(m, b, ctx),
+        10 => range_trigger(m, b),
+        11 => delay_trigger(m, b, ctx.tick),
+        12 => state_generator(m, b),
+        13 => {
+            let n = u8_at(m, b) as usize;
+            i32::from((0..n).any(|i| w(m, b + 4 + 4 * i) != 0))
+        }
+        14 => envelope(m, b, ctx.tick),
+        15 => table(m, b, ctx.bank),
+        16 => delay_line(m, b, ctx.tick),
+        17 => {
+            let n = u8_at(m, b) as i32;
+            let control = w(m, b + 4);
+            if (1..=n).contains(&control) { w(m, b + 8 + 4 * (control - 1) as usize) } else { 0 }
+        }
+        18 => demux(m, b),
+        19 | 20 => {
+            let n = (u8_at(m, b) as usize).max(1);
+            let it = (0..n).map(|i| w(m, b + 4 + 4 * i));
+            if opcode == 19 { it.min().unwrap_or(0) } else { it.max().unwrap_or(0) }
+        }
+        21 => {
+            let n = u8_at(m, b) as usize;
+            let scale = f32_at(m, b + 4);
+            let mut acc = w(m, b + 8) as f32;
+            for i in 1..n {
+                acc *= w(m, b + 8 + 4 * i) as f32;
+            }
+            round(scale * acc)
+        }
+        22 => {
+            let n = (u8_at(m, b) as usize).max(1);
+            (0..n).fold(0i32, |s, i| s.wrapping_add(w(m, b + 4 + 4 * i)))
+        }
+        23 => w(m, b).wrapping_sub(w(m, b + 4)),
+        24 => w(m, b).wrapping_mul(w(m, b + 4)),
+        25 => divide(w(m, b), w(m, b + 4)),
+        26 => {
+            let (a, d) = (w(m, b), w(m, b + 4));
+            if d == 0 { 0 } else { a.wrapping_sub(divide(a, d).wrapping_mul(d)) }
+        }
+        28 => oscillator(m, b, ctx.tick),
+        29 => ramp(m, b, ctx.tick),
+        30 => {
+            let n = (u8_at(m, b) as usize).max(1);
+            let sum = (0..n).fold(0i32, |s, i| s.wrapping_add(w(m, b + 8 + 4 * i)));
+            sum.min(w(m, b + 4))
+        }
+        31 => w(m, b + 4).wrapping_sub(w(m, b + 8)).max(w(m, b)),
+        32 => w(m, b + 4).wrapping_mul(w(m, b + 8)).min(w(m, b)),
+        33 => w(m, b).min(w(m, b + 4)),
+        34 => w(m, b).max(w(m, b + 4)),
+        35 => {
+            let s = f32_at(m, b);
+            round((w(m, b + 8) as f32 * w(m, b + 4) as f32) * s)
+        }
+        36 => w(m, b).wrapping_add(w(m, b + 4)),
+        _ => return None,
+    })
+}
+
+/// Integer division with the retail guards: x/0 = 0 and i32::MIN/−1 = 0; truncates toward zero.
+fn divide(a: i32, b: i32) -> i32 {
+    if b == 0 || (a == i32::MIN && b == -1) { 0 } else { a / b }
+}
+
+/// Op 6 Counter: +0 min, +4 max, +8 value, +12 s8 step, +16 trigger, +20 override.
+fn counter(m: &mut [u8], b: usize) -> i32 {
+    let (min, max, ovr) = (w(m, b), w(m, b + 4), w(m, b + 20));
+    if min <= ovr && ovr <= max {
+        return ovr;
+    }
+    let mut value = w(m, b + 8);
+    if w(m, b + 16) > 0 {
+        value = value.wrapping_add(i32::from(i8_at(m, b + 12)));
+        if value > max {
+            value = min;
+        } else if value < min {
+            value = max;
+        }
+        put_i32(m, b + 8, value);
+    }
+    value
+}
+
+/// Op 7 Random: +0 min, +4 range, +8 current, +12 trigger.
+fn random(m: &mut [u8], b: usize, ctx: &mut Ctx) -> i32 {
+    if w(m, b + 12) != 0 {
+        let (min, range) = (w(m, b), u32_at(m, b + 4));
+        let r = ctx.rng.draw();
+        let pick = if range == 0 { r } else { r % range };
+        put_i32(m, b + 8, min.wrapping_add(pick as i32));
+    }
+    w(m, b + 8)
+}
+
+/// Op 8 RandomShuffle: draws without repeats from the number set; the last pick of a pass is kept
+/// out of the next pass's first pick.
+fn shuffle(m: &mut [u8], b: usize, ctx: &mut Ctx) -> i32 {
+    let trigger_at = b + u16_at(m, b) as usize;
+    if w(m, trigger_at) == 0 {
+        return w(m, b + 12);
+    }
+    let wide = u8_at(m, b + 2) != 1;
+    let avoid = i32::from(i8_at(m, b + 3));
+    let index = i32::from(u16_at(m, b + 8));
+    let range = i32::from(u16_at(m, b + 10));
+    let span = range - avoid - index;
+    let r = ctx.rng.draw();
+    // Span 0 never occurs on disc (retail would divide by zero); pick the slot at `index`.
+    let k = index + if span > 0 { (r % span as u32) as i32 } else { 0 };
+    let set = b + 16;
+    let (at_k, at_i) = if wide { (set + 2 * k as usize, set + 2 * index as usize) } else { (set + k as usize, set + index as usize) };
+    let (vk, vi) = if wide { (u16_at(m, at_k) as i32, u16_at(m, at_i) as i32) } else { (u8_at(m, at_k) as i32, u8_at(m, at_i) as i32) };
+    if wide {
+        put_u16(m, at_k, vi as u16);
+        put_u16(m, at_i, vk as u16);
+    } else {
+        put_u8(m, at_k, vi as u8);
+        put_u8(m, at_i, vk as u8);
+    }
+    let current = vk.wrapping_add(w(m, b + 4));
+    put_i32(m, b + 12, current);
+    let next = index + 1;
+    if next >= range {
+        put_u16(m, b + 8, 0);
+        put_u8(m, b + 3, 1);
+    } else {
+        put_u16(m, b + 8, next as u16);
+        put_u8(m, b + 3, 0);
+    }
+    current
+}
+
+/// Op 9 RandomWeighted: +0 TABLE (s8 weights), +4 min, +8 count, +12 current, +16 trigger.
+fn weighted(m: &mut [u8], b: usize, ctx: &mut Ctx) -> i32 {
+    if w(m, b + 16) != 0 {
+        let table = u32_at(m, b) as usize;
+        let r = ctx.rng.draw() % 100;
+        let mut sum = 0i32;
+        for i in 0..w(m, b + 8).max(0) as usize {
+            sum = sum.wrapping_add(i32::from(i8_at(ctx.bank, table + 16 + i)));
+            if sum as u32 > r {
+                put_i32(m, b + 12, w(m, b + 4).wrapping_add(i as i32));
+                break;
+            }
+        }
+    }
+    w(m, b + 12)
+}
+
+/// Op 10 RangeTrigger: +0/+4 trip range, +8/+12 reset range, +16 s8 tripped, +17 s8 output, +20 input.
+fn range_trigger(m: &mut [u8], b: usize) -> i32 {
+    let input = w(m, b + 20);
+    let in_trip = w(m, b) <= input && input <= w(m, b + 4);
+    if in_trip && i8_at(m, b + 16) == 0 {
+        put_u8(m, b + 16, 1);
+        put_u8(m, b + 17, 1);
+        return 1;
+    }
+    if !in_trip && w(m, b + 8) <= input && input <= w(m, b + 12) {
+        put_u8(m, b + 16, 0);
+    }
+    put_u8(m, b + 17, 0);
+    0
+}
+
+/// Op 11 DelayTrigger: +0 f32 time (−1 idle), +4 s8 output, +8 restart trigger, +12 delay ms.
+fn delay_trigger(m: &mut [u8], b: usize, tick: f32) -> i32 {
+    if w(m, b + 8) != 0 {
+        put_f32(m, b, 0.0);
+    }
+    let time = f32_at(m, b);
+    if time < 0.0 {
+        return 0;
+    }
+    if time >= w(m, b + 12) as f32 {
+        put_u8(m, b + 4, 1);
+        put_f32(m, b, -1.0);
+        return 1;
+    }
+    put_f32(m, b, time + tick);
+    put_u8(m, b + 4, 0);
+    0
+}
+
+/// Op 12 StateGenerator: +0 u16 self-relative offset of the triggers, +2 u8 n, +4 current, +8 values.
+fn state_generator(m: &mut [u8], b: usize) -> i32 {
+    let triggers = b + u16_at(m, b) as usize;
+    let n = u8_at(m, b + 2) as usize;
+    if let Some(i) = (0..n).find(|&i| w(m, triggers + 4 * i) != 0) {
+        put_i32(m, b + 4, w(m, b + 8 + 4 * i));
+    }
+    w(m, b + 4)
+}
+
+/// Op 14 Envelope (§4.1).
+fn envelope(m: &mut [u8], b: usize, tick: f32) -> i32 {
+    let control = w(m, b + u16_at(m, b) as usize);
+    let prev = i8_at(m, b + 2);
+    let mut segment = u8_at(m, b + 3);
+    let mut remaining = f32_at(m, b + 4);
+    let mut delta = f32_at(m, b + 8);
+    let mut output = f32_at(m, b + 12);
+    let count = u8_at(m, b + 16);
+    let release = i16_at(m, b + 18);
+    let duration = |s: u8| f32_at(m, b + 24 + 8 * s as usize);
+    let target = |s: u8| f32_at(m, b + 28 + 8 * s as usize);
+    let program = |s: u8, from: f32, remaining: &mut f32, delta: &mut f32| {
+        let d = duration(s);
+        *remaining = d;
+        *delta = ((target(s) - from) / d) * tick;
+    };
+    if control == 1 && prev == 0 {
+        output = f32_at(m, b + 20);
+        segment = 0;
+        program(0, output, &mut remaining, &mut delta);
+    } else if control == 3 && prev != 3 && i16::from(segment) < release {
+        segment = release as u8;
+        program(segment, output, &mut remaining, &mut delta);
+    } else if control == 1 || control == 3 {
+        if segment < count {
+            remaining -= tick;
+            if remaining > 0.0 {
+                output += delta;
+            } else {
+                output = target(segment);
+                segment += 1;
+                if segment < count {
+                    program(segment, target(segment - 1), &mut remaining, &mut delta);
+                } else {
+                    output = 0.0;
+                }
+            }
+        }
+        if segment >= count {
+            output = 0.0;
+        }
+    } else if control != 2 {
+        output = 0.0;
+    }
+    put_u8(m, b + 3, segment);
+    put_f32(m, b + 4, remaining);
+    put_f32(m, b + 8, delta);
+    put_f32(m, b + 12, output);
+    // prevcontrol = low byte of the control word, re-read after the stores (the word may lie inside
+    // this block).
+    let control = w(m, b + u16_at(m, b) as usize);
+    put_u8(m, b + 2, control as u8);
+    round(output)
+}
+
+/// A TABLE entry (sign-extended), at a possibly negative index (op 15's i0 can be −1).
+fn entry(bank: &[u8], table: usize, size: u8, index: i64) -> i32 {
+    let width = match size {
+        1 => 1,
+        2 => 2,
+        _ => 4,
+    };
+    let at = table as i64 + 16 + index * width;
+    if at < 0 {
+        return 0;
+    }
+    let at = at as usize;
+    match size {
+        1 => i32::from(i8_at(bank, at)),
+        2 => i32::from(i16_at(bank, at)),
+        _ => i32_at(bank, at),
+    }
+}
+
+/// Op 15 Table (§4.2): +0 TABLE, +4 previous input, +8 output, +12 input.
+fn table(m: &mut [u8], b: usize, bank: &[u8]) -> i32 {
+    let input = w(m, b + 12);
+    if input == w(m, b + 4) {
+        return w(m, b + 8);
+    }
+    put_i32(m, b + 4, input);
+    let t = u32_at(m, b) as usize;
+    let size = u8_at(bank, t);
+    let count = i64::from(u16_at(bank, t + 2));
+    let (min, max) = (i32_at(bank, t + 4), i32_at(bank, t + 8));
+    let resolution = f32_at(bank, t + 12);
+    let idx = input.clamp(min, max.max(min)).wrapping_sub(min);
+    let output = if resolution == 1.0 {
+        entry(bank, t, size, i64::from(idx))
+    } else {
+        let x = idx as f32 * resolution;
+        let i0 = round(x - 0.5);
+        let frac = x - i0 as f32;
+        let i1 = (i64::from(i0) + 1).min(count - 1);
+        let e0 = entry(bank, t, size, i64::from(i0)) as f32;
+        let e1 = entry(bank, t, size, i1) as f32;
+        round(fused(e1 - e0, frac, e0))
+    };
+    put_i32(m, b + 8, output);
+    output
+}
+
+/// Op 16 DelayLine (§4.3): +0 u16 self-relative offset of {value, delay ms}, +2 u16 slots,
+/// +4 u16 in, +6 u16 out, +8 previous delay, +12 ring.
+fn delay_line(m: &mut [u8], b: usize, tick: f32) -> i32 {
+    let input = b + u16_at(m, b) as usize;
+    let value = w(m, input);
+    let mut delay = w(m, input + 4);
+    let slots = u16_at(m, b + 2);
+    let mut write = u16_at(m, b + 4);
+    let mut read = u16_at(m, b + 6);
+    if delay != w(m, b + 8) {
+        put_i32(m, b + 8, delay);
+        if delay < 0 {
+            // Retail writes 0 back into the input word. [?] We also use 0 for this walk's offset.
+            put_i32(m, input + 4, 0);
+            delay = 0;
+        }
+        let mut offset = trunc((delay as f32 / tick) + 0.5);
+        if offset >= i32::from(slots) {
+            offset = i32::from(slots) - 1;
+        }
+        write = read.wrapping_add(offset as u16);
+    }
+    if write >= slots {
+        write = write.wrapping_sub(slots);
+    }
+    if read >= slots {
+        read = 0;
+    }
+    put_i32(m, b + 12 + 4 * write as usize, value);
+    let result = w(m, b + 12 + 4 * read as usize);
+    put_u16(m, b + 4, write.wrapping_add(1));
+    put_u16(m, b + 6, read.wrapping_add(1));
+    result
+}
+
+/// Op 18 Demux: +0 u8 n, +2 s16 previous, +4 control, +8 value, +12 outputs.
+fn demux(m: &mut [u8], b: usize) -> i32 {
+    let n = i32::from(u8_at(m, b));
+    let prev = i32::from(i16_at(m, b + 2));
+    if (1..=n).contains(&prev) {
+        put_i32(m, b + 12 + 4 * (prev - 1) as usize, 0);
+    }
+    let control = w(m, b + 4);
+    if (1..=n).contains(&control) {
+        put_i32(m, b + 12 + 4 * (control - 1) as usize, w(m, b + 8));
+        put_u16(m, b + 2, control as u16);
+    }
+    w(m, b + 12)
+}
+
+/// Op 28 Oscillator (§4.4): +0 u8 waveform, +4 f32 phase, +8 period ms, +12 amplitude.
+fn oscillator(m: &mut [u8], b: usize, tick: f32) -> i32 {
+    let period = w(m, b + 8);
+    if period <= 0 {
+        return 0;
+    }
+    let inc = tick / period as f32;
+    let mut phase = f32_at(m, b + 4);
+    if !phase.is_finite() {
+        phase = 0.0; // retail would spin forever
+    }
+    while phase >= 1.0 {
+        phase -= 1.0;
+    }
+    let amp = w(m, b + 12) as f32;
+    let sample = match u8_at(m, b) {
+        0 => {
+            let u = round(phase * 1024.0);
+            let (q, i) = ((u >> 8) & 3, (u & 255) as usize);
+            let t = quarter_sine();
+            let s = match q {
+                0 => i32::from(t[i]),
+                1 => i32::from(t[256 - i]),
+                2 => -i32::from(t[i]),
+                _ => -i32::from(t[256 - i]),
+            };
+            (s as f32 * amp) * (1.0 / 65536.0)
+        }
+        1 => {
+            if phase < 0.5 { 0.0 } else { amp }
+        }
+        2 => phase * amp,
+        _ => {
+            if phase < 0.5 { phase * amp * 2.0 } else { (1.0 - phase) * amp * 2.0 }
+        }
+    };
+    put_f32(m, b + 4, phase + inc);
+    round(sample)
+}
+
+/// Op 29 Ramp (§4.5): +0 f32 current, +4 f32 delta, +8 previous target, +12 previous duration,
+/// +16 duration ms, +20 scale (4096 = 1×), +24 target.
+fn ramp(m: &mut [u8], b: usize, tick: f32) -> i32 {
+    let target = w(m, b + 24);
+    let mut current = f32_at(m, b);
+    if target as f32 == current {
+        return target;
+    }
+    let duration = w(m, b + 16);
+    let mut delta = f32_at(m, b + 4);
+    if target != w(m, b + 8) || duration != w(m, b + 12) {
+        put_i32(m, b + 8, target);
+        put_i32(m, b + 12, duration);
+        if duration <= 0 {
+            put_f32(m, b, target as f32);
+            return target;
+        }
+        delta = (((target as f32 - current) / duration as f32) * tick) * (1.0 / 4096.0);
+        put_f32(m, b + 4, delta);
+    }
+    current = fused(w(m, b + 20) as f32, delta, current);
+    let t = target as f32;
+    if (delta < 0.0 && current < t) || (delta >= 0.0 && current > t) {
+        current = t;
+    }
+    put_f32(m, b, current);
+    round(current)
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/skate-audio/src/eval/ops/tests.rs b/crates/skate-audio/src/eval/ops/tests.rs
new file mode 100644
index 00000000..dd42fec9
--- /dev/null
+++ b/crates/skate-audio/src/eval/ops/tests.rs
@@ -0,0 +1,383 @@
+//! Per-opcode tests from the spec's rules (§4, §8.1), on hand-built blocks.
+use super::*;
+use crate::eval::tick_scale;
+
+fn words(v: &[i32]) -> Vec<u8> {
+    v.iter().flat_map(|w| w.to_be_bytes()).collect()
+}
+
+fn run_op(opcode: u8, m: &mut [u8], bank: &[u8], rng: &mut Rng) -> i32 {
+    let mut ctx = Ctx { bank, rng, tick: tick_scale() };
+    run(opcode, m, 0, &mut ctx).unwrap()
+}
+
+fn op(opcode: u8, m: &mut [u8]) -> i32 {
+    run_op(opcode, m, &[], &mut Rng::default())
+}
+
+#[test]
+fn tick_scale_is_the_f32_value() {
+    assert_eq!(tick_scale(), 31.999998);
+    assert_eq!(tick_scale().to_bits(), 31.999998f32.to_bits());
+}
+
+#[test]
+fn arithmetic_ops() {
+    assert_eq!(op(23, &mut words(&[5, 7])), -2);
+    assert_eq!(op(24, &mut words(&[0x10000, 0x10000])), 0); // low 32 bits
+    assert_eq!(op(25, &mut words(&[7, 0])), 0);
+    assert_eq!(op(25, &mut words(&[i32::MIN, -1])), 0);
+    assert_eq!(op(25, &mut words(&[-7, 2])), -3);
+    assert_eq!(op(26, &mut words(&[-7, 2])), -1);
+    assert_eq!(op(26, &mut words(&[7, 0])), 0);
+    assert_eq!(op(33, &mut words(&[3, -4])), -4);
+    assert_eq!(op(34, &mut words(&[3, -4])), 3);
+    assert_eq!(op(36, &mut words(&[i32::MAX, 1])), i32::MIN);
+    // n-ary: n = 0 still reads input 0.
+    assert_eq!(op(22, &mut words(&[0, 9, 100])), 9);
+    assert_eq!(op(22, &mut words(&[3 << 24, 1, 2, 3])), 6);
+    assert_eq!(op(19, &mut words(&[3 << 24, 4, -2, 9])), -2);
+    assert_eq!(op(20, &mut words(&[3 << 24, 4, -2, 9])), 9);
+    assert_eq!(op(20, &mut words(&[0, 4, 50])), 4);
+    // AddMaximum, SubtractMinimum, MultiplyMaximum.
+    assert_eq!(op(30, &mut words(&[2 << 24, 10, 6, 7])), 10);
+    assert_eq!(op(30, &mut words(&[0, 10, 6, 7])), 6);
+    assert_eq!(op(31, &mut words(&[0, 3, 10])), 0);
+    assert_eq!(op(32, &mut words(&[50, 6, 7])), 42);
+    assert_eq!(op(32, &mut words(&[40, 6, 7])), 40);
+}
+
+#[test]
+fn scale_ops_round_in_f32() {
+    // Scale: 0.5 × 3 × 5 = 7.5 → 8.
+    let mut m = words(&[2 << 24, 0.5f32.to_bits() as i32, 3, 5]);
+    assert_eq!(op(21, &mut m), 8);
+    // n = 0 still uses input 0: 0.5 × 3 = 1.5 → 2.
+    let mut m = words(&[0, 0.5f32.to_bits() as i32, 3]);
+    assert_eq!(op(21, &mut m), 2);
+    // Scale2: round(b·a·s) = 4096 × 3 × 0.25 = 3072; negative rounds away from zero.
+    assert_eq!(op(35, &mut words(&[0.25f32.to_bits() as i32, 3, 4096])), 3072);
+    assert_eq!(op(35, &mut words(&[0.5f32.to_bits() as i32, -3, 1])), -2);
+}
+
+#[test]
+fn mux_and_demux() {
+    assert_eq!(op(17, &mut words(&[2 << 24, 2, 10, 20])), 20);
+    assert_eq!(op(17, &mut words(&[2 << 24, 3, 10, 20])), 0);
+    assert_eq!(op(17, &mut words(&[2 << 24, 0, 10, 20])), 0);
+    // Demux: n = 3, prev = 1, control 2, value 77 → outputs [0, 77, 0], prev = 2, returns out[0].
+    let mut m = words(&[(3 << 24) | 1, 2, 77, 5, 0, 0]);
+    assert_eq!(op(18, &mut m), 0);
+    assert_eq!(&m[12..24], &words(&[0, 77, 0])[..]);
+    assert_eq!(i16_at(&m, 2), 2);
+    // Next walk with control 0: the previous output is cleared, prev unchanged.
+    put_i32(&mut m, 4, 0);
+    op(18, &mut m);
+    assert_eq!(&m[12..24], &words(&[0, 0, 0])[..]);
+    assert_eq!(i16_at(&m, 2), 2);
+}
+
+#[test]
+fn counter_wraps_and_override_wins() {
+    // min 0, max 2, value 2, step +1, trigger 1, override −1 (out of range).
+    let mut m = words(&[0, 2, 2, 1 << 24, 1, -1]);
+    assert_eq!(op(6, &mut m), 0);
+    assert_eq!(op(6, &mut m), 1);
+    // Step −1 from 0 wraps to max.
+    let mut m = words(&[0, 2, 0, (-1i32 as u8 as i32) << 24, 1, -1]);
+    assert_eq!(op(6, &mut m), 2);
+    // Override in range: returned, value untouched.
+    let mut m = words(&[0, 2, 0, 1 << 24, 1, 1]);
+    assert_eq!(op(6, &mut m), 1);
+    assert_eq!(i32_at(&m, 8), 0);
+    // Trigger must be > 0 (signed).
+    let mut m = words(&[0, 5, 1, 1 << 24, -1, -1]);
+    assert_eq!(op(6, &mut m), 1);
+}
+
+#[test]
+fn random_draws_mod_range() {
+    let mut rng = Rng::default();
+    // draws 0, 1, 7 → min 10 + draw mod 5 → 10, 11, 12.
+    let mut m = words(&[10, 5, 0, 1]);
+    let got: Vec<i32> = (0..3).map(|_| run_op(7, &mut m, &[], &mut rng)).collect();
+    assert_eq!(got, [10, 11, 12]);
+    // No trigger: current unchanged, no draw.
+    put_i32(&mut m, 12, 0);
+    assert_eq!(run_op(7, &mut m, &[], &mut rng), 12);
+    assert_eq!(rng.w, [7, 6, 5, 4, 3, 3]);
+    // Range 0: min + draw.
+    let mut m = words(&[10, 0, 0, 1]);
+    let draw = Rng::new(rng.w).draw() as i32;
+    assert_eq!(run_op(7, &mut m, &[], &mut rng), 10 + draw);
+}
+
+/// A shuffle block: trigger at +16 + set size, u8 entries.
+fn shuffle_block(range: u16, min: i32) -> Vec<u8> {
+    let mut m = vec![0u8; 16 + range as usize + 4];
+    m.resize((m.len() + 3) & !3, 0);
+    let trig = (m.len() - 4) as u16;
+    put_u16(&mut m, 0, trig);
+    put_u8(&mut m, 2, 1);
+    put_u8(&mut m, 3, 0);
+    put_i32(&mut m, 4, min);
+    put_u16(&mut m, 8, 0);
+    put_u16(&mut m, 10, range);
+    for i in 0..range as usize {
+        put_u8(&mut m, 16 + i, i as u8);
+    }
+    put_i32(&mut m, trig as usize, 1);
+    m
+}
+
+#[test]
+fn shuffle_never_repeats_within_a_pass_or_across_the_wrap() {
+    let mut rng = Rng::new([0x1234, 0x5678, 9, 10, 11, 12]);
+    let range = 7u16;
+    let mut m = shuffle_block(range, 100);
+    let mut last = None;
+    let mut pass = Vec::new();
+    for draw in 0..10_000 {
+        let v = run_op(8, &mut m, &[], &mut rng);
+        assert!((100..107).contains(&v));
+        assert_ne!(Some(v), last, "repeat at draw {draw}");
+        last = Some(v);
+        pass.push(v);
+        if pass.len() == range as usize {
+            let mut sorted = pass.clone();
+            sorted.sort_unstable();
+            assert_eq!(sorted, (100..107).collect::<Vec<_>>(), "a pass plays every value once");
+            pass.clear();
+        }
+    }
+    // Without a trigger the current value is returned and nothing is drawn.
+    let trig = u16_at(&m, 0) as usize;
+    put_i32(&mut m, trig, 0);
+    let state = rng;
+    assert_eq!(run_op(8, &mut m, &[], &mut rng), last.unwrap());
+    assert_eq!(rng, state);
+}
+
+#[test]
+fn shuffle_span_arithmetic() {
+    // From zero RNG: draw 0 → k = index + 0. range 3: picks set[0] = 0 first.
+    let mut rng = Rng::default();
+    let mut m = shuffle_block(3, 0);
+    assert_eq!(run_op(8, &mut m, &[], &mut rng), 0); // draw 0, span 3 → k 0
+    assert_eq!(run_op(8, &mut m, &[], &mut rng), 2); // draw 1, span 2, index 1 → k 2 (set[2] = 2)
+    assert_eq!(run_op(8, &mut m, &[], &mut rng), 1); // draw 7, span 1 → k 2 (set now [0,2,1])
+    // Pass done: index 0, avoid-repeat 1 → span 2 excludes the last slot.
+    assert_eq!((u16_at(&m, 8), i8_at(&m, 3)), (0, 1));
+}
+
+fn table_bank(entry: u8, values: &[i32], min: i32, max: i32, resolution: f32) -> Vec<u8> {
+    let mut t = vec![entry, 0];
+    t.extend_from_slice(&(values.len() as u16).to_be_bytes());
+    t.extend_from_slice(&min.to_be_bytes());
+    t.extend_from_slice(&max.to_be_bytes());
+    t.extend_from_slice(&resolution.to_bits().to_be_bytes());
+    for &v in values {
+        match entry {
+            1 => t.push(v as i8 as u8),
+            2 => t.extend_from_slice(&(v as i16).to_be_bytes()),
+            _ => t.extend_from_slice(&v.to_be_bytes()),
+        }
+    }
+    t
+}
+
+#[test]
+fn table_nearest_and_linear() {
+    let mut rng = Rng::default();
+    // Nearest: s16 entries, input clamped to [10, 13].
+    let bank = table_bank(2, &[-100, 200, 300, 400], 10, 13, 1.0);
+    let mut m = words(&[0, 0x7FFF_FFF1, 0, 12]);
+    assert_eq!(run_op(15, &mut m, &bank, &mut rng), 300);
+    put_i32(&mut m, 12, 99);
+    assert_eq!(run_op(15, &mut m, &bank, &mut rng), 400);
+    put_i32(&mut m, 12, -5);
+    assert_eq!(run_op(15, &mut m, &bank, &mut rng), -100);
+    // Same input again: cached output, even if the table changed.
+    assert_eq!(run_op(15, &mut m, &[0; 32], &mut rng), -100);
+    // Linear: resolution 0.5 entries per unit, s8 entries.
+    let bank = table_bank(1, &[0, 100, 50], 0, 4, 0.5);
+    let mut m = words(&[0, 0x7FFF_FFF1, 0, 1]);
+    assert_eq!(run_op(15, &mut m, &bank, &mut rng), 50); // x = 0.5 between 0 and 100
+    put_i32(&mut m, 12, 3);
+    assert_eq!(run_op(15, &mut m, &bank, &mut rng), 75); // x = 1.5 between 100 and 50
+    put_i32(&mut m, 12, 4);
+    assert_eq!(run_op(15, &mut m, &bank, &mut rng), 50); // x = 2.0: i1 clamps to the last entry
+    // x = 0: i0 rounds to −1 (reads the resolution's low byte) yet lands exactly on entry 0.
+    let bank = table_bank(1, &[-7, 100, 50], 0, 4, 0.5);
+    put_i32(&mut m, 12, 0);
+    assert_eq!(run_op(15, &mut m, &bank, &mut rng), -7);
+}
+
+#[test]
+fn weighted_takes_the_first_cumulative_weight_above_the_draw() {
+    let bank = table_bank(1, &[30, 30, 40], 0, 2, 1.0);
+    let mut rng = Rng::new([0; 6]);
+    // draws 0, 1, 7: all below 30 → index 0.
+    let mut m = words(&[0, 5, 3, -1, 1]);
+    assert_eq!(run_op(9, &mut m, &bank, &mut rng), 5);
+    // A draw of 45 → cumulative 30, 60 → index 1.
+    let mut rng = Rng::new([44, 0, 0, 0, 0, 0]); // next w0 = 44 + 1 (w1 + carry) … check via draw
+    let mut probe = rng;
+    let r = probe.draw() % 100;
+    let expect = if r < 30 { 5 } else if r < 60 { 6 } else { 7 };
+    assert_eq!(run_op(9, &mut m, &bank, &mut rng), expect);
+}
+
+#[test]
+fn range_trigger_trips_once_until_reset() {
+    // trip [10, 20], reset [0, 5]
+    let mut m = words(&[10, 20, 0, 5, 0, 15]);
+    assert_eq!(op(10, &mut m), 1);
+    assert_eq!(op(10, &mut m), 0); // still tripped
+    put_i32(&mut m, 20, 30);
+    assert_eq!(op(10, &mut m), 0); // outside both: stays tripped
+    put_i32(&mut m, 20, 15);
+    assert_eq!(op(10, &mut m), 0);
+    put_i32(&mut m, 20, 3);
+    assert_eq!(op(10, &mut m), 0); // reset
+    put_i32(&mut m, 20, 12);
+    assert_eq!(op(10, &mut m), 1);
+}
+
+#[test]
+fn delay_trigger_fires_after_the_delay_rounded_up_to_a_tick() {
+    let mut m = words(&[(-1.0f32).to_bits() as i32, 0, 1, 100]);
+    let mut fired = Vec::new();
+    for walk in 0..8 {
+        if walk == 1 {
+            put_i32(&mut m, 8, 0); // restart released after the first walk
+        }
+        fired.push(op(11, &mut m));
+    }
+    // time 0 → 32 → 64 → 96 → 128 ≥ 100 on the 5th walk.
+    assert_eq!(fired, [0, 0, 0, 0, 1, 0, 0, 0]);
+    assert_eq!(f32_at(&m, 0), -1.0);
+}
+
+#[test]
+fn delay_line_delays_by_whole_ticks() {
+    // offset 12 → {value, delay}; 4 slots; ring at +12. Words: [hdr, in/out, prev, ring×4, value, delay]
+    let mut m = vec![0u8; 12 + 16 + 8];
+    put_u16(&mut m, 0, 28);
+    put_u16(&mut m, 2, 4);
+    put_i32(&mut m, 8, -12345);
+    put_i32(&mut m, 32, 64); // 64 ms = 2 ticks
+    let mut out = Vec::new();
+    for v in 1..=6 {
+        put_i32(&mut m, 28, v);
+        out.push(op(16, &mut m));
+    }
+    assert_eq!(out, [0, 0, 1, 2, 3, 4]);
+    // Delay 0 passes the value straight through (write before read).
+    put_i32(&mut m, 32, 0);
+    put_i32(&mut m, 28, 42);
+    assert_eq!(op(16, &mut m), 42);
+    // A negative delay is written back as 0.
+    put_i32(&mut m, 32, -5);
+    op(16, &mut m);
+    assert_eq!(i32_at(&m, 32), 0);
+}
+
+#[test]
+fn oscillator_waveforms_and_quadrants() {
+    // Sine, amplitude 65536 → sample = T value (×1).
+    let t = quarter_sine();
+    let mut m = words(&[0, 0.0f32.to_bits() as i32, 128_000, 65536]);
+    // Phase 0, 0.25, 0.5, 0.75 → 0, T[256], 0 (−T[0]), −T[256].
+    for (phase, want) in [(0.0f32, 0), (0.25, i32::from(t[256])), (0.5, 0), (0.75, -i32::from(t[256])), (0.125, i32::from(t[128]))] {
+        put_f32(&mut m, 4, phase);
+        assert_eq!(op(28, &mut m), want, "phase {phase}");
+    }
+    // u = 1024 (phase just below 1 rounds up): quadrant (1024 >> 8) & 3 = 0, i = 0 → 0.
+    put_f32(&mut m, 4, 0.9999);
+    assert_eq!(op(28, &mut m), 0);
+    // Phase advances by tick/period and wraps.
+    put_f32(&mut m, 4, 0.0);
+    op(28, &mut m);
+    assert_eq!(f32_at(&m, 4), tick_scale() / 128_000.0);
+    // Square, saw, triangle.
+    let mut m = words(&[1 << 24, 0.6f32.to_bits() as i32, 1000, 100]);
+    assert_eq!(op(28, &mut m), 100);
+    let mut m = words(&[2 << 24, 0.25f32.to_bits() as i32, 1000, 100]);
+    assert_eq!(op(28, &mut m), 25);
+    let mut m = words(&[3 << 24, 0.75f32.to_bits() as i32, 1000, 100]);
+    assert_eq!(op(28, &mut m), 50);
+    // Period ≤ 0: 0 and no state change.
+    let mut m = words(&[0, 0.3f32.to_bits() as i32, 0, 100]);
+    assert_eq!(op(28, &mut m), 0);
+    assert_eq!(f32_at(&m, 4), 0.3);
+    // Phase ≥ 1 wraps first.
+    let mut m = words(&[2 << 24, 2.5f32.to_bits() as i32, 1000, 100]);
+    assert_eq!(op(28, &mut m), 50);
+}
+
+#[test]
+fn ramp_reaches_its_target_in_its_duration() {
+    // current 0, target 4096 over 320 ms at scale 4096 (1×): 10 ticks of ~409.6.
+    let mut m = words(&[0, 0, 0, 0, 320, 4096, 4096]);
+    let mut out = Vec::new();
+    for _ in 0..12 {
+        out.push(op(29, &mut m));
+    }
+    assert_eq!(out[0], 410);
+    assert_eq!(*out.last().unwrap(), 4096);
+    assert!(out.windows(2).all(|w| w[0] <= w[1]));
+    // Overshoot is clamped; reaching the target exactly returns the target without work.
+    assert_eq!(f32_at(&m, 0), 4096.0);
+    // Duration ≤ 0 snaps.
+    let mut m = words(&[0, 0, 0, 0, 0, 4096, 77]);
+    assert_eq!(op(29, &mut m), 77);
+    assert_eq!(f32_at(&m, 0), 77.0);
+    // Scale 0 freezes until target/duration change.
+    let mut m = words(&[0, 0, 0, 0, 320, 0, 4096]);
+    assert_eq!(op(29, &mut m), 0);
+    assert_eq!(op(29, &mut m), 0);
+}
+
+/// Envelope block: control word at +24 + 8·nseg (self-relative offset at +0).
+fn envelope_block(segments: &[(f32, f32)], release: i16, initial: f32) -> (Vec<u8>, usize) {
+    let control = 24 + 8 * segments.len();
+    let mut m = vec![0u8; control + 4];
+    put_u16(&mut m, 0, control as u16);
+    put_u8(&mut m, 16, segments.len() as u8);
+    put_u16(&mut m, 18, release as u16);
+    put_f32(&mut m, 20, initial);
+    for (i, &(d, t)) in segments.iter().enumerate() {
+        put_f32(&mut m, 24 + 8 * i, d);
+        put_f32(&mut m, 28 + 8 * i, t);
+    }
+    (m, control)
+}
+
+#[test]
+fn envelope_start_hold_release_and_end() {
+    // Attack 64 ms to 1000, hold-ish segment 640 ms to 1000, release 64 ms to 0 (segment 2).
+    let (mut m, ctl) = envelope_block(&[(64.0, 1000.0), (640.0, 1000.0), (64.0, 0.0)], 2, 0.0);
+    put_i32(&mut m, ctl, 1);
+    let start = op(14, &mut m);
+    assert_eq!(start, 0); // output = initial on the start walk
+    let a = op(14, &mut m);
+    assert!(a > 450 && a < 550, "{a}");
+    let b = op(14, &mut m);
+    assert_eq!(b, 1000); // segment 0 done, segment 1 programmed from its target
+    // Hold (2): unchanged.
+    put_i32(&mut m, ctl, 2);
+    assert_eq!(op(14, &mut m), 1000);
+    // Release (3): jump to segment 2 from the current output.
+    put_i32(&mut m, ctl, 3);
+    assert_eq!(op(14, &mut m), 1000);
+    let r1 = op(14, &mut m);
+    assert!(r1 < 600, "{r1}");
+    let r2 = op(14, &mut m);
+    assert_eq!(r2, 0); // last segment done → output 0
+    assert_eq!(op(14, &mut m), 0);
+    // Stop (0): output 0.
+    put_i32(&mut m, ctl, 0);
+    assert_eq!(op(14, &mut m), 0);
+    assert_eq!(i8_at(&m, 2), 0);
+}
diff --git a/crates/skate-audio/src/eval/rng.rs b/crates/skate-audio/src/eval/rng.rs
new file mode 100644
index 00000000..ac2d4450
--- /dev/null
+++ b/crates/skate-audio/src/eval/rng.rs
@@ -0,0 +1,59 @@
+//! The AEMS random generator (spec §2.8): six u32 words shared by every instance, used only by
+//! ops 7, 8 and 9. All zero at boot; deterministic from there.
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Rng {
+    pub w: [u32; 6],
+}
+
+impl Rng {
+    pub fn new(state: [u32; 6]) -> Self {
+        Self { w: state }
+    }
+
+    /// One draw; returns the low 32 bits of the new w0.
+    pub fn draw(&mut self) -> u32 {
+        let w = &mut self.w;
+        // Ripple-add upward: w4 += w5, then w3 += w4' + carry, … w0 += w1' + carry. The carry of each
+        // step is "the result is below the original word" (retail's compare-based carry).
+        let mut carry = 0u32;
+        for k in (0..5).rev() {
+            let original = w[k];
+            w[k] = original.wrapping_add(w[k + 1]).wrapping_add(carry);
+            carry = u32::from(w[k] < original);
+        }
+        // Then w5 += 1, rippling an increment upward while words wrap to zero.
+        w[5] = w[5].wrapping_add(1);
+        if w[5] == 0 {
+            for k in (0..5).rev() {
+                w[k] = w[k].wrapping_add(1);
+                if w[k] != 0 {
+                    break;
+                }
+            }
+        }
+        w[0]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn first_draws_from_zero() {
+        let mut r = Rng::default();
+        assert_eq!([r.draw(), r.draw(), r.draw()], [0, 1, 7]);
+        assert_eq!(r.w, [7, 6, 5, 4, 3, 3]);
+    }
+
+    #[test]
+    fn full_ripple_of_the_increment() {
+        let mut r = Rng::new([0, 0, 0, 0, 0, 0xFFFF_FFFF]);
+        // w4 += w5 → FFFFFFFF (no carry), w3..w0 take FFFFFFFF in turn; w5 wraps to 0 and the
+        // increment ripples through every word.
+        let v = r.draw();
+        assert_eq!(r.w, [0, 0, 0, 0, 0, 0]);
+        assert_eq!(v, 0);
+    }
+}
diff --git a/crates/skate-audio/src/eval/symbols.rs b/crates/skate-audio/src/eval/symbols.rs
new file mode 100644
index 00000000..b17704e2
--- /dev/null
+++ b/crates/skate-audio/src/eval/symbols.rs
@@ -0,0 +1,97 @@
+//! Installed Csis projects and their run-time symbol records (spec §1.8, §2.7).
+//!
+//! Each Function, Class and GlobalVariable becomes one record with its client list. Lookup follows
+//! retail: pass 1 scans projects whose id matches the reference's project id, pass 2 every
+//! project; newest project first; a hit needs an equal name id and an equal name.
+use crate::formats::Project;
+use crate::formats::abk::InterfaceKind;
+
+/// A resolved symbol.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum SymRef {
+    Function(usize),
+    Class(usize),
+    Global(usize),
+}
+
+/// A subscription: (instance id, state offset in the instance).
+pub type Client = (u32, u32);
+
+#[derive(Clone, Debug)]
+pub struct FunctionRec {
+    pub name: String,
+    pub subscribers: Vec<Client>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ClassRec {
+    pub name: String,
+    /// Constructor clients (bank index, module index) in install order; posts call them newest
+    /// first.
+    pub constructors: Vec<(usize, usize)>,
+}
+
+#[derive(Clone, Debug)]
+pub struct GlobalRec {
+    pub name: String,
+    pub value: i32,
+    pub subscribers: Vec<Client>,
+}
+
+struct Installed {
+    id: u16,
+    /// Per table: (name id, name, record index).
+    tables: [Vec<(u16, String, usize)>; 3],
+}
+
+#[derive(Default)]
+pub struct Registry {
+    /// Install order (lookup walks it newest first).
+    projects: Vec<Installed>,
+    pub functions: Vec<FunctionRec>,
+    pub classes: Vec<ClassRec>,
+    pub globals: Vec<GlobalRec>,
+}
+
+impl Registry {
+    pub fn install(&mut self, project: &Project) {
+        let mut tables: [Vec<(u16, String, usize)>; 3] = Default::default();
+        for s in &project.tables[0] {
+            tables[0].push((s.name_id, s.name.clone(), self.functions.len()));
+            self.functions.push(FunctionRec { name: s.name.clone(), subscribers: Vec::new() });
+        }
+        for s in &project.tables[1] {
+            tables[1].push((s.name_id, s.name.clone(), self.classes.len()));
+            self.classes.push(ClassRec { name: s.name.clone(), constructors: Vec::new() });
+        }
+        for s in &project.tables[2] {
+            tables[2].push((s.name_id, s.name.clone(), self.globals.len()));
+            self.globals.push(GlobalRec { name: s.name.clone(), value: s.default, subscribers: Vec::new() });
+        }
+        self.projects.push(Installed { id: project.id, tables });
+    }
+
+    /// Resolve an interface reference; None = retail's −5 (not found).
+    pub fn lookup(&self, kind: InterfaceKind, project: u16, name_id: u16, name: &str) -> Option<SymRef> {
+        let t = kind.table();
+        let find = |p: &Installed| p.tables[t].iter().find(|(id, n, _)| *id == name_id && n == name).map(|e| e.2);
+        let hit = self
+            .projects
+            .iter()
+            .rev()
+            .filter(|p| p.id == project)
+            .find_map(find)
+            .or_else(|| self.projects.iter().rev().find_map(find))?;
+        Some(match kind {
+            InterfaceKind::Function => SymRef::Function(hit),
+            InterfaceKind::Class => SymRef::Class(hit),
+            InterfaceKind::GlobalVariable => SymRef::Global(hit),
+        })
+    }
+
+    /// First record with this name in a table (newest project first), for game-side posting.
+    pub fn by_name(&self, kind: InterfaceKind, name: &str) -> Option<usize> {
+        let t = kind.table();
+        self.projects.iter().rev().find_map(|p| p.tables[t].iter().find(|e| e.1 == name).map(|e| e.2))
+    }
+}
diff --git a/crates/skate-audio/src/eval/tests.rs b/crates/skate-audio/src/eval/tests.rs
new file mode 100644
index 00000000..9ca90faa
--- /dev/null
+++ b/crates/skate-audio/src/eval/tests.rs
@@ -0,0 +1,477 @@
+//! Evaluator tests on hand-built banks: posting, payload delivery, the player's open / push /
+//! query / restart edge, release → destroy, capacity, and the function → global round trip with
+//! its walk-order rule (spec §2, §5).
+use super::*;
+use crate::formats::Project;
+use crate::formats::csi::Symbol;
+
+/// One module of a synthetic bank.
+struct Spec {
+    max: i16,
+    globals: u16,
+    functions: u16,
+    destructor: bool,
+    class_data: bool,
+    players: Vec<u32>,
+    template: Vec<u8>,
+    /// (opcode, pairs, block offset); advances are derived from the next op's block.
+    program: Vec<(u8, Vec<(i32, i32)>, u32)>,
+    /// Template offsets that must hold the bank offset of the shared sample group.
+    group_ptrs: Vec<u32>,
+}
+
+/// An export: kind (0 global, 1 class, 2 function), name id, name, and where the handle goes:
+/// None = the module's class handle, Some(off) = template offset.
+struct Ex {
+    module: usize,
+    kind: u32,
+    name_id: u16,
+    name: &'static str,
+    at: Option<u32>,
+}
+
+const PROJECT: u16 = 0x1234;
+
+fn project() -> Project {
+    let s = |name: &str, id: u16, default: i32| Symbol { name: name.into(), name_id: id, default };
+    Project {
+        name: "test.csi".into(),
+        id: PROJECT,
+        tables: [
+            vec![s("f_msg", 1, 0)],
+            vec![s("c_test", 1, 0), s("c_util", 2, 0), s("c_req", 3, 0)],
+            vec![s("g_snd", 1, 77)],
+        ],
+    }
+}
+
+fn be(v: &mut Vec<u8>, w: u32) {
+    v.extend_from_slice(&w.to_be_bytes());
+}
+
+/// Build an ABKC bank: header | module records | templates | programs | sample group | S10A |
+/// interface list + id records | empty rebase list. Samples: (frames, looping) at 48 kHz mono.
+fn bank(modules: &[Spec], exports: &[Ex], samples: &[(u32, bool)]) -> Bank {
+    let records: usize = modules.iter().map(|m| 60 + 4 * m.players.len()).sum();
+    let mut at = 0x5C + records;
+    let mut template_at = Vec::new();
+    for m in modules {
+        template_at.push(at);
+        at += m.template.len();
+    }
+    let mut program_at = Vec::new();
+    let mut programs = Vec::new();
+    for m in modules {
+        program_at.push(at);
+        let mut p = Vec::new();
+        for (i, (op, pairs, block)) in m.program.iter().enumerate() {
+            let next = m.program.get(i + 1).map_or(m.template.len() as u32, |o| o.2);
+            p.push(*op);
+            p.push(pairs.len() as u8);
+            p.extend_from_slice(&[0, 0]);
+            for &(s, d) in pairs {
+                be(&mut p, s as u32);
+                be(&mut p, d as u32);
+            }
+            be(&mut p, next - block);
+        }
+        p.push(255);
+        p.extend_from_slice(&[0, 0, 0]);
+        at += p.len();
+        programs.push(p);
+    }
+    let group_at = at;
+    let mut group = Vec::new();
+    be(&mut group, samples.len() as u32);
+    for i in 0..samples.len() {
+        group.extend_from_slice(&(i as u16).to_be_bytes());
+        group.push(100);
+        // Bytes 3..7 azimuths; byte 8 is the first byte of the stream offset word.
+        group.extend_from_slice(&[0, 0, 0, 0, (i + 1) as u8]);
+        be(&mut group, u32::MAX);
+    }
+    at += group.len();
+    let s10a_at = at;
+    let mut s10a = b"S10A".to_vec();
+    be(&mut s10a, 0);
+    be(&mut s10a, samples.len() as u32);
+    let mut bodies = Vec::new();
+    let table = 12 + 4 * samples.len();
+    for &(frames, looping) in samples {
+        be(&mut s10a, (table + bodies.len()) as u32);
+        be(&mut bodies, (3 << 24) | 48000);
+        be(&mut bodies, (u32::from(looping) << 29) | frames);
+        be(&mut bodies, 0);
+    }
+    s10a.extend_from_slice(&bodies);
+    at += s10a.len();
+    let interface_at = at;
+    let mut iface = Vec::new();
+    be(&mut iface, exports.len() as u32);
+    let ids_at = interface_at + 4 + 12 * exports.len();
+    let mut ids = Vec::new();
+    let mut module_at = Vec::new();
+    let mut r = 0x5C;
+    for m in modules {
+        module_at.push(r);
+        r += 60 + 4 * m.players.len();
+    }
+    for e in exports {
+        let handle = match e.at {
+            None => module_at[e.module] + 4,
+            Some(off) => template_at[e.module] + off as usize,
+        };
+        be(&mut iface, handle as u32);
+        be(&mut iface, (ids_at + ids.len()) as u32);
+        be(&mut iface, e.kind << 24);
+        ids.extend_from_slice(&PROJECT.to_be_bytes());
+        ids.extend_from_slice(&e.name_id.to_be_bytes());
+        ids.extend_from_slice(e.name.as_bytes());
+        ids.push(0);
+        while ids.len() % 4 != 0 {
+            ids.push(0);
+        }
+    }
+    at = ids_at + ids.len();
+    let rebase_at = at;
+
+    let mut d = vec![0u8; 0x5C];
+    d[..4].copy_from_slice(b"ABKC");
+    d[0x0A..0x0C].copy_from_slice(&(modules.len() as u16).to_be_bytes());
+    d[0x18..0x1C].copy_from_slice(&(s10a_at as u32).to_be_bytes());
+    d[0x1C..0x20].copy_from_slice(&0x5Cu32.to_be_bytes());
+    d[0x20..0x24].copy_from_slice(&(s10a_at as u32).to_be_bytes());
+    d[0x34..0x38].copy_from_slice(&(rebase_at as u32).to_be_bytes());
+    d[0x38..0x3C].copy_from_slice(&(interface_at as u32).to_be_bytes());
+    for (i, m) in modules.iter().enumerate() {
+        let mut rec = vec![0u8; 60];
+        rec[0x1E..0x20].copy_from_slice(&m.max.to_be_bytes());
+        rec[0x20..0x22].copy_from_slice(&m.globals.to_be_bytes());
+        rec[0x22..0x24].copy_from_slice(&m.functions.to_be_bytes());
+        rec[0x24] = m.players.len() as u8;
+        rec[0x25] = u8::from(m.destructor);
+        rec[0x26] = u8::from(m.class_data);
+        rec[0x28..0x2C].copy_from_slice(&(program_at[i] as u32).to_be_bytes());
+        rec[0x2C..0x30].copy_from_slice(&(template_at[i] as u32).to_be_bytes());
+        rec[0x30..0x34].copy_from_slice(&(m.template.len() as u32).to_be_bytes());
+        rec[0x34..0x38].copy_from_slice(&(m.template.len() as u32 - 16).to_be_bytes());
+        for p in &m.players {
+            be(&mut rec, *p);
+        }
+        d.extend_from_slice(&rec);
+    }
+    for m in modules {
+        let mut t = m.template.clone();
+        for &g in &m.group_ptrs {
+            put_u32(&mut t, g as usize, group_at as u32);
+        }
+        d.extend_from_slice(&t);
+    }
+    for p in &programs {
+        d.extend_from_slice(p);
+    }
+    d.extend_from_slice(&group);
+    d.extend_from_slice(&s10a);
+    d.extend_from_slice(&iface);
+    d.extend_from_slice(&ids);
+    be(&mut d, 0); // empty rebase list
+    Bank::parse("test.abk", d).expect("synthetic bank")
+}
+
+/// Template words helper.
+fn words(n: usize) -> Vec<u8> {
+    vec![0u8; 4 * n]
+}
+
+/// A c_test module: destructor @24, ClassData (2 values) @44, Create @72, Player @76 (one input:
+/// pitch), Destroy @124. Payload w0 → playcontrol, w1 → pitch, w2 → sample select.
+fn player_module(max: i16) -> Spec {
+    let mut t = words(35); // 140 bytes
+    put_u8(&mut t, 44 + 16, 3); // ClassData: 3 values ((3 + 5)·4 = 32 B → @44..76)
+    // Create @76
+    put_i32(&mut t, 76, 1);
+    // Player @80: n = 1 input, update outputs
+    let p = 80usize;
+    put_u8(&mut t, p + 14, 1);
+    put_u8(&mut t, p + 15, 1);
+    put_u8(&mut t, p + 28, 0); // input id 0 (pitch)
+    put_i32(&mut t, p + 32, -1); // applied
+    // Destroy @124 (datasize 140 − 16)
+    Spec {
+        max,
+        globals: 0,
+        functions: 0,
+        destructor: true,
+        class_data: true,
+        players: vec![80],
+        template: t,
+        program: vec![
+            (0, vec![(-1, 124 + 12 - 24)], 24),
+            // ClassData @44: values at +20,+24,+28 → playcontrol (+24 of player), pitch value
+            // (+36), sample select (+20).
+            (1, vec![(20, 80 + 24 - 44), (24, 80 + 36 - 44), (28, 80 + 20 - 44)], 44),
+            (3, vec![], 76),
+            (27, vec![], 80),
+            (4, vec![], 124),
+        ],
+        group_ptrs: vec![80 + 4],
+    }
+}
+
+#[derive(Default)]
+struct Log {
+    calls: Vec<String>,
+    next: u32,
+    alive: HashMap<u32, bool>,
+}
+
+impl VoiceHost for Log {
+    fn open(&mut self, r: &OpenRequest) -> Option<u32> {
+        self.next += 1;
+        self.alive.insert(self.next, true);
+        self.calls.push(format!("open v{} slot {}", self.next, r.slot));
+        Some(self.next)
+    }
+    fn release(&mut self, v: u32) {
+        self.calls.push(format!("release v{v}"));
+    }
+    fn pause(&mut self, v: u32) {
+        self.calls.push(format!("pause v{v}"));
+    }
+    fn resume(&mut self, v: u32) {
+        self.calls.push(format!("resume v{v}"));
+    }
+    fn set(&mut self, v: u32, id: u8, value: i32) {
+        self.calls.push(format!("set v{v} {id}={value}"));
+    }
+    fn set_azimuth(&mut self, v: u32, value: i32) {
+        self.calls.push(format!("az v{v} {value}"));
+    }
+    fn query(&mut self, v: u32) -> VoiceStatus {
+        let alive = self.alive.get(&v).copied().unwrap_or(false);
+        VoiceStatus { alive, remaining_ms: if alive { 500 } else { 0 }, elapsed_ms: 7 }
+    }
+}
+
+fn setup(modules: Vec<Spec>, exports: Vec<Ex>) -> Evaluator {
+    let mut e = Evaluator::new();
+    e.install_project(&project());
+    e.load_bank(bank(&modules, &exports, &[(48000, false), (24000, false)]));
+    e
+}
+
+fn walk(e: &mut Evaluator, log: &mut Log) {
+    for _ in 0..BLOCKS_PER_WALK {
+        e.block(log);
+    }
+}
+
+#[test]
+fn walks_every_sixth_block_starting_on_the_sixth() {
+    let mut e = setup(vec![player_module(2)], vec![Ex { module: 0, kind: 1, name_id: 1, name: "c_test", at: None }]);
+    let mut log = Log::default();
+    let walked: Vec<bool> = (0..13).map(|_| e.block(&mut log)).collect();
+    assert_eq!(walked.iter().positions(), vec![5, 11]);
+}
+
+trait Positions {
+    fn positions(self) -> Vec<usize>;
+}
+impl<'a, I: Iterator<Item = &'a bool>> Positions for I {
+    fn positions(self) -> Vec<usize> {
+        self.enumerate().filter(|e| *e.1).map(|e| e.0).collect()
+    }
+}
+
+#[test]
+fn post_opens_pushes_restarts_on_an_edge_and_release_destroys() {
+    let mut e = setup(vec![player_module(1)], vec![Ex { module: 0, kind: 1, name_id: 1, name: "c_test", at: None }]);
+    let class = e.class_id("c_test").unwrap();
+    let mut log = Log::default();
+    let node = e.post(class, &[1, 4096, 1]);
+    assert_eq!(e.instances().len(), 1);
+    // refcount: poster + destructor client + ClassData client.
+    assert_eq!(e.node_refcount(node), Some(3));
+    // Capacity 1: a second post creates nothing but still succeeds.
+    let extra = e.post(class, &[1, 4096, 0]);
+    assert_eq!(e.instances().len(), 1);
+    e.release(extra);
+    assert_eq!(e.node_refcount(extra), None);
+
+    walk(&mut e, &mut log);
+    assert_eq!(log.calls, ["open v1 slot 1", "set v1 0=4096"]);
+    // Outputs: time left / current written in the same walk.
+    let (id, ..) = e.instances()[0];
+    let mem = e.instance_memory(id).unwrap();
+    assert_eq!((i32_at(mem, 80 + 40), i32_at(mem, 80 + 44)), (500, 7));
+
+    // A payload change pushes only the changed input, and clamps (0..65535).
+    log.calls.clear();
+    e.redeliver(node, &[1, 99999, 1]);
+    walk(&mut e, &mut log);
+    assert_eq!(log.calls, ["set v1 0=65535"]);
+
+    // The voice ends: released, outputs cleared; play control is still 1 → no restart.
+    log.calls.clear();
+    log.alive.insert(1, false);
+    walk(&mut e, &mut log);
+    walk(&mut e, &mut log);
+    assert_eq!(log.calls, ["release v1"]);
+    let mem = e.instance_memory(id).unwrap();
+    assert_eq!((i32_at(mem, 80 + 40), u32_at(mem, 80 + 8)), (0, 0));
+
+    // A 0 → 1 edge restarts, and the open applies the full input set again.
+    log.calls.clear();
+    e.redeliver(node, &[0, 4096, 0]);
+    walk(&mut e, &mut log);
+    e.redeliver(node, &[1, 4096, 0]);
+    walk(&mut e, &mut log);
+    assert_eq!(log.calls, ["open v2 slot 0", "set v2 0=4096"]);
+
+    // Release: the destructor pulse reaches Destroy in the same walk; the voice is released and
+    // the node freed once every client is gone.
+    log.calls.clear();
+    e.release(node);
+    assert_eq!(e.node_refcount(node), Some(2));
+    walk(&mut e, &mut log);
+    assert_eq!(log.calls, ["release v2"]);
+    assert!(e.instances().is_empty());
+    assert_eq!(e.node_refcount(node), None);
+    // Capacity is free again.
+    e.post(class, &[0, 0, 0]);
+    assert_eq!(e.instances().len(), 1);
+}
+
+#[test]
+fn pause_and_resume_follow_the_play_control() {
+    let mut e = setup(vec![player_module(1)], vec![Ex { module: 0, kind: 1, name_id: 1, name: "c_test", at: None }]);
+    let class = e.class_id("c_test").unwrap();
+    let mut log = Log::default();
+    let node = e.post(class, &[1, 4096, 0]);
+    walk(&mut e, &mut log);
+    log.calls.clear();
+    e.redeliver(node, &[2, 4096, 0]);
+    walk(&mut e, &mut log);
+    e.redeliver(node, &[1, 4096, 0]);
+    walk(&mut e, &mut log);
+    assert_eq!(log.calls, ["pause v1", "resume v1"]);
+    // A voice that died while paused is not restarted by 2 → 1.
+    log.calls.clear();
+    e.redeliver(node, &[2, 4096, 0]);
+    walk(&mut e, &mut log);
+    log.alive.insert(1, false);
+    let (id, ..) = e.instances()[0];
+    // Simulate the device dropping the handle while paused (the program sees no voice).
+    {
+        let i = e.instance_mut(id).unwrap();
+        put_u32(&mut i.mem, 80 + 8, 0);
+    }
+    e.redeliver(node, &[1, 4096, 0]);
+    walk(&mut e, &mut log);
+    assert_eq!(log.calls, ["pause v1"]);
+}
+
+/// Requester (c_req): Create → op 5 calls f_msg with param 5; reads g_snd through a GlobalVariable
+/// state into a word we inspect. Utility (c_util): op 37 on f_msg → op 39 publishes the parameter
+/// into g_snd.
+fn round_trip_modules() -> (Vec<Spec>, Vec<Ex>) {
+    // Requester: destructor @24 (20 B), global state @44 (28 B), Create @72, op 5 @76 (handle 8 B,
+    // flag 0, n 1 → inputs {trig @88, param @92}), sink word @96, Destroy @100, size 116.
+    let mut t = words(29);
+    put_i32(&mut t, 72, 1);
+    put_u8(&mut t, 76 + 9, 1);
+    put_i32(&mut t, 92, 5);
+    let requester = Spec {
+        max: 4,
+        globals: 1,
+        functions: 0,
+        destructor: true,
+        class_data: false,
+        players: vec![],
+        template: t,
+        program: vec![
+            (0, vec![(-1, 100 + 12 - 24)], 24),
+            (2, vec![(-1, 96 - 44)], 44),
+            (3, vec![(-1, 88 - 72)], 72),
+            (5, vec![], 76),
+            (4, vec![], 100),
+        ],
+        group_ptrs: vec![],
+    };
+    // Utility: function state @24 (n 1 → (1 + 7)·4 = 32 B → @24..56), op 39 @56 (handle, min,
+    // max, prev, value → 24 B), Destroy @80, size 96.
+    let mut t = words(24);
+    put_u8(&mut t, 24 + 24, 1);
+    put_i32(&mut t, 56 + 8, 0);
+    put_i32(&mut t, 56 + 12, 1000);
+    put_i32(&mut t, 56 + 16, 0x7FFF_FFFE);
+    put_i32(&mut t, 56 + 20, 0x7FFF_FFFE);
+    let utility = Spec {
+        max: 1,
+        globals: 0,
+        functions: 1,
+        destructor: false,
+        class_data: false,
+        players: vec![],
+        template: t,
+        // op 37: on a call, copy the parameter (+28) into op 39's value (+20).
+        program: vec![(37, vec![(28, 56 + 20 - 24)], 24), (39, vec![], 56), (4, vec![], 80)],
+        group_ptrs: vec![],
+    };
+    let exports = vec![
+        Ex { module: 0, kind: 1, name_id: 3, name: "c_req", at: None },
+        Ex { module: 0, kind: 0, name_id: 1, name: "g_snd", at: Some(44) },
+        Ex { module: 0, kind: 2, name_id: 1, name: "f_msg", at: Some(76) },
+        Ex { module: 1, kind: 1, name_id: 2, name: "c_util", at: None },
+        Ex { module: 1, kind: 2, name_id: 1, name: "f_msg", at: Some(24) },
+        Ex { module: 1, kind: 0, name_id: 1, name: "g_snd", at: Some(56) },
+    ];
+    (vec![requester, utility], exports)
+}
+
+#[test]
+fn function_call_and_global_publish_follow_walk_order() {
+    let (modules, exports) = round_trip_modules();
+    let mut e = setup(modules, exports);
+    let mut log = Log::default();
+    let g = e.global_id("g_snd").unwrap();
+    assert_eq!(e.global(g), Some(77)); // csi default
+    e.post(e.class_id("c_util").unwrap(), &[]);
+    let req = e.post(e.class_id("c_req").unwrap(), &[]);
+    let (rid, ..) = e.instances()[0]; // newest first: the requester runs first
+    // A new subscriber copies the global's current value at creation.
+    assert_eq!(i32_at(e.instance_memory(rid).unwrap(), 44 + 24), 77);
+    walk(&mut e, &mut log);
+    // Walk 1: the requester read the old value (77), then called f_msg; the utility (older, later
+    // in the walk) published 5 in the same walk, delivered synchronously into the requester's state.
+    let mem = e.instance_memory(rid).unwrap();
+    assert_eq!(i32_at(mem, 96), 77);
+    assert_eq!(i32_at(mem, 44 + 24), 5);
+    assert_eq!(e.global(g), Some(5));
+    walk(&mut e, &mut log);
+    assert_eq!(i32_at(e.instance_memory(rid).unwrap(), 96), 5);
+    // Release: the requester ends; its subscription is gone.
+    e.release(req);
+    walk(&mut e, &mut log);
+    assert_eq!(e.instances().len(), 1);
+    assert!(e.registry.globals[g].subscribers.is_empty());
+    // Setting the same value notifies nobody; a different one is stored.
+    e.set_global(g, 5);
+    e.set_global(g, 9);
+    assert_eq!(e.global(g), Some(9));
+}
+
+#[test]
+fn unload_bank_destroys_its_instances_and_stops_answering_posts() {
+    let mut e = setup(vec![player_module(2)], vec![Ex { module: 0, kind: 1, name_id: 1, name: "c_test", at: None }]);
+    let class = e.class_id("c_test").unwrap();
+    let mut log = Log::default();
+    e.post(class, &[1, 4096, 0]);
+    walk(&mut e, &mut log);
+    e.unload_bank(0, &mut log);
+    assert!(e.instances().is_empty());
+    assert_eq!(log.calls.last().map(String::as_str), Some("release v1"));
+    e.post(class, &[1, 4096, 0]);
+    assert!(e.instances().is_empty());
+}
+
diff --git a/crates/skate-audio/src/formats/abk.rs b/crates/skate-audio/src/formats/abk.rs
new file mode 100644
index 00000000..42f724b0
--- /dev/null
+++ b/crates/skate-audio/src/formats/abk.rs
@@ -0,0 +1,256 @@
+//! AEMS ModuleBank (`.abk`, magic `ABKC`): modules (patch programs + instance templates), the
+//! interface (export) list that binds them to Csis symbols, and the `S10A` sample bank.
+//! Layout: `.claude/notes/aems-evaluator-spec.md` §1.1–1.5.
+//!
+//! Pointers inside the bank (TABLE, sample group, …) are kept as bank-relative offsets, which is
+//! what they hold on disc before the loader's rebase; ops resolve them through the bank bytes.
+use super::{FormatError, SampleHeader, err};
+use crate::be::{cstr, i32_at, i16_at, u8_at, u16_at, u32_at};
+
+/// Symbol table an export binds to (top byte of the export kind).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum InterfaceKind {
+    GlobalVariable,
+    Class,
+    Function,
+}
+
+impl InterfaceKind {
+    /// Csis table index (0 functions, 1 classes, 2 globals).
+    pub fn table(self) -> usize {
+        match self {
+            Self::Function => 0,
+            Self::Class => 1,
+            Self::GlobalVariable => 2,
+        }
+    }
+}
+
+/// One interface reference: "resolve this symbol and put its handle at `handle_offset`".
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Export {
+    pub handle_offset: u32,
+    pub kind: InterfaceKind,
+    pub project: u16,
+    pub name_id: u16,
+    pub name: String,
+}
+
+/// One program record: opcode, copy pairs {src, dst} (src −1 = the op's result) relative to the
+/// op's block, and the block's offset in the instance.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Op {
+    pub opcode: u8,
+    pub pairs: Vec<(i32, i32)>,
+    /// Byte offset of this op's data block from the instance start.
+    pub block: u32,
+}
+
+/// One Module (patch): program, instance template and the template's subscription layout.
+#[derive(Clone, Debug)]
+pub struct Module {
+    /// Bank offset of the module record (its class handle is at +4).
+    pub offset: u32,
+    pub max_instances: i16,
+    pub num_globals: u16,
+    pub num_functions: u16,
+    pub num_players: u8,
+    pub has_destructor: bool,
+    pub has_class_data: bool,
+    pub num_controllers: u8,
+    pub program_offset: u32,
+    pub template_offset: u32,
+    pub data_size: u32,
+    pub destroy_offset: u32,
+    /// Instance offsets of each Player state, then each ControlClass state.
+    pub objects: Vec<u32>,
+    pub program: Vec<Op>,
+    /// Instance offsets of the subscription states (§1.4).
+    pub destructor_state: Option<u32>,
+    pub global_states: Vec<u32>,
+    pub class_data_state: Option<u32>,
+    pub function_states: Vec<u32>,
+}
+
+impl Module {
+    /// The template bytes inside `bank`.
+    pub fn template<'a>(&self, bank: &'a [u8]) -> &'a [u8] {
+        let start = self.template_offset as usize;
+        &bank[start..start + self.data_size as usize]
+    }
+
+    /// Instance offsets of the Player (op 27) states.
+    pub fn players(&self) -> &[u32] {
+        &self.objects[..self.num_players as usize]
+    }
+
+    /// Instance offsets of the ControlClass (op 38) states.
+    pub fn controllers(&self) -> &[u32] {
+        &self.objects[self.num_players as usize..]
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Bank {
+    pub name: String,
+    pub data: Vec<u8>,
+    pub modules: Vec<Module>,
+    pub exports: Vec<Export>,
+    /// Bank offset of the `S10A` tag.
+    pub sample_bank: u32,
+    /// Per used S10A slot: the bank offset of its sample and the parsed header (None if the slot
+    /// does not hold a recognisable RAM sample).
+    pub samples: Vec<(u32, Option<SampleHeader>)>,
+}
+
+/// Highest opcode in the TU3 opcode table.
+pub const OPCODES: u8 = 40;
+
+impl Bank {
+    pub fn parse(name: &str, data: Vec<u8>) -> Result<Self, FormatError> {
+        let d = &data[..];
+        if d.len() < 0x5C || &d[..4] != b"ABKC" {
+            return err(format!("{name}: not an ABKC bank"));
+        }
+        let count = u16_at(d, 0x0A) as usize;
+        let module_at = u32_at(d, 0x1C) as usize;
+        let sample_bank = u32_at(d, 0x20);
+        let interface = u32_at(d, 0x38) as usize;
+
+        // Interface references.
+        let n = u32_at(d, interface) as usize;
+        if interface + 4 + 12 * n > d.len() {
+            return err(format!("{name}: interface list runs past the file"));
+        }
+        let mut exports = Vec::with_capacity(n);
+        for i in 0..n {
+            let r = interface + 4 + 12 * i;
+            let (handle_offset, id_at, kind) = (u32_at(d, r), u32_at(d, r + 4) as usize, u32_at(d, r + 8));
+            let kind = match kind >> 24 {
+                0 => InterfaceKind::GlobalVariable,
+                1 => InterfaceKind::Class,
+                2 => InterfaceKind::Function,
+                k => return err(format!("{name}: export {i} has interface type {k}")),
+            };
+            exports.push(Export {
+                handle_offset,
+                kind,
+                project: u16_at(d, id_at),
+                name_id: u16_at(d, id_at + 2),
+                name: cstr(d, id_at + 4),
+            });
+        }
+
+        // Modules.
+        let mut modules = Vec::with_capacity(count);
+        let mut at = module_at;
+        for m in 0..count {
+            if at + 0x3C > d.len() {
+                return err(format!("{name}: module {m} runs past the file"));
+            }
+            let num_players = u8_at(d, at + 0x24);
+            let num_controllers = u8_at(d, at + 0x27);
+            let objects: Vec<u32> =
+                (0..(num_players as usize + num_controllers as usize)).map(|i| u32_at(d, at + 0x3C + 4 * i)).collect();
+            let mut module = Module {
+                offset: at as u32,
+                max_instances: i16_at(d, at + 0x1E),
+                num_globals: u16_at(d, at + 0x20),
+                num_functions: u16_at(d, at + 0x22),
+                num_players,
+                has_destructor: u8_at(d, at + 0x25) != 0,
+                has_class_data: u8_at(d, at + 0x26) != 0,
+                num_controllers,
+                program_offset: u32_at(d, at + 0x28),
+                template_offset: u32_at(d, at + 0x2C),
+                data_size: u32_at(d, at + 0x30),
+                destroy_offset: u32_at(d, at + 0x34),
+                objects,
+                program: Vec::new(),
+                destructor_state: None,
+                global_states: Vec::new(),
+                class_data_state: None,
+                function_states: Vec::new(),
+            };
+            if (module.template_offset + module.data_size) as usize > d.len() || module.data_size < 24 {
+                return err(format!("{name}: module {m} template runs past the file"));
+            }
+            module.program = decode_program(name, d, module.program_offset as usize, module.data_size)?;
+            layout_states(&mut module, d);
+            at += 0x3C + 4 * module.objects.len();
+            modules.push(module);
+        }
+
+        // Sample bank.
+        let mut samples = Vec::new();
+        let s = sample_bank as usize;
+        if d.get(s..s + 4) == Some(b"S10A") {
+            let capacity = u32_at(d, s + 8) as usize;
+            for i in 0..capacity {
+                let off = u32_at(d, s + 12 + 4 * i);
+                if off == 0xFFFF_FFFF {
+                    break;
+                }
+                let at = s as u32 + off;
+                samples.push((at, SampleHeader::parse(d, at as usize)));
+            }
+        }
+        Ok(Self { name: name.to_string(), data, modules, exports, sample_bank, samples })
+    }
+}
+
+/// Decode a program and check the block walk: every opcode < 40 and the data pointer, starting at
+/// instance +24, ends exactly at the template size.
+fn decode_program(name: &str, d: &[u8], start: usize, data_size: u32) -> Result<Vec<Op>, FormatError> {
+    let mut ops = Vec::new();
+    let mut pc = start;
+    let mut block: i64 = 24;
+    loop {
+        if pc + 4 > d.len() {
+            return err(format!("{name}: program runs past the file"));
+        }
+        let opcode = u8_at(d, pc);
+        if opcode == 255 {
+            break;
+        }
+        if opcode >= OPCODES {
+            return err(format!("{name}: opcode {opcode} at {pc:#x} (only 0..39 exist)"));
+        }
+        let npairs = u8_at(d, pc + 1) as usize;
+        let pairs = (0..npairs).map(|p| (i32_at(d, pc + 4 + 8 * p), i32_at(d, pc + 8 + 8 * p))).collect();
+        let advance = i32_at(d, pc + 4 + 8 * npairs);
+        ops.push(Op { opcode, pairs, block: block as u32 });
+        block += i64::from(advance);
+        pc += 8 + 8 * npairs;
+        if block < 0 || block > i64::from(data_size) {
+            return err(format!("{name}: program data pointer leaves the template"));
+        }
+    }
+    if block != i64::from(data_size) {
+        return err(format!("{name}: program walk ends at {block}, template size {data_size}"));
+    }
+    Ok(ops)
+}
+
+/// Instance offsets of the subscription states (§1.4): ClassDestructor (20 B), GlobalVariables
+/// (28 B each), ClassData ((n + 5)·4 B), Functions ((n + 7)·4 B each), from instance +24.
+fn layout_states(m: &mut Module, d: &[u8]) {
+    let t = m.template_offset as usize;
+    let mut at = 24u32;
+    if m.has_destructor {
+        m.destructor_state = Some(at);
+        at += 20;
+    }
+    for _ in 0..m.num_globals {
+        m.global_states.push(at);
+        at += 28;
+    }
+    if m.has_class_data {
+        m.class_data_state = Some(at);
+        at += (u32::from(u8_at(d, t + at as usize + 16)) + 5) * 4;
+    }
+    for _ in 0..m.num_functions {
+        m.function_states.push(at);
+        at += (u32::from(u8_at(d, t + at as usize + 24)) + 7) * 4;
+    }
+}
diff --git a/crates/skate-audio/src/formats/csi.rs b/crates/skate-audio/src/formats/csi.rs
new file mode 100644
index 00000000..7b2cfaa4
--- /dev/null
+++ b/crates/skate-audio/src/formats/csi.rs
@@ -0,0 +1,52 @@
+//! Csis project (`.csi`, magic `MOIR`): the symbol tables game code and banks bind to.
+//! Table 0 = Functions (`*_msg`), 1 = Classes (`c_*`), 2 = GlobalVariables (with a default value).
+use super::{FormatError, err};
+use crate::be::{cstr, i32_at, u16_at, u32_at};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Symbol {
+    pub name: String,
+    pub name_id: u16,
+    /// GlobalVariables only: the default value.
+    pub default: i32,
+}
+
+#[derive(Clone, Debug)]
+pub struct Project {
+    pub name: String,
+    pub id: u16,
+    /// [functions, classes, globals]
+    pub tables: [Vec<Symbol>; 3],
+}
+
+impl Project {
+    pub fn parse(name: &str, d: &[u8]) -> Result<Self, FormatError> {
+        if d.len() < 0x28 || &d[..4] != b"MOIR" {
+            return err(format!("{name}: not a MOIR project"));
+        }
+        let counts = [u16_at(d, 0x0A), u16_at(d, 0x0C), u16_at(d, 0x0E)];
+        let id = u16_at(d, 0x10);
+        let mut at = 0x28usize;
+        let mut tables: [Vec<Symbol>; 3] = Default::default();
+        for (t, &count) in counts.iter().enumerate() {
+            let stride = if t == 2 { 16 } else { 12 };
+            for i in 0..count as usize {
+                let r = at + stride * i;
+                if r + stride > d.len() {
+                    return err(format!("{name}: table {t} runs past the file"));
+                }
+                let (name_off, name_id, default) = if t == 2 {
+                    (u32_at(d, r + 8), u16_at(d, r + 12), i32_at(d, r + 4))
+                } else {
+                    (u32_at(d, r + 4), u16_at(d, r + 8), 0)
+                };
+                if name_off as usize >= d.len() {
+                    return err(format!("{name}: symbol name outside the file"));
+                }
+                tables[t].push(Symbol { name: cstr(d, name_off as usize), name_id, default });
+            }
+            at += stride * count as usize;
+        }
+        Ok(Self { name: name.to_string(), id, tables })
+    }
+}
diff --git a/crates/skate-audio/src/formats/mod.rs b/crates/skate-audio/src/formats/mod.rs
new file mode 100644
index 00000000..c84699dd
--- /dev/null
+++ b/crates/skate-audio/src/formats/mod.rs
@@ -0,0 +1,24 @@
+//! Disc containers used by the AEMS runtime. Layouts: `.claude/notes/aems-evaluator-spec.md` §1.
+pub mod abk;
+pub mod csi;
+pub mod snr;
+
+pub use abk::{Bank, Export, InterfaceKind, Module, Op};
+pub use csi::Project;
+pub use snr::SampleHeader;
+
+/// A container that failed validation.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FormatError(pub String);
+
+impl std::fmt::Display for FormatError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+impl std::error::Error for FormatError {}
+
+pub(crate) fn err<T>(msg: impl Into<String>) -> Result<T, FormatError> {
+    Err(FormatError(msg.into()))
+}
diff --git a/crates/skate-audio/src/formats/snr.rs b/crates/skate-audio/src/formats/snr.rs
new file mode 100644
index 00000000..c6112dd2
--- /dev/null
+++ b/crates/skate-audio/src/formats/snr.rs
@@ -0,0 +1,63 @@
+//! EA Audio Core "SNR" sample header, as it starts every slot of an `S10A` sample bank: two
+//! big-endian words (plus a loop-start word when looped).
+//! - word 0: version (bits 28..31), codec (24..27), channels − 1 (18..23), sample rate (0..17);
+//! - word 1: type (30..31; 0 = RAM), loop flag (29), sample frames (0..28);
+//! - word 2 (looped only): loop start frame.
+use crate::be::u32_at;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SampleHeader {
+    pub codec: u8,
+    pub channels: u8,
+    pub rate: u32,
+    pub frames: u32,
+    pub loop_start: Option<u32>,
+}
+
+impl SampleHeader {
+    /// Parse the header at `at`, or None when it is not a plausible RAM sample.
+    pub fn parse(d: &[u8], at: usize) -> Option<Self> {
+        if at + 8 > d.len() {
+            return None;
+        }
+        let w0 = u32_at(d, at);
+        let w1 = u32_at(d, at + 4);
+        let (version, codec) = (w0 >> 28, ((w0 >> 24) & 0xF) as u8);
+        let channels = (((w0 >> 18) & 0x3F) + 1) as u8;
+        let rate = w0 & 0x3FFFF;
+        let (kind, looped, frames) = (w1 >> 30, (w1 >> 29) & 1 == 1, w1 & 0x1FFF_FFFF);
+        if version > 1 || kind != 0 || rate == 0 || frames == 0 || channels > 8 {
+            return None;
+        }
+        let loop_start = if looped { Some(u32_at(d, at + 8)) } else { None };
+        Some(Self { codec, channels, rate, frames, loop_start })
+    }
+
+    /// Duration in seconds (source time: frames / rate).
+    pub fn seconds(&self) -> f64 {
+        f64::from(self.frames) / f64::from(self.rate)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_mono_xma_with_and_without_loop() {
+        // version 0, codec 3 (EA-XMA), 1 channel, 48000 Hz; 96000 frames.
+        let mut d = Vec::new();
+        d.extend_from_slice(&((3u32 << 24) | 48000).to_be_bytes());
+        d.extend_from_slice(&96000u32.to_be_bytes());
+        let h = SampleHeader::parse(&d, 0).unwrap();
+        assert_eq!((h.codec, h.channels, h.rate, h.frames, h.loop_start), (3, 1, 48000, 96000, None));
+        assert_eq!(h.seconds(), 2.0);
+        // Stereo, looped from frame 100.
+        let mut d = Vec::new();
+        d.extend_from_slice(&((3u32 << 24) | (1 << 18) | 44100).to_be_bytes());
+        d.extend_from_slice(&((1u32 << 29) | 44100).to_be_bytes());
+        d.extend_from_slice(&100u32.to_be_bytes());
+        let h = SampleHeader::parse(&d, 0).unwrap();
+        assert_eq!((h.channels, h.loop_start), (2, Some(100)));
+    }
+}
diff --git a/crates/skate-audio/src/grain/bed.rs b/crates/skate-audio/src/grain/bed.rs
new file mode 100644
index 00000000..6e586832
--- /dev/null
+++ b/crates/skate-audio/src/grain/bed.rs
@@ -0,0 +1,491 @@
+//! One board's rolling bed on the block clock (spec §2.1, §3.1): two trucks, each with players A
+//! and B bound to the same recording, each player feeding its own bus chain into the default
+//! bus; plus the rocket layer straight into the default bus. One title-wide generator feeds every
+//! pick (retail's `0x82FD7D74` generator, distinct from the AEMS one).
+//!
+//! Chain per player (`sub_824C8878`; `.claude/notes/aems-grain-chain-spec.md`), all three graphs
+//! inside one block (pass order 2 < 3 < 5):
+//! - graph 1: SubMix (the player's mono bus) → HighPass → LowPass → FrequencyShiftSsb → Send (→
+//!   graph 3) → Gain (level ramp × wobble) → Send (→ graph 2, level 1);
+//! - graph 3: SubMix → Clip ±0.09 → Gain (wobble) → HighShelf 5 kHz × 0.65 → Send (→ graph 2,
+//!   level 1);
+//! - graph 2: SubMix → Send (→ FlangeSub return A `[[manager+116]]`: not rendered, there is no
+//!   such bus here; its level is kept) → Send (→ the environment bus, mono, pre-pan) → Pan2D1
+//!   (1 → 6 channels) → Send into the default bus.
+//!
+//! [`GrainBed::chain_extras`] = false keeps the older chain (HighPass → LowPass → Gain → Pan2D1 →
+//! Send: no FSS, graph 3 or env send), bit-identical to the renders before the full chain.
+use std::sync::Arc;
+
+use crate::BLOCK;
+use crate::bus::env::Level;
+use crate::dsp::biquad::{Iir2, Kind};
+use crate::dsp::fss::FrequencyShift;
+use crate::dsp::gain::Gain;
+use crate::dsp::pan::{self, Pan2D};
+use crate::dsp::peaking::clip;
+use crate::dsp::routes::to_six;
+use crate::dsp::send::{Mode, Send, fold_release};
+use crate::dsp::shelf::HighShelfIir2;
+use crate::eval::rng::Rng;
+
+use super::chain::ChainTuning;
+use super::player::{BLOCK_DELTA, GrainParams, GrainPlayer, GrainSource, Record};
+
+/// Values the board owner posts to a player's chain each frame (§3.2; computed by
+/// [`super::chain::ChainState::values`]).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ChainValues {
+    /// HighPass / LowPass cutoffs (Hz): MixMap SkateBoard level(12) / level(11).
+    pub highpass_hz: f32,
+    pub lowpass_hz: f32,
+    /// Pan2D1 angle (degrees): raw(0) × 360/65535.
+    pub pan_degrees: f32,
+    /// The graph-1 Gain (level ramp × wobble, as last posted).
+    pub level: f32,
+    /// FrequencyShiftSsb shift (Hz; 0 is an allpass, not a bypass).
+    pub fss_hz: f32,
+    /// Graph-1 → graph-3 send level (0 below 46 km/h … 3.0 at 70 km/h).
+    pub graph3_send: f32,
+    /// The graph-3 Gain (wobble, as last posted).
+    pub graph3_gain: f32,
+    /// Graph-2 environment send: level(13)/32767.
+    pub env_send: f32,
+    /// Graph-2 first send (→ FlangeSub return A): level(21)/32767 (A) or level(22)/32767 (B).
+    /// Kept, not rendered.
+    pub flange_send: f32,
+}
+
+impl Default for ChainValues {
+    fn default() -> Self {
+        Self {
+            highpass_hz: 77.0,
+            lowpass_hz: 24971.0,
+            pan_degrees: 0.0,
+            level: 1.0,
+            fss_hz: 0.0,
+            graph3_send: 0.0,
+            graph3_gain: 1.0,
+            env_send: 0.0,
+            flange_send: 0.0,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct Chain {
+    bus: [[f32; BLOCK]; 6],
+    hpf: Iir2,
+    lpf: Iir2,
+    gain: Gain,
+    pan: Pan2D,
+    send: Send,
+    values: ChainValues,
+    fss: FrequencyShift,
+    /// Graph 1's Send → graph 3, graph 3's Gain and HighShelf, the two level-1 Sends into graph 2.
+    to_graph3: Level,
+    gain3: Gain,
+    shelf: HighShelfIir2,
+    from_graph1: Level,
+    from_graph3: Level,
+    /// Graph 2's env Send.
+    env: Level,
+}
+
+impl Chain {
+    fn new() -> Self {
+        Self {
+            bus: [[0.0; BLOCK]; 6],
+            hpf: Iir2::new(Kind::HighPass),
+            lpf: Iir2::new(Kind::LowPass),
+            gain: Gain::default(),
+            pan: Pan2D::new(1),
+            send: Send::default(),
+            values: ChainValues::default(),
+            fss: FrequencyShift::default(),
+            to_graph3: Level::new(0.0),
+            gain3: Gain::default(),
+            shelf: HighShelfIir2::new(96_000.0, 1.0),
+            from_graph1: Level::new(1.0),
+            from_graph3: Level::new(1.0),
+            env: Level::new(0.0),
+        }
+    }
+
+    /// The older chain: HighPass → LowPass → Gain → Pan2D1 → Send.
+    fn process(&mut self, out: &mut [[f32; BLOCK]; 6]) {
+        let v = self.values;
+        let mut mono = self.bus[0];
+        self.hpf.cutoff = v.highpass_hz;
+        self.lpf.cutoff = v.lowpass_hz;
+        self.hpf.process(&mut [&mut mono[..]], crate::MIX_RATE as f32);
+        self.lpf.process(&mut [&mut mono[..]], crate::MIX_RATE as f32);
+        self.gain.target = v.level;
+        self.gain.process(&mut [&mut mono[..]]);
+        self.pan_and_send(&mono, out);
+        for ch in &mut self.bus {
+            *ch = [0.0; BLOCK];
+        }
+    }
+
+    /// The full chain (graphs 1, 3, 2); the env send adds into `env` (mono, × `user`). Returns
+    /// whether the env send contributed.
+    fn process_full(&mut self, out: &mut [[f32; BLOCK]; 6], env: &mut [f32; BLOCK], tuning: &ChainTuning, user: f32) -> bool {
+        let rate = crate::MIX_RATE as f32;
+        let v = self.values;
+        let mut mono = self.bus[0];
+        // Graph 1.
+        self.hpf.cutoff = v.highpass_hz;
+        self.lpf.cutoff = v.lowpass_hz;
+        self.hpf.process(&mut [&mut mono[..]], rate);
+        self.lpf.process(&mut [&mut mono[..]], rate);
+        self.fss.shift_hz = v.fss_hz;
+        self.fss.process(&mut mono, rate);
+        let mut g3 = [0.0f32; BLOCK];
+        self.to_graph3.target = v.graph3_send;
+        self.to_graph3.add(&mono, &mut g3);
+        self.gain.target = v.level;
+        self.gain.process(&mut [&mut mono[..]]);
+        let mut g2 = [0.0f32; BLOCK];
+        self.from_graph1.add(&mono, &mut g2);
+        // Graph 3.
+        clip(&mut [&mut g3[..]], tuning.clip);
+        self.gain3.target = v.graph3_gain;
+        self.gain3.process(&mut [&mut g3[..]]);
+        self.shelf.freq = tuning.shelf_hz;
+        self.shelf.gain = tuning.shelf_gain;
+        self.shelf.process(&mut [&mut g3[..]], rate);
+        self.from_graph3.add(&g3, &mut g2);
+        // Graph 2: the FlangeSub send has no bus here; the env send is mono, before the panner.
+        self.env.target = v.env_send * user;
+        let sends = !self.env.silent();
+        if sends {
+            self.env.add(&g2, env);
+        }
+        self.pan_and_send(&g2, out);
+        for ch in &mut self.bus {
+            *ch = [0.0; BLOCK];
+        }
+        sends
+    }
+
+    fn pan_and_send(&mut self, mono: &[f32; BLOCK], out: &mut [[f32; BLOCK]; 6]) {
+        self.pan.params[pan::ANGLE] = self.values.pan_degrees;
+        let mut six = [[0.0f32; BLOCK]; 6];
+        self.pan.process(&[&mono[..]], &mut six);
+        let outs: [&[f32]; 6] = std::array::from_fn(|c| &six[c][..]);
+        self.send.process(&outs, to_six(6), out, Mode::Normal);
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Truck {
+    pub players: [GrainPlayer; 2],
+    chains: [Chain; 2],
+    /// Retail builds a truck's chains at its first bind (`sub_824C8878`); the full chain is only
+    /// processed from then on (the older chain always runs, as before).
+    built: bool,
+}
+
+impl Truck {
+    fn new() -> Self {
+        Self { players: [GrainPlayer::new(), GrainPlayer::new()], chains: [Chain::new(), Chain::new()], built: false }
+    }
+
+    pub fn bound(&self) -> Option<&str> {
+        self.players[0].bound().map(|s| s.name.as_str())
+    }
+}
+
+pub struct GrainBed {
+    pub trucks: [Truck; 2],
+    pub rocket: GrainPlayer,
+    rocket_send: Send,
+    rocket_bus: [[f32; BLOCK]; 6],
+    pub rng: Rng,
+    /// Our own user-volume scale on the bed's output (1 = retail level).
+    pub gain: f32,
+    /// Release de-click of chains torn down by a bind.
+    fold: [f32; 6],
+    /// The full retail chain (FSS, graph 3, env send); false = the older chain, bit-identical to
+    /// the renders before it.
+    pub chain_extras: bool,
+    /// Graph 3's clip and shelf (the owner vault; the speed-driven values come from the host).
+    pub chain_tuning: ChainTuning,
+    /// This block's dry 6-channel mix (before [`GrainBed::gain`]) and the chains' env sends.
+    mix: Box<[[f32; BLOCK]; 6]>,
+    env: Box<[f32; BLOCK]>,
+    env_active: bool,
+}
+
+impl Default for GrainBed {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GrainBed {
+    /// The title generator's fixed constants (`0x82FD36A0`); retail adds the time base at boot.
+    pub const SEED: [u32; 6] = [0xF22D_0E56, 0x8831_26E9, 0xC624_DD2F, 0x0702_C49C, 0x9E35_3F7D, 0x6FDF_3B64];
+
+    pub fn new() -> Self {
+        Self {
+            trucks: [Truck::new(), Truck::new()],
+            rocket: GrainPlayer::new(),
+            rocket_send: Send::default(),
+            rocket_bus: [[0.0; BLOCK]; 6],
+            rng: Rng::new(Self::SEED),
+            gain: 1.0,
+            fold: [0.0; 6],
+            chain_extras: true,
+            chain_tuning: ChainTuning::default(),
+            mix: Box::new([[0.0; BLOCK]; 6]),
+            env: Box::new([0.0; BLOCK]),
+            env_active: false,
+        }
+    }
+
+    /// Bind both players of a truck to a recording (A with params[0], B with params[1]). Retail
+    /// tears the truck's chains down and rebuilds them on every bind, so their histories restart.
+    pub fn bind_truck(&mut self, truck: usize, source: Arc<GrainSource>, params: [GrainParams; 2], records: [Record; 2]) {
+        let t = &mut self.trucks[truck];
+        t.built = true;
+        for c in &mut t.chains {
+            for (f, l) in self.fold.iter_mut().zip(c.send.last) {
+                *f += l;
+            }
+            let values = c.values;
+            *c = Chain::new();
+            c.values = values;
+        }
+        for (p, (params, record)) in t.players.iter_mut().zip(params.into_iter().zip(records)) {
+            p.record = record;
+            p.bind(source.clone(), params, &mut self.rng);
+        }
+    }
+
+    /// Stop both players of a truck at once (surface change, no contact).
+    pub fn stop_truck(&mut self, truck: usize) {
+        for p in &mut self.trucks[truck].players {
+            p.stop();
+        }
+    }
+
+    pub fn set_records(&mut self, truck: usize, records: [Record; 2]) {
+        for (p, r) in self.trucks[truck].players.iter_mut().zip(records) {
+            p.record = r;
+        }
+    }
+
+    pub fn set_chains(&mut self, truck: usize, values: [ChainValues; 2]) {
+        for (c, v) in self.trucks[truck].chains.iter_mut().zip(values) {
+            c.values = v;
+        }
+    }
+
+    pub fn start_rocket(&mut self, source: Arc<GrainSource>, params: GrainParams, record: Record) {
+        self.rocket.record = record;
+        self.rocket.bind(source, params, &mut self.rng);
+    }
+
+    pub fn stop_rocket(&mut self) {
+        self.rocket.stop();
+    }
+
+    /// Grain voices sounding.
+    pub fn voices(&self) -> usize {
+        self.trucks.iter().flat_map(|t| &t.players).map(GrainPlayer::voices).sum::<usize>() + self.rocket.voices()
+    }
+
+    /// One 256-frame block: the scheduler (phase 1), then the voices and chains, added into `out`.
+    pub fn render(&mut self, out: &mut [[f32; BLOCK]; 6]) {
+        if self.render_block() {
+            self.add_to(out);
+        }
+    }
+
+    /// Render one block into the bed's own buffers ([`GrainBed::add_to`], [`GrainBed::env_send`]);
+    /// false = idle (nothing to add). The runtime renders the bed before the mixer so that its env
+    /// sends reach this block's environment network.
+    pub fn render_block(&mut self) -> bool {
+        self.env_active = false;
+        let pending = self.trucks.iter().flat_map(|t| &t.players).chain([&self.rocket]).any(GrainPlayer::pending);
+        let idle = self.voices() == 0 && !pending && self.fold.iter().all(|&f| f == 0.0);
+        if idle {
+            return false;
+        }
+        let mix = &mut *self.mix;
+        *mix = [[0.0f32; BLOCK]; 6];
+        fold_release(mix, &self.fold);
+        self.fold = [0.0; 6];
+        if self.chain_extras {
+            self.env.fill(0.0);
+        }
+        for t in &mut self.trucks {
+            for (p, c) in t.players.iter_mut().zip(t.chains.iter_mut()) {
+                p.tick(BLOCK_DELTA, &mut self.rng);
+                p.render(&mut c.bus);
+                if self.chain_extras && !t.built {
+                    c.bus = [[0.0; BLOCK]; 6];
+                } else if self.chain_extras {
+                    self.env_active |= c.process_full(mix, &mut self.env, &self.chain_tuning, self.gain);
+                } else {
+                    c.process(mix);
+                }
+            }
+        }
+        self.rocket.tick(BLOCK_DELTA, &mut self.rng);
+        self.rocket.render(&mut self.rocket_bus);
+        // The rocket binds to the default bus directly: mono → the centre channel.
+        let mono = self.rocket_bus[0];
+        self.rocket_send.process(&[&mono[..]], to_six(1), mix, Mode::Normal);
+        self.rocket_bus = [[0.0; BLOCK]; 6];
+        true
+    }
+
+    /// Add the last rendered block × [`GrainBed::gain`] into `out`.
+    pub fn add_to(&self, out: &mut [[f32; BLOCK]; 6]) {
+        for (o, m) in out.iter_mut().zip(self.mix.iter()) {
+            for (a, b) in o.iter_mut().zip(m.iter()) {
+                *a += self.gain * b;
+            }
+        }
+    }
+
+    /// The last block's mono input to the environment bus (graph 2's env sends, already × the
+    /// user gain), or None when no chain sends.
+    pub fn env_send(&self) -> Option<&[f32; BLOCK]> {
+        self.env_active.then_some(&*self.env)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mixer::Pcm;
+
+    fn source() -> Arc<GrainSource> {
+        let data: Vec<f32> = (0..48000 * 20).map(|i| ((i as f32) * 0.05).sin() * 0.5).collect();
+        Arc::new(GrainSource { name: "t".into(), duration: 20.0, pcm: Arc::new(Pcm { rate: 48000, channels: vec![data] }) })
+    }
+
+    #[test]
+    fn a_bound_truck_sounds_and_stops() {
+        let mut bed = GrainBed::new();
+        let a = GrainParams { attack: 0.1, sustain: 0.2, release: 0.1, window: 1.6, drift: 0.05 };
+        let b = GrainParams { attack: 0.2, sustain: 0.1, release: 0.2, window: 1.5, drift: 0.05 };
+        let rec = [Record { gain: 0.5, pitch: 1.0, position: 0.3 }, Record { gain: 0.25, pitch: 1.0, position: 0.2 }];
+        bed.bind_truck(0, source(), [a, b], rec);
+        let mut energy = 0.0f32;
+        for _ in 0..200 {
+            let mut out = [[0.0f32; BLOCK]; 6];
+            bed.render(&mut out);
+            energy += out.iter().flat_map(|c| c.iter()).map(|s| s * s).sum::<f32>();
+            assert!(bed.voices() <= 4);
+        }
+        assert!(energy > 1.0, "the bed sounds ({energy})");
+        bed.stop_truck(0);
+        assert_eq!(bed.voices(), 0);
+        let mut out = [[0.0f32; BLOCK]; 6];
+        bed.render(&mut out); // release de-click only
+        bed.render(&mut out);
+        let mut out = [[0.0f32; BLOCK]; 6];
+        bed.render(&mut out);
+        assert!(out.iter().all(|c| c.iter().all(|&s| s == 0.0)));
+    }
+
+    /// 382 Hz tone bed (A only), `blocks` blocks with the chain values, the centre channel.
+    fn render_a(values: ChainValues, tuning: ChainTuning, blocks: usize) -> (Vec<f32>, Vec<f32>) {
+        let mut bed = GrainBed::new();
+        bed.chain_tuning = tuning;
+        let a = GrainParams { attack: 0.1, sustain: 0.2, release: 0.1, window: 1.6, drift: 0.05 };
+        let rec = [Record { gain: 0.5, pitch: 1.0, position: 0.3 }, Record { gain: 0.0, pitch: 1.0, position: 0.2 }];
+        bed.bind_truck(0, source(), [a, a], rec);
+        bed.set_chains(0, [values, ChainValues { graph3_send: values.graph3_send, ..ChainValues::default() }]);
+        let (mut centre, mut env) = (Vec::new(), Vec::new());
+        for _ in 0..blocks {
+            let mut out = [[0.0f32; BLOCK]; 6];
+            bed.render(&mut out);
+            centre.extend_from_slice(&out[1]);
+            env.extend_from_slice(bed.env_send().map_or(&[0.0; BLOCK], |e| e));
+        }
+        (centre, env)
+    }
+
+    fn amplitude(x: &[f32], f: f64) -> f64 {
+        let w = std::f64::consts::TAU * f / 48000.0;
+        let (mut re, mut im) = (0.0f64, 0.0f64);
+        for (k, &s) in x.iter().enumerate() {
+            re += s as f64 * (w * k as f64).cos();
+            im -= s as f64 * (w * k as f64).sin();
+        }
+        2.0 * (re * re + im * im).sqrt() / x.len() as f64
+    }
+
+    #[test]
+    fn the_special_shift_moves_the_bed_up_150_hz() {
+        let f0 = 0.05 * 48000.0 / std::f64::consts::TAU;
+        let (plain, _) = render_a(ChainValues::default(), ChainTuning::default(), 400);
+        let (shifted, _) = render_a(ChainValues { fss_hz: 150.0, ..ChainValues::default() }, ChainTuning::default(), 400);
+        let tail = |x: &[f32]| x[x.len() / 2..].to_vec();
+        let (plain, shifted) = (tail(&plain), tail(&shifted));
+        let (p0, p1) = (amplitude(&plain, f0), amplitude(&plain, f0 + 150.0));
+        let (s0, s1) = (amplitude(&shifted, f0), amplitude(&shifted, f0 + 150.0));
+        assert!(p0 > 20.0 * p1, "unshifted: {p0} at f0, {p1} at f0 + 150");
+        assert!(s1 > 20.0 * s0, "shifted: {s0} at f0, {s1} at f0 + 150");
+        assert!((s1 / p0 - 1.0).abs() < 0.1, "same level ({s1} vs {p0})");
+    }
+
+    #[test]
+    fn graph3_adds_a_clipped_copy_only_with_its_send() {
+        let loose = ChainTuning { clip: 0.5, ..ChainTuning::default() };
+        let (a, _) = render_a(ChainValues::default(), ChainTuning::default(), 200);
+        let (b, _) = render_a(ChainValues::default(), loose, 200);
+        assert_eq!(a, b, "send 0: graph 3 contributes nothing");
+        let rms = |x: &[f32]| (x.iter().map(|v| v * v).sum::<f32>() / x.len() as f32).sqrt();
+        let (c, _) = render_a(ChainValues { graph3_send: 3.0, ..ChainValues::default() }, ChainTuning::default(), 200);
+        assert!(rms(&c) > 1.2 * rms(&a), "send 3 adds the copy ({} vs {})", rms(&c), rms(&a));
+        // Clipped at ±0.09 before the shelf: the copy's peak stays near 0.09 + the dry peak.
+        let peak = |x: &[f32]| x.iter().fold(0.0f32, |m, v| m.max(v.abs()));
+        assert!(peak(&c) < peak(&a) + 0.09 * 1.2, "{} vs {}", peak(&c), peak(&a));
+    }
+
+    #[test]
+    fn the_env_send_is_mono_before_the_pan() {
+        let (_, none) = render_a(ChainValues::default(), ChainTuning::default(), 100);
+        assert!(none.iter().all(|&v| v == 0.0), "level 0: no env input");
+        let half = ChainValues { env_send: 0.5, pan_degrees: -90.0, ..ChainValues::default() };
+        let (centre, env) = render_a(half, ChainTuning::default(), 200);
+        let (dry, _) = render_a(ChainValues { pan_degrees: 0.0, ..ChainValues::default() }, ChainTuning::default(), 200);
+        let leak = centre[BLOCK..].iter().fold(0.0f32, |m, v| m.max(v.abs()));
+        assert!(leak < 1e-6, "panned hard left: nothing in the centre ({leak})");
+        // The env tap is the pre-pan mono × 0.5: half the centre-panned dry signal, sample for sample.
+        for (k, (&e, &d)) in env.iter().zip(&dry).enumerate().skip(BLOCK) {
+            assert!((e - 0.5 * d).abs() <= 1e-6 * d.abs().max(1e-3), "{k}: {e} vs {d}");
+        }
+    }
+
+    #[test]
+    fn extras_off_is_the_older_chain() {
+        // The older chain ignores the new values (no FSS, graph 3 or env send).
+        let run = |extras: bool, v: ChainValues| {
+            let mut bed = GrainBed::new();
+            bed.chain_extras = extras;
+            let a = GrainParams { attack: 0.1, sustain: 0.2, release: 0.1, window: 1.6, drift: 0.05 };
+            let rec = [Record { gain: 0.5, pitch: 1.0, position: 0.3 }, Record { gain: 0.25, pitch: 1.0, position: 0.2 }];
+            bed.bind_truck(0, source(), [a, a], rec);
+            bed.set_chains(0, [v; 2]);
+            let mut all = Vec::new();
+            for _ in 0..100 {
+                let mut out = [[0.0f32; BLOCK]; 6];
+                bed.render(&mut out);
+                all.extend(out.iter().flatten().copied());
+                assert!(bed.env_send().is_none());
+            }
+            all
+        };
+        let busy = ChainValues { fss_hz: 150.0, graph3_send: 3.0, graph3_gain: 1.2, env_send: 1.0, ..ChainValues::default() };
+        assert_eq!(run(false, ChainValues::default()), run(false, busy));
+        assert_ne!(run(true, ChainValues::default()), run(false, ChainValues::default()), "FSS at 0 Hz is an allpass");
+    }
+}
diff --git a/crates/skate-audio/src/grain/board.rs b/crates/skate-audio/src/grain/board.rs
new file mode 100644
index 00000000..5ebbe0e5
--- /dev/null
+++ b/crates/skate-audio/src/grain/board.rs
@@ -0,0 +1,512 @@
+//! The board owner's side of the rolling bed (spec §1.5, §2.2, §2.7, §2.8): per-surface tuning
+//! from the vault, the speed → read position curve, the per-frame records of players A and B, and
+//! the owner's modulators. Game thread, 60 Hz, single precision throughout.
+use super::player::{GrainParams, Record};
+
+/// Push envelope tuning (§2.7): peak speed scale and frequency shift by speed, segment times.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct PushTuning {
+    pub ramp_kmh: f32,
+    pub scale_low: f32,
+    pub scale_high: f32,
+    pub shift_low_hz: f32,
+    pub shift_high_hz: f32,
+    /// Attack, hold, return (ms).
+    pub scale_ms: [f32; 3],
+    pub shift_ms: [f32; 3],
+}
+
+/// One grain collection of the vault's grain class (inheriting from `default`).
+#[derive(Clone, Debug, PartialEq)]
+pub struct SurfaceTuning {
+    pub max_kmh: f32,
+    /// Position-curve control points P0..P3.
+    pub bezier: [f32; 4],
+    /// GrainParams of players A and B.
+    pub params: [GrainParams; 2],
+    pub turn_cap: f32,
+    pub turn_rise_step: f32,
+    pub turn_fall_step: f32,
+    pub special_gain: f32,
+    pub special_shift_hz: f32,
+    pub b_slope_gain: f32,
+    pub b_slope_ramp_kmh: f32,
+    pub a_shift_per_slope_hz: f32,
+    pub b_base_shift_hz: f32,
+    pub b_shift_per_slope_hz: f32,
+    /// The slope inputs' divisors (`0x57A78D3BE8D47BB3` down = −10, `0x8DD4C3FC8DAF4059` up = 10).
+    pub slope_divisors: (f32, f32),
+    pub push: PushTuning,
+}
+
+/// The rocket layer's owner tuning (§2.8): start / top speed, gain word, GrainParams.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct RocketTuning {
+    pub start_kmh: f32,
+    pub top_kmh: f32,
+    pub gain_word: i32,
+    pub params: GrainParams,
+}
+
+/// f32 1/32767 as the owner code multiplies by it (`0x38000100`).
+pub const INV_32767: f32 = f32::from_bits(0x3800_0100);
+
+/// t = clamp((v / max km/h)·3.6, 0, 1), rounded as retail (divide, then scale).
+pub fn speed_fraction(speed: f32, max_kmh: f32) -> f32 {
+    let x = (speed / max_kmh) * 3.6;
+    let x = if x >= 0.0 { x } else { 0.0 };
+    if 1.0 - x >= 0.0 { x } else { 1.0 }
+}
+
+/// Cubic Bézier of t with control points P0..P3 (not clamped: two members leave [0, 1] slightly),
+/// in retail's factored single-precision form: with u = 1 − t and s = 1 − u,
+/// pos = u³·P0 + 3·(s·(P2·s + P1·u))·u + s³·P3, the two outer sums and P2·s + P1·u fused.
+pub fn position(bezier: &[f32; 4], t: f32) -> f32 {
+    let [p0, p1, p2, p3] = *bezier;
+    let u = 1.0 - t;
+    let s = 1.0 - u;
+    let inner = p2.mul_add(s, p1 * u);
+    let middle = (inner * s) * u;
+    let ends = (s * s * s) * p3;
+    ((u * u) * u).mul_add(p0, middle.mul_add(3.0, ends))
+}
+
+/// What the owner update reads for one sounding truck (§2.2).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct BoardInputs {
+    /// Ground speed (m/s).
+    pub speed: f32,
+    /// The push speed-scale envelope while it runs.
+    pub speed_scale: Option<f32>,
+    /// MixMap SkateBoard level(1), level(2) (Q15) and pitch(3) (4096 = 1.0).
+    pub level_a: i32,
+    pub level_b: i32,
+    pub pitch: i32,
+    /// Slewed turn intensity I and brake Bk (0..1).
+    pub turn: f32,
+    pub brake: f32,
+    /// Manual or trick latch: A × special gain.
+    pub special: bool,
+    /// Downhill slope level D (0..1).
+    pub downhill: f32,
+    /// Seam-pattern gain envelope while it runs.
+    pub seam: Option<f32>,
+}
+
+/// The records of players A and B (§2.2 steps 1–7).
+pub fn records(t: &SurfaceTuning, inp: &BoardInputs) -> [Record; 2] {
+    let v = inp.speed_scale.map_or(inp.speed, |s| s * inp.speed);
+    let pos_a = position(&t.bezier, speed_fraction(v, t.max_kmh));
+    let pos_b = pos_a - 0.1;
+    let pos_b = if pos_b >= 0.0 { pos_b } else { 0.0 };
+    let pitch = inp.pitch as f32 * (1.0 / 4096.0);
+    let larger = if inp.turn - inp.brake >= 0.0 { inp.turn } else { inp.brake };
+    let mut gain_a = (1.0 - larger) * (inp.level_a as f32 * INV_32767);
+    if inp.special {
+        gain_a *= t.special_gain;
+    }
+    if let Some(seam) = inp.seam {
+        gain_a *= seam;
+    }
+    let mut gain_b = inp.turn * (inp.level_b as f32 * INV_32767);
+    if let Some(seam) = inp.seam {
+        gain_b *= seam;
+    }
+    if inp.downhill > 0.0 {
+        let ramp = if t.b_slope_ramp_kmh > 0.0 { speed_fraction(v, t.b_slope_ramp_kmh) } else { 1.0 };
+        gain_b = ((inp.downhill * ramp) * t.b_slope_gain).mul_add(gain_a, gain_b);
+        if gain_b > 1.0 {
+            gain_b = 1.0;
+        }
+    }
+    [Record { gain: gain_a, pitch, position: pos_a }, Record { gain: gain_b, pitch, position: pos_b }]
+}
+
+/// The rocket record (§2.8): gain = level(5)/32767 × gain word/32767, pitch(3)/4096, position
+/// = clamp((v·3.6 − start) / (top − start), 0, 1).
+pub fn rocket_record(t: &RocketTuning, speed: f32, level: i32, pitch: i32) -> Record {
+    Record {
+        gain: level as f32 / 32767.0 * (t.gain_word as f32 / 32767.0),
+        pitch: pitch as f32 / 4096.0,
+        position: ((speed * 3.6 - t.start_kmh) / (t.top_kmh - t.start_kmh)).clamp(0.0, 1.0),
+    }
+}
+
+/// A linear attack → hold → return envelope from `start` to `peak` and back to `rest`, advanced
+/// by the frame time (the push speed scale and frequency shift, §2.7).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct PushEnvelope {
+    from: f32,
+    peak: f32,
+    rest: f32,
+    ms: [f32; 3],
+    elapsed_ms: f32,
+    running: bool,
+}
+
+impl PushEnvelope {
+    /// Start a new push from the current value (or `rest` when idle).
+    pub fn trigger(&mut self, peak: f32, rest: f32, ms: [f32; 3]) {
+        let from = if self.running { self.value().unwrap_or(rest) } else { rest };
+        *self = Self { from, peak, rest, ms, elapsed_ms: 0.0, running: true };
+    }
+
+    pub fn advance(&mut self, dt: f32) {
+        if self.running {
+            self.elapsed_ms += dt * 1000.0;
+            if self.elapsed_ms >= self.ms.iter().sum::<f32>() {
+                self.running = false;
+            }
+        }
+    }
+
+    /// The value while running.
+    pub fn value(&self) -> Option<f32> {
+        if !self.running {
+            return None;
+        }
+        let [a, h, r] = self.ms;
+        let e = self.elapsed_ms;
+        Some(if e < a {
+            self.from + (self.peak - self.from) * (e / a.max(1e-3))
+        } else if e < a + h {
+            self.peak
+        } else {
+            self.peak + (self.rest - self.peak) * ((e - a - h) / r.max(1e-3)).min(1.0)
+        })
+    }
+}
+
+/// The push tuning's peaks at speed `v` (m/s): t = clamp((v − 1)·3.6 / ramp, 0, 1); speed scale
+/// lerp(low, high, t), shift lerp(low, high, t).
+pub fn push_peaks(p: &PushTuning, v: f32) -> (f32, f32) {
+    let t = (((v - 1.0) * 3.6) / p.ramp_kmh).clamp(0.0, 1.0);
+    (p.scale_low + (p.scale_high - p.scale_low) * t, p.shift_low_hz + (p.shift_high_hz - p.shift_low_hz) * t)
+}
+
+/// Move `value` toward `target` by at most `step` (the turn and brake slews, per frame).
+pub fn slew(value: f32, target: f32, step: f32) -> f32 {
+    if target > value { (value + step).min(target) } else { (value - step).max(target) }
+}
+
+/// `0x8209xxxx` 0.24: |COM velocity| → turn intensity scale (`sub_824C8588`).
+pub const TURN_SPEED_SCALE: f32 = 0.24;
+
+/// The owner's turn intensity (`sub_824C8588`, owner `+1160` signed, `+1164` = |·|), per frame:
+/// raw = min(clamp(|COM v|·0.24, 0, cap)·turn, cap), then max(raw, −cap); 0 while the manual or
+/// trick latch holds; the signed value moves toward raw by at most the primary truck's rise step
+/// when raw is above it, else its fall step (both from the grain collection). Returns |value|.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct TurnIntensity {
+    pub value: f32,
+}
+
+impl TurnIntensity {
+    /// One step; `frames` scales the slew steps for frame times other than retail's 1/60 s.
+    pub fn step(&mut self, t: &SurfaceTuning, com_speed: f32, turn: f32, special: bool, frames: f32) -> f32 {
+        let cap = t.turn_cap;
+        let scaled = com_speed * TURN_SPEED_SCALE;
+        let scaled = if -scaled >= 0.0 { 0.0 } else { scaled };
+        let scaled = if cap - scaled >= 0.0 { scaled } else { cap };
+        let mut raw = scaled * turn;
+        if raw > cap {
+            raw = cap;
+        }
+        if raw < -cap {
+            raw = -cap;
+        }
+        if special {
+            raw = 0.0;
+        }
+        let step = if raw > self.value { t.turn_rise_step } else { t.turn_fall_step } * frames;
+        if raw - self.value > step {
+            raw = self.value + step;
+        } else if self.value - raw > step {
+            raw = self.value - step;
+        }
+        self.value = raw;
+        raw.abs()
+    }
+}
+
+/// The owner's two latches (`sub_824CA688` / `sub_824CA6E0`): manual (`+1504`) set while balancing
+/// (state `+340`), cleared once the wheel count is 0 or 4; trick (`+1505`) set while the hippy-jump
+/// flag (`+372`) holds, cleared once both feet are in the deck box (`+615 && +616`). "Special" =
+/// either: gain A × special gain, turn intensity 0.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Latches {
+    pub manual: bool,
+    pub trick: bool,
+}
+
+impl Latches {
+    pub fn update(&mut self, balance: bool, wheel_count: u32, hippy_jump: bool, feet_in_box: [bool; 2]) -> bool {
+        if balance {
+            self.manual = true;
+        } else if self.manual && (wheel_count == 0 || wheel_count == 4) {
+            self.manual = false;
+        }
+        if hippy_jump {
+            self.trick = true;
+        } else if self.trick && feet_in_box[0] && feet_in_box[1] {
+            self.trick = false;
+        }
+        self.manual || self.trick
+    }
+}
+
+/// `sub_824CA738`: with the primary truck on a grain surface, a downhill slope (`+712` < 0) gives
+/// D = clamp01(slope / down) and an uphill one U = clamp01(slope / up) (`down` / `up` = the grain
+/// collection's divisors, −10 / 10); otherwise both 0. Owner inputs 2 / 3 = trunc(level·32767).
+pub fn slope_levels(slope: f32, grain_surface: bool, down_divisor: f32, up_divisor: f32) -> (f32, f32) {
+    let unit = |x: f32| {
+        let lo = if -x >= 0.0 { 0.0 } else { x };
+        if 1.0 - lo >= 0.0 { lo } else { 1.0 }
+    };
+    if !grain_surface {
+        (0.0, 0.0)
+    } else if slope < 0.0 {
+        (unit(slope / down_divisor), 0.0)
+    } else if slope > 0.0 {
+        (0.0, unit(slope / up_divisor))
+    } else {
+        (0.0, 0.0)
+    }
+}
+
+/// The seam-pattern gain envelope (`sub_824CA448` / draw `sub_824CA318`, owner `+1336..+1484`,
+/// local player): when wheel 0's seam pattern changes the envelope resets; for a pattern whose
+/// wobble is not {1, 1} it becomes active and ramps linearly from 1 to a random gain in
+/// [low, high) (steps of 0.01) over a random duration in [ms_low, ms_high) ms, then holds; the
+/// same pattern frame after frame only advances it. While active both grain gains are multiplied
+/// by its value. (The grain spec's "random walk" reading is corrected: retail adds one segment
+/// per pattern change.)
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct SeamEnvelope {
+    pattern: u32,
+    active: bool,
+    from: f32,
+    to: f32,
+    ms: f32,
+    elapsed_ms: f32,
+}
+
+impl SeamEnvelope {
+    /// Draw the target gain and duration as `sub_824CA318` does (`draw` = the title generator).
+    pub fn draw(w: &crate::player::tuning::SeamWobble, mut draw: impl FnMut() -> u32) -> (f32, i32) {
+        let mut gain = w.gain_low;
+        if w.gain_low != w.gain_high {
+            let range = ((w.gain_high - w.gain_low) * 100.0) as i32;
+            let m = if range > 0 {
+                (draw() % range as u32) as f32 * 0.01
+            } else {
+                let r = range.unsigned_abs().max(1);
+                (draw() % r) as f32 * -0.01
+            };
+            gain = m + w.gain_low;
+        }
+        let mut ms = w.ms_low;
+        if w.ms_high != w.ms_low {
+            let r = w.ms_high.wrapping_sub(w.ms_low).unsigned_abs().max(1);
+            ms = (draw() % r) as i32 + w.ms_low;
+        }
+        (gain, ms)
+    }
+
+    /// One frame with wheel 0's pattern. `wobble(pattern)` looks up the tuning; `draw` is used only
+    /// on a change to an active pattern.
+    pub fn update(&mut self, pattern: u32, dt: f32, wobble: impl Fn(u32) -> crate::player::tuning::SeamWobble, draw: impl FnMut() -> u32) {
+        if pattern != self.pattern {
+            *self = Self { pattern, ..Self::default() };
+            if pattern != 0 {
+                let w = wobble(pattern);
+                if w.gain_low != 1.0 || w.gain_high != 1.0 {
+                    let (gain, ms) = Self::draw(&w, draw);
+                    *self = Self { pattern, active: true, from: 1.0, to: gain, ms: ms as f32, elapsed_ms: 0.0 };
+                }
+            }
+        } else if self.active && self.elapsed_ms < self.ms {
+            self.elapsed_ms += dt * 1000.0;
+        }
+    }
+
+    /// The gain factor while active.
+    pub fn value(&self) -> Option<f32> {
+        if !self.active {
+            return None;
+        }
+        if self.ms <= 0.0 || self.elapsed_ms >= self.ms {
+            return Some(self.to);
+        }
+        Some(self.from + (self.to - self.from) * (self.elapsed_ms / self.ms))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tuning(max_kmh: f32, bezier: [u32; 4]) -> SurfaceTuning {
+        let p = GrainParams { attack: 0.1, sustain: 0.2, release: 0.1, window: 1.6, drift: 0.05 };
+        SurfaceTuning {
+            max_kmh,
+            bezier: bezier.map(f32::from_bits),
+            params: [p, p],
+            turn_cap: 0.6,
+            turn_rise_step: 0.06,
+            turn_fall_step: 0.06,
+            special_gain: 0.65,
+            special_shift_hz: 150.0,
+            b_slope_gain: 2.0,
+            b_slope_ramp_kmh: 10.0,
+            a_shift_per_slope_hz: -100.0,
+            b_base_shift_hz: -10.0,
+            b_shift_per_slope_hz: 50.0,
+            slope_divisors: (-10.0, 10.0),
+            push: PushTuning { ramp_kmh: 45.0, scale_low: 1.4, scale_high: 1.1, shift_low_hz: -52.0, shift_high_hz: -20.0, scale_ms: [35.0, 200.0, 600.0], shift_ms: [30.0, 200.0, 600.0] },
+        }
+    }
+
+    /// The PoC's POS vectors (PR #4's `board_records`, `.local/audio-re/grains/grain_vectors.tsv`):
+    /// speed in km/h → position A / B bit patterns.
+    #[test]
+    fn positions_match_the_golden_vectors() {
+        let golden: &[(&str, f32, [u32; 4], &[(u32, u32, u32)])] = &[
+            ("concrete_rough_hard", 60.0, [0, 0x3D0D_3DCB, 0x3F69_EE58, 0x3F80_0000], &[
+                (0, 0x0000_0000, 0x0000_0000), (5, 0x3CCF_0A1D, 0x0000_0000), (10, 0x3DA3_F6DB, 0x0000_0000),
+                (15, 0x3E22_7B96, 0x3D70_54BE), (20, 0x3E82_C772, 0x3E1F_287E), (25, 0x3EBA_B135, 0x3E87_7E02),
+                (30, 0x3EF6_11A8, 0x3EC2_DE75), (35, 0x3F18_FFAE, 0x3EFE_CC29), (40, 0x3F35_C86C, 0x3F1C_2ED2),
+                (45, 0x3F4F_EE57, 0x3F36_54BD), (50, 0x3F65_FCBC, 0x3F4C_6322), (55, 0x3F76_7EDB, 0x3F5C_E541),
+                (60, 0x3F80_0000, 0x3F66_6666), (80, 0x3F80_0000, 0x3F66_6666),
+            ]),
+            ("default", 74.0, [0, 0x3EB9_611C, 0x3F34_F72B, 0x3F80_0000], &[
+                (0, 0x0000_0000, 0x0000_0000), (5, 0x3D95_CD5D, 0x0000_0000), (10, 0x3E15_40D0, 0x3D3B_69A6),
+                (15, 0x3E5E_FDB1, 0x3DF1_2E95), (20, 0x3E94_0647, 0x3E41_A628), (25, 0x3EB8_2E5A, 0x3E84_FB27),
+                (30, 0x3EDB_EEB2, 0x3EA8_BB7F), (35, 0x3EFF_3EF4, 0x3ECC_0BC1), (40, 0x3F11_0B5E, 0x3EEE_E389),
+                (45, 0x3F22_36DB, 0x3F08_9D41), (50, 0x3F33_1DBE, 0x3F19_8424), (55, 0x3F43_BBDB, 0x3F2A_2241),
+                (60, 0x3F54_0D02, 0x3F3A_7368), (65, 0x3F64_0D04, 0x3F4A_736A), (70, 0x3F73_B7B2, 0x3F5A_1E18),
+                (75, 0x3F80_0000, 0x3F66_6666),
+            ]),
+        ];
+        let mut mismatches = Vec::new();
+        for (name, max, bezier, rows) in golden {
+            let t = tuning(*max, *bezier);
+            for &(kmh, a, b) in rows.iter() {
+                let inp = BoardInputs { speed: kmh as f32 / 3.6, speed_scale: None, level_a: 7859, level_b: 16000, pitch: 4096, turn: 0.0, brake: 0.0, special: false, downhill: 0.0, seam: None };
+                let [ra, rb] = records(&t, &inp);
+                if (ra.position.to_bits(), rb.position.to_bits()) != (a, b) {
+                    mismatches.push(format!("{name} {kmh}: A {:08X} want {a:08X}, B {:08X} want {b:08X}", ra.position.to_bits(), rb.position.to_bits()));
+                }
+                assert_eq!(format!("{:.6}", ra.gain), "0.239845");
+            }
+        }
+        assert!(mismatches.is_empty(), "{}", mismatches.join("\n"));
+    }
+
+    #[test]
+    fn b_is_the_turning_and_downhill_layer() {
+        let t = tuning(60.0, [0, 0x3D0D_3DCB, 0x3F69_EE58, 0x3F80_0000]);
+        let mut inp = BoardInputs { speed: 5.0, speed_scale: None, level_a: 16384, level_b: 16384, pitch: 4096, turn: 0.0, brake: 0.0, special: false, downhill: 0.0, seam: None };
+        assert_eq!(records(&t, &inp)[1].gain, 0.0);
+        inp.turn = 0.5;
+        let [a, b] = records(&t, &inp);
+        assert!((a.gain - 0.25).abs() < 1e-3 && (b.gain - 0.25).abs() < 1e-3);
+        inp.turn = 0.0;
+        inp.downhill = 1.0;
+        let [a, b] = records(&t, &inp);
+        assert!((b.gain - (2.0 * a.gain).min(1.0)).abs() < 1e-6);
+        inp.special = true;
+        assert!((records(&t, &inp)[0].gain - a.gain * 0.65).abs() < 1e-6);
+    }
+
+    #[test]
+    fn push_envelope_rises_holds_and_returns() {
+        let mut e = PushEnvelope::default();
+        assert_eq!(e.value(), None);
+        e.trigger(1.4, 1.0, [35.0, 200.0, 600.0]);
+        e.advance(0.035);
+        assert!((e.value().unwrap() - 1.4).abs() < 1e-5);
+        e.advance(0.2);
+        e.advance(0.3);
+        assert!((e.value().unwrap() - 1.2).abs() < 0.01);
+        e.advance(0.4);
+        assert_eq!(e.value(), None);
+        let p = PushTuning { ramp_kmh: 45.0, scale_low: 1.4, scale_high: 1.1, shift_low_hz: -52.0, shift_high_hz: -20.0, scale_ms: [35.0, 200.0, 600.0], shift_ms: [30.0, 200.0, 600.0] };
+        assert_eq!(push_peaks(&p, 0.5), (1.4, -52.0));
+        assert_eq!(push_peaks(&p, 30.0), (1.1, -20.0));
+    }
+
+    #[test]
+    fn turn_intensity_caps_slews_and_zeroes_while_special() {
+        let t = tuning(60.0, [0, 0x3D0D_3DCB, 0x3F69_EE58, 0x3F80_0000]);
+        let mut i = TurnIntensity::default();
+        // 10 m/s COM × 0.24 = 2.4 → capped 0.6, × turn −1 → −0.6: reached in steps of 0.06.
+        let steps: Vec<f32> = (0..12).map(|_| i.step(&t, 10.0, -1.0, false, 1.0)).collect();
+        assert!((steps[0] - 0.06).abs() < 1e-6 && (steps[9] - 0.6).abs() < 1e-5 && (steps[11] - 0.6).abs() < 1e-5);
+        assert!(i.value < 0.0, "signed internally");
+        // Straight: falls back toward 0 by the step (raw 0 > −0.6 uses the rise step).
+        assert!((i.step(&t, 10.0, 0.0, false, 1.0) - 0.54).abs() < 1e-5);
+        // A manual or trick latch forces 0 as the target.
+        let mut j = TurnIntensity { value: 0.3 };
+        assert!((j.step(&t, 10.0, 1.0, true, 1.0) - 0.24).abs() < 1e-5);
+        // Slow: |COM v|·0.24 = 0.12 is the cap there.
+        let mut k = TurnIntensity::default();
+        for _ in 0..10 {
+            k.step(&t, 0.5, 1.0, false, 1.0);
+        }
+        assert!((k.value - 0.12).abs() < 1e-6);
+    }
+
+    #[test]
+    fn latches_hold_until_their_release_conditions() {
+        let mut l = Latches::default();
+        assert!(l.update(true, 2, false, [false; 2]), "balancing sets the manual latch");
+        assert!(l.update(false, 2, false, [false; 2]), "held on two wheels");
+        assert!(!l.update(false, 4, false, [false; 2]), "four wheels down clears it");
+        assert!(l.update(false, 4, true, [false; 2]));
+        assert!(l.update(false, 4, false, [true, false]));
+        assert!(!l.update(false, 4, false, [true, true]), "both feet back in the box");
+    }
+
+    #[test]
+    fn slope_levels_need_a_grain_surface() {
+        assert_eq!(slope_levels(-5.0, true, -10.0, 10.0), (0.5, 0.0));
+        assert_eq!(slope_levels(20.0, true, -10.0, 10.0), (0.0, 1.0));
+        assert_eq!(slope_levels(-5.0, false, -10.0, 10.0), (0.0, 0.0));
+        assert_eq!(slope_levels(0.0, true, -10.0, 10.0), (0.0, 0.0));
+    }
+
+    #[test]
+    fn seam_envelope_ramps_once_per_pattern_change() {
+        use crate::player::tuning::SeamWobble;
+        let spider = SeamWobble { gain_low: 0.8, gain_high: 0.6, ms_low: 30, ms_high: 80 };
+        let wobble = |p: u32| if p == 1 { spider } else { SeamWobble::default() };
+        let mut e = SeamEnvelope::default();
+        e.update(4, 1.0 / 60.0, wobble, || unreachable!("a {{1, 1}} wobble draws nothing"));
+        assert_eq!(e.value(), None);
+        // range = trunc(−0.2·100) = −19 (f32): gain = 0.8 − (r mod 19)·0.01; ms = 30 + r mod 50.
+        let mut draws = [7u32, 23].into_iter();
+        e.update(1, 1.0 / 60.0, wobble, || draws.next().unwrap());
+        assert_eq!(e.value(), Some(1.0));
+        let (gain, ms) = (0.8 - 0.07, 53.0);
+        for _ in 0..2 {
+            e.update(1, 1.0 / 60.0, wobble, || unreachable!());
+        }
+        let v = e.value().unwrap();
+        assert!((v - (1.0 + (gain - 1.0) * (33.333332 / ms))).abs() < 1e-4, "{v}");
+        for _ in 0..10 {
+            e.update(1, 1.0 / 60.0, wobble, || unreachable!());
+        }
+        assert!((e.value().unwrap() - gain).abs() < 1e-6, "holds the drawn gain");
+        e.update(0, 1.0 / 60.0, wobble, || unreachable!());
+        assert_eq!(e.value(), None);
+    }
+
+    #[test]
+    fn rocket_position_spans_35_to_60_kmh() {
+        let t = RocketTuning { start_kmh: 35.0, top_kmh: 60.0, gain_word: 22000, params: GrainParams { attack: 0.1, sustain: 0.4, release: 0.1, window: 2.4, drift: 0.1 } };
+        assert_eq!(rocket_record(&t, 35.0 / 3.6, 32767, 4096).position, 0.0);
+        assert!((rocket_record(&t, 47.5 / 3.6, 32767, 4096).position - 0.5).abs() < 1e-4);
+        assert!((rocket_record(&t, 47.5 / 3.6, 32767, 4096).gain - 22000.0 / 32767.0).abs() < 1e-6);
+    }
+}
diff --git a/crates/skate-audio/src/grain/chain.rs b/crates/skate-audio/src/grain/chain.rs
new file mode 100644
index 00000000..5e3cf77a
--- /dev/null
+++ b/crates/skate-audio/src/grain/chain.rs
@@ -0,0 +1,539 @@
+//! The board owner's side of the grain bus chains (spec `.claude/notes/aems-grain-chain-spec.md`
+//! §3–§4): what `SFXObj_SkateBoard`'s process (`sub_824C6A78`, game thread, before the frame's
+//! MixMap evaluation) posts to the four chains each frame. Pure state machines; the host feeds the
+//! results into [`super::GrainBed::set_chains`] as [`ChainValues`].
+//!
+//! - [`fss_shifts`] (`sub_824C9058`): the FrequencyShiftSsb values of players A and B.
+//! - [`PushShift`] (`sub_824C6198`, owner `+1036`): the push frequency-shift envelope.
+//! - [`ChainState::frame`]: the graph-1 → graph-3 send and the graph-1 level ramp by speed
+//!   (`sub_824CAEC0`), the two random-walk gain wobbles (`sub_824CB078`) and their posting
+//!   (`sub_824CB180`), local player only.
+//! - [`Envelope`]: retail's multi-segment envelope (`sub_8248D368` reset, `sub_8248D3C0` add,
+//!   `sub_8248D498` append, `sub_8248D510` advance), linear segments.
+use super::bed::ChainValues;
+use super::board::SurfaceTuning;
+
+/// Retail's segment envelope (up to 5 segments; only the linear kind is used by these callers).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Envelope {
+    /// Time inside the current segment (s, `+0`).
+    t: f32,
+    /// Per segment: duration (s, `+4`), start (`+28`), end (`+52`), start = previous end (`+76`).
+    dur: [f32; 6],
+    start: [f32; 6],
+    end: [f32; 6],
+    chained: [bool; 6],
+    count: usize,
+    seg: usize,
+    value: f32,
+    done: bool,
+}
+
+impl Default for Envelope {
+    /// The reset state (`sub_8248D368`): empty, value 0, done.
+    fn default() -> Self {
+        Self { t: 0.0, dur: [0.0; 6], start: [0.0; 6], end: [0.0; 6], chained: [false; 6], count: 0, seg: 0, value: 0.0, done: true }
+    }
+}
+
+/// ms → s as `sub_8248D3C0` (`0x82063A48` 0.001, f32).
+const MS: f32 = f32::from_bits(0x3A83_126F);
+/// A non-positive duration becomes this (`0x820D71E8`).
+const MIN_DUR: f32 = f32::from_bits(0x3C23_D70A);
+
+impl Envelope {
+    pub fn reset(&mut self) {
+        *self = Self::default();
+    }
+
+    /// Add a linear segment `start → end` over `ms` (`sub_8248D3C0`); the first one sets the value
+    /// to `start`. False when the envelope is full (5 segments).
+    pub fn add(&mut self, start: f32, end: f32, ms: i32) -> bool {
+        let i = self.count;
+        if i == 5 {
+            return false;
+        }
+        let d = ms as f32 * MS;
+        self.dur[i] = if d > 0.0 { d } else { MIN_DUR };
+        self.end[i] = end;
+        self.start[i] = start;
+        self.chained[i] = false;
+        self.done = false;
+        if i == 0 {
+            self.value = self.start[0];
+        }
+        self.count = i + 1;
+        true
+    }
+
+    /// Append a segment that starts where the previous one ends (`sub_8248D498`; needs one).
+    pub fn append(&mut self, end: f32, ms: i32) -> bool {
+        if self.count == 0 || !self.add(0.0, end, ms) {
+            return false;
+        }
+        self.chained[self.count - 1] = true;
+        true
+    }
+
+    /// Advance by `dt` seconds (`sub_8248D510`): past a segment's end the value is that end and
+    /// the next segment starts with the overshoot; past the last one the envelope is done.
+    pub fn advance(&mut self, dt: f32) {
+        if self.done || self.count == 0 {
+            return;
+        }
+        self.t += dt;
+        let s = self.seg;
+        if self.t > self.dur[s] {
+            self.value = self.end[s];
+            if s + 1 < self.count {
+                self.t -= self.dur[s];
+                self.seg = s + 1;
+                if self.chained[s + 1] {
+                    self.start[s + 1] = self.end[s];
+                }
+            } else {
+                self.done = true;
+            }
+            return;
+        }
+        let u = self.t / self.dur[s];
+        self.value = (self.end[s] - self.start[s]).mul_add(u, self.start[s]);
+    }
+
+    pub fn value(&self) -> f32 {
+        self.value
+    }
+
+    pub fn done(&self) -> bool {
+        self.done
+    }
+}
+
+/// The push frequency-shift envelope (owner `+1036`, `sub_824C6198`): on each push plant
+/// 0 → peak over the attack, hold, → 0 over the return (ms from the primary truck's collection,
+/// peak = [`super::board::push_peaks`]'s shift). Advanced by the frame time every frame, after a
+/// trigger. Its value only counts while it runs ([`PushShift::value`]).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct PushShift {
+    pub env: Envelope,
+}
+
+impl PushShift {
+    pub fn trigger(&mut self, peak: f32, ms: [f32; 3]) {
+        self.env.reset();
+        self.env.add(0.0, peak, ms[0] as i32);
+        self.env.append(peak, ms[1] as i32);
+        self.env.append(0.0, ms[2] as i32);
+    }
+
+    pub fn advance(&mut self, dt: f32) {
+        self.env.advance(dt);
+    }
+
+    /// `+1152` while `+1156` (done) is clear.
+    pub fn value(&self) -> Option<f32> {
+        (!self.env.done()).then_some(self.env.value())
+    }
+}
+
+/// The FrequencyShiftSsb values of players A and B (`sub_824C9058`), Hz:
+/// - A = (special ? `special_shift` : 0) + push shift + D × A's shift per slope;
+/// - B = B's base shift + push shift + D × B's shift per slope.
+///
+/// `this` is the truck's grain collection (special shift, B base shift), `primary` the primary
+/// truck's (both per-slope values); the slope terms only while D > 0 (fused multiply-adds).
+pub fn fss_shifts(this: &SurfaceTuning, primary: &SurfaceTuning, special: bool, push_shift: Option<f32>, downhill: f32) -> [f32; 2] {
+    let mut a = if special { this.special_shift_hz } else { 0.0 };
+    let mut b = this.b_base_shift_hz;
+    if let Some(p) = push_shift {
+        a = p + a;
+        b = p + b;
+    }
+    if downhill > 0.0 {
+        a = primary.a_shift_per_slope_hz.mul_add(downhill, a);
+        b = downhill.mul_add(primary.b_shift_per_slope_hz, b);
+    }
+    [a, b]
+}
+
+/// One random-walk wobble's tuning (owner `+1572..+1584` for A's chains, `+1728..+1740` for B's).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct WobbleTuning {
+    pub ms_low: i32,
+    pub ms_high: i32,
+    pub low: f32,
+    pub high: f32,
+}
+
+/// The chain tuning of the board owner class `0x6E878344774A7999` (`default`, `sub_824CA938`);
+/// [`Default`] = the vault values.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ChainTuning {
+    /// Graph-1 → graph-3 send: 0 below `send_start_kmh`, linear to `send_max` at `send_end_kmh`.
+    pub send_start_kmh: f32,
+    pub send_end_kmh: f32,
+    pub send_max: f32,
+    /// Graph-1 level ramp: 1 at `level_start_kmh` → `level_floor` at `level_end_kmh`.
+    pub level_start_kmh: f32,
+    pub level_end_kmh: f32,
+    pub level_floor: f32,
+    /// Wobble depth ramp: 0 at `wobble_start_kmh` → 1 at `wobble_end_kmh`.
+    pub wobble_start_kmh: f32,
+    pub wobble_end_kmh: f32,
+    /// A's chains, B's chains.
+    pub wobble: [WobbleTuning; 2],
+    /// Graph 3: DCl0 level, HS20 corner and gain.
+    pub clip: f32,
+    pub shelf_hz: f32,
+    pub shelf_gain: f32,
+}
+
+impl Default for ChainTuning {
+    fn default() -> Self {
+        Self {
+            send_start_kmh: 46.0,
+            send_end_kmh: 70.0,
+            send_max: 3.0,
+            level_start_kmh: 52.0,
+            level_end_kmh: 74.0,
+            level_floor: f32::from_bits(0x3EE6_6666),
+            wobble_start_kmh: 42.0,
+            wobble_end_kmh: 70.0,
+            wobble: [
+                WobbleTuning { ms_low: 15, ms_high: 30, low: 0.0, high: f32::from_bits(0x3E99_999A) },
+                WobbleTuning { ms_low: 5, ms_high: 15, low: f32::from_bits(0x3DCC_CCCD), high: 0.25 },
+            ],
+            clip: f32::from_bits(0x3DB8_51EC),
+            shelf_hz: 5000.0,
+            shelf_gain: f32::from_bits(0x3F26_6666),
+        }
+    }
+}
+
+/// km/h from m/s as the owner code (`0x822F8628` 3.6).
+const KMH: f32 = f32::from_bits(0x4066_6666);
+
+/// One wobble record (`+16` previous target, `+20` graph-1 gain, `+24` last posted, `+28`
+/// graph-3 gain, `+32` envelope).
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Wobble {
+    target: f32,
+    gain1: f32,
+    posted: f32,
+    gain3: f32,
+    env: Envelope,
+}
+
+impl Default for Wobble {
+    /// `sub_824C59C8`: target 0, gains 1, envelope reset (done → the first frame draws).
+    fn default() -> Self {
+        Self { target: 0.0, gain1: 1.0, posted: 1.0, gain3: 1.0, env: Envelope::default() }
+    }
+}
+
+impl Wobble {
+    /// `sub_824CB078` for one record: a finished segment draws the next (duration in
+    /// [ms_low, ms_high) ms, |target| in [low, high) in steps of 0.01, sign opposite to the last
+    /// target's — non-negative → negative), else the envelope advances by `dt`.
+    fn step(&mut self, t: &WobbleTuning, dt: f32, draw: &mut impl FnMut() -> u32) {
+        if self.env.done() {
+            let span = t.ms_high.wrapping_sub(t.ms_low) as u32;
+            let ms = t.ms_low.wrapping_add((draw() % span.max(1)) as i32);
+            let range = ((t.high - t.low) * 100.0) as i32 as u32;
+            let m = (draw() % range.max(1)) as i32 as f32;
+            let mut target = m.mul_add(0.01, t.low);
+            if self.target >= 0.0 {
+                target *= -1.0;
+            }
+            self.env.reset();
+            self.env.add(self.target, target, ms);
+            self.target = target;
+        } else {
+            self.env.advance(dt);
+        }
+    }
+}
+
+/// The owner's chain state (local player): `+1556` send, `+1560` level, the two wobbles, and the
+/// gains each chain module currently holds.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ChainState {
+    send: f32,
+    level: f32,
+    wobble: [Wobble; 2],
+    /// [truck][player] = (graph-1 Gain, graph-3 Gain) as last posted to that chain (1.0 = the
+    /// constructor default of a freshly built chain).
+    applied: [[(f32, f32); 2]; 2],
+}
+
+impl Default for ChainState {
+    fn default() -> Self {
+        Self { send: 0.0, level: 1.0, wobble: [Wobble::default(); 2], applied: [[(1.0, 1.0); 2]; 2] }
+    }
+}
+
+impl ChainState {
+    /// A truck's chains were (re)built (`sub_824C8878`, on every bind): their gains are back at the
+    /// module default 1.0 until the wobble next changes; the send is posted at build time.
+    pub fn rebuilt(&mut self, truck: usize) {
+        self.applied[truck] = [(1.0, 1.0); 2];
+    }
+
+    /// One owner frame, in retail's order: `sub_824CAEC0` (send, level ramp), then
+    /// `sub_824CB180` → `sub_824CB078` (wobble draws / advance, gains, posts). `speed` = ground speed
+    /// (m/s, audio state `+208`), `dt` = the frame time (s), `bound[t]` = truck t has chains (a
+    /// post to a chain that doesn't exist is lost, the compare value still updates). `draw` = the
+    /// title generator (shared with the seam-pattern draws, which run first in retail's frame).
+    pub fn frame(&mut self, t: &ChainTuning, speed: f32, dt: f32, bound: [bool; 2], mut draw: impl FnMut() -> u32) {
+        let kmh = speed * KMH;
+        // sub_824CAEC0.
+        self.send = if kmh >= t.send_end_kmh {
+            t.send_max
+        } else if kmh >= t.send_start_kmh {
+            ((kmh - t.send_start_kmh) / (t.send_end_kmh - t.send_start_kmh)) * t.send_max
+        } else {
+            0.0
+        };
+        if kmh >= t.level_end_kmh {
+            self.level = t.level_floor;
+        } else if kmh >= t.level_start_kmh {
+            let u = (kmh - t.level_start_kmh) / (t.level_end_kmh - t.level_start_kmh);
+            self.level = (-u).mul_add(1.0 - t.level_floor, 1.0);
+        }
+        // Below the start the level keeps its last value (no branch there).
+        // sub_824CB180.
+        for (w, wt) in self.wobble.iter_mut().zip(&t.wobble) {
+            w.step(wt, dt, &mut draw);
+        }
+        let ramp = if kmh >= t.wobble_end_kmh {
+            1.0
+        } else if kmh >= t.wobble_start_kmh {
+            (kmh - t.wobble_start_kmh) / (t.wobble_end_kmh - t.wobble_start_kmh)
+        } else {
+            0.0
+        };
+        for w in &mut self.wobble {
+            let g = w.env.value().mul_add(ramp, 1.0);
+            w.gain3 = g;
+            w.gain1 = g * self.level;
+        }
+        // Post on change; the compare value is per player, not per chain, so after truck 0 posts
+        // truck 1 always compares equal and never receives a wobble (retail behaviour).
+        for (truck, applied) in self.applied.iter_mut().enumerate() {
+            for (p, w) in self.wobble.iter_mut().enumerate() {
+                if w.gain3 != w.posted {
+                    w.posted = w.gain3;
+                    if bound[truck] {
+                        applied[p] = (w.gain1, w.gain3);
+                    }
+                }
+            }
+        }
+    }
+
+    /// The graph-1 → graph-3 send level (posted to all four chains on change and at every build,
+    /// so every chain holds the current value).
+    pub fn send(&self) -> f32 {
+        self.send
+    }
+
+    /// The graph-1 level ramp (`+1560`).
+    pub fn level(&self) -> f32 {
+        self.level
+    }
+
+    /// The wobble values e of A's and B's chains (envelope outputs, before the speed ramp).
+    pub fn wobble(&self) -> [f32; 2] {
+        [self.wobble[0].env.value(), self.wobble[1].env.value()]
+    }
+
+    /// (graph-1 Gain, graph-3 Gain) held by truck `t`'s chains A and B.
+    pub fn gains(&self, truck: usize) -> [(f32, f32); 2] {
+        self.applied[truck]
+    }
+
+    /// The truck's two [`ChainValues`] from this state plus the frame's MixMap values.
+    pub fn values(&self, truck: usize, f: &ChainFrame) -> [ChainValues; 2] {
+        let g = self.applied[truck];
+        [0, 1].map(|p| ChainValues {
+            highpass_hz: f.highpass_hz,
+            lowpass_hz: f.lowpass_hz,
+            pan_degrees: f.pan_degrees,
+            level: g[p].0,
+            fss_hz: f.fss_hz[p],
+            graph3_send: self.send,
+            graph3_gain: g[p].1,
+            env_send: f.env_send,
+            flange_send: f.flange_send[p],
+        })
+    }
+}
+
+/// The per-frame inputs of [`ChainState::values`] (`sub_824C9058`, from SkateBoard's MixMap
+/// outputs): HPF level(12) / LPF level(11) Hz, pan raw(0) × 360/65535, env send level(13)/32767,
+/// the graph-2 first send level(21)/32767 (A) and level(22)/32767 (B) (local player), and the two
+/// [`fss_shifts`].
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ChainFrame {
+    pub highpass_hz: f32,
+    pub lowpass_hz: f32,
+    pub pan_degrees: f32,
+    pub env_send: f32,
+    pub flange_send: [f32; 2],
+    pub fss_hz: [f32; 2],
+}
+
+/// raw(0) → Pan2D1 degrees (`0x822F8C64`, 360/65535 as f32).
+pub const DEGREES_PER_RAW: f32 = f32::from_bits(0x3BB4_00B4);
+/// Level outputs → send levels (`0x822F8898`).
+pub const PER_LEVEL: f32 = crate::dsp::INV_32767;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::eval::rng::Rng;
+
+    #[test]
+    fn envelope_segments_carry_their_overshoot() {
+        let mut e = Envelope::default();
+        assert!(e.done());
+        e.add(0.0, -40.0, 30);
+        e.append(-40.0, 200);
+        e.append(0.0, 600);
+        assert_eq!(e.value(), 0.0);
+        e.advance(0.015);
+        assert!((e.value() + 20.0).abs() < 1e-3);
+        e.advance(0.02); // 35 ms: past the attack → its end, 5 ms into the hold
+        assert_eq!(e.value(), -40.0);
+        e.advance(0.1);
+        assert_eq!(e.value(), -40.0, "hold (start copied from the previous end)");
+        e.advance(0.1); // 205 ms: past the hold → −40, 5 ms into the return
+        assert_eq!(e.value(), -40.0);
+        e.advance(0.3); // 305 of 600 ms
+        assert!((e.value() + 40.0 * (1.0 - 0.305 / 0.6)).abs() < 1e-3, "{}", e.value());
+        e.advance(0.31);
+        assert_eq!((e.value(), e.done()), (0.0, true));
+        let mut p = PushShift::default();
+        assert_eq!(p.value(), None);
+        p.trigger(-52.0, [30.0, 200.0, 600.0]);
+        p.advance(1.0 / 60.0);
+        assert!(p.value().unwrap() < -25.0);
+        assert!(Envelope::default().add(1.0, 2.0, 0), "0 ms becomes 10 ms");
+    }
+
+    #[test]
+    fn fss_values_follow_sub_824c9058() {
+        use crate::grain::board::PushTuning;
+        use crate::grain::player::GrainParams;
+        let p = GrainParams { attack: 0.1, sustain: 0.2, release: 0.1, window: 1.6, drift: 0.05 };
+        let t = SurfaceTuning {
+            max_kmh: 60.0,
+            bezier: [0.0, 0.0, 1.0, 1.0],
+            params: [p, p],
+            turn_cap: 0.6,
+            turn_rise_step: 0.06,
+            turn_fall_step: 0.06,
+            special_gain: 0.65,
+            special_shift_hz: 150.0,
+            b_slope_gain: 2.0,
+            b_slope_ramp_kmh: 10.0,
+            a_shift_per_slope_hz: -100.0,
+            b_base_shift_hz: -10.0,
+            b_shift_per_slope_hz: 50.0,
+            slope_divisors: (-10.0, 10.0),
+            push: PushTuning { ramp_kmh: 45.0, scale_low: 1.4, scale_high: 1.1, shift_low_hz: -52.0, shift_high_hz: -20.0, scale_ms: [35.0, 200.0, 600.0], shift_ms: [30.0, 200.0, 600.0] },
+        };
+        assert_eq!(fss_shifts(&t, &t, false, None, 0.0), [0.0, -10.0]);
+        assert_eq!(fss_shifts(&t, &t, true, None, 0.0), [150.0, -10.0], "manual / trick: +150 Hz on A");
+        assert_eq!(fss_shifts(&t, &t, true, Some(-30.0), 0.0), [120.0, -40.0]);
+        assert_eq!(fss_shifts(&t, &t, false, None, 0.5), [-50.0, 15.0]);
+    }
+
+    #[test]
+    fn send_and_level_by_speed_with_the_hold_quirk() {
+        let t = ChainTuning::default();
+        let mut s = ChainState::default();
+        let mut rng = Rng::new(crate::grain::GrainBed::SEED);
+        let mut at = |s: &mut ChainState, kmh: f32| {
+            s.frame(&t, kmh / 3.6, 1.0 / 60.0, [true, false], || rng.draw());
+            (s.send(), s.level())
+        };
+        assert_eq!(at(&mut s, 40.0), (0.0, 1.0));
+        let (send, level) = at(&mut s, 58.0);
+        assert!((send - 1.5).abs() < 1e-4 && (level - (1.0 - 6.0 / 22.0 * 0.55)).abs() < 1e-4, "{send} {level}");
+        assert_eq!(at(&mut s, 90.0), (3.0, t.level_floor));
+        let (send, level) = at(&mut s, 30.0);
+        assert_eq!((send, level), (0.0, t.level_floor), "the level holds below its start");
+    }
+
+    #[test]
+    fn wobbles_walk_within_their_bounds_and_alternate() {
+        let t = ChainTuning::default();
+        let mut s = ChainState::default();
+        let mut rng = Rng::new(crate::grain::GrainBed::SEED);
+        let mut targets = [Vec::new(), Vec::new()];
+        let (mut lo, mut hi) = ([f32::MAX; 2], [f32::MIN; 2]);
+        for _ in 0..20_000 {
+            s.frame(&t, 100.0 / 3.6, 1.0 / 60.0, [true, true], || rng.draw());
+            for p in 0..2 {
+                let w = s.wobble[p];
+                if targets[p].last() != Some(&w.target) {
+                    targets[p].push(w.target);
+                }
+                let g = s.gains(0)[p].1;
+                lo[p] = lo[p].min(g);
+                hi[p] = hi[p].max(g);
+                // Full ramp at 100 km/h; graph 1 = graph 3 × the level floor once posted (the
+                // first frame draws, its value 0 → 1.0 = the default: nothing posted).
+                if g != 1.0 {
+                    assert_eq!(s.gains(0)[p].0, g * t.level_floor);
+                }
+            }
+            assert_eq!(s.gains(1), [(1.0, 1.0); 2], "truck 1 never receives a wobble");
+        }
+        assert!(lo[0] >= 0.7 - 1e-6 && hi[0] <= 1.3 + 1e-6 && lo[0] < 0.75 && hi[0] > 1.25, "A {} {}", lo[0], hi[0]);
+        assert!(lo[1] >= 0.75 - 1e-6 && hi[1] <= 1.25 + 1e-6, "B {} {}", lo[1], hi[1]);
+        for (p, ts) in targets.iter().enumerate() {
+            assert!(ts[0] <= 0.0, "the first target is negative");
+            for w in ts.windows(2) {
+                assert!(w[0] * w[1] <= 0.0, "signs alternate ({p}: {} {})", w[0], w[1]);
+            }
+            let (low, high) = (t.wobble[p].low, t.wobble[p].high);
+            assert!(ts.iter().all(|x| x.abs() >= low - 1e-6 && x.abs() < high), "{p}");
+        }
+        // B's 5–15 ms segments end every frame at 60 Hz (one frame of advance, one of redraw).
+        assert!(targets[1].len() > targets[0].len());
+    }
+
+    #[test]
+    fn rebuilt_chains_hold_unity_until_the_next_change() {
+        let t = ChainTuning::default();
+        let mut s = ChainState::default();
+        let mut rng = Rng::new(crate::grain::GrainBed::SEED);
+        for _ in 0..30 {
+            s.frame(&t, 60.0 / 3.6, 1.0 / 60.0, [true, false], || rng.draw());
+        }
+        assert_ne!(s.gains(0)[0], (1.0, 1.0));
+        // Slow down below 42 km/h: the wobble settles at 1 and posts once, × the held level.
+        for _ in 0..3 {
+            s.frame(&t, 20.0 / 3.6, 1.0 / 60.0, [true, false], || rng.draw());
+        }
+        let held = s.level();
+        assert!(held < 1.0);
+        assert_eq!(s.gains(0)[0], (held, 1.0));
+        s.rebuilt(0);
+        for _ in 0..30 {
+            s.frame(&t, 20.0 / 3.6, 1.0 / 60.0, [true, false], || rng.draw());
+        }
+        assert_eq!(s.gains(0)[0], (1.0, 1.0), "a rebuilt chain loses the held level until a change");
+    }
+
+    #[test]
+    fn vault_defaults() {
+        let t = ChainTuning::default();
+        assert_eq!((t.clip, t.shelf_gain, t.level_floor), (0.09, 0.65, 0.45));
+        assert_eq!(t.wobble[0].high, 0.3);
+        assert_eq!(t.wobble[1].low, 0.1);
+        assert_eq!(DEGREES_PER_RAW, 360.0 / 65535.0);
+    }
+}
diff --git a/crates/skate-audio/src/grain/format.rs b/crates/skate-audio/src/grain/format.rs
new file mode 100644
index 00000000..50316b57
--- /dev/null
+++ b/crates/skate-audio/src/grain/format.rs
@@ -0,0 +1,229 @@
+//! `.grain` members of `grains.big` (spec `.claude/notes/grain-player-spec.md` §1.2–1.3):
+//! `+0` u32 header length H (= offset of the EA Audio Core stream), `+4` f32 stored duration
+//! (seconds; the player uses this float), `+8..H` a seek table, then one EAAC stream.
+//!
+//! The seek table maps a sample position to the XMA entry's byte offset; in every retail grain
+//! row 0 already spans the whole stream, so a seek to t seconds is "read from frame ⌊rate·t⌋" of
+//! the decoded PCM. We parse it only to validate a member.
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GrainError(pub String);
+
+impl std::fmt::Display for GrainError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "grain: {}", self.0)
+    }
+}
+
+impl std::error::Error for GrainError {}
+
+/// EA Audio Core stream header (two big-endian words).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Eaac {
+    pub version: u32,
+    pub codec: u32,
+    pub channels: u32,
+    pub rate: u32,
+    pub kind: u32,
+    pub looped: bool,
+    pub samples: u32,
+}
+
+/// One seek-table row: (byte step, side-data step, samples, key flag).
+pub type SeekRow = [i64; 4];
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SeekTable {
+    /// 0 = run-length columns.
+    pub kind: u8,
+    pub layout: u8,
+    pub low: u8,
+    /// Samples decoded and discarded before a target.
+    pub preroll: u16,
+    /// Offset of the per-entry side data from the table start (0 = none).
+    pub side_offset: u32,
+    pub rows: Vec<SeekRow>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct GrainFile {
+    pub header_len: u32,
+    /// The stored duration (seconds), not samples/rate.
+    pub duration: f32,
+    pub seek: SeekTable,
+    pub stream: Eaac,
+}
+
+fn be32(b: &[u8], at: usize) -> Result<u32, GrainError> {
+    b.get(at..at + 4).map(|w| u32::from_be_bytes(w.try_into().unwrap())).ok_or_else(|| GrainError(format!("truncated at {at:#x}")))
+}
+
+/// The shared byte cursor of the seek table's columns.
+struct Cursor<'a> {
+    data: &'a [u8],
+    pos: usize,
+}
+
+impl Cursor<'_> {
+    fn byte(&self, k: usize) -> Option<u32> {
+        self.data.get(self.pos + k).map(|&b| u32::from(b))
+    }
+
+    /// Signed variable-length integer: the first byte picks 1–5 bytes; the lowest bit of the last
+    /// byte is the sign (set: value = −1 − magnitude); 0xFF = a raw big-endian i32.
+    fn varint(&mut self) -> Option<i64> {
+        let b0 = self.byte(0)?;
+        let (magnitude, sign, len) = if b0 < 0xC0 {
+            (b0 >> 1, b0 & 1, 1)
+        } else if b0 < 0xF0 {
+            let b1 = self.byte(1)?;
+            ((((b0 << 8) | b1) >> 1 & !0x6000) + 96, b1 & 1, 2)
+        } else if b0 < 0xFC {
+            let (b1, b2) = (self.byte(1)?, self.byte(2)?);
+            ((((((b0 << 8) | b1) & !0xF000) << 8 | b2) >> 1) + 6240, b2 & 1, 3)
+        } else if b0 < 0xFF {
+            let (b1, b2, b3) = (self.byte(1)?, self.byte(2)?, self.byte(3)?);
+            (((((b0 & 3) << 24) | (b1 << 16) | (b2 << 8) | (b3 & 0xFE)) >> 1) + 0x60000 + 6240, b3 & 1, 4)
+        } else {
+            let raw = ((self.byte(1)? << 24) | (self.byte(2)? << 16) | (self.byte(3)? << 8) | self.byte(4)?) as i32;
+            self.pos += 5;
+            return Some(i64::from(raw));
+        };
+        self.pos += len;
+        Some(if sign == 1 { -1 - i64::from(magnitude) } else { i64::from(magnitude) })
+    }
+}
+
+/// A run-length column: a header h ≥ 0 gives one delta for the next h+1 rows; h < 0 gives 1−h
+/// rows that each read their own delta. The column value is the running sum of the deltas read.
+#[derive(Default)]
+struct Column {
+    value: i64,
+    left: i64,
+    repeat: bool,
+}
+
+impl Column {
+    fn next(&mut self, cur: &mut Cursor) -> Option<i64> {
+        if self.left <= 0 {
+            let h = cur.varint()?;
+            if h >= 0 {
+                (self.left, self.repeat) = (h + 1, true);
+                self.value += cur.varint()?;
+            } else {
+                (self.left, self.repeat) = (1 - h, false);
+            }
+        }
+        if !self.repeat {
+            self.value += cur.varint()?;
+        }
+        self.left -= 1;
+        Some(self.value)
+    }
+}
+
+impl SeekTable {
+    pub fn parse(table: &[u8]) -> Result<Self, GrainError> {
+        if table.len() < 8 {
+            return Err(GrainError("seek table shorter than its header".into()));
+        }
+        let side_offset = be32(table, 4)?;
+        let columns = if side_offset != 0 { table.get(..side_offset as usize).unwrap_or(table) } else { table };
+        let mut cur = Cursor { data: columns, pos: 8 };
+        let mut cols: [Column; 4] = Default::default();
+        let mut rows = Vec::new();
+        'rows: while rows.len() < 4096 && cur.pos < columns.len() {
+            let mut row = [0i64; 4];
+            for (c, v) in cols.iter_mut().zip(row.iter_mut()) {
+                match c.next(&mut cur) {
+                    Some(x) => *v = x,
+                    None => break 'rows,
+                }
+            }
+            rows.push(row);
+            if row[2] < 0 {
+                break;
+            }
+        }
+        Ok(Self {
+            kind: table[0],
+            layout: table[1] >> 4,
+            low: table[1] & 0xF,
+            preroll: u16::from_be_bytes([table[2], table[3]]),
+            side_offset,
+            rows,
+        })
+    }
+}
+
+impl GrainFile {
+    pub fn parse(data: &[u8]) -> Result<Self, GrainError> {
+        let header_len = be32(data, 0)?;
+        let duration = f32::from_bits(be32(data, 4)?);
+        let h = header_len as usize;
+        if !(16..data.len()).contains(&h) {
+            return Err(GrainError(format!("header length {h} outside the member ({} bytes)", data.len())));
+        }
+        let seek = SeekTable::parse(&data[8..h])?;
+        let (w0, w1) = (be32(data, h)?, be32(data, h + 4)?);
+        let stream = Eaac {
+            version: w0 >> 28,
+            codec: (w0 >> 24) & 0xF,
+            channels: ((w0 >> 18) & 0x3F) + 1,
+            rate: w0 & 0x3FFFF,
+            kind: w1 >> 30,
+            looped: (w1 >> 29) & 1 == 1,
+            samples: w1 & 0x1FFF_FFFF,
+        };
+        if stream.rate == 0 || stream.samples == 0 {
+            return Err(GrainError("empty EAAC stream".into()));
+        }
+        let seconds = stream.samples as f32 / stream.rate as f32;
+        if !(duration > 0.0) || (duration - seconds).abs() > 0.01 {
+            return Err(GrainError(format!("stored duration {duration} s does not match the stream ({seconds} s)")));
+        }
+        Ok(Self { header_len, duration, seek, stream })
+    }
+
+    /// Whether row 0 is one key entry spanning the whole stream (true for every retail grain).
+    pub fn single_entry(&self) -> bool {
+        self.seek.rows.first().is_some_and(|r| r[2] == i64::from(self.stream.samples) && r[3] == 1)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn varint_forms() {
+        let mut c = Cursor { data: &[0x06, 0x07, 0xC0, 0x01, 0xFF, 0x00, 0x00, 0x01, 0x00], pos: 0 };
+        assert_eq!(c.varint(), Some(3));
+        assert_eq!(c.varint(), Some(-4));
+        // 2-byte: ((0xC001 >> 1) & !0x6000) + 96 = 96; sign bit set → −97.
+        assert_eq!(c.varint(), Some(-97));
+        assert_eq!(c.varint(), Some(256));
+    }
+
+    #[test]
+    fn a_minimal_member_parses() {
+        let mut m = Vec::new();
+        m.extend_from_slice(&24u32.to_be_bytes());
+        m.extend_from_slice(&1.0f32.to_be_bytes());
+        // Seek header: kind 0, layout 1, pre-roll 384, no side data; one row of four run headers
+        // h = 0 with one delta each: bytes 10, side 0, samples 1, key 1.
+        m.extend_from_slice(&[0x00, 0x10, 0x01, 0x80, 0, 0, 0, 0]);
+        m.extend_from_slice(&[0x00, 0x14, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02]);
+        // Header word: version 0, codec 3, mono, 48000 Hz; samples 48000.
+        m.extend_from_slice(&((3u32 << 24) | 48000).to_be_bytes());
+        m.extend_from_slice(&48000u32.to_be_bytes());
+        m.extend_from_slice(&[0; 16]);
+        let g = GrainFile::parse(&m).unwrap();
+        assert_eq!(g.duration, 1.0);
+        assert_eq!(g.stream.rate, 48000);
+        assert_eq!(g.seek.preroll, 384);
+        assert_eq!(g.seek.layout, 1);
+        assert_eq!(g.seek.rows, vec![[10, 0, 1, 1]]);
+        assert!(!g.single_entry());
+    }
+}
diff --git a/crates/skate-audio/src/grain/mod.rs b/crates/skate-audio/src/grain/mod.rs
new file mode 100644
index 00000000..975f5523
--- /dev/null
+++ b/crates/skate-audio/src/grain/mod.rs
@@ -0,0 +1,17 @@
+//! The granular rolling bed (`grains.big` + GrainPlayer), our own port from
+//! `.claude/notes/grain-player-spec.md`:
+//! - [`format`]: `.grain` members (header, stored duration, seek table, EAAC header);
+//! - [`player`]: the GrainPlayer (pick, per-block scheduler, voices with square-root fades);
+//! - [`board`]: per-surface tuning, the speed → position curve and the per-frame records;
+//! - [`chain`]: the owner side of the bus chains (FSS values, graph-3 send, gain wobbles);
+//! - [`bed`]: the per-board players (2 trucks × A/B) with their bus chains, and the rocket layer,
+//!   rendered on the runtime's block clock.
+pub mod bed;
+pub mod board;
+pub mod chain;
+pub mod format;
+pub mod player;
+
+pub use bed::{ChainValues, GrainBed};
+pub use format::GrainFile;
+pub use player::{GrainParams, GrainPlayer, GrainSource, Record};
diff --git a/crates/skate-audio/src/grain/player.rs b/crates/skate-audio/src/grain/player.rs
new file mode 100644
index 00000000..ca99cf6c
--- /dev/null
+++ b/crates/skate-audio/src/grain/player.rs
@@ -0,0 +1,610 @@
+//! The GrainPlayer (spec `.claude/notes/grain-player-spec.md` §2.1–2.6): two voice slots that
+//! play short windows of one long slow-to-fast recording, picked without repeats around a read
+//! position, cross-faded with equal-power square-root fades, rescheduled every 256-frame block.
+//!
+//! - **Pick** (§2.3): target T = (D − W)·position; the free gaps between recently played windows,
+//!   clamped to [T, T + W], are tiled with back-to-back windows of the grain length
+//!   L = attack + sustain + release; one is drawn uniformly with the title-wide generator and
+//!   remembered (16-entry list; it collapses to the last window when it is full or nothing fits).
+//! - **Per block** (§2.4): a drift of the read position beyond the threshold releases the current
+//!   grain and starts a new one; otherwise each voice runs attack → sustain (timer × pitch) →
+//!   release, and the end of a sustain starts the next grain in the other slot.
+//! - **Voice** (§2.5–2.6): SndPlayer1 (PCM from frame ⌊rate·start⌋; the first block of a new
+//!   player is silent, as in the standard graph) → Resample (rate/48000 × pitch) → GainFader
+//!   (square-root fades) → Send (the record gain, 64-sample ramp) into the player's mono bus.
+use std::sync::Arc;
+
+use crate::BLOCK;
+use crate::dsp::resample::{Resampler, ratio};
+use crate::dsp::send::{Mode, Send};
+use crate::eval::rng::Rng;
+use crate::mixer::Pcm;
+
+/// One block's time as the block driver passes it: f32(256/48000) = `0x3BAEC33E`.
+pub const BLOCK_DELTA: f32 = f32::from_bits(0x3BAE_C33E);
+/// 2⁻³¹, the pick's scale for the generator's u32 draw.
+const TWO_POW_MINUS_31: f32 = f32::from_bits(0x3000_0000);
+const RECENT: u16 = 16;
+const MAX_CANDIDATES: usize = 64;
+
+/// GrainParams (vault `D18D1174735E5CDE`): seconds of source at pitch 1, the search window and the
+/// drift threshold (in position units).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct GrainParams {
+    pub attack: f32,
+    pub sustain: f32,
+    pub release: f32,
+    pub window: f32,
+    pub drift: f32,
+}
+
+impl GrainParams {
+    pub fn from_slice(v: &[f32]) -> Option<Self> {
+        match *v {
+            [attack, sustain, release, window, drift, ..] => Some(Self { attack, sustain, release, window, drift }),
+            _ => None,
+        }
+    }
+
+    /// The grain length L, summed as retail does: (sustain + release) + attack.
+    pub fn length(&self) -> f32 {
+        (self.sustain + self.release) + self.attack
+    }
+}
+
+/// The per-frame record the game writes (§2.2): send gain, pitch (1 = native), read position 0..1.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Record {
+    pub gain: f32,
+    pub pitch: f32,
+    pub position: f32,
+}
+
+impl Default for Record {
+    fn default() -> Self {
+        Self { gain: 1.0, pitch: 1.0, position: 0.0 }
+    }
+}
+
+/// A bound recording: the stored duration and mono PCM at its native rate.
+#[derive(Clone, Debug)]
+pub struct GrainSource {
+    pub name: String,
+    pub duration: f32,
+    pub pcm: Arc<Pcm>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Stage {
+    Attack,
+    Sustain,
+    Release,
+}
+
+/// What the scheduler did, for tests and traces.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Event {
+    Start { slot: usize, start: f32, position: f32 },
+    Release { slot: usize },
+    Stop { slot: usize },
+}
+
+/// The recently played windows: a start-sorted list holding a sentinel (−2, −1) after a reset,
+/// and how many windows were inserted since (retail's 16-entry pool hands out entries 1..15).
+#[derive(Clone, Debug)]
+struct Recent {
+    windows: Vec<(f32, f32)>,
+    /// Entry 0's window (the sentinel, or the window a collapse kept).
+    first: (f32, f32),
+    inserted: u16,
+    last: (f32, f32),
+}
+
+impl Recent {
+    fn new() -> Self {
+        Self { windows: vec![(-2.0, -1.0)], first: (-2.0, -1.0), inserted: 0, last: (-2.0, -1.0) }
+    }
+
+    fn collapse(&mut self) {
+        let keep = if self.inserted == 0 { self.first } else { self.last };
+        (self.windows, self.first, self.inserted) = (vec![keep], keep, 0);
+    }
+
+    fn insert(&mut self, w: (f32, f32)) {
+        let at = self.windows.iter().position(|e| !(e.0 < w.0)).unwrap_or(self.windows.len());
+        self.windows.insert(at, w);
+        self.inserted += 1;
+        self.last = w;
+    }
+}
+
+/// Tile the free interval [lo, hi], clamped to [low, high], with back-to-back windows of `len`
+/// while a whole window still fits (single precision), at most 64 in all.
+fn candidates(out: &mut Vec<(f32, f32)>, lo: f32, hi: f32, len: f32, low: f32, high: f32) {
+    if hi < low || lo > high {
+        return;
+    }
+    let mut lo = if lo >= low { lo } else { low };
+    let hi = if hi <= high { hi } else { high };
+    if hi - lo < len {
+        return;
+    }
+    loop {
+        out.push((lo, lo + len));
+        lo += len;
+        if hi - lo < len || lo + len > high || out.len() >= MAX_CANDIDATES {
+            return;
+        }
+    }
+}
+
+/// The equal-power fader (GaF0 with curve 1): g = from + (to − from)·√(n/N) rising,
+/// to + (from − to)·√(1 − n/N) falling; N = max(1, ⌊seconds·48000⌋) samples.
+#[derive(Clone, Debug)]
+struct Fader {
+    gain: f32,
+    from: f32,
+    to: f32,
+    n: u32,
+    total: u32,
+}
+
+impl Fader {
+    fn new() -> Self {
+        Self { gain: 1.0, from: 1.0, to: 1.0, n: 0, total: 0 }
+    }
+
+    fn fade(&mut self, to: f32, seconds: f32) {
+        let total = ((seconds * crate::MIX_RATE as f32) as i64).max(1) as u32;
+        (self.from, self.to, self.n, self.total) = (self.gain, to, 0, total);
+    }
+
+    fn apply(&mut self, x: &mut [f32]) {
+        for s in x.iter_mut() {
+            if self.total > 0 {
+                let f = self.n as f32 / self.total as f32;
+                self.gain = if self.to >= self.from {
+                    self.from + (self.to - self.from) * f.sqrt()
+                } else {
+                    self.to + (self.from - self.to) * (1.0 - f).sqrt()
+                };
+                self.n += 1;
+                if self.n >= self.total {
+                    self.total = 0;
+                    self.gain = self.to;
+                }
+            }
+            *s *= self.gain;
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct Voice {
+    pcm: Arc<Pcm>,
+    resampler: Resampler,
+    started: bool,
+    fader: Fader,
+    send: Send,
+}
+
+impl Voice {
+    fn new(pcm: Arc<Pcm>, start: f32, gain: f32) -> Self {
+        let frame = (f64::from(pcm.rate) * f64::from(start)).floor().max(0.0) as u64;
+        let mut fader = Fader::new();
+        fader.gain = 0.0;
+        let mut send = Send::default();
+        send.target = gain;
+        let mut resampler = Resampler::default();
+        resampler.position = frame;
+        Self { pcm, resampler, started: false, fader, send }
+    }
+
+    fn render(&mut self, pitch: f32, gain: f32, bus: &mut [[f32; BLOCK]; 6]) {
+        let mut buf = [0.0f32; BLOCK];
+        if self.started {
+            self.resampler.set_ratio(ratio(self.pcm.rate, pitch));
+            let data = self.pcm.channels.first().map_or(&[][..], |c| &c[..]);
+            self.resampler.render(&mut buf, |i| data.get(i as usize).copied().unwrap_or(0.0));
+            self.resampler.advance(BLOCK);
+        }
+        self.started = true;
+        self.fader.apply(&mut buf);
+        self.send.target = gain;
+        self.send.process(&[&buf], &[(0, 0, 1.0)], bus, Mode::Normal);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct Slot {
+    voice: Option<Voice>,
+    timer: f32,
+    start: f32,
+    picked_at: f32,
+    stage: Stage,
+}
+
+impl Slot {
+    fn new() -> Self {
+        Self { voice: None, timer: 0.0, start: 0.0, picked_at: 0.0, stage: Stage::Attack }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct GrainPlayer {
+    pub params: GrainParams,
+    pub record: Record,
+    source: Option<Arc<GrainSource>>,
+    slots: [Slot; 2],
+    active: usize,
+    recent: Recent,
+    /// Retail's hold flag (+36): cleared on bind, no known writer (spec §2.4).
+    pub hold: bool,
+    /// Release de-click of voices torn down since the last render (bus channel 0).
+    fold: f32,
+    /// Scheduler events since the last [`GrainPlayer::take_events`] (kept only when `trace`).
+    pub trace: bool,
+    events: Vec<Event>,
+    /// Voices started since construction.
+    pub starts: u64,
+}
+
+impl Default for GrainPlayer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GrainPlayer {
+    pub fn new() -> Self {
+        Self {
+            // Constructor defaults (always overwritten on bind).
+            params: GrainParams { attack: 0.01, sustain: 0.5, release: 0.01, window: 4.0, drift: 0.05 },
+            record: Record::default(),
+            source: None,
+            slots: [Slot::new(), Slot::new()],
+            active: 0,
+            recent: Recent::new(),
+            hold: false,
+            fold: 0.0,
+            trace: false,
+            events: Vec::new(),
+            starts: 0,
+        }
+    }
+
+    pub fn bound(&self) -> Option<&GrainSource> {
+        self.source.as_deref()
+    }
+
+    /// A torn-down voice's release de-click is still to be rendered.
+    pub fn pending(&self) -> bool {
+        self.fold != 0.0
+    }
+
+    pub fn voices(&self) -> usize {
+        self.slots.iter().filter(|s| s.voice.is_some()).count()
+    }
+
+    pub fn take_events(&mut self) -> Vec<Event> {
+        std::mem::take(&mut self.events)
+    }
+
+    fn log(&mut self, e: Event) {
+        if self.trace {
+            self.events.push(e);
+        }
+    }
+
+    /// Bind a recording (§2.5): reset the recent list, take the params, pick and start a voice in
+    /// slot 0 at once. The record should already hold this frame's values.
+    pub fn bind(&mut self, source: Arc<GrainSource>, params: GrainParams, rng: &mut Rng) {
+        self.stop();
+        self.recent = Recent::new();
+        self.active = 0;
+        self.hold = false;
+        self.params = params;
+        self.source = Some(source);
+        let start = self.pick(rng);
+        self.start_voice(0, start);
+    }
+
+    /// Stop both voices without a release fade and unbind (§2.5 "stop the player").
+    pub fn stop(&mut self) {
+        if self.source.is_none() {
+            return;
+        }
+        for i in 0..2 {
+            self.stop_voice(i);
+        }
+        self.source = None;
+    }
+
+    fn stop_voice(&mut self, i: usize) {
+        if let Some(v) = self.slots[i].voice.take() {
+            self.fold += v.send.last[0];
+            self.log(Event::Stop { slot: i });
+        }
+    }
+
+    fn release(&mut self, i: usize) {
+        let release = self.params.release;
+        let s = &mut self.slots[i];
+        s.timer = release;
+        s.stage = Stage::Release;
+        if let Some(v) = &mut s.voice {
+            v.fader.fade(0.0, release);
+        }
+        self.log(Event::Release { slot: i });
+    }
+
+    fn start_voice(&mut self, i: usize, start: f32) {
+        let Some(source) = self.source.clone() else { return };
+        let at = if !(start >= 0.0) { 0.0 } else if !(start <= source.duration) { source.duration } else { start };
+        let mut voice = Voice::new(source.pcm.clone(), at, self.record.gain);
+        voice.fader.fade(1.0, self.params.attack);
+        self.stop_voice(i);
+        let position = self.record.position;
+        self.slots[i] = Slot { voice: Some(voice), timer: self.params.attack, start: at, picked_at: position, stage: Stage::Attack };
+        self.starts += 1;
+        self.log(Event::Start { slot: i, start: at, position });
+    }
+
+    /// The next grain's start time (§2.3).
+    pub fn pick(&mut self, rng: &mut Rng) -> f32 {
+        let duration = self.source.as_ref().map_or(0.0, |s| s.duration);
+        self.pick_in(duration, rng)
+    }
+
+    fn pick_in(&mut self, duration: f32, rng: &mut Rng) -> f32 {
+        let p = self.params;
+        let len = p.length();
+        let target = (duration - p.window) * self.record.position;
+        let fits = crate::mixmap::tables::trunc(p.window / len);
+        let end = p.window + target;
+        // A collapse leaves one window; retry at most a few times (retail retries until a window
+        // fits, which cannot loop for a region of ≥ 2 windows unless one sits in its middle).
+        for _ in 0..4 {
+            let mut found = Vec::with_capacity(MAX_CANDIDATES);
+            let head = self.recent.windows[0];
+            if !(target >= head.0) {
+                candidates(&mut found, target, head.0, len, target, end);
+            }
+            for k in 0..self.recent.windows.len() {
+                let lo = self.recent.windows[k].1;
+                let hi = self.recent.windows.get(k + 1).map_or(duration, |w| w.0);
+                if found.len() < MAX_CANDIDATES {
+                    candidates(&mut found, lo, hi, len, target, end);
+                }
+            }
+            if found.is_empty() || self.recent.inserted == RECENT - 1 {
+                self.recent.collapse();
+                if fits > 1 {
+                    continue;
+                }
+                return target;
+            }
+            let r = rng.draw();
+            let index = crate::mixmap::tables::trunc(((r as f32 * TWO_POW_MINUS_31) * 0.5) * found.len() as f32);
+            // r within 128 of 2³² rounds the index to the count: retail reads an unfilled record.
+            let w = usize::try_from(index).ok().and_then(|i| found.get(i).copied()).unwrap_or((-1.0, -1.0));
+            self.recent.insert(w);
+            return w.0;
+        }
+        target
+    }
+
+    /// The per-block scheduler (§2.4), `delta` seconds since the last block.
+    pub fn tick(&mut self, delta: f32, rng: &mut Rng) {
+        if self.source.is_none() {
+            return;
+        }
+        let a = self.active;
+        let drift = self.slots[a].picked_at - self.record.position;
+        let threshold = self.params.drift;
+        if (drift > threshold || !(drift >= -threshold)) && !self.hold && self.slots[a].voice.is_some() {
+            let o = 1 - a;
+            if self.slots[o].voice.is_some() {
+                if self.slots[o].stage != Stage::Release {
+                    self.release(o);
+                }
+            } else {
+                if self.slots[a].stage != Stage::Release {
+                    self.release(a);
+                }
+                let start = self.pick(rng);
+                self.start_voice(o, start);
+                self.active = o;
+            }
+        }
+        for i in 0..2 {
+            if self.slots[i].voice.is_none() {
+                continue;
+            }
+            let pitch = self.record.pitch;
+            let sustain = self.params.sustain;
+            let s = &mut self.slots[i];
+            s.timer = if s.stage == Stage::Sustain { (-delta).mul_add(pitch, s.timer) } else { s.timer - delta };
+            if s.timer >= 0.0 {
+                continue;
+            }
+            match s.stage {
+                Stage::Attack => {
+                    s.stage = Stage::Sustain;
+                    s.timer = sustain;
+                }
+                Stage::Sustain => {
+                    self.release(i);
+                    if !self.hold {
+                        let o = 1 - i;
+                        self.stop_voice(o);
+                        let start = self.pick(rng);
+                        self.start_voice(o, start);
+                        self.active = o;
+                    }
+                }
+                Stage::Release => self.stop_voice(i),
+            }
+        }
+    }
+
+    /// Render this block's voices into the player's mono bus (channel 0 of `bus`, added).
+    pub fn render(&mut self, bus: &mut [[f32; BLOCK]; 6]) {
+        if self.fold != 0.0 {
+            crate::dsp::send::fold_release(bus, &[self.fold, 0.0, 0.0, 0.0, 0.0, 0.0]);
+            self.fold = 0.0;
+        }
+        let (gain, pitch) = (self.record.gain, self.record.pitch);
+        for s in &mut self.slots {
+            if let Some(v) = &mut s.voice {
+                v.render(pitch, gain, bus);
+            }
+        }
+    }
+
+    /// Slot state for tests: (has voice, stage, timer, start).
+    pub fn slot(&self, i: usize) -> (bool, Stage, f32, f32) {
+        let s = &self.slots[i];
+        (s.voice.is_some(), s.stage, s.timer, s.start)
+    }
+
+    pub fn active(&self) -> usize {
+        self.active
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const A: GrainParams = GrainParams { attack: 0.1, sustain: 0.2, release: 0.1, window: 1.6, drift: 0.05 };
+    const B: GrainParams = GrainParams { attack: 0.2, sustain: 0.1, release: 0.2, window: 1.5, drift: 0.05 };
+    /// concrete_rough_hard's stored duration.
+    const DURATION: f32 = f32::from_bits(0x41AE_BC39);
+    const IMAGE_SEED: [u32; 6] = [0xF22D_0E56, 0x8831_26E9, 0xC624_DD2F, 0x0702_C49C, 0x9E35_3F7D, 0x6FDF_3B64];
+
+    fn picks(params: GrainParams, position: f32, seed: [u32; 6]) -> Vec<String> {
+        let mut p = GrainPlayer::new();
+        p.params = params;
+        p.record.position = position;
+        let mut rng = Rng::new(seed);
+        (0..24).map(|_| format!("{:.4}", p.pick_in(DURATION, &mut rng))).collect()
+    }
+
+    /// The PoC's golden pick sequences (`.local/audio-re/grains/grain_vectors.tsv`, PR #4's ported
+    /// pick driven from the zero and the image generator state).
+    #[test]
+    fn picks_match_the_golden_vectors() {
+        let golden: &[(&str, f32, &str, &str)] = &[
+            ("A", 0.0, "zero", "0.0000 0.4000 0.8000 0.0000 0.4000 0.0000 0.8000 0.0000 0.4000 0.0000 0.8000 0.0000 0.4000 0.0000 0.8000 0.0000 0.4000 0.0000 0.8000 0.0000 0.4000 0.0000 0.8000 0.0000"),
+            ("A", 0.0, "image", "0.4000 0.0000 0.8000 0.0000 0.4000 0.8000 0.0000 0.4000 0.8000 0.4000 0.0000 0.4000 0.8000 0.0000 0.4000 0.8000 0.0000 0.8000 0.4000 0.8000 0.0000 0.4000 0.8000 0.0000"),
+            ("A", 0.25, "zero", "5.0605 5.4605 5.8605 5.0605 5.4605 5.0605 5.8605 5.0605 5.4605 5.0605 5.8605 5.0605 5.4605 5.0605 5.8605 5.0605 5.4605 5.0605 5.8605 5.0605 5.4605 5.0605 5.8605 5.0605"),
+            ("A", 0.25, "image", "5.4605 5.0605 5.8605 5.0605 5.4605 5.8605 5.0605 5.4605 5.8605 5.4605 5.0605 5.4605 5.8605 5.0605 5.4605 5.8605 5.0605 5.8605 5.4605 5.8605 5.0605 5.4605 5.8605 5.0605"),
+            ("A", 0.63, "zero", "12.7524 13.1524 13.5524 13.9524 12.7524 13.1524 13.5524 13.9524 12.7524 13.1524 13.5524 13.9524 12.7524 13.1524 13.5524 13.9524 12.7524 13.1524 13.5524 13.9524 12.7524 13.1524 13.5524 13.9524"),
+            ("A", 0.63, "image", "13.1524 13.5524 13.9524 12.7524 13.1524 13.9524 12.7524 13.1524 13.5524 13.9524 13.1524 13.5524 13.9524 12.7524 13.1524 13.9524 13.1524 13.9524 13.1524 13.9524 12.7524 13.1524 13.9524 12.7524"),
+            ("A", 1.0, "zero", "20.2419 20.6419 21.0419 21.4419 20.2419 20.6419 21.0419 21.4419 20.2419 20.6419 21.0419 21.4419 20.2419 20.6419 21.0419 21.4419 20.2419 20.6419 21.0419 21.4419 20.2419 20.6419 21.0419 21.4419"),
+            ("A", 1.0, "image", "20.6419 21.0419 21.4419 20.2419 20.6419 21.4419 20.2419 20.6419 21.0419 21.4419 20.6419 21.0419 21.4419 20.2419 20.6419 21.4419 20.6419 21.4419 20.6419 21.4419 20.2419 20.6419 21.4419 20.2419"),
+            ("B", 0.0, "zero", "0.0000 0.5000 1.0000 0.0000 0.5000 0.0000 1.0000 0.0000 0.5000 0.0000 1.0000 0.0000 0.5000 0.0000 1.0000 0.0000 0.5000 0.0000 1.0000 0.0000 0.5000 0.0000 1.0000 0.0000"),
+            ("B", 0.0, "image", "0.5000 0.0000 1.0000 0.0000 0.5000 1.0000 0.0000 0.5000 1.0000 0.5000 0.0000 0.5000 1.0000 0.0000 0.5000 1.0000 0.0000 1.0000 0.5000 1.0000 0.0000 0.5000 1.0000 0.0000"),
+            ("B", 0.25, "zero", "5.0855 5.5855 6.0855 5.0855 5.5855 5.0855 6.0855 5.0855 5.5855 5.0855 6.0855 5.0855 5.5855 5.0855 6.0855 5.0855 5.5855 5.0855 6.0855 5.0855 5.5855 5.0855 6.0855 5.0855"),
+            ("B", 0.25, "image", "5.5855 5.0855 6.0855 5.0855 5.5855 6.0855 5.0855 5.5855 6.0855 5.5855 5.0855 5.5855 6.0855 5.0855 5.5855 6.0855 5.0855 6.0855 5.5855 6.0855 5.0855 5.5855 6.0855 5.0855"),
+            ("B", 0.63, "zero", "12.8154 13.3154 13.8154 12.8154 13.3154 12.8154 13.8154 12.8154 13.3154 12.8154 13.8154 12.8154 13.3154 12.8154 13.8154 12.8154 13.3154 12.8154 13.8154 12.8154 13.3154 12.8154 13.8154 12.8154"),
+            ("B", 0.63, "image", "13.3154 12.8154 13.8154 12.8154 13.3154 13.8154 12.8154 13.3154 13.8154 13.3154 12.8154 13.3154 13.8154 12.8154 13.3154 13.8154 12.8154 13.8154 13.3154 13.8154 12.8154 13.3154 13.8154 12.8154"),
+            ("B", 1.0, "zero", "20.3419 20.8419 21.3419 20.3419 20.8419 20.3419 21.3419 20.3419 20.8419 20.3419 21.3419 20.3419 20.8419 20.3419 21.3419 20.3419 20.8419 20.3419 21.3419 20.3419 20.8419 20.3419 21.3419 20.3419"),
+            ("B", 1.0, "image", "20.8419 20.3419 21.3419 20.3419 20.8419 21.3419 20.3419 20.8419 21.3419 20.8419 20.3419 20.8419 21.3419 20.3419 20.8419 21.3419 20.3419 21.3419 20.8419 21.3419 20.3419 20.8419 21.3419 20.3419"),
+        ];
+        for &(which, pos, seed, want) in golden {
+            let params = if which == "A" { A } else { B };
+            let got = picks(params, pos, if seed == "zero" { [0; 6] } else { IMAGE_SEED }).join(" ");
+            assert_eq!(got, want, "{which} pos {pos} seed {seed}");
+        }
+    }
+
+    /// The golden candidate tilings (CAND rows): 3 windows of 0.4 in [0, 1.6] (the 4th rounds out),
+    /// 3 of 0.5 in [5, 6.5], 4 of 0.4 in [19, 20.6].
+    #[test]
+    fn candidate_tiling_matches_the_golden_vectors() {
+        for (t, w, len, want) in [(0.0f32, 1.6f32, 0.4f32, vec![0.0, 0.4, 0.8]), (5.0, 1.5, 0.5, vec![5.0, 5.5, 6.0]), (19.0, 1.6, 0.4, vec![19.0, 19.4, 19.8, 20.2])] {
+            let mut out = Vec::new();
+            candidates(&mut out, -1.0, 21.84, len, t, t + w);
+            let got: Vec<String> = out.iter().map(|c| format!("{:.4}", c.0)).collect();
+            let want: Vec<String> = want.iter().map(|c| format!("{c:.4}")).collect();
+            assert_eq!(got, want);
+        }
+    }
+
+    fn source(seconds: f32) -> Arc<GrainSource> {
+        let rate = 48000;
+        let n = (seconds * rate as f32) as usize;
+        let data = (0..n).map(|i| ((i as f32) * 0.01).sin() * 0.5).collect();
+        Arc::new(GrainSource { name: "test".into(), duration: n as f32 / rate as f32, pcm: Arc::new(Pcm { rate, channels: vec![data] }) })
+    }
+
+    /// At pitch 1 and a fixed position, player A starts a grain every 0.1 + 0.2 s (quantised up to
+    /// blocks) and never runs more than two voices; B every 0.2 + 0.1 s (§2.4 table).
+    #[test]
+    fn steady_rhythm_and_two_voices_at_most() {
+        for (params, period) in [(A, 0.3f32), (B, 0.3)] {
+            let mut p = GrainPlayer::new();
+            p.trace = true;
+            p.record.position = 0.4;
+            let mut rng = Rng::new(IMAGE_SEED);
+            p.bind(source(20.0), params, &mut rng);
+            let mut starts = Vec::new();
+            let mut bus = [[0.0f32; BLOCK]; 6];
+            for block in 0..2000 {
+                p.tick(BLOCK_DELTA, &mut rng);
+                p.render(&mut bus);
+                assert!(p.voices() <= 2);
+                for e in p.take_events() {
+                    if let Event::Start { start, .. } = e {
+                        starts.push((block, start));
+                    }
+                }
+            }
+            let gaps: Vec<i32> = starts.windows(2).map(|w| w[1].0 - w[0].0).collect();
+            let expect = (period / BLOCK_DELTA).ceil() as i32;
+            assert!(gaps[1..].iter().all(|&g| (expect - 1..=expect + 1).contains(&g)), "{gaps:?} vs {expect}");
+            // Starts stay inside the search region [T, T + W].
+            let t = (20.0 - params.window) * 0.4;
+            assert!(starts.iter().all(|&(_, s)| s >= t - 1e-3 && s <= t + params.window));
+        }
+    }
+
+    /// A position jump beyond the drift threshold releases the grain and starts one in the
+    /// other slot at once.
+    #[test]
+    fn drift_cuts_the_grain() {
+        let mut p = GrainPlayer::new();
+        p.trace = true;
+        p.record.position = 0.1;
+        let mut rng = Rng::new(IMAGE_SEED);
+        p.bind(source(20.0), A, &mut rng);
+        p.take_events();
+        p.tick(BLOCK_DELTA, &mut rng);
+        assert!(p.take_events().is_empty());
+        p.record.position = 0.5;
+        p.tick(BLOCK_DELTA, &mut rng);
+        let events = p.take_events();
+        assert_eq!(events[0], Event::Release { slot: 0 });
+        assert!(matches!(events[1], Event::Start { slot: 1, position, .. } if position == 0.5));
+        assert_eq!(p.active(), 1);
+    }
+
+    /// Release and next attack overlap with square-root fades: g_in² + g_out² = 1.
+    #[test]
+    fn fades_are_equal_power() {
+        let mut a = Fader::new();
+        a.gain = 0.0;
+        a.fade(1.0, 0.1);
+        let mut b = Fader::new();
+        b.fade(0.0, 0.1);
+        let mut x = [1.0f32; BLOCK];
+        let mut y = [1.0f32; BLOCK];
+        a.apply(&mut x);
+        b.apply(&mut y);
+        for (gi, go) in x.iter().zip(y.iter()) {
+            assert!((gi * gi + go * go - 1.0).abs() < 1e-5);
+        }
+    }
+}
diff --git a/crates/skate-audio/src/lib.rs b/crates/skate-audio/src/lib.rs
new file mode 100644
index 00000000..6bb82b5f
--- /dev/null
+++ b/crates/skate-audio/src/lib.rs
@@ -0,0 +1,47 @@
+//! Native port of Skate 3's retail audio runtime, written from our own behavioural specs
+//! (`.claude/notes/aems-evaluator-spec.md`, `.claude/notes/aems-voice-graph-spec.md`).
+//!
+//! Engine independent: no Bevy, no file I/O, no unsafe code. The game (or a test) hands in bank and
+//! project bytes and PCM, posts messages, and pulls 48 kHz output blocks.
+//!
+//! Layers, each usable alone:
+//! - [`formats`]: the disc containers (`ABKC` module banks with their `S10A` sample banks, `MOIR` Csis
+//!   projects, EA SNR sample headers);
+//! - [`eval`]: the AEMS patch-program evaluator (instances, the 40 opcodes, the shared RNG, the 6-block
+//!   tick, Csis classes / functions / global variables) driving voices through the [`eval::VoiceHost`]
+//!   trait;
+//! - [`dsp`]: the voice-graph modules (linear resampler, RBJ high/low-pass biquads, de-click gain,
+//!   send ramps, the 2-D panner, channel routes and the output stage);
+//! - [`mixer`]: voices built from those modules, implementing [`eval::VoiceHost`];
+//! - [`runtime`]: evaluator + mixer on one block clock, with a game-side command queue;
+//! - [`mixmap`]: the MixMap mixer (`MixMapSK8.mxb`): game inputs → per-object volumes, pitches,
+//!   filter cutoffs and azimuths, once per 60 Hz frame;
+//! - [`grain`]: the granular rolling bed (`grains.big`): GrainPlayers picking windows of one long
+//!   slow-to-fast recording around a speed-driven read position, on the block clock;
+//! - [`player`]: the local player's audio state, its MixMap input writers (PlayerPhysics,
+//!   3DObjPos, Jitter, Contacts, Rail, OffBoard) and the player components that post AEMS
+//!   classes (grind, sense of speed, foot drag);
+//! - [`splice`]: the Splice one-shot player of the `SPLC` banks (pops, landings, touchdowns,
+//!   collisions), driven by owner blocks once per frame.
+//!
+//! Nothing here is code from upstream PR #4, skate3recomp or BurnoutDecomp (no licence); constants,
+//! offsets and opcode numbers are facts. See `docs/hails-additions/11-audio.md` (Credits).
+#![forbid(unsafe_code)]
+
+pub mod be;
+pub mod bus;
+pub mod dsp;
+pub mod eval;
+pub mod formats;
+pub mod grain;
+pub mod mixer;
+pub mod mixmap;
+pub mod player;
+pub mod runtime;
+pub mod splice;
+
+/// Mixer rate (Hz) and block size (frames) of the retail runtime.
+pub const MIX_RATE: u32 = 48_000;
+pub const BLOCK: usize = 256;
+/// Internal channel order of the 6-channel mix: L, C, R, Ls, Rs, LFE.
+pub const CHANNELS: usize = 6;
diff --git a/crates/skate-audio/src/mixer.rs b/crates/skate-audio/src/mixer.rs
new file mode 100644
index 00000000..3a649fec
--- /dev/null
+++ b/crates/skate-audio/src/mixer.rs
@@ -0,0 +1,805 @@
+//! The voice graph and the default bus (spec: `.claude/notes/aems-voice-graph-spec.md` §3–§6).
+//!
+//! Per voice: SndPlayer1 (PCM source with loop, end, first-block format change, 16-frame stop
+//! fade) → Rechannel (no-op: our PCM always has the header's channel count) → Resample → HighPassIir2
+//! → LowPassIir2 → Send A (pre-gain, N → 1 into the environment bus at master × FXWET0) → Gain
+//! (master × dry) → [Send B: N → 1 into a FlangeSub return at property 11, when the routing
+//! records ask for one] → Pan2D1 (6 outputs) → Send (6 → 6) into its output bus: an eEQChain bus
+//! (routing codes 0–7, or 10–17 = re-roll the bus's EQ on first use) or SFX Master
+//! ([`crate::bus`]). Direct (Splice / stream) voices take a [`Route`] instead: their bus and the
+//! env send of the owner one-shot bus they play through.
+//!
+//! Not modelled (UNCERTAIN in the spec): the 512/2048 buses — their codes are parsed and kept on
+//! the voice. Send B renders only while the returns are enabled ([`crate::bus::flange`]).
+//! The sample-group "level %" byte is not applied as gain (spec §3.4: its meaning is unproven).
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::dsp::biquad::{Iir2, Kind};
+use crate::dsp::gain::Gain;
+use crate::dsp::pan::{self, Pan2D};
+use crate::dsp::resample::{Resampler, ratio};
+use crate::dsp::routes::to_six;
+use crate::dsp::send::{Mode, Send, fold_release};
+use crate::dsp::{DEGREES_PER_UNIT, INV_32767};
+use crate::bus::env::Level;
+use crate::bus::{Buses, Output, Route};
+use crate::eval::{OpenRequest, VoiceHost, VoiceStatus};
+use crate::formats::SampleHeader;
+use crate::{BLOCK, MIX_RATE};
+
+/// Decoded sample: planar f32 channels at the header's rate.
+#[derive(Clone, Debug)]
+pub struct Pcm {
+    pub rate: u32,
+    pub channels: Vec<Vec<f32>>,
+}
+
+/// Routing selected by a voice's input records with id ≥ 9 at open (evaluator spec §5.4).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Routing {
+    /// eEQChain bus 0..7 and whether resolving it re-rolls its EQ (codes 0–7: no; 10–17: yes).
+    pub output_bus: Option<(u8, bool)>,
+    /// Effect return (codes 4096/8192 → 0, 16384 → 1) and its level.
+    pub effect: Option<(u8, f32)>,
+    /// Fixed buses (codes 512 / 2048).
+    pub fixed: Option<u16>,
+}
+
+impl Routing {
+    pub fn parse(inputs: &[(u8, i32)]) -> Self {
+        let mut r = Self::default();
+        let mut k = 0;
+        while k < inputs.len() {
+            let (id, v) = inputs[k];
+            k += 1;
+            if id < 9 {
+                continue;
+            }
+            match v {
+                4096 | 8192 | 16384 => {
+                    let enable = inputs.get(k).map(|e| e.1);
+                    let level = inputs.get(k + 1).map(|e| e.1);
+                    k += 2;
+                    if enable == Some(1) {
+                        let bus = u8::from(v == 16384);
+                        r.effect = Some((bus, level.unwrap_or(0) as f32 * INV_32767));
+                    }
+                }
+                512 | 2048 => r.fixed = Some(v as u16),
+                0..=7 => r.output_bus = Some((v as u8, false)),
+                10..=17 => r.output_bus = Some(((v - 10) as u8, true)),
+                _ => {}
+            }
+        }
+        r
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum State {
+    Playing,
+    /// Fading out for the pause, then frozen.
+    Pausing,
+    Paused,
+    Resuming,
+    /// Released while sounding: one 16-frame stop-fade block, then removed.
+    Releasing,
+}
+
+struct Voice {
+    id: u32,
+    bank: usize,
+    slot: u16,
+    header: SampleHeader,
+    pcm: Option<Arc<Pcm>>,
+    started: bool,
+    state: State,
+    resampler: Resampler,
+    pitch: f32,
+    hpf: Iir2,
+    lpf: Iir2,
+    master: f32,
+    dry: f32,
+    fx: f32,
+    gain: Gain,
+    pan: Pan2D,
+    send: Send,
+    routing: Routing,
+    /// The final Send's bus.
+    output: Output,
+    /// Send A (pre-gain, N → 1 into the environment bus), level master × FXWET0.
+    env: Level,
+    /// The owner one-shot bus's env send (6 → 1 after the panner), 0 = none.
+    owner_env: Level,
+    /// Send B (post-gain, N → 1 into the FlangeSub return of `routing.effect`), property 11.
+    fx_send: Level,
+    /// The output bus is a mono submix ([`Route::mono`]): the final Send sums L..Rs into the
+    /// bus's centre.
+    mono_out: bool,
+    /// The bank's volume group ([`Mixer::group_gain`]).
+    group: u8,
+    /// Stop fade: (source index where it starts, per-channel last sample).
+    fade: Option<(u64, [f32; 8])>,
+    done: bool,
+}
+
+impl Voice {
+    fn total(&self) -> u64 {
+        u64::from(self.header.frames)
+    }
+
+    /// Source frame index for a virtual (ever-increasing) position, following the loop.
+    fn index(&self, i: u64) -> Option<u64> {
+        let total = self.total();
+        if i < total {
+            return Some(i);
+        }
+        let start = u64::from(self.header.loop_start?);
+        if start >= total {
+            return None;
+        }
+        Some(start + (i - total) % (total - start))
+    }
+
+    fn sample(&self, ch: usize, i: u64) -> f32 {
+        if let Some((from, last)) = self.fade {
+            if i >= from {
+                let k = i - from;
+                return if k < 16 { last[ch] - k as f32 * last[ch] / 16.0 } else { 0.0 };
+            }
+        }
+        match (&self.pcm, self.index(i)) {
+            (Some(pcm), Some(idx)) => pcm.channels.get(ch).and_then(|c| c.get(idx as usize)).copied().unwrap_or(0.0),
+            _ => 0.0,
+        }
+    }
+
+    /// Elapsed source time (s): the position inside the sample.
+    fn elapsed(&self) -> f64 {
+        let at = self.index(self.resampler.position).unwrap_or(self.total());
+        at as f64 / f64::from(self.header.rate)
+    }
+
+    fn render(&mut self, master: &mut [[f32; BLOCK]; 6], buses: &mut Buses, user: f32) {
+        let channels = (self.header.channels as usize).clamp(1, 6);
+        let mut src = [[0.0f32; BLOCK]; 6];
+        if self.started {
+            self.resampler.set_ratio(ratio(self.header.rate, self.pitch));
+            for (c, out) in src.iter_mut().enumerate().take(channels) {
+                let me = &*self;
+                self.resampler.render(out, |i| me.sample(c, i));
+            }
+            self.resampler.advance(BLOCK);
+            if self.header.loop_start.is_none() && self.resampler.position >= self.total() {
+                self.done = true;
+            }
+        }
+        // A new player publishes its format with 0 frames: the first block is silent.
+        self.started = true;
+        {
+            let (head, _) = src.split_at_mut(channels);
+            let mut planes: Vec<&mut [f32]> = head.iter_mut().map(|c| &mut c[..]).collect();
+            self.hpf.process(&mut planes, MIX_RATE as f32);
+            self.lpf.process(&mut planes, MIX_RATE as f32);
+        }
+        // Send A: the channels summed to mono (routes N → 1 at unity, LFE dropped), our user volume
+        // applied like on the dry path.
+        self.env.target = self.master * self.fx * user;
+        if !self.env.silent() {
+            let mut mono = [0.0f32; BLOCK];
+            for c in src.iter().take(channels.min(5)) {
+                for (m, x) in mono.iter_mut().zip(c.iter()) {
+                    *m += x;
+                }
+            }
+            self.env.add(&mono, &mut buses.env_in[..]);
+        }
+        {
+            let (head, _) = src.split_at_mut(channels);
+            let mut planes: Vec<&mut [f32]> = head.iter_mut().map(|c| &mut c[..]).collect();
+            self.gain.target = self.master * self.dry;
+            self.gain.process(&mut planes);
+        }
+        // Send B (`sub_824A3140`: only with an enabled effect record; level posted 0 at open, then
+        // property 11 / 32767), our user volume applied like on the other paths.
+        if let Some((ret, level)) = self.routing.effect {
+            if buses.flange.enabled() {
+                let r = usize::from(ret.min(1));
+                buses.flange_active[r] = true;
+                self.fx_send.target = level * user;
+                if !self.fx_send.silent() {
+                    let mut mono = [0.0f32; BLOCK];
+                    for c in src.iter().take(channels.min(5)) {
+                        for (m, x) in mono.iter_mut().zip(c.iter()) {
+                            *m += x;
+                        }
+                    }
+                    self.fx_send.add(&mono, &mut buses.flange_in[r][..]);
+                }
+            }
+        }
+        let mut six = [[0.0f32; BLOCK]; 6];
+        let planes: Vec<&[f32]> = src[..channels].iter().map(|c| &c[..]).collect();
+        self.pan.process(&planes, &mut six);
+        // Our own user volume of the voice's group (1 = retail level), after the retail graph.
+        if user != 1.0 {
+            for ch in six.iter_mut() {
+                for x in ch.iter_mut() {
+                    *x *= user;
+                }
+            }
+        }
+        let mode = match self.state {
+            State::Pausing => Mode::FadeOut,
+            State::Resuming => Mode::FadeIn,
+            _ => Mode::Normal,
+        };
+        if !self.owner_env.silent() {
+            let mut mono = [0.0f32; BLOCK];
+            for c in six.iter().take(5) {
+                for (m, x) in mono.iter_mut().zip(c.iter()) {
+                    *m += x;
+                }
+            }
+            self.owner_env.add(&mono, &mut buses.env_in[..]);
+        }
+        let outs: Vec<&[f32]> = six.iter().map(|c| &c[..]).collect();
+        let bus = buses.target(self.output, master);
+        let routes = if self.mono_out { SIX_TO_MONO_CENTRE } else { to_six(6) };
+        self.send.process(&outs, routes, bus, mode);
+        self.state = match self.state {
+            State::Pausing => State::Paused,
+            State::Resuming => State::Playing,
+            s => s,
+        };
+    }
+}
+
+/// A 6-channel send into a mono submix that sends on into its bus's centre: routes 6 → 1 (L, C,
+/// R, Ls, Rs at unity, LFE dropped; image tables 0x820ED700 / 0x820ED780) then 1 → 6 (centre).
+const SIX_TO_MONO_CENTRE: &[crate::dsp::routes::Route] = &[(0, 1, 1.0), (1, 1, 1.0), (2, 1, 1.0), (3, 1, 1.0), (4, 1, 1.0)];
+
+/// A live voice as [`Mixer::snapshot`] reports it.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct VoiceInfo {
+    pub id: u32,
+    pub bank: usize,
+    pub slot: u16,
+    pub gain: f32,
+    pub pitch: f32,
+    pub paused: bool,
+    /// Send A (env) level: master × FXWET0, and the owner bus's env send (direct voices).
+    pub send: f32,
+    /// The output bus.
+    pub output: Output,
+}
+
+/// Per loaded bank: sample headers and decoded PCM by S10A slot.
+struct BankSamples {
+    headers: Vec<Option<SampleHeader>>,
+    pcm: Vec<Option<Arc<Pcm>>>,
+    group: u8,
+}
+
+/// Volume groups of the banks (our user volumes; retail has none): world sounds (emitters,
+/// ambience) and the player's own sounds.
+pub const GROUP_WORLD: u8 = 0;
+pub const GROUP_PLAYER: u8 = 1;
+
+pub struct Mixer {
+    voices: Vec<Voice>,
+    /// The environment network and the eEQChain buses behind the voices.
+    pub buses: Buses,
+    next: u32,
+    banks: HashMap<usize, BankSamples>,
+    /// Release de-click values for the next block.
+    fold: [f32; 6],
+    /// User volume per bank group ([`GROUP_WORLD`], [`GROUP_PLAYER`]).
+    pub group_gain: [f32; 2],
+    /// Most voices that may sound at once; further opens fail (retail retires voices by CPU
+    /// budget instead, spec §6.6).
+    pub max_voices: usize,
+    /// Opens refused because of `max_voices` or a missing sample.
+    pub refused: u64,
+}
+
+impl Default for Mixer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Mixer {
+    pub fn new() -> Self {
+        Self { voices: Vec::new(), buses: Buses::default(), next: 0, banks: HashMap::new(), fold: [0.0; 6], group_gain: [1.0; 2], max_voices: 96, refused: 0 }
+    }
+
+    /// Register a bank's sample headers (by slot) and PCM (None = play silence for the sample's
+    /// duration, so programs keep their timing).
+    pub fn add_bank(&mut self, bank: usize, headers: Vec<Option<SampleHeader>>, pcm: Vec<Option<Arc<Pcm>>>) {
+        self.banks.insert(bank, BankSamples { headers, pcm, group: GROUP_WORLD });
+    }
+
+    /// Put a bank's voices in a volume group (voices opened from then on).
+    pub fn set_bank_group(&mut self, bank: usize, group: u8) {
+        if let Some(b) = self.banks.get_mut(&bank) {
+            b.group = group.min(1);
+        }
+    }
+
+    pub fn remove_bank(&mut self, bank: usize) {
+        self.banks.remove(&bank);
+    }
+
+    /// What each live voice is playing and at which gain (master × dry, before pan and sends):
+    /// for diagnostics and tests.
+    pub fn snapshot(&self) -> Vec<VoiceInfo> {
+        self.voices
+            .iter()
+            .map(|v| VoiceInfo {
+                id: v.id,
+                bank: v.bank,
+                slot: v.slot,
+                gain: v.master * v.dry,
+                pitch: v.pitch,
+                paused: v.state == State::Paused,
+                send: v.master * v.fx + v.owner_env.target,
+                output: v.output,
+            })
+            .collect()
+    }
+
+    pub fn voice_count(&self) -> usize {
+        self.voices.len()
+    }
+
+    fn voice(&mut self, id: u32) -> Option<&mut Voice> {
+        self.voices.iter_mut().find(|v| v.id == id)
+    }
+
+    /// A Splice voice (`crate::splice`): SndPlayer1 from `seek` seconds into the sample →
+    /// Resample (pitch) → Gain → Pan2D1 (mono at `azimuth` degrees; multichannel at its default
+    /// layout) → Send into the default bus. The filters stay at their bypassing class defaults.
+    pub fn open_direct(&mut self, bank: usize, slot: u16, seek: f64, pitch: f32, gain: f32, azimuth: Option<f32>) -> Option<u32> {
+        self.open_routed(bank, slot, seek, pitch, gain, azimuth, Route::default())
+    }
+
+    /// [`Mixer::open_direct`] into `route` (its eEQChain bus, resolved now, and the owner bus's env
+    /// send).
+    #[allow(clippy::too_many_arguments)]
+    pub fn open_routed(&mut self, bank: usize, slot: u16, seek: f64, pitch: f32, gain: f32, azimuth: Option<f32>, route: Route) -> Option<u32> {
+        let samples = self.banks.get(&bank);
+        let header = samples.and_then(|b| b.headers.get(usize::from(slot)).copied().flatten());
+        let Some(header) = header else {
+            self.refused += 1;
+            return None;
+        };
+        if self.voices.len() >= self.max_voices {
+            self.refused += 1;
+            return None;
+        }
+        let pcm = samples.and_then(|b| b.pcm.get(usize::from(slot)).cloned().flatten());
+        let group = samples.map_or(GROUP_WORLD, |b| b.group);
+        self.next = self.next.wrapping_add(1).max(1);
+        let channels = (header.channels as usize).clamp(1, 6);
+        let mut pan = Pan2D::new(channels);
+        if channels == 1 {
+            pan.params[pan::ANGLE] = azimuth.unwrap_or(0.0);
+        }
+        let mut resampler = Resampler::default();
+        resampler.position = (seek.max(0.0) * f64::from(header.rate)) as u64;
+        if let Output::Eq(i) = route.output {
+            self.buses.eq.resolve(i, route.create);
+        }
+        self.voices.push(Voice {
+            id: self.next,
+            bank,
+            slot,
+            header,
+            pcm,
+            started: false,
+            state: State::Playing,
+            resampler,
+            pitch,
+            hpf: Iir2::new(Kind::HighPass),
+            lpf: Iir2::new(Kind::LowPass),
+            master: gain,
+            dry: 1.0,
+            fx: 0.0,
+            gain: Gain::default(),
+            pan,
+            send: Send::default(),
+            routing: Routing::default(),
+            output: route.output,
+            env: Level::new(0.0),
+            owner_env: Level::new(route.owner_env),
+            fx_send: Level::new(0.0),
+            mono_out: route.mono,
+            group,
+            fade: None,
+            done: false,
+        });
+        Some(self.next)
+    }
+
+    /// The Splice voice's per-frame values.
+    pub fn set_direct(&mut self, voice: u32, pitch: f32, gain: f32, azimuth: Option<f32>) {
+        if let Some(v) = self.voice(voice) {
+            v.pitch = pitch;
+            v.master = gain;
+            if let (1, Some(a)) = (v.pan.sources(), azimuth) {
+                v.pan.params[pan::ANGLE] = a;
+            }
+        }
+    }
+
+    /// The voice still plays (not ended, released or gone).
+    pub fn direct_alive(&self, voice: u32) -> bool {
+        self.voices.iter().any(|v| v.id == voice && !v.done && v.state != State::Releasing)
+    }
+
+    /// Render one block of SFX Master (6 channels, overwritten): the voices into their buses, then
+    /// the environment network and the eEQChain buses.
+    pub fn render(&mut self, bus: &mut [[f32; BLOCK]; 6]) {
+        self.render_with_env(bus, None);
+    }
+
+    /// [`Mixer::render`] with another contributor's mono input to the environment bus, added after
+    /// the voices' (the grain chains' graph 2, pass order 5 after the voices' 0).
+    pub fn render_with_env(&mut self, bus: &mut [[f32; BLOCK]; 6], env: Option<&[f32; BLOCK]>) {
+        for ch in bus.iter_mut() {
+            *ch = [0.0; BLOCK];
+        }
+        self.buses.clear_inputs();
+        fold_release(bus, &self.fold);
+        self.fold = [0.0; 6];
+        for v in &mut self.voices {
+            if v.state != State::Paused {
+                let user = self.group_gain[usize::from(v.group)];
+                v.render(bus, &mut self.buses, user);
+            }
+        }
+        if let Some(env) = env {
+            for (d, &x) in self.buses.env_in.iter_mut().zip(env.iter()) {
+                *d += x;
+            }
+        }
+        self.buses.render(bus);
+        // Voices that played their stop fade leave now.
+        let mut fold = [0.0f32; 6];
+        self.voices.retain(|v| {
+            if v.state == State::Releasing {
+                for (f, l) in fold.iter_mut().zip(v.send.last) {
+                    *f += l;
+                }
+                false
+            } else {
+                true
+            }
+        });
+        self.fold = fold;
+    }
+}
+
+impl VoiceHost for Mixer {
+    fn open(&mut self, r: &OpenRequest) -> Option<u32> {
+        let samples = self.banks.get(&r.bank);
+        let header = samples.and_then(|b| b.headers.get(r.slot as usize).copied().flatten());
+        let Some(header) = header else {
+            self.refused += 1;
+            return None;
+        };
+        if self.voices.len() >= self.max_voices {
+            self.refused += 1;
+            return None;
+        }
+        let pcm = samples.and_then(|b| b.pcm.get(r.slot as usize).cloned().flatten());
+        let group = samples.map_or(GROUP_WORLD, |b| b.group);
+        self.next = self.next.wrapping_add(1).max(1);
+        let routing = Routing::parse(r.inputs);
+        if let Some((i, create)) = routing.output_bus {
+            self.buses.eq.resolve(i, create);
+        }
+        let channels = (header.channels as usize).clamp(1, 6);
+        let mut pan = Pan2D::new(channels);
+        let angle = |byte: u8| f32::from(u16::from(byte) << 8) * DEGREES_PER_UNIT;
+        // Initial panner angles from the sample-group entry (spec §3.4); the census of all banks
+        // shows per-channel azimuths, e.g. stereo 224/32 = −45°/+45°.
+        match channels {
+            1 => pan.params[pan::ANGLE] = angle(r.azimuth[0]),
+            2 => {
+                pan.params[pan::DISTANCE] = 0.0;
+                pan.params[pan::SPREAD1] = angle(r.azimuth[1]);
+            }
+            4 => {
+                pan.params[pan::DISTANCE] = 0.0;
+                pan.params[pan::SPREAD1] = angle(r.azimuth[1]);
+                pan.params[pan::SPREAD2] = angle(r.azimuth[3]);
+            }
+            _ => {
+                pan.params[pan::DISTANCE] = 0.0;
+                pan.params[pan::SPREAD1] = angle(r.azimuth[2]);
+                pan.params[pan::SPREAD2] = angle(r.azimuth[4]);
+            }
+        }
+        self.voices.push(Voice {
+            id: self.next,
+            bank: r.bank,
+            slot: r.slot,
+            header,
+            pcm,
+            started: false,
+            state: State::Playing,
+            resampler: Resampler::default(),
+            pitch: 1.0,
+            hpf: Iir2::new(Kind::HighPass),
+            lpf: Iir2::new(Kind::LowPass),
+            master: 1.0,
+            dry: 1.0,
+            fx: 0.0,
+            gain: Gain::default(),
+            pan,
+            send: Send::default(),
+            routing,
+            output: routing.output_bus.map_or(Output::Master, |(i, _)| Output::Eq(i)),
+            // Send A is posted 0 at open; property 5 / 2 set it.
+            env: Level::new(0.0),
+            owner_env: Level::new(0.0),
+            fx_send: Level::new(0.0),
+            mono_out: false,
+            group,
+            fade: None,
+            done: false,
+        });
+        Some(self.next)
+    }
+
+    fn release(&mut self, voice: u32) {
+        let Some(at) = self.voices.iter().position(|v| v.id == voice) else { return };
+        let v = &mut self.voices[at];
+        if v.started && !v.done && v.state != State::Paused {
+            // SndPlayer flush: each channel's last sample decays to zero over 16 frames.
+            let mut last = [0.0f32; 8];
+            let from = v.resampler.position;
+            for (c, l) in last.iter_mut().enumerate().take(v.header.channels as usize) {
+                *l = v.sample(c, from);
+            }
+            v.fade = Some((from, last));
+            v.state = State::Releasing;
+        } else {
+            let gone = self.voices.remove(at);
+            for (f, l) in self.fold.iter_mut().zip(gone.send.last) {
+                *f += l;
+            }
+        }
+    }
+
+    fn pause(&mut self, voice: u32) {
+        if let Some(v) = self.voice(voice) {
+            if matches!(v.state, State::Playing | State::Resuming) {
+                v.state = State::Pausing;
+            }
+        }
+    }
+
+    fn resume(&mut self, voice: u32) {
+        if let Some(v) = self.voice(voice) {
+            if matches!(v.state, State::Paused | State::Pausing) {
+                v.state = State::Resuming;
+            }
+        }
+    }
+
+    fn set(&mut self, voice: u32, id: u8, value: i32) {
+        let Some(v) = self.voice(voice) else { return };
+        match id {
+            0 => v.pitch = value as f32 / 4096.0,
+            2 => v.master = value as f32 * INV_32767,
+            8 => v.dry = value as f32 * INV_32767,
+            5 => v.fx = value as f32 * INV_32767,
+            6 => v.lpf.cutoff = value as f32,
+            7 => v.hpf.cutoff = value as f32,
+            11 => {
+                if let Some((_, level)) = &mut v.routing.effect {
+                    *level = value as f32 * INV_32767;
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn set_azimuth(&mut self, voice: u32, value: i32) {
+        if let Some(v) = self.voice(voice) {
+            if v.pan.sources() == 1 {
+                v.pan.params[pan::ANGLE] = value as f32 * DEGREES_PER_UNIT;
+            }
+        }
+    }
+
+    fn query(&mut self, voice: u32) -> VoiceStatus {
+        let Some(v) = self.voice(voice) else { return VoiceStatus::default() };
+        if v.done || v.state == State::Releasing {
+            return VoiceStatus::default();
+        }
+        let duration = v.header.seconds();
+        let elapsed = v.elapsed();
+        VoiceStatus { alive: true, remaining_ms: ((duration - elapsed) * 1000.0) as i32, elapsed_ms: (elapsed * 1000.0) as i32 }
+    }
+}
+
+impl Voice {
+    #[cfg(test)]
+    fn routing(&self) -> Routing {
+        self.routing
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn mono(seconds: f64, rate: u32, looping: bool) -> (SampleHeader, Arc<Pcm>) {
+        let frames = (seconds * f64::from(rate)) as u32;
+        let header = SampleHeader { codec: 3, channels: 1, rate, frames, loop_start: looping.then_some(0) };
+        let data: Vec<f32> = (0..frames).map(|i| (i as f32 * 0.05).sin() * 0.5).collect();
+        (header, Arc::new(Pcm { rate, channels: vec![data] }))
+    }
+
+    fn request(slot: u16) -> OpenRequest<'static> {
+        OpenRequest { bank: 0, slot, level: 100, azimuth: [0; 6], stream_offset: u32::MAX, inputs: &[] }
+    }
+
+    #[test]
+    fn a_voice_starts_after_its_silent_format_block_and_ends_on_time() {
+        let (h, pcm) = mono(0.02, 48000, false); // 960 frames = 3.75 blocks
+        let mut m = Mixer::new();
+        m.add_bank(0, vec![Some(h)], vec![Some(pcm.clone())]);
+        let v = m.open(&request(0)).unwrap();
+        let mut bus = [[0.0f32; BLOCK]; 6];
+        m.render(&mut bus);
+        assert!(bus.iter().all(|c| c.iter().all(|&s| s == 0.0)), "first block silent");
+        m.render(&mut bus);
+        // Mono, azimuth 0 → centre only, unity gain, unity pitch: an exact copy.
+        assert_eq!(&bus[1][..], &pcm.channels[0][..BLOCK]);
+        assert!(bus[0].iter().all(|&s| s == 0.0));
+        let status = m.query(v);
+        assert!(status.alive);
+        assert_eq!(status.elapsed_ms, (256.0 / 48.0) as i32);
+        assert_eq!(status.remaining_ms, ((0.02 - 256.0 / 48000.0) * 1000.0) as i32);
+        for _ in 0..3 {
+            m.render(&mut bus);
+        }
+        assert!(!m.query(v).alive);
+    }
+
+    #[test]
+    fn properties_map_to_the_graph() {
+        let (h, pcm) = mono(1.0, 44100, true);
+        let mut m = Mixer::new();
+        m.add_bank(0, vec![Some(h)], vec![Some(pcm)]);
+        let v = m.open(&request(0)).unwrap();
+        m.set(v, 2, 32767);
+        m.set(v, 8, 16384);
+        m.set(v, 0, 4096 * 2);
+        m.set(v, 6, 1000);
+        m.set_azimuth(v, 65536 - 65536 / 12); // −30° → L
+        let voice = m.voice(v).unwrap();
+        assert_eq!(voice.master, 32767.0 * INV_32767);
+        assert_eq!(voice.pitch, 2.0);
+        assert_eq!(voice.lpf.cutoff, 1000.0);
+        assert!((voice.pan.params[pan::ANGLE] - 330.0).abs() < 0.01);
+        let mut bus = [[0.0f32; BLOCK]; 6];
+        m.render(&mut bus);
+        m.render(&mut bus);
+        assert!(bus[1].iter().all(|&s| s.abs() < 1e-4), "panned hard left: centre (almost) silent");
+        assert!(bus[0].iter().any(|&s| s.abs() > 0.01));
+        // Looping voices stay alive.
+        for _ in 0..400 {
+            m.render(&mut bus);
+        }
+        assert!(m.query(v).alive);
+    }
+
+    #[test]
+    fn release_plays_a_16_frame_decay_then_removes_the_voice() {
+        let (h, _) = mono(1.0, 48000, false);
+        let pcm = Arc::new(Pcm { rate: 48000, channels: vec![vec![0.5; 48000]] });
+        let mut m = Mixer::new();
+        m.add_bank(0, vec![Some(h)], vec![Some(pcm)]);
+        let v = m.open(&request(0)).unwrap();
+        let mut bus = [[0.0f32; BLOCK]; 6];
+        m.render(&mut bus);
+        m.render(&mut bus);
+        m.release(v);
+        m.render(&mut bus);
+        assert_eq!(bus[1][0], 0.5);
+        assert_eq!(bus[1][8], 0.25);
+        assert!(bus[1][16..].iter().all(|&s| s == 0.0));
+        assert_eq!(m.voice_count(), 0);
+        assert!(!m.query(v).alive);
+    }
+
+    #[test]
+    fn a_mono_submix_route_sums_the_panned_voice_into_the_centre() {
+        let (h, pcm) = mono(0.1, 48000, false);
+        let render = |route: Route| {
+            let mut m = Mixer::new();
+            m.add_bank(0, vec![Some(h)], vec![Some(pcm.clone())]);
+            m.open_routed(0, 0, 0.0, 1.0, 1.0, Some(70.0), route).unwrap();
+            let mut bus = [[0.0f32; BLOCK]; 6];
+            m.render(&mut bus);
+            m.render(&mut bus);
+            (bus, m.buses.env_in.to_vec())
+        };
+        let (stereo, _) = render(Route::default());
+        let (mono, env) = render(Route { mono: true, owner_env: 0.1, ..Route::default() });
+        // Panned off-centre: the plain route spreads it over the speakers; the submix folds every
+        // speaker (L..Rs) into the centre, louder than the centre alone by the pan's sum.
+        assert!(stereo[2].iter().any(|&v| v != 0.0) && stereo[4].iter().any(|&v| v != 0.0));
+        for k in 0..BLOCK {
+            let sum: f32 = (0..5).map(|c| stereo[c][k]).sum();
+            assert!((mono[1][k] - sum).abs() < 1e-6);
+            assert!((env[k] - 0.1 * sum).abs() < 1e-6, "the env send taps the same sum");
+        }
+        assert!((0..6).filter(|&c| c != 1).all(|c| mono[c].iter().all(|&v| v == 0.0)));
+    }
+
+    #[test]
+    fn send_b_feeds_the_flange_return_only_when_enabled() {
+        use crate::bus::flange::FlangePreset;
+        let render = |enabled: bool, inputs: &[(u8, i32)]| {
+            let (h, pcm) = mono(0.5, 48000, false);
+            let mut m = Mixer::new();
+            if enabled {
+                let a = FlangePreset([20.0, 0.3, 0.2, 0.1, 1500.0, 0.002, 0.5, 0.9, 0.03]);
+                let b = FlangePreset([1.7, 0.3, 0.0, 1.0, 250.0, 0.0005, 0.25, 0.6, 0.11]);
+                m.buses.flange.set_presets(a, b);
+                m.buses.flange.frame([32692, 2313, 32692, 2313]);
+            }
+            m.add_bank(0, vec![Some(h)], vec![Some(pcm)]);
+            let v = m.open(&OpenRequest { inputs, ..request(0) }).unwrap();
+            for &(id, value) in inputs {
+                m.set(v, id, value);
+            }
+            let mut out = Vec::new();
+            for _ in 0..20 {
+                let mut bus = [[0.0f32; BLOCK]; 6];
+                m.render(&mut bus);
+                out.push(bus);
+            }
+            out
+        };
+        let plain = render(false, &[]);
+        let fx = [(9u8, 4096i32), (10, 1), (11, 16384), (12, 5)];
+        // Disabled returns: a routed voice renders exactly like before (its EQ bus 5 aside).
+        assert_eq!(render(false, &[(9, 5)]), render(false, &fx));
+        // Enabled, but the voice has no effect record: identical to the plain render.
+        assert_eq!(plain, render(true, &[]));
+        // Enabled with the record: the delayed copy adds into the centre.
+        let wet = render(true, &[(9, 4096), (10, 1), (11, 16384)]);
+        let diff: f32 = wet.iter().zip(&plain).map(|(a, b)| a[1].iter().zip(&b[1]).map(|(x, y)| (x - y).abs()).sum::<f32>()).sum();
+        assert!(diff > 0.1, "{diff}");
+        // Enable record 0: no Send B.
+        assert_eq!(plain, render(true, &[(9, 4096), (10, 0), (11, 16384)]));
+    }
+
+    #[test]
+    fn routing_codes() {
+        let r = Routing::parse(&[(2, 4096), (9, 3), (10, 4096), (12, 1), (11, 16384)]);
+        assert_eq!(r.output_bus, Some((3, false)));
+        let (bus, level) = r.effect.unwrap();
+        assert_eq!(bus, 0);
+        assert!((level - 0.5).abs() < 1e-4);
+        assert_eq!(Routing::parse(&[(9, 12)]).output_bus, Some((2, true)));
+        assert_eq!(Routing::parse(&[(9, 2048)]).fixed, Some(2048));
+        assert_eq!(Routing::parse(&[(9, 4096), (10, 0), (11, 9)]).effect, None);
+        let (h, pcm) = mono(0.1, 48000, false);
+        let mut m = Mixer::new();
+        m.add_bank(0, vec![Some(h)], vec![Some(pcm)]);
+        let inputs = [(9u8, 5i32)];
+        let v = m.open(&OpenRequest { inputs: &inputs, ..request(0) }).unwrap();
+        assert_eq!(m.voice(v).unwrap().routing().output_bus, Some((5, false)));
+        assert_eq!(m.voice(v).unwrap().output, Output::Eq(5));
+    }
+}
diff --git a/crates/skate-audio/src/mixmap/format.rs b/crates/skate-audio/src/mixmap/format.rs
new file mode 100644
index 00000000..1be062f8
--- /dev/null
+++ b/crates/skate-audio/src/mixmap/format.rs
@@ -0,0 +1,255 @@
+//! `MixMapSK8.mxb` decoding (spec `.claude/notes/mixmap-spec.md` §2). Big-endian throughout.
+//! Our letters for EA's record kinds: A = MixCtl (input product), B = 3DMixCtl (distance/azimuth
+//! lookup), C = SubMixCh (clamped sum), E = MasterMixCh (output sum) with its G = Preset output
+//! list, F = EvtMixCtl (envelope).
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ProductRec {
+    /// Input key; bits 24–27 = curve kind.
+    pub input: u32,
+    /// Low 16 bits of w1: the swing (bit 15 set = a cut of that many mB, else a boost).
+    pub swing: u16,
+    pub refs: Vec<u32>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Variant {
+    /// Camera-state id (bits 24–27 of the first word).
+    pub mode: u32,
+    /// 0 → input 1, 1 → input 0, ≥ 2 → −1.0.
+    pub dist_sel: u32,
+    /// 0 → input 3, 1 → input 2, ≥ 2 → 0.
+    pub angle_sel: u32,
+    /// Curve per quadrant q0..q3.
+    pub curves: [u32; 4],
+    /// Doppler speed constant (0 = none).
+    pub doppler: u32,
+    /// (min, max) metres per direction d0..d3.
+    pub ranges: [(u32, u32); 4],
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct LookupRec {
+    /// Controller selector word (slot/object bits name the SFXCTL input block).
+    pub ctl: u32,
+    pub variants: Vec<Variant>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct SumRec {
+    pub word0: u32,
+    pub max: i32,
+    pub min: i32,
+    pub refs: Vec<u32>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct OutputWord {
+    pub id: u32,
+    /// Which B reference (≥ the number of specials = none).
+    pub special: u32,
+    pub raw_angle: bool,
+    pub offset: i32,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct OutputRec {
+    pub word0: u32,
+    /// Base value (mB / cents).
+    pub base: i32,
+    /// Destination SFXObj controller key.
+    pub dest: u32,
+    /// References; B references ("specials") come first.
+    pub refs: Vec<u32>,
+    /// 0 volume, 1 pitch, 2 filter, 3/≥5 raw, 4 volume.
+    pub kind: u32,
+    pub outs: Vec<OutputWord>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct EnvelopeRec {
+    pub word0: u32,
+    /// 0 = AR, 1 = AHR, 3 = ADSR; others are inert.
+    pub kind: u32,
+    pub gated: bool,
+    pub linear: bool,
+    pub retrigger: bool,
+    pub swing: u16,
+    pub trigger: u32,
+    /// (frames, curve).
+    pub attack: (u32, u32),
+    pub decay: (u32, u32),
+    pub hold: u32,
+    pub release: (u32, u32),
+    /// Sustain level (signed Q15).
+    pub sustain: i32,
+    pub refs: Vec<u32>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Section {
+    pub slot: usize,
+    pub products: Vec<ProductRec>,
+    pub lookups: Vec<LookupRec>,
+    pub sums: Vec<SumRec>,
+    pub outputs: Vec<OutputRec>,
+    pub envelopes: Vec<EnvelopeRec>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct MixMapFile {
+    pub id: u32,
+    /// One entry per slot (None = no section).
+    pub slots: Vec<Option<Section>>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FormatError(pub String);
+
+impl std::fmt::Display for FormatError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "MixMap: {}", self.0)
+    }
+}
+
+impl std::error::Error for FormatError {}
+
+struct Reader<'a>(&'a [u8]);
+
+impl Reader<'_> {
+    fn u32(&self, at: usize) -> Result<u32, FormatError> {
+        self.0
+            .get(at..at + 4)
+            .map(|b| u32::from_be_bytes(b.try_into().unwrap()))
+            .ok_or_else(|| FormatError(format!("truncated at {at:#x}")))
+    }
+    fn i32(&self, at: usize) -> Result<i32, FormatError> {
+        Ok(self.u32(at)? as i32)
+    }
+    fn words(&self, at: usize, n: usize) -> Result<Vec<u32>, FormatError> {
+        (0..n).map(|q| self.u32(at + 4 * q)).collect()
+    }
+}
+
+fn s16(v: u32) -> i32 {
+    i32::from(v as u16 as i16)
+}
+
+impl MixMapFile {
+    pub fn parse(data: &[u8]) -> Result<Self, FormatError> {
+        let r = Reader(data);
+        let id = r.u32(0)?;
+        let count = r.u32(4)? as usize;
+        if count > 64 {
+            return Err(FormatError(format!("{count} slots")));
+        }
+        let table = r.u32(8)? as usize;
+        let mut slots = Vec::with_capacity(count);
+        for s in 0..count {
+            let off = r.i32(table + 4 * s)?;
+            if off < 0 {
+                slots.push(None);
+                continue;
+            }
+            slots.push(Some(Self::section(&r, s, off as usize)?));
+        }
+        Ok(Self { id, slots })
+    }
+
+    fn section(r: &Reader, slot: usize, off: usize) -> Result<Section, FormatError> {
+        let table = |k: usize| -> Result<Option<usize>, FormatError> {
+            let v = r.i32(off + k)?;
+            Ok((v >= 0).then(|| off + v as usize))
+        };
+        let mut sec = Section { slot, ..Section::default() };
+        if let Some(t) = table(4)? {
+            let mut p = t + 16;
+            for _ in 0..r.i32(t)?.max(0) {
+                let (w0, w1) = (r.u32(p)?, r.u32(p + 4)?);
+                let n = ((w1 >> 16) & 0x1F) as usize;
+                sec.products.push(ProductRec { input: w0, swing: w1 as u16, refs: r.words(p + 8, n)? });
+                p += (n + 2) * 4;
+            }
+        }
+        if let Some(t) = table(8)? {
+            let mut p = t + 16;
+            for _ in 0..(r.u32(t)? & 0xFF) {
+                let w0 = r.u32(p)?;
+                let nv = ((w0 >> 24) & 0xF) as usize;
+                let mut variants = Vec::with_capacity(nv);
+                for v in 0..nv {
+                    let q = p + 4 + 24 * v;
+                    let (r0, r1) = (r.u32(q)?, r.u32(q + 4)?);
+                    let mut ranges = [(0, 0); 4];
+                    for (d, range) in ranges.iter_mut().enumerate() {
+                        let w = r.u32(q + 8 + 4 * d)?;
+                        *range = (w & 0x7FFF, (w >> 16) & 0x7FFF);
+                    }
+                    variants.push(Variant {
+                        mode: (r0 >> 24) & 0xF,
+                        dist_sel: (r0 >> 12) & 0xF,
+                        angle_sel: (r0 >> 8) & 0xF,
+                        curves: [(r1 >> 28) & 0xF, (r1 >> 16) & 0xF, (r1 >> 24) & 0xF, (r1 >> 20) & 0xF],
+                        doppler: r1 & 0xFFFF,
+                        ranges,
+                    });
+                }
+                if variants.is_empty() {
+                    return Err(FormatError(format!("slot {slot}: lookup at {p:#x} has no variant")));
+                }
+                sec.lookups.push(LookupRec { ctl: w0, variants });
+                p += nv * 24 + 4;
+            }
+        }
+        if let Some(t) = table(12)? {
+            let mut p = t + 16;
+            for _ in 0..r.i32(t)?.max(0) {
+                let (w0, w1) = (r.u32(p)?, r.u32(p + 4)?);
+                let n = ((w0 >> 16) & 0xFF) as usize;
+                sec.sums.push(SumRec { word0: w0, max: ((w1 >> 16) & 0x7FFF) as i32, min: s16(w1), refs: r.words(p + 8, n)? });
+                p += (n + 2) * 4;
+            }
+        }
+        if let (Some(t), Some(mut g)) = (table(16)?, table(20)?) {
+            let mut p = t + 16;
+            for _ in 0..r.i32(t)?.max(0) {
+                let (w0, w1, dest) = (r.u32(p)?, r.u32(p + 4)?, r.u32(p + 8)?);
+                let n = ((w0 >> 16) & 0xFF) as usize;
+                let head = r.u32(g)?;
+                let cnt = (head & 0x1F) as usize;
+                let mut outs = Vec::with_capacity(cnt);
+                for q in 0..cnt {
+                    let d = r.u32(g + 4 + 4 * q)?;
+                    outs.push(OutputWord { id: (d >> 26) & 0x1F, special: (d >> 21) & 0x1F, raw_angle: d & 0x8000_0000 != 0, offset: s16(d) });
+                }
+                sec.outputs.push(OutputRec { word0: w0, base: s16(w1 >> 16), dest, refs: r.words(p + 12, n)?, kind: (head >> 24) & 0xF, outs });
+                g += (cnt + 1) * 4;
+                p += (n + 3) * 4;
+            }
+        }
+        if let Some(t) = table(24)? {
+            let mut p = t + 16;
+            for _ in 0..r.i32(t)?.max(0) {
+                let w = r.words(p, 6)?;
+                let n = ((w[1] >> 16) & 0xF) as usize;
+                sec.envelopes.push(EnvelopeRec {
+                    word0: w[0],
+                    kind: (w[0] >> 24) & 0xF,
+                    gated: w[0] & 0x100 != 0,
+                    linear: w[0] & 0x200 != 0,
+                    retrigger: w[0] & 0x400 != 0,
+                    swing: w[1] as u16,
+                    trigger: w[2],
+                    attack: (w[3] & 0xFFF, (w[3] >> 12) & 0xF),
+                    decay: ((w[4] >> 16) & 0xFFF, (w[4] >> 12) & 0xF),
+                    hold: w[4] & 0xFFF,
+                    release: (w[5] & 0xFFF, (w[5] >> 12) & 0xF),
+                    sustain: (w[5] as i32) >> 16,
+                    refs: r.words(p + 24, n)?,
+                });
+                p += (n + 6) * 4;
+            }
+        }
+        Ok(sec)
+    }
+}
diff --git a/crates/skate-audio/src/mixmap/keys.rs b/crates/skate-audio/src/mixmap/keys.rs
new file mode 100644
index 00000000..8572d3e7
--- /dev/null
+++ b/crates/skate-audio/src/mixmap/keys.rs
@@ -0,0 +1,116 @@
+//! Controller keys (spec §3): bits 29–31 type (2 = SFXObj, 3 = SFXCTL), 16–23 slot, 11–15
+//! instance ("group"), 4–10 object id within the slot, 0–3 input id. A controller is named by
+//! its key with the input bits clear. Object names are the game's SFX factory table.
+
+/// Controller identity bits of a key (type + slot + group + object).
+pub const KEY_MASK: u32 = 0xE0FF_FFF0;
+
+/// An SFXObj controller (owner of outputs and inputs) of `slot`, object `object`, instance `group`.
+pub const fn obj(slot: u32, object: u32, group: u32) -> u32 {
+    0x4000_0000 | (slot << 16) | (group << 11) | (object << 4)
+}
+
+/// An SFXCTL controller (input block only: physics, 3-D positions).
+pub const fn ctl(slot: u32, object: u32, group: u32) -> u32 {
+    0x6000_0000 | (slot << 16) | (group << 11) | (object << 4)
+}
+
+pub mod slot {
+    pub const GLOBAL: u32 = 0;
+    pub const PLAYER: u32 = 1;
+    pub const AMBIENCE: u32 = 2;
+    pub const COLLISION: u32 = 3;
+    pub const TRAFFIC: u32 = 4;
+    pub const PEDESTRIAN: u32 = 5;
+    pub const EMITTER: u32 = 6;
+}
+
+// Global slot objects.
+pub const ANNOUNCER: u32 = obj(0, 0, 0);
+pub const MUSIC: u32 = obj(0, 1, 0);
+pub const MASTER: u32 = obj(0, 2, 0);
+pub const REVERB: u32 = obj(0, 5, 0);
+pub const NIS: u32 = obj(0, 6, 0);
+pub const PAUSE: u32 = obj(0, 7, 0);
+pub const MENU: u32 = obj(0, 13, 0);
+pub const SPEECH: u32 = obj(0, 8, 0);
+pub const VU: u32 = obj(0, 10, 0);
+pub const CHALLENGE: u32 = obj(0, 11, 0);
+pub const HOM: u32 = obj(0, 12, 0);
+/// `SFXObj_Jitter` (inputs 0..4: bounded random walks, `player::jitter`).
+pub const JITTER: u32 = obj(0, 14, 0);
+
+/// The ambience bed owner (input 0 = the bed fade, 0 = up, 32767 = silent).
+pub const AMBIENCE: u32 = obj(2, 0, 0);
+
+/// Player instance `g` (0 = the local player).
+pub const fn skateboard(g: u32) -> u32 {
+    obj(1, 0, g)
+}
+pub const fn contacts(g: u32) -> u32 {
+    obj(1, 1, g)
+}
+pub const fn wheels(g: u32) -> u32 {
+    obj(1, 2, g)
+}
+pub const fn rail(g: u32) -> u32 {
+    obj(1, 3, g)
+}
+pub const fn cracks(g: u32) -> u32 {
+    obj(1, 4, g)
+}
+pub const fn tricks(g: u32) -> u32 {
+    obj(1, 5, g)
+}
+pub const fn clothing(g: u32) -> u32 {
+    obj(1, 6, g)
+}
+pub const fn treatments(g: u32) -> u32 {
+    obj(1, 7, g)
+}
+pub const fn sense_of_speed(g: u32) -> u32 {
+    obj(1, 8, g)
+}
+pub const fn off_board(g: u32) -> u32 {
+    obj(1, 9, g)
+}
+pub const fn hand_grabs(g: u32) -> u32 {
+    obj(1, 10, g)
+}
+pub const fn player_physics(g: u32) -> u32 {
+    ctl(1, 0, g)
+}
+/// The player's two 3DObjPos input blocks (`0x60010010`, `0x60010020`).
+pub const fn obj_pos(g: u32) -> u32 {
+    ctl(1, 1, g)
+}
+pub const fn obj_pos2(g: u32) -> u32 {
+    ctl(1, 2, g)
+}
+
+/// One `CSTATEMGR_Emitter` state (0..4): its SFXObj outputs and its 3-D input block.
+pub const fn emitter(g: u32) -> u32 {
+    obj(6, 0, g)
+}
+pub const fn emitter_pos(g: u32) -> u32 {
+    ctl(6, 0, g)
+}
+
+/// 3DObjPos / SFXCTL input ids (spec §7.3).
+pub mod pos {
+    /// f32 distance from the followed point (skater).
+    pub const DIST_SKATER: usize = 0;
+    /// f32 distance from the camera point.
+    pub const DIST_CAMERA: usize = 1;
+    /// Azimuth (u16 scale) in the skater frame / camera frame.
+    pub const AZ_SKATER: usize = 2;
+    pub const AZ_CAMERA: usize = 3;
+    /// f32 signed relative speed vs skater / camera (negative when closing).
+    pub const SPEED_SKATER: usize = 13;
+    pub const SPEED_CAMERA: usize = 14;
+    /// Bit 0 active; bits 31/30 = speed sign flipped (reset the Doppler slew).
+    pub const FLAGS: usize = 15;
+}
+
+/// Output-block word 15 bit 0: the block is enabled (set at build).
+pub const ENABLE_WORD: usize = 15;
diff --git a/crates/skate-audio/src/mixmap/mod.rs b/crates/skate-audio/src/mixmap/mod.rs
new file mode 100644
index 00000000..18f6f60b
--- /dev/null
+++ b/crates/skate-audio/src/mixmap/mod.rs
@@ -0,0 +1,750 @@
+//! The MixMap mixer (`MixMapSK8.mxb`), our own port from `.claude/notes/mixmap-spec.md`
+//! (and our reference evaluator `.claude/skills/audio-tuning/tools/re/mxb_tool.py`, which gives
+//! the same outputs as upstream PR #4's port on 73,800 golden cells).
+//!
+//! The game writes controller **inputs** (16 i32 words per controller: physics, 3-D positions,
+//! menu / pause / music flags), calls [`MixMap::tick`] once per 60 Hz frame, and the audio objects
+//! read **outputs** (16 u32 words per SFXObj controller, two 16-bit halves each: volumes as Q15,
+//! pitch in cents, filter cutoffs in Hz, raw azimuths) through the owner readers
+//! [`MixMap::level`], [`MixMap::raw`], [`MixMap::pitch_4096`], [`MixMap::filter_hz`].
+//!
+//! Evaluation order per tick (spec §5): input entries (in runs by curve kind) → A products → B
+//! lookups → F envelopes → C sums → E sums → output conversion. References read whatever is stored,
+//! so earlier records see this tick's values and later ones last tick's (retail's one-tick lags).
+//! Integer math is i32 with wrapping, floats are f32 at every step (the spec's rounding rules).
+pub mod format;
+pub mod keys;
+pub mod tables;
+
+use std::collections::HashMap;
+
+pub use format::{FormatError, MixMapFile};
+use format::Variant;
+use keys::KEY_MASK;
+use tables::{SILENT_MB, Tables, trunc};
+
+/// Instances per slot in retail free skate (spec §4.1): Global 1, Player 2, Ambience 1,
+/// Collision 10, Traffic 4, Pedestrian 15, Emitter 5, Crowd 5, Dynamic 5, Speaker 3, Whoosh 3,
+/// ObjectInstance 0, NISCharacter 5, PlayerSpeech 7 = 247 controllers.
+pub const RETAIL_INSTANCES: [usize; 14] = [1, 2, 1, 10, 4, 15, 5, 5, 5, 3, 3, 0, 5, 7];
+
+/// A resolved reference.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Ref {
+    Ctl(usize, usize),
+    A(usize),
+    B(usize),
+    F(usize),
+    C(usize),
+    E(usize),
+    Missing,
+}
+
+#[derive(Clone, Debug)]
+struct Controller {
+    key: u32,
+    inputs: [i32; 16],
+    outputs: [u32; 16],
+    has_outputs: bool,
+}
+
+#[derive(Clone, Debug)]
+struct Entry {
+    key: u32,
+    source: Ref,
+    lin: i32,
+    mb: i32,
+}
+
+#[derive(Clone, Debug)]
+struct Product {
+    input: usize,
+    offset: i32,
+    depth: i32,
+    refs: Vec<Ref>,
+    mb: i32,
+}
+
+#[derive(Clone, Debug)]
+struct Lookup {
+    variants: Vec<Variant>,
+    variant: Variant,
+    ctl: usize,
+    angle: u32,
+    mb: i32,
+    lin: i32,
+    doppler: i32,
+}
+
+#[derive(Clone, Debug)]
+struct Envelope {
+    kind: u32,
+    gated: bool,
+    linear: bool,
+    retrigger: bool,
+    boost: bool,
+    curves: [u32; 3],
+    sustain: i32,
+    offset: i32,
+    depth: i32,
+    trigger: Ref,
+    /// Attack, decay, hold, release in ms.
+    ms: [f32; 4],
+    refs: Vec<Ref>,
+    stage: u32,
+    elapsed: f32,
+    start: i32,
+    t0: f32,
+    level: i32,
+    mb: i32,
+}
+
+#[derive(Clone, Debug)]
+struct Sum {
+    min: i32,
+    max: i32,
+    refs: Vec<Ref>,
+    value: i32,
+}
+
+#[derive(Clone, Debug)]
+struct OutputSum {
+    kind: u32,
+    base: i32,
+    dest: usize,
+    special: Vec<usize>,
+    outs: Vec<format::OutputWord>,
+    refs: Vec<Ref>,
+    value: i32,
+}
+
+/// Node identity during the build: (type, slot, group, index).
+type NodeKey = (u8, u32, u32, u32);
+
+pub struct MixMap {
+    t: Tables,
+    ctls: Vec<Controller>,
+    by_key: HashMap<u32, usize>,
+    entries: Vec<Entry>,
+    order: Vec<usize>,
+    products: Vec<Product>,
+    lookups: Vec<Lookup>,
+    envelopes: Vec<Envelope>,
+    sums: Vec<Sum>,
+    outputs: Vec<OutputSum>,
+    /// Camera-state mode word (retail keeps −1: variant 0).
+    pub mode: u32,
+    dt_ms: f32,
+    /// Ticks evaluated.
+    pub ticks: u64,
+}
+
+fn swing(t: &Tables, w: u16) -> (i32, i32) {
+    if w & 0x8000 == 0 {
+        let w = i32::from(w & 0x7FFF);
+        (w, 32767 - t.mb_to_lin(-w))
+    } else {
+        (0, 32767 - t.mb_to_lin(i32::from(w as i16)))
+    }
+}
+
+struct Builder<'a> {
+    n: &'a [usize],
+    ctls: Vec<Controller>,
+    by_key: HashMap<u32, usize>,
+}
+
+impl Builder<'_> {
+    fn ctl(&mut self, key: u32) -> usize {
+        let key = key & KEY_MASK;
+        if let Some(&i) = self.by_key.get(&key) {
+            return i;
+        }
+        self.ctls.push(Controller { key, inputs: [0; 16], outputs: [0; 16], has_outputs: false });
+        self.by_key.insert(key, self.ctls.len() - 1);
+        self.ctls.len() - 1
+    }
+
+    /// Cross-slot references expand to every instance of the other slot (spec §4.2).
+    fn expand(&self, refs: &[u32], own_slot: u32, group: u32) -> Vec<u32> {
+        let mut out = Vec::with_capacity(refs.len());
+        for &r in refs {
+            let s = (r >> 16) & 0xFF;
+            let base = r & 0xFFFF_07FF;
+            if s == own_slot {
+                out.push(base | (group << 11));
+            } else {
+                let count = self.n.get(s as usize).copied().unwrap_or(0) as u32;
+                out.extend((0..count).map(|g| base | (g << 11)));
+            }
+        }
+        out
+    }
+}
+
+fn node_key(key: u32) -> Option<NodeKey> {
+    let (top, s, g, idx) = (key >> 29, (key >> 16) & 0xFF, (key >> 11) & 0x1F, key & 0xFF);
+    match top {
+        0 => Some((0, s, g, idx)),
+        1 => Some((1, s, g, idx | (key & 0x1000_0000))),
+        4 => Some((4, s, g, idx)),
+        5 => Some((5, s, g, idx)),
+        _ => None,
+    }
+}
+
+impl MixMap {
+    /// Build the graph for `instances[slot]` game objects per slot.
+    pub fn new(file: &MixMapFile, instances: &[usize]) -> Self {
+        let t = Tables::generate();
+        let mut b = Builder { n: instances, ctls: Vec::new(), by_key: HashMap::new() };
+        let mut nodes: HashMap<NodeKey, (u8, usize)> = HashMap::new();
+        let mut entries: Vec<Entry> = Vec::new();
+        let mut entry_at: HashMap<u32, usize> = HashMap::new();
+        // Raw (unresolved) references per node, resolved once every node exists.
+        let mut products = Vec::new();
+        let mut product_refs: Vec<Vec<u32>> = Vec::new();
+        let mut lookups = Vec::new();
+        let mut envelopes = Vec::new();
+        let mut envelope_refs: Vec<(u32, Vec<u32>)> = Vec::new();
+        let mut sums = Vec::new();
+        let mut sum_refs: Vec<Vec<u32>> = Vec::new();
+        let mut outputs = Vec::new();
+        let mut output_refs: Vec<(Vec<u32>, Vec<u32>)> = Vec::new();
+        let count = |s: usize| instances.get(s).copied().unwrap_or(0) as u32;
+
+        for sec in file.slots.iter().flatten() {
+            let s = sec.slot as u32;
+            for j in 0..count(sec.slot) {
+                for (k, a) in sec.products.iter().enumerate() {
+                    let key = (a.input & 0xFFFF_07FF) | (j << 11);
+                    let input = *entry_at.entry(key).or_insert_with(|| {
+                        entries.push(Entry { key, source: Ref::Missing, lin: 32767, mb: 0 });
+                        entries.len() - 1
+                    });
+                    let (offset, depth) = swing(&t, a.swing);
+                    product_refs.push(b.expand(&a.refs, (a.input >> 16) & 0xFF, j));
+                    products.push(Product { input, offset, depth, refs: Vec::new(), mb: 0 });
+                    nodes.insert((0, s, j, k as u32), (0, products.len() - 1));
+                }
+                for (k, l) in sec.lookups.iter().enumerate() {
+                    let ctl = b.ctl(0x6000_0000 | (j << 11) | (l.ctl & 0x1FFF_FFFF));
+                    lookups.push(Lookup { variants: l.variants.clone(), variant: l.variants[0], ctl, angle: 0, mb: 0, lin: 32767, doppler: 0 });
+                    nodes.insert((4, s, j, k as u32), (4, lookups.len() - 1));
+                }
+                for (k, f) in sec.envelopes.iter().enumerate() {
+                    let (offset, depth) = swing(&t, f.swing);
+                    let short = matches!(f.kind, 0..=2);
+                    let frames = [
+                        if short { f.attack.0.max(1) } else { f.attack.0 },
+                        f.decay.0,
+                        if f.kind == 1 { f.hold.max(1) } else { f.hold },
+                        if short { f.release.0.max(1) } else { f.release.0 },
+                    ];
+                    envelope_refs.push((f.trigger | (j << 11), b.expand(&f.refs, (f.word0 >> 16) & 0xFF, j)));
+                    envelopes.push(Envelope {
+                        kind: f.kind,
+                        gated: f.gated,
+                        linear: f.linear,
+                        retrigger: f.retrigger,
+                        boost: (f.swing as i16) > 0,
+                        curves: [f.attack.1, f.decay.1, f.release.1],
+                        sustain: f.sustain,
+                        offset,
+                        depth,
+                        trigger: Ref::Missing,
+                        ms: frames.map(|n| n as f32 * t.k_frame_ms),
+                        refs: Vec::new(),
+                        stage: 0,
+                        elapsed: 0.0,
+                        start: 0,
+                        t0: 0.0,
+                        level: 0,
+                        mb: 0,
+                    });
+                    nodes.insert((5, s, j, k as u32), (5, envelopes.len() - 1));
+                }
+            }
+        }
+        for sec in file.slots.iter().flatten() {
+            let s = sec.slot as u32;
+            for j in 0..count(sec.slot) {
+                for (k, c) in sec.sums.iter().enumerate() {
+                    sum_refs.push(b.expand(&c.refs, s, j));
+                    sums.push(Sum { min: c.min, max: c.max, refs: Vec::new(), value: 0 });
+                    nodes.insert((1, s, j, k as u32 | 0x1000_0000), (1, sums.len() - 1));
+                }
+                for (k, e) in sec.outputs.iter().enumerate() {
+                    let specials = e.refs.iter().filter(|&&r| r >> 29 == 4).count();
+                    let special: Vec<u32> = e.refs[..specials].iter().map(|&r| (r & 0xFFFF_07FF) | (j << 11)).collect();
+                    let dest = b.ctl(e.dest | (j << 11));
+                    if !b.ctls[dest].has_outputs {
+                        b.ctls[dest].has_outputs = true;
+                        b.ctls[dest].outputs[keys::ENABLE_WORD] = 1;
+                    }
+                    output_refs.push((special, b.expand(&e.refs[specials..], s, j)));
+                    outputs.push(OutputSum { kind: e.kind, base: e.base, dest, special: Vec::new(), outs: e.outs.clone(), refs: Vec::new(), value: SILENT_MB });
+                    nodes.insert((1, s, j, k as u32), (2, outputs.len() - 1));
+                }
+            }
+        }
+        let resolve = |b: &mut Builder, key: u32| -> Ref {
+            match key >> 29 {
+                2 | 3 => Ref::Ctl(b.ctl(key), (key & 0xF) as usize),
+                _ => match node_key(key).and_then(|nk| nodes.get(&nk)) {
+                    Some(&(0, i)) => Ref::A(i),
+                    Some(&(4, i)) => Ref::B(i),
+                    Some(&(5, i)) => Ref::F(i),
+                    Some(&(1, i)) => Ref::C(i),
+                    Some(&(2, i)) => Ref::E(i),
+                    _ => Ref::Missing,
+                },
+            }
+        };
+        for e in &mut entries {
+            e.source = resolve(&mut b, e.key);
+        }
+        for (p, refs) in products.iter_mut().zip(product_refs) {
+            p.refs = refs.into_iter().map(|r| resolve(&mut b, r)).collect();
+        }
+        for (f, (trigger, refs)) in envelopes.iter_mut().zip(envelope_refs) {
+            f.trigger = resolve(&mut b, trigger);
+            f.refs = refs.into_iter().map(|r| resolve(&mut b, r)).collect();
+        }
+        for (c, refs) in sums.iter_mut().zip(sum_refs) {
+            c.refs = refs.into_iter().map(|r| resolve(&mut b, r)).collect();
+        }
+        for (e, (special, refs)) in outputs.iter_mut().zip(output_refs) {
+            e.special = special
+                .into_iter()
+                .filter_map(|k| match resolve(&mut b, k) {
+                    Ref::B(i) => Some(i),
+                    _ => None,
+                })
+                .collect();
+            e.refs = refs.into_iter().map(|r| resolve(&mut b, r)).collect();
+        }
+        // Input entries run in curve-kind order, first use order within a kind (spec §4.3).
+        let mut order: Vec<usize> = (0..entries.len()).collect();
+        order.sort_by_key(|&i| (entries[i].key >> 24) & 0xF);
+        Self {
+            t,
+            ctls: b.ctls,
+            by_key: b.by_key,
+            entries,
+            order,
+            products,
+            lookups,
+            envelopes,
+            sums,
+            outputs,
+            mode: u32::MAX,
+            dt_ms: 0.0,
+            ticks: 0,
+        }
+    }
+
+    /// Parse and build with the retail instance counts.
+    pub fn from_bytes(bytes: &[u8]) -> Result<Self, FormatError> {
+        Ok(Self::new(&MixMapFile::parse(bytes)?, &RETAIL_INSTANCES))
+    }
+
+    pub fn tables(&self) -> &Tables {
+        &self.t
+    }
+
+    /// Number of controllers (retail free skate: 247).
+    pub fn controller_count(&self) -> usize {
+        self.ctls.len()
+    }
+
+    /// (input entries, A, B, F, C, E) counts.
+    pub fn counts(&self) -> [usize; 6] {
+        [self.entries.len(), self.products.len(), self.lookups.len(), self.envelopes.len(), self.sums.len(), self.outputs.len()]
+    }
+
+    /// Every controller key (type + slot + group + object).
+    pub fn controller_keys(&self) -> impl Iterator<Item = u32> + '_ {
+        self.ctls.iter().map(|c| c.key)
+    }
+
+    /// Output blocks.
+    pub fn output_blocks(&self) -> usize {
+        self.ctls.iter().filter(|c| c.has_outputs).count()
+    }
+
+    fn find(&self, key: u32) -> Option<usize> {
+        self.by_key.get(&(key & KEY_MASK)).copied()
+    }
+
+    /// Whether a controller with this key exists in the built graph.
+    pub fn has_controller(&self, key: u32) -> bool {
+        self.find(key).is_some()
+    }
+
+    /// Write one input word (`id` 0..15). Unknown controllers are ignored (nothing reads them).
+    pub fn set_input(&mut self, key: u32, id: usize, value: i32) {
+        if let (Some(i), true) = (self.find(key), id < 16) {
+            self.ctls[i].inputs[id] = value;
+        }
+    }
+
+    pub fn set_input_f32(&mut self, key: u32, id: usize, value: f32) {
+        self.set_input(key, id, value.to_bits() as i32);
+    }
+
+    pub fn input(&self, key: u32, id: usize) -> i32 {
+        self.find(key).filter(|_| id < 16).map_or(0, |i| self.ctls[i].inputs[id])
+    }
+
+    /// Enable or disable an output block (word 15 bit 0).
+    pub fn set_enabled(&mut self, key: u32, on: bool) {
+        if let Some(i) = self.find(key) {
+            let w = &mut self.ctls[i].outputs[keys::ENABLE_WORD];
+            *w = (*w & !1) | u32::from(on);
+        }
+    }
+
+    /// The output half `id` as the owners load it: even ids the whole word (callers mask), odd
+    /// ids the high half, arithmetic shift.
+    pub fn half(&self, key: u32, id: usize) -> i32 {
+        let Some(i) = self.find(key) else { return 0 };
+        let w = self.ctls[i].outputs[(id >> 1) & 15] as i32;
+        if id & 1 == 1 { w >> 16 } else { w }
+    }
+
+    /// Owner vfunc60 / vfunc64: a level (Q15, /32767) or a filter cutoff (Hz).
+    pub fn level(&self, key: u32, id: usize) -> i32 {
+        self.half(key, id) & 0x7FFF
+    }
+
+    pub fn filter_hz(&self, key: u32, id: usize) -> i32 {
+        self.level(key, id)
+    }
+
+    /// Owner vfunc52: a raw u16 (azimuth, 65536 = 360°).
+    pub fn raw(&self, key: u32, id: usize) -> i32 {
+        self.half(key, id) & 0xFFFF
+    }
+
+    /// Owner vfunc56: pitch with 4096 = 1.0.
+    pub fn pitch_4096(&self, key: u32, id: usize) -> i32 {
+        self.t.pitch_4096(i32::from(self.half(key, id) as i16))
+    }
+
+    fn value(&self, r: Ref, mb: bool) -> i32 {
+        match r {
+            Ref::Ctl(c, id) => self.ctls[c].inputs[id],
+            Ref::A(i) => {
+                let p = &self.products[i];
+                if mb { p.mb } else { self.entries[p.input].lin }
+            }
+            Ref::B(i) => {
+                let l = &self.lookups[i];
+                if mb { l.mb } else { l.lin }
+            }
+            Ref::F(i) => {
+                let f = &self.envelopes[i];
+                if mb { f.mb } else { f.level }
+            }
+            Ref::C(i) => self.sums[i].value,
+            Ref::E(i) => self.outputs[i].value,
+            Ref::Missing => 0,
+        }
+    }
+
+    fn scale(&self, refs: &[Ref]) -> i32 {
+        refs.iter().fold(32767i32, |acc, &r| self.value(r, false).wrapping_mul(acc) >> 15)
+    }
+
+    /// One evaluation with frame time `dt` seconds (retail: 1/60 per game frame).
+    pub fn tick(&mut self, dt: f32) {
+        self.dt_ms = dt * 1000.0;
+        for k in 0..self.order.len() {
+            let i = self.order[k];
+            let raw = self.value(self.entries[i].source, false);
+            let lin = self.t.shape(raw, (self.entries[i].key >> 24) & 0xF);
+            let e = &mut self.entries[i];
+            e.lin = lin;
+            e.mb = self.t.lin_to_mb(lin);
+        }
+        for i in 0..self.products.len() {
+            let p = &self.products[i];
+            let lin = self.entries[p.input].lin;
+            let x = 32767i32.wrapping_sub(32767i32.wrapping_sub(lin).wrapping_mul(p.depth) >> 15);
+            let mb = p.offset.wrapping_add(self.t.lin_to_mb(x));
+            let acc = self.scale(&p.refs);
+            self.products[i].mb = acc.wrapping_mul(mb) >> 15;
+        }
+        self.lookups_tick();
+        self.envelopes_tick();
+        for i in 0..self.sums.len() {
+            let v = self.sums[i].refs.iter().fold(0i32, |s, &r| s.wrapping_add(self.value(r, true)));
+            let c = &mut self.sums[i];
+            c.value = v.min(c.max).max(c.min);
+        }
+        for i in 0..self.outputs.len() {
+            let e = &self.outputs[i];
+            let v = if self.ctls[e.dest].outputs[keys::ENABLE_WORD] & 1 == 0 {
+                SILENT_MB
+            } else {
+                e.refs.iter().fold(e.base, |s, &r| s.wrapping_add(self.value(r, true)))
+            };
+            self.outputs[i].value = v;
+        }
+        self.write_outputs();
+        self.ticks += 1;
+    }
+
+    fn lookups_tick(&mut self) {
+        let mode = self.mode;
+        for i in 0..self.lookups.len() {
+            let l = &mut self.lookups[i];
+            if mode != u32::MAX {
+                l.variant = l.variants.iter().copied().find(|v| v.mode == mode & 0xF).unwrap_or(l.variants[0]);
+            }
+            let blk = &mut self.ctls[l.ctl].inputs;
+            let fl = |w: usize| f32::from_bits(blk[w] as u32);
+            if blk[keys::pos::FLAGS] & 1 == 0 {
+                (l.mb, l.lin, l.angle, l.doppler) = (SILENT_MB, 0, 0, 0);
+                continue;
+            }
+            let v = l.variant;
+            let x = match v.dist_sel {
+                0 => fl(keys::pos::DIST_CAMERA),
+                1 => fl(keys::pos::DIST_SKATER),
+                _ => -1.0,
+            };
+            let ang = match v.angle_sel {
+                0 => blk[keys::pos::AZ_CAMERA],
+                1 => blk[keys::pos::AZ_SKATER],
+                _ => 0,
+            } as u32;
+            l.angle = ang;
+            let q = (ang >> 14) & 3;
+            let frac = (ang as i32).wrapping_sub(16384 * q as i32);
+            let (d0, d1) = [(0, 1), (1, 2), (2, 3), (3, 0)][q as usize];
+            let kind = v.curves[q as usize];
+            let ((mn0, mx0), (mn1, mx1)) = (v.ranges[d0], v.ranges[d1]);
+            let (mn0, mx0, mn1, mx1) = (mn0 as f32, mx0 as f32, mn1 as f32, mx1 as f32);
+            if x > mx0 && x > mx1 {
+                (l.mb, l.lin, l.doppler) = (SILENT_MB, 0, 0);
+                continue;
+            }
+            let clamp = |x: f32, lo: f32, hi: f32| {
+                let v = if lo > x { lo } else { x };
+                if hi < v { hi } else { v }
+            };
+            let ratio = |x: f32, lo: f32, hi: f32| if hi != lo { trunc(((x - lo) / (hi - lo)) * 32767.0) } else { 0 };
+            let ra = ratio(clamp(x, mn0, mx0), mn0, mx0);
+            let rb = ratio(clamp(x, mn1, mx1), mn1, mx1);
+            let ca = self.t.shape(ra, kind);
+            let cb = if frac != 0 { self.t.shape(rb, kind) } else { 32767 };
+            let w = frac.wrapping_shl(1);
+            l.lin = (32767i32.wrapping_sub(w).wrapping_mul(ca) >> 15).wrapping_add(w.wrapping_mul(cb) >> 15);
+            l.mb = self.t.lin_to_mb(l.lin);
+            let c = v.doppler;
+            if c == 0 {
+                continue;
+            }
+            let (flag, speed) = if v.dist_sel == 1 { (0x8000_0000u32, fl(keys::pos::SPEED_SKATER)) } else { (0x4000_0000, fl(keys::pos::SPEED_CAMERA)) };
+            let target = if blk[keys::pos::FLAGS] as u32 & flag != 0 {
+                blk[keys::pos::FLAGS] = (blk[keys::pos::FLAGS] as u32 & !flag) as i32;
+                0
+            } else {
+                let mut span = speed + c as f32;
+                if !(span > 0.0) {
+                    span = c as f32;
+                }
+                self.t.ratio_to_cents(c as f32 / span)
+            };
+            let step = trunc((i64::from(target) - i64::from(l.doppler)) as f32 * -0.2f32);
+            l.doppler = l.doppler.wrapping_sub(step);
+        }
+    }
+
+    fn envelopes_tick(&mut self) {
+        for i in 0..self.envelopes.len() {
+            let trig = self.value(self.envelopes[i].trigger, false) != 0;
+            let f = &mut self.envelopes[i];
+            if f.stage == 0 && !trig {
+                (f.elapsed, f.start, f.t0, f.stage, f.level) = (0.0, 0, 0.0, 0, 0);
+                f.mb = if f.linear { SILENT_MB } else { 0 };
+                continue;
+            }
+            f.elapsed += self.dt_ms;
+            step_envelope(&self.t, f, trig);
+            let t = &self.t;
+            f.mb = if f.linear {
+                t.lin_to_mb(f.level)
+            } else {
+                let scaled = f.level.wrapping_mul(f.depth) >> 15;
+                if f.boost {
+                    f.offset.wrapping_add(t.lin_to_mb(scaled.wrapping_sub(f.depth).wrapping_add(32767)))
+                } else {
+                    t.lin_to_mb(32767i32.wrapping_sub(scaled))
+                }
+            };
+            if !self.envelopes[i].refs.is_empty() {
+                let acc = self.scale(&self.envelopes[i].refs);
+                let t = &self.t;
+                let f = &mut self.envelopes[i];
+                f.mb = if f.linear { t.lin_to_mb(t.mb_to_lin(f.mb).wrapping_mul(acc) >> 15) } else { f.mb.wrapping_mul(acc) >> 15 };
+            }
+        }
+    }
+
+    fn write_outputs(&mut self) {
+        for i in 0..self.outputs.len() {
+            let e = &self.outputs[i];
+            let dest = e.dest;
+            let put = |blk: &mut [u32; 16], id: u32, v: i32| {
+                let (w, sh) = ((id >> 1) as usize & 15, if id & 1 == 1 { 16 } else { 0 });
+                blk[w] = (blk[w] & !(0xFFFF << sh)) | (((v as u32) & 0xFFFF) << sh);
+            };
+            if self.ctls[dest].outputs[keys::ENABLE_WORD] & 1 == 0 {
+                if let Some(o) = e.outs.first() {
+                    let v = match e.kind {
+                        1 => 0,
+                        2 => 25000,
+                        _ => SILENT_MB,
+                    };
+                    put(&mut self.ctls[dest].outputs, o.id, v);
+                }
+                continue;
+            }
+            for o in &e.outs {
+                let v = e.value.wrapping_add(o.offset);
+                let val = if let Some(&b) = e.special.get(o.special as usize) {
+                    let b = &self.lookups[b];
+                    if o.raw_angle {
+                        put(&mut self.ctls[dest].outputs, o.id, (b.angle & 0xFFFF) as i32);
+                        continue;
+                    }
+                    match e.kind {
+                        0 | 4 => self.t.mb_to_lin(b.mb.wrapping_add(v).clamp(SILENT_MB, 0)),
+                        1 => {
+                            let x = b.doppler.wrapping_add(v);
+                            if x > 2400 {
+                                2400
+                            } else if x < -4800 {
+                                0
+                            } else {
+                                x
+                            }
+                        }
+                        2 => v.clamp(SILENT_MB, 0),
+                        _ => e.value,
+                    }
+                } else {
+                    match e.kind {
+                        0 | 4 => self.t.mb_to_lin(v.clamp(SILENT_MB, 0)),
+                        1 => v.clamp(-4800, 2400),
+                        2 => trunc(self.t.cents_ratio(v.clamp(SILENT_MB, 0)) * 25000.0),
+                        _ => v.clamp(0, 25000),
+                    }
+                };
+                put(&mut self.ctls[dest].outputs, o.id, val);
+            }
+        }
+    }
+}
+
+/// The envelope stage machine (spec §5.4), one evaluation.
+fn step_envelope(t: &Tables, f: &mut Envelope, trig: bool) {
+    let [a_ms, d_ms, h_ms, r_ms] = f.ms;
+    let [ca, cd, cr] = f.curves;
+    let kind = f.kind;
+    let progress = |f: &Envelope, span: f32| {
+        let sp = span - f.t0;
+        let x = f.elapsed - f.t0;
+        if sp > 0.0 { x / sp } else { x }
+    };
+    let enter = |f: &mut Envelope, stage: u32, level: i32| {
+        (f.elapsed, f.stage, f.t0, f.start) = (0.0, stage, 0.0, level);
+    };
+    let carry = |f: &mut Envelope, stage: u32, from: f32, to: f32| {
+        f.stage = stage;
+        f.start = f.level;
+        let x = if from < t.k_min_ramp { to } else { ((from - f.elapsed) / from) * to };
+        (f.t0, f.elapsed) = (x, x);
+    };
+    for _ in 0..16 {
+        let s = f.stage;
+        if (kind == 3 && s > 3) || (kind != 3 && s >= 4) || (kind == 0 && s > 1) {
+            if !(f.elapsed < r_ms) {
+                (f.elapsed, f.t0, f.start, f.stage, f.level, f.mb) = (0.0, 0.0, 0, 0, 0, 0);
+                return;
+            }
+            if !trig || !f.retrigger {
+                let c = t.curve01(cr, 1.0 - progress(f, r_ms));
+                let start = f.start;
+                f.level = if kind == 0 { start - trunc(c * start as f32) } else { start - trunc((1.0 - c) * start as f32) };
+                return;
+            }
+            carry(f, 1, r_ms, a_ms);
+            continue;
+        }
+        if s == 0 {
+            f.stage = 1;
+        }
+        if s <= 1 {
+            if kind != 0 && f.gated && !trig {
+                carry(f, 4, a_ms, r_ms);
+                continue;
+            }
+            if f.elapsed < a_ms {
+                if (kind == 3 && !(a_ms > t.k_min_ramp)) || (kind != 3 && a_ms == 0.0) {
+                    f.level = 32767;
+                    return;
+                }
+                let c = t.curve01(ca, progress(f, a_ms));
+                f.level = trunc(c * (32767 - f.start) as f32) + f.start;
+                return;
+            }
+            enter(f, if kind == 0 { 4 } else if kind == 1 { 3 } else { 2 }, 32767);
+            continue;
+        }
+        if kind == 1 && s == 3 {
+            if (!trig && f.gated) || (!f.gated && f.elapsed > h_ms) {
+                enter(f, 4, 32767);
+                continue;
+            }
+            f.level = 32767;
+            if f.gated {
+                f.elapsed = 0.0;
+            }
+            return;
+        }
+        if kind == 3 && s == 2 {
+            if !trig && f.gated {
+                f.stage = 4;
+                let x = ((d_ms - f.elapsed) / d_ms) * r_ms;
+                (f.start, f.t0, f.elapsed) = (f.level, x, x);
+                continue;
+            }
+            if !(f.elapsed > d_ms) {
+                let c = t.curve01(cd, 1.0 - progress(f, d_ms));
+                f.level = trunc((1.0 - c) * (f.sustain - f.start) as f32) + f.start;
+                return;
+            }
+            enter(f, 3, f.sustain);
+            continue;
+        }
+        if kind == 3 && s == 3 {
+            if (!trig && f.gated) || (!f.gated && f.elapsed > h_ms) {
+                enter(f, 4, f.sustain);
+                continue;
+            }
+            f.level = f.sustain;
+            if f.gated {
+                f.elapsed = 0.0;
+            }
+            return;
+        }
+        return;
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/skate-audio/src/mixmap/tables.rs b/crates/skate-audio/src/mixmap/tables.rs
new file mode 100644
index 00000000..56fb95bc
--- /dev/null
+++ b/crates/skate-audio/src/mixmap/tables.rs
@@ -0,0 +1,254 @@
+//! The MixMap's lookup tables and integer conversions (spec `.claude/notes/mixmap-spec.md` §5.0).
+//!
+//! Every table is generated by its formula. Against the TU3 image (`mxb_tool.py tables`) POW, LOG,
+//! CURVE and SEMI are identical; FINE differs by one ulp at entries 15, 36, 56 and 65, which are
+//! patched here with the image's values (facts, not code).
+
+pub const SILENT_MB: i32 = -10_000;
+
+#[derive(Clone, Debug)]
+pub struct Tables {
+    /// `int(32768·10^(−(r+1)/2000))`, r = 0..601, with POW[601] = 16384.
+    pub pow: [i32; 602],
+    /// lin → mB fraction table (512 entries).
+    pub log: [i32; 512],
+    /// `floor(32767·cos(π/2·i/511))`, i = 0..511.
+    pub curve: [i32; 512],
+    /// f32(2^(i/12)).
+    pub semi: [f32; 12],
+    /// f32(2^(i/1200)), four entries patched.
+    pub fine: [f32; 100],
+    /// Cents per mB for ratios > 1 and ≤ 1 (`0x822F8AE0` / `0x822F8AE4`).
+    pub k_ratio: (f32, f32),
+    /// The envelopes' "too short to ramp" threshold (ms, `0x822F8ADC`).
+    pub k_min_ramp: f32,
+    /// One 60 Hz frame in ms (`0x822F8F04`).
+    pub k_frame_ms: f32,
+}
+
+impl Default for Tables {
+    fn default() -> Self {
+        Self::generate()
+    }
+}
+
+impl Tables {
+    pub fn generate() -> Self {
+        let mut pow = [0i32; 602];
+        for (r, p) in pow.iter_mut().enumerate() {
+            *p = (32768.0 * 10f64.powf(-((r + 1) as f64) / 2000.0)) as i32;
+        }
+        pow[601] = 16384;
+        let mut log = [0i32; 512];
+        for (i, l) in log.iter_mut().enumerate() {
+            let above = pow.iter().filter(|&&p| p >= 16384 + 32 * i as i32).count() as i32;
+            *l = (601 - above).max(0);
+        }
+        let mut curve = [0i32; 512];
+        for (i, c) in curve.iter_mut().enumerate() {
+            *c = (32767.0 * (std::f64::consts::FRAC_PI_2 * i as f64 / 511.0).cos()).floor() as i32;
+        }
+        let semi = std::array::from_fn(|i| 2f64.powf(i as f64 / 12.0) as f32);
+        let mut fine: [f32; 100] = std::array::from_fn(|i| 2f64.powf(i as f64 / 1200.0) as f32);
+        fine[15] = 1.008_701_920_509_338_4;
+        fine[36] = 1.021_012_187_004_089_4;
+        fine[56] = 1.032_875_776_290_893_6;
+        fine[65] = 1.038_259_267_807_006_8;
+        Self {
+            pow,
+            log,
+            curve,
+            semi,
+            fine,
+            // ±1200/602.06 as stored in the image (not the nearest f32 to 1.99316).
+            k_ratio: (f32::from_bits(0xBFFF_1FC4), f32::from_bits(0x3FFF_1FC4)),
+            k_min_ramp: 16.666,
+            // 16.66667 as stored (2 ulps above the nearest f32 to 1000/60).
+            k_frame_ms: f32::from_bits(0x4185_5557),
+        }
+    }
+
+    /// mB → Q15 linear, for m ≤ 0 (anything above 0 gives 0, as retail's callers never pass it).
+    /// 0 mB → 32730, not 32767.
+    pub fn mb_to_lin(&self, m: i32) -> i32 {
+        if m > 0 {
+            return 0;
+        }
+        let neg = -(m as i64);
+        let k = neg / 602;
+        let rem = neg - 602 * k;
+        if k > 15 {
+            return 0;
+        }
+        self.pow[rem as usize] >> k
+    }
+
+    /// Q15 linear → mB; 0 or anything above 32767 (as an unsigned word) → `default`.
+    pub fn lin_to_mb_or(&self, x: i32, default: i32) -> i32 {
+        let x = x as u32;
+        if x == 0 || x > 0x7FFF {
+            return default;
+        }
+        let c = 14 - (31 - x.leading_zeros()) as i32; // 0 for 16384..32767
+        let idx = if c <= 5 {
+            ((x - (1 << (14 - c))) >> (5 - c)) as usize
+        } else {
+            let scaled = (x << (c - 5)).wrapping_sub(512) | ((1 << (c - 5)) - 1);
+            (scaled & 0x1FF) as usize
+        };
+        self.log[idx] - 602 * (c + 1)
+    }
+
+    pub fn lin_to_mb(&self, x: i32) -> i32 {
+        self.lin_to_mb_or(x, SILENT_MB)
+    }
+
+    /// The input curve `kind` (0..9) applied to a Q15 value (spec §5.0 `shape`).
+    pub fn shape(&self, x: i32, kind: u32) -> i32 {
+        let frac = |x: i32| (((x >> 1) & 0xF) << 10) | 1023;
+        match kind {
+            0 => {
+                let i = x >> 6;
+                if !(0..511).contains(&i) {
+                    return 0;
+                }
+                let t = self.curve[i as usize];
+                if t == 0 {
+                    return 0;
+                }
+                ((self.curve[i as usize + 1] - t).wrapping_mul(frac(x)) >> 15).wrapping_add(t)
+            }
+            1 => self.shape(32767i32.wrapping_sub(x), 0),
+            2 => {
+                let y = self.shape(x, 0);
+                y.wrapping_mul(y) >> 15
+            }
+            3 => self.shape(32767i32.wrapping_sub(x), 2),
+            4 => {
+                let i = 511i32.wrapping_sub(x >> 6);
+                let at = |i: i32| if (0..512).contains(&i) { Some(self.curve[i as usize]) } else { None };
+                let a = at(i).map_or(32767, |c| 32767 - c);
+                let b = 32767 - at(i.wrapping_add(1)).unwrap_or(0);
+                ((b - a).wrapping_mul(frac(x)) >> 15).wrapping_add(a)
+            }
+            5 => self.shape(32767i32.wrapping_sub(x), 4),
+            6 => {
+                let y = self.shape(x, 4);
+                y.wrapping_mul(y) >> 15
+            }
+            7 => self.shape(32767i32.wrapping_sub(x), 6),
+            8 => 32767i32.wrapping_sub(x),
+            9 => x,
+            _ => 0,
+        }
+    }
+
+    /// `shape(trunc(f·32767), kind) / 32767` in f32 (the envelopes' curve on a 0..1 progress).
+    pub fn curve01(&self, kind: u32, f: f32) -> f32 {
+        let r = if kind <= 9 { self.shape(trunc(f * 32767.0), kind) } else { 0 };
+        r as f32 * (1.0f32 / 32767.0)
+    }
+
+    /// 2^(c/1200) from whole octaves × SEMI × FINE, single precision (spec §5.0).
+    pub fn cents_ratio(&self, c: i32) -> f32 {
+        let neg = c < 0;
+        let mut c = c;
+        let mut f0 = 1.0f32;
+        if c >= 1200 {
+            let q = c / 1200;
+            c -= q * 1200;
+            f0 *= 2f32.powi(q);
+        }
+        if c <= -1200 {
+            let q = (-1200 - c) / 1200 + 1;
+            c += q * 1200;
+            f0 *= 2f32.powi(q);
+        }
+        if !neg {
+            return (self.fine[(c % 100) as usize] * self.semi[(c / 100) as usize]) * f0;
+        }
+        let r = -c;
+        ((1.0f32 / self.semi[(r / 100) as usize]) / f0) * (1.0f32 / self.fine[(r % 100) as usize])
+    }
+
+    /// Ratio → cents via the mB table (the Doppler target).
+    pub fn ratio_to_cents(&self, r: f32) -> i32 {
+        let (lin, k) = if r > 1.0 { (32767.0f32 / r, self.k_ratio.0) } else { (r * 32767.0, self.k_ratio.1) };
+        trunc(self.lin_to_mb(trunc(lin)) as f32 * k)
+    }
+
+    /// Owner reader vfunc56: cents → pitch with 4096 = 1.0.
+    pub fn pitch_4096(&self, cents: i32) -> i32 {
+        trunc(self.cents_ratio(cents) * 4096.0)
+    }
+}
+
+/// Round toward zero (fctiwz); NaN → 0, saturating.
+pub fn trunc(x: f32) -> i32 {
+    if x.is_nan() { 0 } else { x as i32 }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn spec_examples() {
+        let t = Tables::generate();
+        assert_eq!(t.mb_to_lin(0), 32730);
+        assert_eq!(t.mb_to_lin(-10000), 0);
+        assert_eq!(t.mb_to_lin(-602), 32730 >> 1);
+        assert_eq!(t.lin_to_mb(32767), -1);
+        assert_eq!(t.lin_to_mb(16384), -602);
+        assert_eq!(t.lin_to_mb(1), 601 - 602 * 15);
+        assert_eq!(t.lin_to_mb(0), -10000);
+        assert_eq!(t.lin_to_mb(40000), -10000);
+        assert_eq!(t.pow[601], 16384);
+        assert_eq!(t.curve[0], 32767);
+        assert_eq!(t.curve[511], 0);
+        // Curves: cos falls 1 → 0, sin rises, 1−x, x.
+        assert_eq!(t.shape(0, 0), 32766); // the 4-bit fraction interpolates a little
+        assert_eq!(t.shape(32767, 0), 0);
+        assert_eq!(t.shape(0, 1), 0);
+        assert_eq!(t.shape(1000, 8), 31767);
+        assert_eq!(t.shape(1000, 9), 1000);
+        assert_eq!(t.shape(1000, 12), 0);
+        // Pitch reader: 0 cents = 4096, an octave up/down.
+        assert_eq!(t.pitch_4096(0), 4096);
+        assert_eq!(t.pitch_4096(1200), 8192);
+        assert_eq!(t.pitch_4096(-1200), 2048);
+        // Filter conversion: −2 cents of 25 kHz = 24971 Hz, −10000 → 77 Hz.
+        assert_eq!(trunc(t.cents_ratio(-2) * 25000.0), 24971);
+        assert_eq!(trunc(t.cents_ratio(-1) * 25000.0), 24985);
+        assert_eq!(trunc(t.cents_ratio(-10000) * 25000.0), 77);
+    }
+
+    /// The generated tables against the retail image's, when the private TU3 image is present.
+    #[test]
+    fn tables_match_the_image_when_present() {
+        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../../.local/tu3-image/default_82000000_011B0000.bin");
+        let Ok(img) = std::fs::read(path) else {
+            eprintln!("skipped: no TU3 image at {path}");
+            return;
+        };
+        let word = |a: u32| u32::from_be_bytes(img[(a - 0x8200_0000) as usize..][..4].try_into().unwrap());
+        let t = Tables::generate();
+        for i in 0..512 {
+            assert_eq!(t.log[i], word(0x82FD_BFB0 + 4 * i as u32) as i32, "log {i}");
+            assert_eq!(t.curve[i], word(0x82FD_C7B0 + 4 * i as u32) as i32, "curve {i}");
+        }
+        for r in 0..602 {
+            assert_eq!(t.pow[r], word(0x82FD_BFAC - 4 * r as u32) as i32, "pow {r}");
+        }
+        for i in 0..12 {
+            assert_eq!(t.semi[i].to_bits(), word(0x82FD_CFB4 + 4 * i as u32), "semi {i}");
+        }
+        for i in 0..100 {
+            assert_eq!(t.fine[i].to_bits(), word(0x82FD_CFE8 + 4 * i as u32), "fine {i}");
+        }
+        assert_eq!(t.k_ratio.0.to_bits(), word(0x822F_8AE0));
+        assert_eq!(t.k_ratio.1.to_bits(), word(0x822F_8AE4));
+        assert_eq!(t.k_min_ramp.to_bits(), word(0x822F_8ADC));
+        assert_eq!(t.k_frame_ms.to_bits(), word(0x822F_8F04));
+    }
+}
diff --git a/crates/skate-audio/src/mixmap/tests.rs b/crates/skate-audio/src/mixmap/tests.rs
new file mode 100644
index 00000000..58a2fdcf
--- /dev/null
+++ b/crates/skate-audio/src/mixmap/tests.rs
@@ -0,0 +1,151 @@
+use super::format::*;
+use super::*;
+
+/// A one-slot file built in memory: Ambience-like slot 0 with one input product, one sum, one
+/// volume output and one envelope ducking it.
+fn tiny() -> MixMapFile {
+    let input = keys::obj(0, 0, 0); // Obj 0.0 input 0, curve 0 (cos)
+    let section = Section {
+        slot: 0,
+        products: vec![ProductRec { input, swing: (-10000i16) as u16, refs: vec![] }],
+        lookups: vec![],
+        sums: vec![SumRec { word0: 0xD001_0000, max: 0, min: -10000, refs: vec![0x0000_0000] }],
+        outputs: vec![OutputRec {
+            word0: 0xC002_0000,
+            base: -600,
+            dest: keys::obj(0, 0, 0),
+            refs: vec![0x3000_0000, 0xA000_0000],
+            kind: 0,
+            outs: vec![OutputWord { id: 0, special: 31, raw_angle: false, offset: 0 }],
+        }],
+        envelopes: vec![EnvelopeRec {
+            word0: 0x0100_0100,
+            kind: 1,
+            gated: true,
+            linear: false,
+            retrigger: false,
+            swing: (-1000i16) as u16,
+            trigger: keys::obj(0, 0, 0) | 1,
+            attack: (6, 9),
+            decay: (0, 9),
+            hold: 5,
+            release: (6, 9),
+            sustain: 32767,
+            refs: vec![],
+        }],
+    };
+    MixMapFile { id: 0, slots: vec![Some(section)] }
+}
+
+#[test]
+fn a_duck_envelope_and_a_cut_product_drive_a_volume_output() {
+    // The E record sums C0 (key 0x3000_0000 = C/E type with the C bit) and F0 (0xA000_0000).
+    let mut m = MixMap::new(&tiny(), &[1]);
+    let owner = keys::obj(0, 0, 0);
+    m.tick(1.0 / 60.0);
+    // Input 0 = 0 → cos(0) = full → the cut is 0 mB; base −600 → 16422-ish; the duck is idle.
+    let full = m.level(owner, 0);
+    assert_eq!(full, m.tables().mb_to_lin(-600 - 1));
+    // Input 0 at 32767 → cos → 0 → the cut reaches −10000: silent.
+    m.set_input(owner, 0, 32767);
+    m.tick(1.0 / 60.0);
+    assert!(m.level(owner, 0) <= 1);
+    // Duck: trigger on → attack over 6 frames (100 ms) to −1000 mB.
+    m.set_input(owner, 0, 0);
+    m.set_input(owner, 1, 1);
+    let mut levels = Vec::new();
+    for _ in 0..12 {
+        m.tick(1.0 / 60.0);
+        levels.push(m.level(owner, 0));
+    }
+    assert!(levels.windows(2).all(|w| w[1] <= w[0]), "attack falls monotonically: {levels:?}");
+    let ducked = *levels.last().unwrap();
+    let expect = m.tables().mb_to_lin(-600 - 1 - 1000);
+    assert!((ducked - expect).abs() <= 40, "{ducked} vs {expect}");
+    // Release when the trigger goes off.
+    m.set_input(owner, 1, 0);
+    for _ in 0..20 {
+        m.tick(1.0 / 60.0);
+    }
+    assert_eq!(m.level(owner, 0), full);
+}
+
+#[test]
+fn a_disabled_block_writes_its_first_id_only() {
+    let mut fixed = tiny();
+    fixed.slots[0].as_mut().unwrap().outputs[0].refs = vec![];
+    let mut m = MixMap::new(&fixed, &[1]);
+    let owner = keys::obj(0, 0, 0);
+    m.set_enabled(owner, false);
+    m.tick(1.0 / 60.0);
+    // −10000 read back through & 0x7FFF = 22768 (spec §5.7).
+    assert_eq!(m.level(owner, 0), 22768);
+}
+
+fn disc_mxb() -> Option<Vec<u8>> {
+    let root = concat!(env!("CARGO_MANIFEST_DIR"), "/../..");
+    ["/assets/private/audio/aems/MixMapSK8.mxb", "/.local/skate3-disc/data/audio/MixMapSK8.mxb"]
+        .iter()
+        .find_map(|p| std::fs::read(format!("{root}{p}")).ok())
+}
+
+/// The retail file instantiates exactly the spec's census (§2.4).
+#[test]
+fn disc_mixmap_census() {
+    let Some(bytes) = disc_mxb() else {
+        eprintln!("skipped: no MixMapSK8.mxb in the dev install or .local/skate3-disc");
+        return;
+    };
+    let file = MixMapFile::parse(&bytes).unwrap();
+    assert_eq!(file.slots.len(), 14);
+    let per_slot: Vec<[usize; 5]> = file
+        .slots
+        .iter()
+        .map(|s| s.as_ref().map_or([0; 5], |s| [s.products.len(), s.lookups.len(), s.envelopes.len(), s.sums.len(), s.outputs.len()]))
+        .collect();
+    assert_eq!(per_slot[0], [180, 1, 245, 12, 65]);
+    assert_eq!(per_slot[1], [122, 14, 37, 18, 92]);
+    assert_eq!(per_slot[2], [3, 0, 0, 1, 4]);
+    assert_eq!(per_slot[6], [0, 1, 0, 2, 8]);
+    let m = MixMap::new(&file, &RETAIL_INSTANCES);
+    assert_eq!(m.counts(), [547, 853, 635, 350, 240, 1044]);
+    assert_eq!(m.output_blocks(), 154);
+    assert_eq!(m.controller_count(), 247);
+}
+
+/// Free-skate steady state (Master.in1–4 = 32767, the rest 0): the spec's emitter and ambience
+/// outputs (§6.2, §6.3).
+#[test]
+fn disc_mixmap_free_skate_outputs() {
+    let Some(bytes) = disc_mxb() else {
+        eprintln!("skipped: no MixMapSK8.mxb");
+        return;
+    };
+    let mut m = MixMap::from_bytes(&bytes).unwrap();
+    for id in 1..=4 {
+        m.set_input(keys::MASTER, id, 32767);
+    }
+    for _ in 0..5 {
+        m.tick(1.0 / 60.0);
+    }
+    let e = keys::emitter(0);
+    // Positional dry −600 mB + the Global ducks' rest values (no distance roll-off); the same
+    // value the PoC's MixMap port gives (golden1.poc.csv).
+    assert_eq!(m.level(e, 4), 16365);
+    assert_eq!(m.pitch_4096(e, 5), 4096);
+    assert_eq!(m.filter_hz(e, 6), 24971); // −2 cents of 25 kHz
+    // Emitter 3-D input inactive → B0 silent → the positional send is 0.
+    assert_eq!(m.level(e, 8), 0);
+    // Ambience out0 ≈ −1100 mB (bed fade 0 = up), out3 = 24971 Hz.
+    let t = m.tables();
+    let bed = m.level(keys::AMBIENCE, 0);
+    assert!((t.lin_to_mb(bed) + 1100).abs() < 20, "bed {bed}");
+    assert_eq!(m.filter_hz(keys::AMBIENCE, 3), 24971);
+    assert_eq!(m.pitch_4096(keys::AMBIENCE, 2), 4096);
+    // Without the Master category gains everything is about −100 dB.
+    let mut silent = MixMap::from_bytes(&bytes).unwrap();
+    for _ in 0..5 {
+        silent.tick(1.0 / 60.0);
+    }
+    assert_eq!(silent.level(e, 4), 0);
+}
diff --git a/crates/skate-audio/src/player/clothing.rs b/crates/skate-audio/src/player/clothing.rs
new file mode 100644
index 00000000..3b1e195d
--- /dev/null
+++ b/crates/skate-audio/src/player/clothing.rs
@@ -0,0 +1,363 @@
+//! The skater's clothing: retail's `SFXObj_Clothing` (controller `0x40010060`). Written from our
+//! reading of the retail code (TU3, reference only; spec `.claude/notes/aems-offboard-clothing-spec.md`):
+//!
+//! - process `sub_824DBB68`: cloth falls `sub_824DBF10`, push foley `sub_824DBBB8`, body slide
+//!   `sub_824DC0E8`;
+//! - cloth falls: `c_cloth_falls` (10 words, `Foley_Cloth`, constructor `sub_824B72D8`) posted on
+//!   the bail's rising edge (`+676`) with w3 = trunc(`+328` / 5 × 1000), released at the end of the
+//!   bail (`+677`) or when the bail flag drops; the level word kept for the update is max of that
+//!   and trunc(`+672` / 5 × 1000);
+//! - push foley: `sk8_foley` 73 on the push stroke's rising edge (`+337`; stopped by the push plant
+//!   `+335` or a bail) and 74 on each push plant (`+335`; stopped by a bail), both on eEQChain
+//!   bus 0 (`AEA5BA7E64515945`, created by the local player);
+//! - body slide: `c_body_slide` (12 words, `Bodyslide`, constructor `sub_824B7070`; helper
+//!   `sub_824DC2B0`): any of the six body-part slide records (`+528..+548`) non-zero is a slide;
+//!   speed word trunc(|COM v| / 4.5 × 1000); type = AudioSurfaceMap word 10 (`+40`) of the slide's
+//!   surface tag − 1 (part 0, overridden by part 1, else the first of parts 2..5 with a tag), 4
+//!   with `+593`, 2 without a surface; posted above speed 350, held while sliding above 150;
+//! - update `sub_824DCB98`: body slide `sub_824DC578`, cloth falls `sub_824DCA48`, push foley
+//!   `sub_824DC7D8` (level 4, pitch 3).
+//!
+//! What retail's `sk8_foley` containers 62/63/64 played by caller `824D8164` are: the pedestrians'
+//! footsteps (`SFXObj_PedestrianSFX`, vtable `0x822FCCC8`, process `sub_824D8078`), not the player.
+use super::components::{Command, Slot};
+use super::contacts::SpliceHost;
+use super::state::NO_MATERIAL;
+use super::tuning::PlayerTuning;
+use super::{AudioState, Outputs, trunc_clamp};
+use crate::splice::SoundId;
+
+pub const CLOTH_FALLS: &str = "c_cloth_falls";
+pub const BODY_SLIDE: &str = "c_body_slide";
+
+const LEVEL: f32 = f32::from_bits(0x3800_0100); // 1/32767
+const PITCH: f32 = f32::from_bits(0x3980_0000); // 1/4096
+const DEGREES: f32 = f32::from_bits(0x3BB4_00B4); // 360/65535
+/// `0x82256FE8`.
+const THOUSAND: f32 = 1000.0;
+
+/// The Clothing tuning (class `0xA867FBE3454326FF` `default` unless named; the defaults are the
+/// retail values).
+#[derive(Clone, Debug, PartialEq)]
+pub struct ClothingTuning {
+    /// `0A9A9BD1150FE838`: the cloth falls' speed divisor; eEQChain `E633C8F009CAEFFC`.
+    pub falls_divisor: f32,
+    pub falls_eq: i32,
+    /// `6FD273157742AC4B` (stroke) / `616CE02AA10D596F` (plant), `sk8_foley`; eEQChain
+    /// `AEA5BA7E64515945`.
+    pub push_ids: [u32; 2],
+    pub push_eq: u8,
+    /// Class `6EBA5BCD3E38A98A` `default`: the slide speed divisor `787171ECD02DBBC3`, the start /
+    /// hold thresholds `B021DB338B89D0F2` / `746EA8EF187E1571`, the w10 divisor `5D2F244E82CF7255`;
+    /// eEQChain `4A022FEF9905D8F4`.
+    pub slide_divisor: f32,
+    pub slide_start: i32,
+    pub slide_hold: i32,
+    pub slide_body_divisor: f32,
+    pub slide_eq: i32,
+}
+
+impl Default for ClothingTuning {
+    fn default() -> Self {
+        Self {
+            falls_divisor: 5.0,
+            falls_eq: 5,
+            push_ids: [73, 74],
+            push_eq: 0,
+            slide_divisor: 4.5,
+            slide_start: 350,
+            slide_hold: 150,
+            slide_body_divisor: 8.0,
+            slide_eq: 7,
+        }
+    }
+}
+
+/// `sub_824DC2B0`: (slide type 0..4, speed word, sliding).
+pub fn slide(s: &AudioState, t: &PlayerTuning, ct: &ClothingTuning) -> (i32, i32, bool) {
+    let mut sliding = false;
+    let mut flag = false;
+    let mut tag = 0u32;
+    for part in 0..6 {
+        if s.body_slide[part].abs() > 0.0 {
+            sliding = true;
+            if s.body_slide_flag {
+                flag = true;
+            }
+            let m = s.body_tag[part];
+            if m != 0 && (part < 2 || tag == 0) {
+                tag = m;
+            }
+        }
+    }
+    let speed = trunc_clamp((s.com_speed() / ct.slide_divisor) * THOUSAND, i32::MIN, i32::MAX);
+    let material = if (1..=NO_MATERIAL + 1).contains(&tag) { (tag - 1).min(NO_MATERIAL) } else { NO_MATERIAL };
+    let kind = if material == NO_MATERIAL {
+        2
+    } else if flag {
+        4
+    } else {
+        t.surface_entry(material).map_or(2, |e| e[10])
+    };
+    (kind, speed, sliding)
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Clothing {
+    /// `+36` last frame's bail, `+40` the cloth falls packet, `+44` its level word.
+    was_bail: bool,
+    falls: Option<Vec<i32>>,
+    falls_level: i32,
+    /// `+48` the stroke foley, `+52` the plant foley, `+56` last frame's stroke.
+    stroke: Option<SoundId>,
+    plant: Option<SoundId>,
+    was_stroke: bool,
+    /// `+60` the body slide packet.
+    slide: Option<Vec<i32>>,
+    /// Sounds started (diagnostics).
+    pub starts: u64,
+}
+
+impl Clothing {
+    /// `sub_824B72D8`'s words.
+    pub fn falls_words(level: i32, ct: &ClothingTuning) -> Vec<i32> {
+        let mut w = vec![0i32; 10];
+        w[3] = level.clamp(0, 1000);
+        w[4] = 25000;
+        w[9] = ct.falls_eq.clamp(0, 32767);
+        w
+    }
+
+    /// `sub_824B7070`'s words.
+    pub fn slide_words(speed: i32, kind: i32, bail: bool, ct: &ClothingTuning) -> Vec<i32> {
+        let mut w = vec![0i32; 12];
+        w[3] = speed.clamp(0, 1000);
+        w[4] = 25000;
+        w[8] = kind.clamp(0, 4);
+        w[9] = i32::from(bail);
+        w[11] = ct.slide_eq.clamp(0, 32767);
+        w
+    }
+
+    /// One frame before the MixMap tick (`sub_824DBB68`).
+    pub fn process(&mut self, s: &AudioState, t: &PlayerTuning, ct: &ClothingTuning, host: &mut dyn SpliceHost) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        self.cloth_falls(s, ct, &mut cmds);
+        self.push_foley(s, ct, host);
+        self.body_slide(s, t, ct, &mut cmds);
+        cmds
+    }
+
+    /// `sub_824DBF10`.
+    fn cloth_falls(&mut self, s: &AudioState, ct: &ClothingTuning, cmds: &mut Vec<Command>) {
+        let rising = !self.was_bail && s.bail;
+        let k = 1.0 / ct.falls_divisor;
+        let body = trunc_clamp((k * s.body_speed) * THOUSAND, i32::MIN, i32::MAX);
+        let limbs = trunc_clamp((s.limb_speed * k) * THOUSAND, i32::MIN, i32::MAX);
+        self.falls_level = body.max(limbs);
+        if self.falls.is_some() {
+            if s.bail_end || !s.bail {
+                self.falls = None;
+                cmds.push(Command::Release { slot: Slot::ClothFalls });
+            }
+        } else if rising {
+            let words = Self::falls_words(body, ct);
+            cmds.push(Command::Post { slot: Slot::ClothFalls, class: CLOTH_FALLS, words: words.clone() });
+            self.falls = Some(words);
+        }
+        self.was_bail = s.bail;
+    }
+
+    /// `sub_824DBBB8`.
+    fn push_foley(&mut self, s: &AudioState, ct: &ClothingTuning, host: &mut dyn SpliceHost) {
+        let stroke = s.push_stroke && !self.was_stroke;
+        let block = [0.0, 1.0, 0.0, s.dt, if s.local { 1.0 } else { 0.0 }, 1.0];
+        let route = crate::bus::Route { output: crate::bus::Output::Eq(ct.push_eq), create: s.local, owner_env: 0.0, mono: false };
+        match self.stroke {
+            None => {
+                if stroke {
+                    host.set_route(route);
+                    self.stroke = host.start("sk8_foley", ct.push_ids[0], block);
+                    self.starts += u64::from(self.stroke.is_some());
+                }
+            }
+            Some(sound) => {
+                if s.push_trigger || s.bail {
+                    host.release(sound);
+                    self.stroke = None;
+                }
+            }
+        }
+        self.was_stroke = s.push_stroke;
+        if s.push_trigger {
+            if let Some(old) = self.plant.take() {
+                host.release(old);
+            }
+            host.set_route(route);
+            self.plant = host.start("sk8_foley", ct.push_ids[1], block);
+            self.starts += u64::from(self.plant.is_some());
+        } else if s.bail {
+            if let Some(old) = self.plant.take() {
+                host.release(old);
+            }
+        }
+    }
+
+    /// `sub_824DC0E8`.
+    fn body_slide(&mut self, s: &AudioState, t: &PlayerTuning, ct: &ClothingTuning, cmds: &mut Vec<Command>) {
+        let (kind, speed, sliding) = slide(s, t, ct);
+        if self.slide.is_some() {
+            if !(speed > ct.slide_hold && sliding) {
+                self.slide = None;
+                cmds.push(Command::Release { slot: Slot::BodySlide });
+            }
+        } else if sliding && speed > ct.slide_start {
+            let words = Self::slide_words(speed, kind, s.bail, ct);
+            cmds.push(Command::Post { slot: Slot::BodySlide, class: BODY_SLIDE, words: words.clone() });
+            self.slide = Some(words);
+        }
+    }
+
+    /// One frame after the MixMap tick (`sub_824DCB98`); `out` = the Clothing outputs.
+    pub fn update(&mut self, s: &AudioState, t: &PlayerTuning, ct: &ClothingTuning, out: &dyn Outputs, host: &mut dyn SpliceHost) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        // sub_824DC578
+        if let Some(w) = self.slide.as_mut() {
+            let (kind, speed, _) = slide(s, t, ct);
+            let body = trunc_clamp((s.body_speed / ct.slide_body_divisor) * THOUSAND, i32::MIN, i32::MAX);
+            w[0] = 32767;
+            w[1] = out.raw(0).clamp(0, 65535);
+            w[2] = out.pitch(6).clamp(0, 8192);
+            w[3] = speed.clamp(0, 1000);
+            w[7] = out.level(5).clamp(0, 32767);
+            w[8] = kind.clamp(0, 4);
+            w[10] = body.clamp(0, 1000);
+            w[9] = i32::from(s.bail);
+            cmds.push(Command::Redeliver { slot: Slot::BodySlide, words: w.clone() });
+        }
+        // sub_824DCA48
+        if let Some(w) = self.falls.as_mut() {
+            w[1] = out.raw(0).clamp(0, 65535);
+            w[2] = out.pitch(1).clamp(0, 8192);
+            w[3] = self.falls_level.clamp(0, 1000);
+            w[0] = 32767;
+            w[7] = out.level(2).clamp(0, 32767);
+            cmds.push(Command::Redeliver { slot: Slot::ClothFalls, words: w.clone() });
+        }
+        // sub_824DC7D8
+        let block = [out.level(4) as f32 * LEVEL, out.pitch(3) as f32 * PITCH, out.raw(0) as f32 * DEGREES, s.dt, if s.local { 1.0 } else { 0.0 }, 1.0];
+        for slot in [&mut self.stroke, &mut self.plant] {
+            let Some(sound) = *slot else { continue };
+            if host.alive(sound) {
+                host.update(sound, block);
+            } else {
+                host.release(sound);
+                *slot = None;
+            }
+        }
+        cmds
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Default)]
+    struct Log {
+        started: Vec<(u32, crate::bus::Route)>,
+        route: crate::bus::Route,
+        live: Vec<SoundId>,
+    }
+    impl SpliceHost for Log {
+        fn set_route(&mut self, route: crate::bus::Route) {
+            self.route = route;
+        }
+        fn start(&mut self, _: &str, id: u32, _: [f32; 6]) -> Option<SoundId> {
+            self.started.push((id, std::mem::take(&mut self.route)));
+            self.live.push(self.started.len());
+            Some(self.started.len())
+        }
+        fn update(&mut self, _: SoundId, _: [f32; 6]) {}
+        fn alive(&self, sound: SoundId) -> bool {
+            self.live.contains(&sound)
+        }
+        fn release(&mut self, sound: SoundId) {
+            self.live.retain(|&s| s != sound);
+        }
+    }
+
+    struct Out;
+    impl Outputs for Out {
+        fn level(&self, id: usize) -> i32 {
+            1000 + id as i32
+        }
+        fn raw(&self, _: usize) -> i32 {
+            100
+        }
+        fn pitch(&self, id: usize) -> i32 {
+            4000 + id as i32
+        }
+    }
+
+    #[test]
+    fn a_bail_posts_the_cloth_falls_and_its_end_releases_them() {
+        let (t, ct) = (PlayerTuning::default(), ClothingTuning::default());
+        let mut c = Clothing::default();
+        let mut h = Log::default();
+        let s = AudioState { bail: true, body_speed: 3.0, limb_speed: 4.0, ..Default::default() };
+        let cmds = c.process(&s, &t, &ct, &mut h);
+        // w3 = trunc(0.2 × 3 × 1000) = 600 (the body part only); the update writes max(600, 800).
+        assert_eq!(cmds, vec![Command::Post { slot: Slot::ClothFalls, class: CLOTH_FALLS, words: vec![0, 0, 0, 600, 25000, 0, 0, 0, 0, 5] }]);
+        let up = c.update(&s, &t, &ct, &Out, &mut h);
+        assert_eq!(up, vec![Command::Redeliver { slot: Slot::ClothFalls, words: vec![32767, 100, 4001, 800, 25000, 0, 0, 1002, 0, 5] }]);
+        assert!(c.process(&s, &t, &ct, &mut h).is_empty(), "held through the bail");
+        let end = AudioState { bail_end: true, ..s };
+        assert_eq!(c.process(&end, &t, &ct, &mut h), vec![Command::Release { slot: Slot::ClothFalls }]);
+        assert!(c.process(&end, &t, &ct, &mut h).is_empty(), "only on the next rising edge");
+    }
+
+    #[test]
+    fn the_push_stroke_and_plant_play_the_push_foley_on_eq_bus_zero() {
+        let (t, ct) = (PlayerTuning::default(), ClothingTuning::default());
+        let mut c = Clothing::default();
+        let mut h = Log::default();
+        let mut s = AudioState { push_stroke: true, ..Default::default() };
+        c.process(&s, &t, &ct, &mut h);
+        c.process(&s, &t, &ct, &mut h);
+        assert_eq!(h.started.iter().map(|x| x.0).collect::<Vec<_>>(), [73], "once per stroke");
+        assert_eq!(h.started[0].1, crate::bus::Route { output: crate::bus::Output::Eq(0), create: true, owner_env: 0.0, mono: false });
+        s.push_trigger = true;
+        c.process(&s, &t, &ct, &mut h);
+        assert_eq!(h.started.last().unwrap().0, 74);
+        assert!(c.stroke.is_none(), "the plant stops the stroke foley");
+    }
+
+    #[test]
+    fn a_body_slide_posts_above_350_and_holds_above_150() {
+        let mut t = PlayerTuning::default();
+        t.surface_table = vec![[0; 18]; 95];
+        t.surface_table[40][10] = 1;
+        let ct = ClothingTuning::default();
+        let mut c = Clothing::default();
+        let mut h = Log::default();
+        let mut body_slide = [0.0; 6];
+        body_slide[2] = 0.8;
+        let mut body_tag = [0; 6];
+        body_tag[2] = 41;
+        let fast = AudioState { com_velocity: [2.0, 0.0, 0.0], body_slide, body_tag, bail: true, body_speed: 4.0, ..Default::default() };
+        // |COM v| 2 m/s → 444 > 350; the slide's tag 41 → material 40 → AudioSurfaceMap +40 = 1.
+        let cmds = c.process(&AudioState { bail: false, ..fast }, &t, &ct, &mut h);
+        assert_eq!(cmds, vec![Command::Post { slot: Slot::BodySlide, class: BODY_SLIDE, words: vec![0, 0, 0, 444, 25000, 0, 0, 0, 1, 0, 0, 7] }]);
+        let up = c.update(&fast, &t, &ct, &Out, &mut h);
+        let Command::Redeliver { words, .. } = &up[0] else { panic!() };
+        // w1 raw, w2 pitch(6), w3 speed, w7 level(5), w8 type, w9 bail, w10 trunc(4 / 8 × 1000).
+        assert_eq!(words, &vec![32767, 100, 4006, 444, 25000, 0, 0, 1005, 1, 1, 500, 7]);
+        let slow = AudioState { com_velocity: [0.5, 0.0, 0.0], bail: false, ..fast };
+        assert_eq!(c.process(&slow, &t, &ct, &mut h), vec![Command::Release { slot: Slot::BodySlide }]);
+        // With the +593 flag every slide is type 4.
+        let flagged = AudioState { body_slide_flag: true, ..fast };
+        assert_eq!(slide(&flagged, &t, &ct).0, 4);
+        assert_eq!(slide(&AudioState { body_tag: [0; 6], ..fast }, &t, &ct).0, 2);
+    }
+}
diff --git a/crates/skate-audio/src/player/collision.rs b/crates/skate-audio/src/player/collision.rs
new file mode 100644
index 00000000..8416b98c
--- /dev/null
+++ b/crates/skate-audio/src/player/collision.rs
@@ -0,0 +1,693 @@
+//! The collision manager (`CSTATEMGR_Collision` with ten `CSTATE_Collision` slots, each one
+//! `SFXObj_Collision`): the contact one-shots of two materials meeting — a board landing on a
+//! landing-flag surface, the board / truck hitting a rail or ledge at a grind start, deck impacts,
+//! body impacts. Written from our reading of the retail code (TU3, reference only; addresses are
+//! facts):
+//!
+//! - post `sub_82486EF0`: a 48-byte message (`+0/+4` materials A/B, `+8/+12` their impact tiers
+//!   (3 = none), `+16` a world position, `+32/+36` the two 0..32767 contact levels, bytes
+//!   `+40..+42`) goes to the router `sub_824F1818`: the first inactive slot in list order, else the
+//!   slot with the oldest stamp (deactivated first, `sub_824F8B58`); `sub_824F8990` stamps it, parks
+//!   the message and activates it (`sub_828DF6F0` → `sub_824D1DB8`: the slot's 3-D position
+//!   controller takes the message position);
+//! - process `sub_824D1E00` (before the MixMap tick): inputs 0 and 1 of the slot's controller
+//!   (`0x40030000 | slot << 11`) cleared; while active and holding a voice, input 0 = 32767 and
+//!   input 1 = 10000 / 20000 / 32767 for the larger message tier 0 / 1 / 2 (3 = "take the other");
+//! - update `sub_824D2318` (after the tick): with no voice held, start them (`sub_824D1F68`: per
+//!   material with a tier ≠ 3, the sample `sub_824965D0` → `sub_824967F8` picks from the
+//!   material's AudioSurface record by its kind (the Splice bank family: Skate_Collisions /
+//!   Skate_Metal / HOM_Set_1), its tier and the other material's collision class; gain record
+//!   `+52`, pitch `+68`); else per held voice the block [gain, pitch, azimuth, dt, 0, 1] with gain
+//!   = trunc(trunc(level_msg / 32767 × level(category output)) × gain_rec / 32767) / 32767, pitch
+//!   = trunc(pitch output × pitch_rec / 4096) / 4096 (output 22 for category 9, else 1), azimuth
+//!   raw(0); a voice that ended is released, and with both gone the slot deactivates;
+//! - the contact level `sub_82496C58`: the material's window record (class `13E20D398E385A56`) by
+//!   tier and the other material's class, interpolated over the poster's [low, high] range; the
+//!   impact band `sub_82497088` (class `7DAFF70B3A91CD5D`).
+//!
+//! - the per-voice "Collision SubMix" `sub_824D25E0` (built before each voice starts, when
+//!   [`CollisionManager::submix`] is on): a mono bus (order 4, `Sub0 → Sen0 → Sen0`) the voice's
+//!   final Send sums into (6 → 1); Sen0 #1 → the env bus at the Collision output of the
+//!   material's category (`sub_824D21D0`: outputs 2..11) / 32767, posted once at build; Sen0 #2
+//!   (class default 1.0) → the eEQChain bus `sub_82497BF8` picks from the material's
+//!   AudioSurfaceMap words 12..16 by tier and the other material's class (every shipped entry
+//!   holds 8 = SFX Master), into the bus's centre.
+//!
+//! Not modelled: the Hall of Meat override in `sub_824965D0` (global `+564`, materials 97..100 → kind 8), the stamp's
+//! global counter (`*(0x830CFD94)+16`, UNCERTAIN: we use the post order) and the flagged
+//! (`+57` / `+56`) alternate window / band records, which no ported poster asks for.
+use super::Outputs;
+use super::contacts::SpliceHost;
+use super::objpos::{Listener, ObjPos};
+use crate::mixmap::{MixMap, keys};
+use crate::splice::SoundId;
+
+/// Slots `sub_824F17B8` builds.
+pub const SLOTS: usize = 10;
+/// No material (`+620` and the message words).
+pub const NO_MATERIAL: i32 = 143;
+/// The message's "no tier".
+pub const NO_TIER: i32 = 3;
+/// The Splice bank of each material kind (the image table's `+0` word).
+pub const BANKS: [&str; 3] = ["Skate_Collisions", "Skate_Metal", "HOM_Set_1"];
+
+const INV_32767: f32 = f32::from_bits(0x3800_0100);
+const INV_4096: f32 = f32::from_bits(0x3980_0000);
+const DEGREES: f32 = f32::from_bits(0x3BB4_00B4);
+
+/// One material's AudioSurface record as the collision code reads it (exported by setup,
+/// `audio_export.collision_tuning`).
+#[derive(Clone, Debug, PartialEq)]
+pub struct Material {
+    /// The image table's kind word (Splice bank family; −1 = none).
+    pub kind: i32,
+    /// Sample ids [tier 2, tier 0 × class 0/1/2, tier 1 × class 0/1/2].
+    pub ids: [i32; 7],
+    /// `+52` gain (clamped 0..32767 at use), `+68` pitch (4096 = 1), `+56` pitch override flag
+    /// and the optional override `0x3A3DD47E8DAFE796`, `+72` category, `+124` landing flag.
+    pub gain: i32,
+    pub pitch: i32,
+    pub pitch_flag: bool,
+    pub pitch_alt: i32,
+    pub category: i32,
+    pub landing: bool,
+    /// The contact-level windows (record offsets +0..+36 and +44..+56, 14 words) and `+40` (the
+    /// second deck post's level scale, `sub_82496F50`). Zero when the RefSpec does not resolve.
+    pub windows: [i32; 14],
+    pub scale: f32,
+    /// Impact bands `+0`, `+4`, `+8`, `+12` (zero when unresolved).
+    pub bands: [f32; 4],
+}
+
+impl Default for Material {
+    fn default() -> Self {
+        Self {
+            kind: -1,
+            ids: [0; 7],
+            gain: 0,
+            pitch: 4096,
+            pitch_flag: false,
+            pitch_alt: 0,
+            category: 0,
+            landing: false,
+            windows: [0; 14],
+            scale: 0.0,
+            bands: [0.0; 4],
+        }
+    }
+}
+
+impl Material {
+    /// The window word at record offset `off` (0..=56, not 40).
+    fn window(&self, off: usize) -> i32 {
+        let i = if off < 40 { off / 4 } else { off / 4 - 1 };
+        self.windows.get(i).copied().unwrap_or(0)
+    }
+}
+
+/// `sub_82497910`'s jump table for materials 95..=113 (`None` = the AudioSurfaceMap entry 94).
+const CLASS_95: [Option<i32>; 19] = [
+    Some(1), Some(2), Some(1), Some(0), Some(1), Some(1), Some(1), Some(1), Some(0), Some(1), Some(1), Some(1), Some(0),
+    Some(0), Some(0), None, None, None, Some(1),
+];
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct CollisionTuning {
+    /// Materials 0..142.
+    pub materials: Vec<Material>,
+    /// The AudioSurfaceMap words 7 (+28: the collision class) of entries 0..94.
+    pub surface_class: Vec<i32>,
+    /// The AudioSurfaceMap words 12..16 (+48..+64: the collision voices' eEQChain bus at tier 0,
+    /// tier 1 against class 0 / 1 / 2, tier 2) of entries 0..94; empty = 8 (SFX Master).
+    pub surface_eq: Vec<[i32; 5]>,
+}
+
+impl CollisionTuning {
+    pub fn material(&self, m: i32) -> Option<&Material> {
+        usize::try_from(m).ok().and_then(|m| self.materials.get(m))
+    }
+
+    /// `sub_82497910`: the collision class (0..2) of a material.
+    pub fn class(&self, m: i32) -> i32 {
+        let entry = |i: usize| self.surface_class.get(i).copied().unwrap_or(0);
+        if (95..=113).contains(&m) {
+            if let Some(c) = CLASS_95[(m - 95) as usize] {
+                return c;
+            }
+        }
+        if (0..94).contains(&m) { entry(m as usize) } else { entry(94) }
+    }
+
+    /// `sub_82497BF8`: the eEQChain bus of a collision voice of `m` at `tier` against `other`
+    /// (entry `m` for 0..93, else entry 94; 8 = SFX Master without a table).
+    pub fn eq_bus(&self, m: i32, tier: i32, other: i32) -> i32 {
+        let entry = if (0..94).contains(&m) { m as usize } else { 94 };
+        let word = match tier {
+            0 => 0,
+            2 => 4,
+            _ if other == NO_MATERIAL => 1,
+            _ => match self.class(other) {
+                0 => 1,
+                1 => 2,
+                _ => 3,
+            },
+        };
+        self.surface_eq.get(entry).map_or(8, |e| e[word])
+    }
+
+    /// `sub_824D21D0`: the Collision output whose level is the Collision SubMix's env send for a
+    /// voice of `m`.
+    pub fn env_output(&self, m: i32) -> usize {
+        let cat = if m >= NO_MATERIAL { 8 } else { self.category(m) };
+        match cat {
+            0 => 3,
+            1 => 4,
+            2 => 5,
+            3 => 6,
+            4 => 7,
+            5 => 8,
+            6 => 2,
+            7 => 9,
+            9 => 11,
+            _ => 10,
+        }
+    }
+
+    /// `sub_82496FD0`: the category (`+72`; 8 for a negative material or one without a record).
+    pub fn category(&self, m: i32) -> i32 {
+        if m < 0 {
+            return 8;
+        }
+        self.material(m).map_or(0, |r| r.category)
+    }
+
+    /// `sub_82496C58`: the contact level of `m` against `other` at `tier`, interpolating its
+    /// window over [low, high] at `value` (clamped to high).
+    pub fn contact_level(&self, m: i32, other: i32, tier: i32, low: f32, high: f32, value: f32) -> i32 {
+        if m < 0 || tier == NO_TIER {
+            return 0;
+        }
+        let value = if value < high { value } else { high };
+        let zero = Material::default();
+        let rec = self.material(m).unwrap_or(&zero);
+        let class = if m >= 97 || other == NO_MATERIAL { 0 } else { self.class(other) };
+        let (lo, hi) = match tier {
+            0 => match class {
+                0 => (rec.window(8), rec.window(12)),
+                1 => (rec.window(24), rec.window(28)),
+                _ => (rec.window(52), rec.window(56)),
+            },
+            1 => match class {
+                0 => (rec.window(0), rec.window(4)),
+                1 => (rec.window(16), rec.window(20)),
+                _ => (rec.window(44), rec.window(48)),
+            },
+            2 => (rec.window(32), rec.window(36)),
+            _ => (0, 32767),
+        };
+        if high > low {
+            let span = (hi - lo) as f32 / (high - low);
+            span.mul_add(value - low, lo as f32) as i32
+        } else {
+            hi
+        }
+    }
+
+    /// `sub_82497088`: (tier, low, high) of an impact against the material's bands; tier 3 under
+    /// the floor.
+    pub fn impact_band(&self, m: i32, impact: f32) -> (i32, f32, f32) {
+        let Some(rec) = (m >= 0).then(|| self.material(m)).flatten() else { return (NO_TIER, 0.0, 0.0) };
+        let [b0, b4, b8, b12] = rec.bands;
+        if impact < b12 {
+            return (NO_TIER, 0.0, 0.0);
+        }
+        if impact > b0 {
+            (2, b0, b4)
+        } else if impact > b8 {
+            (1, b8, b0)
+        } else {
+            (0, b12, b8)
+        }
+    }
+
+    /// `sub_82496F50`: the window record's `+40` scale (1 for a material without one).
+    pub fn level_scale(&self, m: i32) -> f32 {
+        if !(0..NO_MATERIAL).contains(&m) {
+            return 1.0;
+        }
+        self.material(m).map_or(0.0, |r| r.scale)
+    }
+
+    /// `sub_824965D0` / `sub_824967F8`: (bank family, sound id, gain word, pitch word) of `m`
+    /// against `other` at `tier`; `None` = no sound (id −1).
+    pub fn sample(&self, m: i32, other: i32, tier: i32, local: bool) -> Option<(usize, u32, i32, i32)> {
+        if !(0..NO_MATERIAL).contains(&m) {
+            return None;
+        }
+        let rec = self.material(m)?;
+        if rec.kind < 0 {
+            return None;
+        }
+        let class = if other == NO_MATERIAL { 0 } else { self.class(other) };
+        let id = match tier {
+            2 => rec.ids[0],
+            0 => match class {
+                0..=2 => rec.ids[1 + class as usize],
+                _ => 0,
+            },
+            _ => match class {
+                0..=2 => rec.ids[4 + class as usize],
+                _ => 0,
+            },
+        };
+        if id == -1 {
+            return None;
+        }
+        let gain = rec.gain.clamp(0, 32767);
+        let pitch = if local && rec.pitch_flag { rec.pitch_alt } else { rec.pitch };
+        Some((rec.kind as usize, id as u32, gain, pitch))
+    }
+
+    /// `sub_824D20E8`: the Collision output whose level scales a voice of `m`.
+    pub fn level_output(&self, m: i32) -> usize {
+        let cat = if m >= NO_MATERIAL { 8 } else { self.category(m) };
+        match cat {
+            0 => 13,
+            1 => 14,
+            2 => 15,
+            3 => 16,
+            4 => 17,
+            5 => 18,
+            6 => 12,
+            7 => 19,
+            9 => 21,
+            _ => 20,
+        }
+    }
+
+    /// `sub_824D22B8`: the Collision output whose pitch scales a voice of `m`.
+    pub fn pitch_output(&self, m: i32) -> usize {
+        if m >= NO_MATERIAL || self.category(m) != 9 { 1 } else { 22 }
+    }
+}
+
+/// `sub_82486EF0`'s message.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Message {
+    pub material: [i32; 2],
+    pub tier: [i32; 2],
+    pub position: [f32; 3],
+    pub level: [i32; 2],
+    /// Byte `+40`: the local player (owner `+72` set and `+64` = 0) — selects the pitch override.
+    pub local: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Voice {
+    sound: SoundId,
+    /// `+44` gain word, `+48` pitch word (`sub_824965D0`).
+    gain: i32,
+    pitch: i32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+struct Slot {
+    active: bool,
+    stamp: u64,
+    message: Option<Message>,
+    voices: [Option<Voice>; 2],
+    position: ObjPos,
+}
+
+/// The manager and its ten slots.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct CollisionManager {
+    slots: [Slot; SLOTS],
+    clock: u64,
+    /// Messages posted / voices started (diagnostics).
+    pub posts: u64,
+    pub starts: u64,
+    /// Play the voices through their Collision SubMix (`sub_824D25E0`: mono, env send, eEQChain
+    /// bus); off = straight into SFX Master as before.
+    pub submix: bool,
+}
+
+/// The Collision controller of slot `g`.
+pub const fn controller(g: usize) -> u32 {
+    keys::obj(keys::slot::COLLISION, 0, g as u32)
+}
+
+/// The slot's 3-D position block (SFXCTL slot 3 object 0).
+pub const fn position_controller(g: usize) -> u32 {
+    keys::ctl(keys::slot::COLLISION, 0, g as u32)
+}
+
+impl CollisionManager {
+    /// Active slots (diagnostics, tests).
+    pub fn active(&self) -> usize {
+        self.slots.iter().filter(|s| s.active).count()
+    }
+
+    /// `sub_82486EF0` → router `sub_824F1818` → `sub_824F8990`.
+    pub fn post(&mut self, msg: Message, host: &mut dyn SpliceHost) {
+        let slot = match self.slots.iter().position(|s| !s.active) {
+            Some(i) => i,
+            None => {
+                let mut best = 0;
+                for (i, s) in self.slots.iter().enumerate() {
+                    if s.stamp < self.slots[best].stamp {
+                        best = i;
+                    }
+                }
+                Self::deactivate(&mut self.slots[best], host);
+                best
+            }
+        };
+        self.clock += 1;
+        let s = &mut self.slots[slot];
+        s.stamp = self.clock;
+        s.message = Some(msg);
+        s.active = true;
+        s.voices = [None, None];
+        self.posts += 1;
+    }
+
+    /// `sub_828DF770` with the component's release: the voices stop, the message goes.
+    fn deactivate(s: &mut Slot, host: &mut dyn SpliceHost) {
+        for v in s.voices.iter_mut() {
+            if let Some(v) = v.take() {
+                host.release(v.sound);
+            }
+        }
+        s.active = false;
+        s.message = None;
+    }
+
+    /// `sub_824D1E00` for every slot, plus the 3-D position blocks (the message position for an
+    /// active slot, inactive otherwise). Before the MixMap tick.
+    pub fn process(&mut self, m: &mut MixMap, listener: Option<&Listener>) {
+        for (g, s) in self.slots.iter_mut().enumerate() {
+            let key = controller(g);
+            m.set_input(key, 0, 0);
+            m.set_input(key, 1, 0);
+            let msg = s.message.filter(|_| s.active);
+            match (msg, listener) {
+                (Some(msg), Some(l)) => s.position.write(m, position_controller(g), l, Some((msg.position, [0.0; 3]))),
+                _ => s.position.write(m, position_controller(g), &Listener::default(), None),
+            }
+            let Some(msg) = msg else { continue };
+            if s.voices.iter().all(Option::is_none) {
+                continue;
+            }
+            m.set_input(key, 0, 32767);
+            let [a, b] = msg.tier;
+            let tier = if a == NO_TIER {
+                b
+            } else if b == NO_TIER || a > b {
+                a
+            } else {
+                b
+            };
+            let weight = match tier {
+                1 => 20000,
+                2 => 32767,
+                _ => 10000,
+            };
+            m.set_input(key, 1, weight);
+        }
+    }
+
+    /// `sub_824D2318` for every slot (after the tick).
+    pub fn update(&mut self, m: &MixMap, t: &CollisionTuning, dt: f32, host: &mut dyn SpliceHost) {
+        for g in 0..SLOTS {
+            let s = &mut self.slots[g];
+            if !s.active {
+                continue;
+            }
+            let Some(msg) = s.message else { continue };
+            let out = super::Owner { mixmap: m, key: controller(g) };
+            if s.voices.iter().all(Option::is_none) {
+                let routes = self.submix.then(|| Self::submix_routes(&msg, t, &out));
+                self.starts += Self::start(s, &msg, t, dt, routes, host);
+                continue;
+            }
+            let level = [out.level(t.level_output(msg.material[0])), out.level(t.level_output(msg.material[1]))];
+            let pitch = [out.pitch(t.pitch_output(msg.material[0])), out.pitch(t.pitch_output(msg.material[1]))];
+            for i in 0..2 {
+                let Some(v) = s.voices[i] else { continue };
+                if !host.alive(v.sound) {
+                    host.release(v.sound);
+                    s.voices[i] = None;
+                    continue;
+                }
+                let first = ((msg.level[i] as f32 * INV_32767) * level[i] as f32) as i32;
+                let gain = (first as f32 * (v.gain as f32 * INV_32767)) as i32;
+                let p = (pitch[i] as f32 * (v.pitch as f32 * INV_4096)) as i32;
+                let block = [gain as f32 * INV_32767, p as f32 * INV_4096, out.raw(0) as f32 * DEGREES, dt, 0.0, 1.0];
+                host.update(v.sound, block);
+            }
+            if s.voices.iter().all(Option::is_none) {
+                Self::deactivate(s, host);
+            }
+        }
+    }
+
+    /// `sub_824D25E0` per material: the Collision SubMix route of its voice (env level read now,
+    /// after this frame's tick; the bus resolved with the message's create byte, UNCERTAIN: byte
+    /// `+41`, taken as the local flag — irrelevant while every entry is 8).
+    fn submix_routes(msg: &Message, t: &CollisionTuning, out: &dyn Outputs) -> [crate::bus::Route; 2] {
+        std::array::from_fn(|i| {
+            let (mat, other) = (msg.material[i], msg.material[1 - i]);
+            let bus = t.eq_bus(mat, msg.tier[i], other);
+            crate::bus::Route {
+                output: if (0..8).contains(&bus) { crate::bus::Output::Eq(bus as u8) } else { crate::bus::Output::Master },
+                create: msg.local,
+                owner_env: out.level(t.env_output(mat)) as f32 * INV_32767,
+                mono: true,
+            }
+        })
+    }
+
+    /// `sub_824D1F68`: one voice per material with a tier.
+    fn start(s: &mut Slot, msg: &Message, t: &CollisionTuning, dt: f32, routes: Option<[crate::bus::Route; 2]>, host: &mut dyn SpliceHost) -> u64 {
+        let mut started = 0;
+        for i in 0..2 {
+            let (mat, other) = (msg.material[i], msg.material[1 - i]);
+            if mat == NO_MATERIAL || msg.tier[i] == NO_TIER {
+                continue;
+            }
+            let Some((kind, id, gain, pitch)) = t.sample(mat, other, msg.tier[i], msg.local) else { continue };
+            let Some(bank) = BANKS.get(kind) else { continue };
+            if let Some(r) = routes {
+                host.set_route(r[i]);
+            }
+            if let Some(sound) = host.start(bank, id, [0.0, 1.0, 0.0, dt, 1.0, 1.0]) {
+                s.voices[i] = Some(Voice { sound, gain, pitch });
+                started += 1;
+            }
+        }
+        started
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[derive(Default)]
+    struct Log {
+        started: Vec<(String, u32)>,
+        live: HashMap<SoundId, u32>,
+        next: SoundId,
+        updates: Vec<(u32, [f32; 6])>,
+        route: Option<crate::bus::Route>,
+        routes: Vec<Option<crate::bus::Route>>,
+    }
+    impl SpliceHost for Log {
+        fn set_route(&mut self, route: crate::bus::Route) {
+            self.route = Some(route);
+        }
+        fn start(&mut self, bank: &str, id: u32, _: [f32; 6]) -> Option<SoundId> {
+            self.started.push((bank.to_owned(), id));
+            self.routes.push(self.route.take());
+            self.next += 1;
+            self.live.insert(self.next, id);
+            Some(self.next)
+        }
+        fn update(&mut self, sound: SoundId, block: [f32; 6]) {
+            self.updates.push((self.live[&sound], block));
+        }
+        fn alive(&self, sound: SoundId) -> bool {
+            self.live.contains_key(&sound)
+        }
+        fn release(&mut self, sound: SoundId) {
+            self.live.remove(&sound);
+        }
+    }
+
+    fn tuning() -> CollisionTuning {
+        let mut materials = vec![Material::default(); 143];
+        // A concrete-like surface (kind 0) and a metal (kind 1), the board (95) and truck (96).
+        materials[2] = Material {
+            kind: 0,
+            ids: [991, 958, 958, 0, 1047, 1047, 871],
+            gain: 30000,
+            pitch: 2096,
+            windows: [12000, 26000, 6000, 22000, 12000, 26000, 6000, 22000, 16000, 24000, 8000, 20000, 8000, 18000],
+            bands: [1.85, 2.0, 1.0, 0.12],
+            ..Material::default()
+        };
+        materials[9] = Material { kind: 1, ids: [400, 401, 402, 403, 404, 405, 406], gain: 32767, category: 3, landing: true, ..Material::default() };
+        materials[95] = Material {
+            kind: 0,
+            ids: [993, 876, 878, 878, 877, 879, 879],
+            gain: 28000,
+            category: 6,
+            windows: [10000, 23000, 10000, 2000, 12000, 24000, 9000, 22000, 11000, 16000, 12000, 24000, 9000, 22000],
+            bands: [0.4, 2.0, 0.15, 0.025],
+            ..Material::default()
+        };
+        let mut surface_class = vec![2; 95];
+        surface_class[2] = 2;
+        surface_class[9] = 1;
+        CollisionTuning { materials, surface_class, surface_eq: Vec::new() }
+    }
+
+    #[test]
+    fn classes_follow_the_jump_table_and_the_surface_map() {
+        let t = tuning();
+        assert_eq!(t.class(95), 1);
+        assert_eq!(t.class(96), 2);
+        assert_eq!(t.class(98), 0);
+        assert_eq!(t.class(110), 2, "110..112 read entry 94");
+        assert_eq!(t.class(9), 1);
+    }
+
+    #[test]
+    fn the_contact_level_interpolates_the_window() {
+        let t = tuning();
+        // Board 95 against material 2 (class 2), tier 1 over [0.25, 0.5] at 0.375: (+44, +48) =
+        // (12000, 24000) → 18000.
+        assert_eq!(t.contact_level(95, 2, 1, 0.25, 0.5, 0.375), 18000);
+        // Clamped to high.
+        assert_eq!(t.contact_level(95, 2, 1, 0.25, 0.5, 5.0), 24000);
+        // Tier 3 is silent; materials ≥ 97 read class 0: tier 0 (+8, +12).
+        assert_eq!(t.contact_level(95, 2, 3, 0.0, 1.0, 0.5), 0);
+        assert_eq!(t.contact_level(2, 95, 2, 0.0, 0.0, 0.5), 24000, "high ≤ low → the window's high word (+36)");
+    }
+
+    #[test]
+    fn the_impact_band_tiles_the_record() {
+        let t = tuning();
+        assert_eq!(t.impact_band(95, 0.01).0, NO_TIER);
+        assert_eq!(t.impact_band(95, 0.1), (0, 0.025, 0.15));
+        assert_eq!(t.impact_band(95, 0.3), (1, 0.15, 0.4));
+        assert_eq!(t.impact_band(95, 1.0), (2, 0.4, 2.0));
+    }
+
+    #[test]
+    fn a_message_starts_two_voices_then_follows_the_outputs() {
+        let t = tuning();
+        let bytes = std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/private/audio/aems/MixMapSK8.mxb"));
+        let Ok(bytes) = bytes else { return eprintln!("skipped: no MixMap") };
+        let mut m = MixMap::from_bytes(&bytes).unwrap();
+        let mut c = CollisionManager::default();
+        let mut h = Log::default();
+        let msg = Message { material: [95, 9], tier: [1, 1], position: [0.0; 3], level: [20000, 30000], local: true };
+        c.post(msg, &mut h);
+        let l = Listener { camera: [-3.0, 1.5, 0.0], view: [1.0, 0.0, 0.0], ..Listener::default() };
+        for id in 1..=4 {
+            m.set_input(keys::MASTER, id, 32767);
+        }
+        c.process(&mut m, Some(&l));
+        assert_eq!(m.input(controller(0), 0), 0, "no voice held yet: the gate stays 0");
+        m.tick(1.0 / 60.0);
+        c.update(&m, &t, 1.0 / 60.0, &mut h);
+        // Board 95 against metal 9 (class 1), tier 1 → id 879; metal 9 against the board (class 1) → 405.
+        assert_eq!(h.started, [("Skate_Collisions".to_owned(), 879), ("Skate_Metal".to_owned(), 405)]);
+        c.process(&mut m, Some(&l));
+        assert_eq!((m.input(controller(0), 0), m.input(controller(0), 1)), (32767, 20000));
+        m.tick(1.0 / 60.0);
+        c.update(&m, &t, 1.0 / 60.0, &mut h);
+        let out = super::super::Owner { mixmap: &m, key: controller(0) };
+        let lv = out.level(12);
+        let expect = ((20000.0f32 * INV_32767 * lv as f32) as i32 as f32 * (28000.0 * INV_32767)) as i32 as f32 * INV_32767;
+        let board = h.updates.iter().find(|u| u.0 == 879).unwrap().1;
+        assert!((board[0] - expect).abs() < 1e-6, "gain {} vs {expect}", board[0]);
+        assert!(board[0] > 0.0, "the category output is open with the gate up");
+        // Both voices end → the slot deactivates.
+        h.live.clear();
+        c.update(&m, &t, 1.0 / 60.0, &mut h);
+        assert_eq!(c.active(), 0);
+    }
+
+    #[test]
+    fn the_submix_picks_its_bus_and_env_output_like_the_retail_tables() {
+        let mut t = tuning();
+        assert_eq!(t.eq_bus(2, 1, 9), 8, "no table: SFX Master");
+        t.surface_eq = (0..95).map(|e| [e * 10, e * 10 + 1, e * 10 + 2, e * 10 + 3, e * 10 + 4]).collect();
+        assert_eq!(t.eq_bus(2, 0, 9), 20);
+        assert_eq!(t.eq_bus(2, 2, 9), 24);
+        assert_eq!(t.eq_bus(2, 1, NO_MATERIAL), 21);
+        assert_eq!(t.eq_bus(2, 1, 9), 22, "metal 9 is class 1");
+        assert_eq!(t.eq_bus(2, 1, 96), 23, "the truck is class 2");
+        assert_eq!(t.eq_bus(95, 1, 2), 943, "materials ≥ 94 read entry 94");
+        // Categories 0..9 → outputs 3, 4, 5, 6, 7, 8, 2, 9, 10, 11; none (143) → 10.
+        assert_eq!(t.env_output(9), 6);
+        assert_eq!(t.env_output(95), 2);
+        assert_eq!(t.env_output(2), 3);
+        assert_eq!(t.env_output(NO_MATERIAL), 10);
+    }
+
+    #[test]
+    fn with_the_submix_each_voice_starts_on_its_mono_bus_at_the_category_send() {
+        let t = tuning();
+        let bytes = std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/private/audio/aems/MixMapSK8.mxb"));
+        let Ok(bytes) = bytes else { return eprintln!("skipped: no MixMap") };
+        let l = Listener { camera: [-3.0, 1.5, 0.0], view: [1.0, 0.0, 0.0], ..Listener::default() };
+        let msg = Message { material: [95, 9], tier: [1, 1], position: [0.0; 3], level: [20000, 30000], local: true };
+        let run = |submix: bool| {
+            let (mut c, mut h) = (CollisionManager { submix, ..Default::default() }, Log::default());
+            let mut m = MixMap::from_bytes(&bytes).unwrap();
+            for id in 1..=4 {
+                m.set_input(keys::MASTER, id, 32767);
+            }
+            // The game's MixMap has been running long before the first collision.
+            for _ in 0..30 {
+                c.process(&mut m, Some(&l));
+                m.tick(1.0 / 60.0);
+            }
+            c.post(msg, &mut h);
+            c.process(&mut m, Some(&l));
+            m.tick(1.0 / 60.0);
+            c.update(&m, &t, 1.0 / 60.0, &mut h);
+            let out = super::super::Owner { mixmap: &m, key: controller(0) };
+            (h.routes, [out.level(2), out.level(6)])
+        };
+        assert_eq!(run(false).0, vec![None, None], "off: no route, SFX Master as before");
+        let (routes, [board, metal]) = run(true);
+        // Board 95 (category 6 → output 2), metal 9 (category 3 → output 6): −2000 mB near the
+        // camera, the retail trace's 0.100 cluster.
+        let r: Vec<_> = routes.into_iter().map(Option::unwrap).collect();
+        assert!(r.iter().all(|r| r.mono && r.output == crate::bus::Output::Master));
+        assert_eq!(r[0].owner_env, board as f32 * INV_32767);
+        assert_eq!(r[1].owner_env, metal as f32 * INV_32767);
+        assert!((r[0].owner_env - 0.1).abs() < 0.02, "{}", r[0].owner_env);
+    }
+
+    #[test]
+    fn the_router_reuses_the_oldest_slot() {
+        let mut c = CollisionManager::default();
+        let mut h = Log::default();
+        let msg = Message { material: [95, 2], tier: [0, 0], position: [0.0; 3], level: [1, 1], local: true };
+        for _ in 0..SLOTS {
+            c.post(msg, &mut h);
+        }
+        assert_eq!(c.active(), SLOTS);
+        c.post(Message { level: [7, 7], ..msg }, &mut h);
+        assert_eq!(c.active(), SLOTS);
+        assert_eq!(c.slots[0].message.unwrap().level, [7, 7], "slot 0 had the oldest stamp");
+    }
+}
+
diff --git a/crates/skate-audio/src/player/components.rs b/crates/skate-audio/src/player/components.rs
new file mode 100644
index 00000000..1111ca1f
--- /dev/null
+++ b/crates/skate-audio/src/player/components.rs
@@ -0,0 +1,676 @@
+//! The player components that post AEMS classes (the board, grind, foot-drag and speed sounds),
+//! as pure state machines: `process` (before the MixMap tick: posts and releases) and `update`
+//! (after it: rewrite the held packets from the owner's MixMap outputs and redeliver) return
+//! [`Command`]s the host applies to the runtime. Each packet is the class's payload words (the
+//! object minus its 4-byte header), built exactly as retail's constructor and updater write them.
+//!
+//! Ported so far (retail functions read in the TU3 recompilation, word tables cross-checked with
+//! upstream PR #4's driver notes):
+//! - [`Grind`] `Class_grind` (`GRINDS.abk`), owner `SFXObj_Rail`: poster `sub_824C28B0`, constructor
+//!   `sub_824AF8C8`, updater `sub_824C39E0`, levels `sub_824C2E48` / `sub_824C2D00`.
+//! - [`SenseOfSpeed`] `SenseOfSpeed_rattle` / `SenseOfSpeed_wind` (`sense_of_speed.abk`), owner
+//!   `SFXObj_SenseOfSpeed`: process `sub_824E7980`, update `sub_824E7CB0`, constructors
+//!   `sub_824B0520` / `sub_824B0388`.
+//! - [`FootDrag`] `Class_foot_drag` (`FOOT_DRAG.abk`), owner `SFXObj_Contacts`: trigger
+//!   `sub_824BB540`, constructor `sub_824AF498`, updater `sub_824BEEE8`, surface `sub_824BA390`.
+//!
+//! Not modelled (marked in the words): the bool-class word (`0x11A631878B239355` through a global
+//! setting; 0 in free skate as far as we know) and `[[owner+16]+64]` (taken as 0 for the local
+//! player).
+use super::state::NO_MATERIAL;
+use super::tuning::PlayerTuning;
+use super::{AudioState, Outputs, clamp01, trunc_clamp};
+
+/// Which held packet a command is about.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum Slot {
+    /// Class_grind main layer (`+36`) and the layer-1 companion of grind family 0 (`+40`).
+    Grind(u8),
+    Rattle,
+    Wind,
+    FootDrag,
+    Skid,
+    Squeaks,
+    /// `Class_Seams`' per-wheel packet (`player::seams`).
+    Seam(u8),
+    /// `Class_rolling`'s per-truck surface patch (`player::rolling`, owner `+1312 + 4·truck`).
+    RollingSurface(u8),
+    /// `Class_rolling`'s held layers 0 / 3 (`+1304` / `+1308`) and the spidercrack layer 5 (`+1332`).
+    RollingLayer(u8),
+    /// `Rolling_Rattle_Class` (`+1300`).
+    RollingRattle,
+    /// `c_board_slide` (`+1884`).
+    BoardSlide,
+    /// The Tricks component (`player::tricks`): `Class_Flips` (`+36`) and the two `cloth_trick`
+    /// packets, 0 = the trick's (`+40`), 1 = the one after it ends (`+44`).
+    Flips,
+    Cloth(u8),
+    /// `Class_Treatment` (`player::treatment`, `+36`) and its `hall_of_meat_slo_mo` companion (`+40`).
+    Treatment,
+    HomSloMo,
+    /// `playercharacter_footstep`: foot A (OffBoard `+36`) = 0, foot B (`+220`) = 1
+    /// (`player::footsteps`).
+    Footstep(u8),
+    /// `c_cloth_falls` and `c_body_slide` (`player::clothing`).
+    ClothFalls,
+    BodySlide,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Command {
+    Post { slot: Slot, class: &'static str, words: Vec<i32> },
+    Redeliver { slot: Slot, words: Vec<i32> },
+    Release { slot: Slot },
+}
+
+/// The banks the components post into (loaded at start so their classes bind).
+pub const BANKS: &[&str] =
+    &["GRINDS", "sense_of_speed", "FOOT_DRAG", "WHEEL_SKID_BANK", "Brd_Squeaks", "Seams_Bank", "fstep_skateshoe1_sm", "Foley_Cloth", "Bodyslide"];
+
+fn speed_word(v: f32, offset: f32, divisor: f32) -> i32 {
+    // trunc(clamp01((v − offset) / divisor · 3.6) · 10000), retail's operation order.
+    trunc_clamp(clamp01(((v - offset) / divisor) * 3.6) * 10000.0, i32::MIN, i32::MAX)
+}
+
+fn intensity(value: f32, low: f32, high: f32) -> i32 {
+    // trunc(clamp01((value − low) / (high − low)) · 1000), 0..1000.
+    trunc_clamp(clamp01((value - low) / (high - low)) * 1000.0, 0, 1000)
+}
+
+// ------------------------------------------------------------------------------------- grind
+
+/// `Class_grind` (17 words). Speed divisor: grind material class `default`, field
+/// `0x4890392C91829954` = 45; offset 0.5 m/s (image); the speed word is capped at 9000.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Grind {
+    held: [Option<Vec<i32>>; 2],
+    /// `+56`: the family the packets were posted for (−1 = none).
+    family: Option<i32>,
+    /// `+140`: the speed word.
+    speed: i32,
+    surface: i32,
+    layer: i32,
+}
+
+pub const GRIND_SPEED_DIVISOR: f32 = 45.0;
+/// The image's grind speed offset (`0x8209975C` region, 0.5 m/s).
+pub const GRIND_SPEED_OFFSET: f32 = 0.5;
+/// eEQChain `default`, field `0xD489344CEDEE5036`.
+pub const GRIND_EQ_TWEAK: i32 = 5;
+
+impl Grind {
+    /// Layer of a grind family (`+192`): 1, 2, 4 → 0; 5 → 3; anything else → 2.
+    pub fn layer(family: i32) -> i32 {
+        match family {
+            1 | 2 | 4 => 0,
+            5 => 3,
+            _ => 2,
+        }
+    }
+
+    fn post_words(&self, t: &PlayerTuning, layer: i32, s: &AudioState, out: &dyn Outputs) -> Vec<i32> {
+        let v = t.grind_levels(self.surface).v[layer as usize];
+        let mut w = vec![0i32; 17];
+        w[1] = 32767;
+        w[5] = 25000;
+        w[7] = self.speed.clamp(0, 10000);
+        w[8] = 1024;
+        w[9] = self.surface.clamp(0, 14);
+        w[10] = layer;
+        w[11] = trunc_clamp(v * 32767.0, i32::MIN, i32::MAX);
+        w[12] = 0; // bool class 0x11A631878B239355 (global setting, not modelled)
+        w[13] = i32::from(s.local); // local && [[owner+16]+64] == 0
+        w[14] = i32::from(s.local);
+        w[15] = if s.local { out.level(6) } else { 0 };
+        w[16] = GRIND_EQ_TWEAK;
+        w
+    }
+
+    /// The poster (before the tick). Rail inputs are written by [`super::inputs::write_rail`].
+    pub fn process(&mut self, s: &AudioState, t: &PlayerTuning, out: &dyn Outputs) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if s.grinding {
+            self.speed = speed_word(s.ground_speed.abs(), GRIND_SPEED_OFFSET, GRIND_SPEED_DIVISOR).min(9000);
+        }
+        if self.held[0].is_none() {
+            if !s.grinding {
+                return cmds;
+            }
+            let surface = t.grind_surface(s.grind_material);
+            if surface == 14 {
+                return cmds; // no grind sound on this material
+            }
+            self.surface = surface;
+            self.layer = Self::layer(s.grind_family);
+            self.family = Some(s.grind_family);
+            let words = self.post_words(t, self.layer, s, out);
+            cmds.push(Command::Post { slot: Slot::Grind(0), class: "Class_grind", words: words.clone() });
+            self.held[0] = Some(words);
+            if s.grind_family == 0 {
+                let words = self.post_words(t, 1, s, out);
+                cmds.push(Command::Post { slot: Slot::Grind(1), class: "Class_grind", words: words.clone() });
+                self.held[1] = Some(words);
+            }
+        } else if !s.grinding {
+            for i in 0..2 {
+                if self.held[i].take().is_some() {
+                    cmds.push(Command::Release { slot: Slot::Grind(i as u8) });
+                }
+            }
+            self.family = None;
+        }
+        cmds
+    }
+
+    /// The updater (after the tick).
+    pub fn update(&mut self, s: &AudioState, t: &PlayerTuning, out: &dyn Outputs) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if !s.grinding || self.held[0].is_none() {
+            return cmds;
+        }
+        let family = s.grind_family;
+        let layer = Self::layer(family);
+        if self.family != Some(family) {
+            // A family change: family 0 gains the layer-1 companion, any other loses it.
+            if family == 0 && self.held[1].is_none() {
+                self.surface = t.grind_surface(s.grind_material).clamp(0, 13);
+                let words = self.post_words(t, 1, s, out);
+                cmds.push(Command::Post { slot: Slot::Grind(1), class: "Class_grind", words: words.clone() });
+                self.held[1] = Some(words);
+            } else if family != 0 && self.held[1].take().is_some() {
+                cmds.push(Command::Release { slot: Slot::Grind(1) });
+            }
+            self.family = Some(family);
+        }
+        let surface = if s.grind_material == NO_MATERIAL { 4 } else { t.grind_surface(s.grind_material) };
+        let f = t.grind_levels(surface).f[layer as usize];
+        let w1 = trunc_clamp(out.level(1) as f32 * f, 0, 32767);
+        for i in 0..2 {
+            let Some(w) = self.held[i].as_mut() else { continue };
+            w[7] = self.speed.clamp(0, 10000);
+            w[0] = 32767;
+            w[1] = w1;
+            w[2] = out.level(5).clamp(0, 32767);
+            if s.local {
+                w[15] = out.level(6).clamp(0, 32767);
+            }
+            w[5] = out.level(3).clamp(0, 25000);
+            w[6] = out.level(4).clamp(0, 25000);
+            w[3] = out.raw(0).clamp(0, 65536);
+            w[4] = out.pitch(2).clamp(0, 8192);
+            if i == 0 {
+                w[10] = layer.clamp(0, 3);
+            }
+            if family == 0 {
+                w[10] = 1;
+            }
+            cmds.push(Command::Redeliver { slot: Slot::Grind(i as u8), words: w.clone() });
+        }
+        cmds
+    }
+}
+
+// ------------------------------------------------------------------------------- sense of speed
+
+/// `SFXObj_SenseOfSpeed`'s rattle and wind (local player only). Tuning: owner class
+/// `0x6E878344774A7999` `default` (rattle 30 → 80 km/h of ground speed, wind 15 → 55 km/h of COM
+/// speed, 1 → 10 km/h while bailing; rattle w0 32767, wind w0 27000) and eEQChain tweaks 7.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct SenseOfSpeed {
+    rattle: Option<Vec<i32>>,
+    wind: Option<Vec<i32>>,
+}
+
+pub const RATTLE_KMH: (f32, f32) = (30.0, 80.0);
+pub const WIND_KMH: (f32, f32) = (15.0, 55.0);
+pub const WIND_BAIL_KMH: (f32, f32) = (1.0, 10.0);
+const RATTLE_WORDS: (i32, i32, i32) = (7, 32767, 23000);
+const WIND_WORDS: (i32, [i32; 4]) = (7, [32767, 17000, 17000, 6750]);
+const RATTLE_W0: i32 = 32767;
+const WIND_W0: i32 = 27000;
+
+impl SenseOfSpeed {
+    fn wind_range(s: &AudioState) -> (f32, f32) {
+        if s.bail { WIND_BAIL_KMH } else { WIND_KMH }
+    }
+
+    pub fn process(&mut self, s: &AudioState) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if !s.local {
+            return cmds;
+        }
+        let kmh = s.ground_speed.abs() * 3.6;
+        if kmh >= RATTLE_KMH.0 {
+            if self.rattle.is_none() {
+                let mut w = vec![0i32; 11];
+                w[2] = 4096;
+                w[3] = intensity(kmh, RATTLE_KMH.0, RATTLE_KMH.1);
+                w[4] = 25000;
+                (w[8], w[9], w[10]) = RATTLE_WORDS;
+                cmds.push(Command::Post { slot: Slot::Rattle, class: "SenseOfSpeed_rattle", words: w.clone() });
+                self.rattle = Some(w);
+            }
+        } else if self.rattle.take().is_some() {
+            cmds.push(Command::Release { slot: Slot::Rattle });
+        }
+        let (low, high) = Self::wind_range(s);
+        let com = s.com_speed() * 3.6;
+        if com >= low {
+            if self.wind.is_none() {
+                let mut w = vec![0i32; 13];
+                w[2] = 4096;
+                w[3] = intensity(com, low, high);
+                w[4] = 25000;
+                w[8] = WIND_WORDS.0;
+                w[9..13].copy_from_slice(&WIND_WORDS.1);
+                cmds.push(Command::Post { slot: Slot::Wind, class: "SenseOfSpeed_wind", words: w.clone() });
+                self.wind = Some(w);
+            }
+        } else if self.wind.take().is_some() {
+            cmds.push(Command::Release { slot: Slot::Wind });
+        }
+        cmds
+    }
+
+    pub fn update(&mut self, s: &AudioState, out: &dyn Outputs) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if !s.local {
+            return cmds;
+        }
+        if let Some(w) = self.rattle.as_mut() {
+            w[0] = RATTLE_W0;
+            w[1] = out.raw(0).clamp(0, 65535);
+            w[2] = out.pitch(2).clamp(0, 8192);
+            w[6] = 0;
+            w[7] = out.level(1).clamp(0, 32767);
+            w[3] = intensity(s.ground_speed.abs() * 3.6, RATTLE_KMH.0, RATTLE_KMH.1);
+            cmds.push(Command::Redeliver { slot: Slot::Rattle, words: w.clone() });
+        }
+        if let Some(w) = self.wind.as_mut() {
+            let (low, high) = Self::wind_range(s);
+            w[0] = WIND_W0;
+            w[2] = out.pitch(3).clamp(0, 8192);
+            w[6] = 0;
+            w[7] = out.level(4).clamp(0, 32767);
+            w[3] = intensity(s.com_speed() * 3.6, low, high);
+            cmds.push(Command::Redeliver { slot: Slot::Wind, words: w.clone() });
+        }
+        cmds
+    }
+}
+
+// ----------------------------------------------------------------------------------- foot drag
+
+/// `Class_foot_drag` (15 words), fired while braking (`+336`), manual-braking (`+339`) or the
+/// off-board hold has expired (`+310`, not modelled: 0). Tuning: class `0xC26949FCB638A2CA`
+/// `default` (speed offset 0.5 / divisor 50 m/s·3.6; w9..w12 = 4000, 4500, 4000, 22500) and
+/// eEQChain tweak 7 (both the brake and the manual-brake key).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct FootDrag {
+    held: Option<Vec<i32>>,
+}
+
+pub const FOOT_DRAG_SPEED: (f32, f32) = (0.5, 50.0);
+const FOOT_DRAG_WORDS: [i32; 4] = [4000, 4500, 4000, 22500];
+const FOOT_DRAG_TWEAK: i32 = 7;
+
+impl FootDrag {
+    /// `sub_824BA390`: the foot-drag surface of wheel 0's material (wheel 2's while manual
+    /// braking): 0 without contact; AudioSurfaceMap `+20`; 1 → 0 while manual braking.
+    pub fn surface(s: &AudioState, t: &PlayerTuning) -> i32 {
+        let material = if s.manual_brake { s.wheel_material[2] } else { s.wheel_material[0] };
+        if material >= NO_MATERIAL {
+            return 0;
+        }
+        let surface = t.surface_entry(material).map_or(0, |e| e[5]);
+        if s.manual_brake && surface == 1 { 0 } else { surface }
+    }
+
+    fn active(s: &AudioState) -> bool {
+        s.brake || s.manual_brake
+    }
+
+    pub fn process(&mut self, s: &AudioState, t: &PlayerTuning) -> Vec<Command> {
+        if !Self::active(s) || self.held.is_some() {
+            return Vec::new();
+        }
+        let mut w = vec![0i32; 15];
+        w[1] = 32767;
+        w[5] = 25000;
+        w[7] = speed_word(s.ground_speed.abs(), FOOT_DRAG_SPEED.0, FOOT_DRAG_SPEED.1).clamp(0, 10000);
+        w[8] = Self::surface(s, t).clamp(0, 10);
+        w[9..13].copy_from_slice(&FOOT_DRAG_WORDS);
+        w[13] = i32::from(!s.brake);
+        w[14] = FOOT_DRAG_TWEAK;
+        self.held = Some(w.clone());
+        vec![Command::Post { slot: Slot::FootDrag, class: "Class_foot_drag", words: w }]
+    }
+
+    pub fn update(&mut self, s: &AudioState, t: &PlayerTuning, out: &dyn Outputs) -> Vec<Command> {
+        if self.held.is_none() {
+            return Vec::new();
+        }
+        if !Self::active(s) {
+            self.held = None;
+            return vec![Command::Release { slot: Slot::FootDrag }];
+        }
+        let w = self.held.as_mut().unwrap();
+        w[7] = speed_word(s.ground_speed.abs(), FOOT_DRAG_SPEED.0, FOOT_DRAG_SPEED.1).clamp(0, 10000);
+        w[0] = 32767;
+        w[1] = out.level(if s.brake { 4 } else { 5 }).clamp(0, 32767);
+        w[2] = out.level(18).clamp(0, 32767);
+        w[5] = out.level(16).clamp(0, 25000);
+        w[6] = out.level(17).clamp(0, 25000);
+        w[3] = out.raw(0).clamp(0, 65536);
+        w[4] = out.pitch(22).clamp(0, 8192);
+        w[8] = Self::surface(s, t).clamp(0, 10);
+        vec![Command::Redeliver { slot: Slot::FootDrag, words: w.clone() }]
+    }
+}
+
+// ------------------------------------------------------------------------------------------ skid
+
+/// `Class_wheels_skid` (18 words, `WHEEL_SKID_BANK`), owner `SFXObj_SkateBoard` (holder `+1288`):
+/// poster `sub_824C7438`, predicate `sub_824C72F0`, constructor `sub_824AF678`, updater
+/// `sub_824C7A20`, surface `sub_824C7388`. Held while the predicate holds — with any slip (`+232`,
+/// which is ≥ 0.75/45 whenever a wheel is down): grinding → only grind family 4; on foot with
+/// `+308` → no; else only without an audio trick (−1) or with a grab (35); without slip: the
+/// revert flag `+690` or the revert counter (+5 per frame while `+690`, cap 45, else −15) > 0. The
+/// slip word w10 = clamp(counter + trunc(90 × slip), 0, 90) carries the skid intensity. Tuning:
+/// holder `0xBA9837A6CF4C26ED` (w11 `0xFB10048CCDD6ADFA` = 23000, w12 `0x8CE42E5A9388A4C8` = 32767),
+/// eEQChain `0xF52450E504250254` = 5.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Skid {
+    held: Option<Vec<i32>>,
+    /// `+1516` the revert counter.
+    counter: i32,
+}
+
+const SKID_WORDS: (i32, i32, i32) = (23000, 32767, 5);
+
+impl Skid {
+    fn predicate(&self, s: &AudioState) -> bool {
+        if s.slip > 0.0 {
+            if s.grinding {
+                return s.grind_family == 4;
+            }
+            if s.on_foot && s.offboard_308 {
+                return false;
+            }
+            return matches!(s.audio_trick, -1 | 35);
+        }
+        s.revert || self.counter > 0
+    }
+
+    /// `sub_824C7388`: AudioSurfaceMap word 3 (`+12`) of wheel 0's material, 0 without one.
+    pub fn surface(s: &AudioState, t: &PlayerTuning) -> i32 {
+        let m = s.wheel_material[0];
+        if m >= NO_MATERIAL { 0 } else { t.surface_entry(m).map_or(0, |e| e[3]) }
+    }
+
+    fn speed(s: &AudioState) -> i32 {
+        trunc_clamp(clamp01(s.ground_speed * f32::from_bits(0x3DA3_D70A)) * 10000.0, 0, 10000)
+    }
+
+    /// The poster (before the tick); SkateBoard input 1 = 32767 while the predicate holds (no
+    /// MixMap output reads it).
+    pub fn process(&mut self, s: &AudioState, t: &PlayerTuning, out: &dyn Outputs) -> Vec<Command> {
+        if !self.predicate(s) || self.held.is_some() {
+            return Vec::new();
+        }
+        let mut w = vec![0i32; 18];
+        w[1] = 32767;
+        w[5] = 25000;
+        w[7] = Self::speed(s);
+        w[8] = i32::from(s.local && s.soft_wheels);
+        w[9] = Self::surface(s, t).clamp(0, 4);
+        w[10] = trunc_clamp(s.slip * 90.0, 0, 90);
+        (w[11], w[12]) = (SKID_WORDS.0, SKID_WORDS.1);
+        w[13] = 0; // bool class 0x11A631878B239355 (global setting, not modelled)
+        w[14] = i32::from(s.local);
+        w[15] = i32::from(s.local);
+        w[16] = if s.local { out.level(20).clamp(0, 32767) } else { 0 };
+        w[17] = SKID_WORDS.2;
+        self.held = Some(w.clone());
+        vec![Command::Post { slot: Slot::Skid, class: "Class_wheels_skid", words: w }]
+    }
+
+    /// The updater (after the tick).
+    pub fn update(&mut self, s: &AudioState, t: &PlayerTuning, out: &dyn Outputs) -> Vec<Command> {
+        if self.held.is_none() {
+            return Vec::new();
+        }
+        if !self.predicate(s) {
+            self.held = None;
+            return vec![Command::Release { slot: Slot::Skid }];
+        }
+        if s.revert {
+            self.counter = (self.counter + 5).min(45);
+        } else if self.counter > 0 {
+            self.counter = (self.counter - 15).max(0);
+        }
+        let counter = self.counter;
+        let w = self.held.as_mut().unwrap();
+        w[7] = Self::speed(s);
+        w[4] = out.pitch(3).clamp(0, 8192);
+        w[0] = 32767;
+        w[1] = out.level(4).clamp(0, 32767);
+        w[3] = out.raw(0).clamp(0, 65536);
+        w[2] = out.level(13).clamp(0, 32767);
+        w[5] = out.level(11).clamp(0, 25000);
+        w[6] = out.level(12).clamp(0, 25000);
+        w[10] = (counter - trunc_clamp(s.slip * -90.0, i32::MIN, i32::MAX)).clamp(0, 90);
+        w[9] = Self::surface(s, t).clamp(0, 4);
+        w[16] = if s.local { out.level(20).clamp(0, 32767) } else { 0 };
+        vec![Command::Redeliver { slot: Slot::Skid, words: w.clone() }]
+    }
+}
+
+// ---------------------------------------------------------------------------------------- squeaks
+
+/// `Class_Squeaks` (11 words, `Brd_Squeaks`), owner `SFXObj_SkateBoard` (holder `+1292`): trigger
+/// `sub_824C7738`, constructor `sub_824AFF48`, updater `sub_824C7DD0`. Gate: both feet in the deck
+/// box (`+615/+616`) and more than one wheel down, else released. Posted once the deck tilt
+/// trunc(|`+264`| × 114.59155) reaches the grain class's `0xA129B33B4A2C7961` = 15 (degrees); a tilt
+/// sign change releases it (and the next frame over the threshold posts again); below the
+/// threshold a held squeak stays. Words: w7 = trunc(clamp01(v × 0.08) × 1000), w9 = the deck spin
+/// word trunc(|`+488`| / 1.5 × 1000) (`0xAC87D592E7601134` = 1.5; < 50 → 0, cap 1000), w8 15, w10
+/// eEQChain `0x22D0D4A5A14FFF7D` = 0; update w1 = level(5), w4 = pitch(3), w5/w6 = filters
+/// 11/12, w3 = raw(0), w2 0.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Squeaks {
+    held: Option<Vec<i32>>,
+    /// `+1296` the tilt sign of the held squeak (true = non-negative).
+    sign: bool,
+}
+
+pub const SQUEAK_TILT_DEGREES: i32 = 15;
+pub const SQUEAK_SPIN_DIVISOR: f32 = 1.5;
+
+impl Squeaks {
+    fn speed(s: &AudioState) -> i32 {
+        trunc_clamp(clamp01(s.ground_speed * f32::from_bits(0x3DA3_D70A)) * 1000.0, 0, 1000)
+    }
+
+    fn spin(s: &AudioState) -> i32 {
+        let x = trunc_clamp((s.deck_spin.abs() / SQUEAK_SPIN_DIVISOR) * 1000.0, i32::MIN, i32::MAX);
+        if x > 1000 { 1000 } else if x >= 50 { x } else { 0 }
+    }
+
+    pub fn process(&mut self, s: &AudioState) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if !(s.feet_in_deck_box[0] && s.feet_in_deck_box[1] && s.wheel_count > 1) {
+            if self.held.take().is_some() {
+                cmds.push(Command::Release { slot: Slot::Squeaks });
+            }
+            return cmds;
+        }
+        let tilt = trunc_clamp(s.deck_tilt.abs() * f32::from_bits(0x42E5_2EE0), i32::MIN, i32::MAX);
+        if tilt < SQUEAK_TILT_DEGREES {
+            return cmds;
+        }
+        let sign = s.deck_tilt >= 0.0;
+        if sign != self.sign && self.held.take().is_some() {
+            cmds.push(Command::Release { slot: Slot::Squeaks });
+        }
+        self.sign = sign;
+        if self.held.is_none() {
+            let mut w = vec![0i32; 11];
+            w[1] = 32767;
+            w[4] = 4096;
+            w[5] = 25000;
+            w[7] = Self::speed(s);
+            w[8] = 15;
+            w[9] = Self::spin(s);
+            w[10] = 0;
+            cmds.push(Command::Post { slot: Slot::Squeaks, class: "Class_Squeaks", words: w.clone() });
+            self.held = Some(w);
+        }
+        cmds
+    }
+
+    pub fn update(&mut self, s: &AudioState, out: &dyn Outputs) -> Vec<Command> {
+        let Some(w) = self.held.as_mut() else { return Vec::new() };
+        w[7] = Self::speed(s);
+        w[9] = Self::spin(s);
+        w[4] = out.pitch(3).clamp(0, 8192);
+        w[0] = 32767;
+        w[1] = out.level(5).clamp(0, 32767);
+        w[2] = 0;
+        w[5] = out.level(11).clamp(0, 25000);
+        w[6] = out.level(12).clamp(0, 25000);
+        w[3] = out.raw(0).clamp(0, 65536);
+        vec![Command::Redeliver { slot: Slot::Squeaks, words: w.clone() }]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Fixed;
+    impl Outputs for Fixed {
+        fn level(&self, id: usize) -> i32 {
+            1000 + id as i32
+        }
+        fn raw(&self, _: usize) -> i32 {
+            16384
+        }
+        fn pitch(&self, _: usize) -> i32 {
+            4096
+        }
+    }
+
+    fn grinding(family: i32, material: u32) -> AudioState {
+        AudioState { grinding: true, grind_family: family, grind_material: material, ground_speed: 6.0, ..Default::default() }
+    }
+
+    #[test]
+    fn grind_posts_one_layer_or_two_for_family_zero_and_releases_both() {
+        let t = PlayerTuning::default();
+        let mut g = Grind::default();
+        let cmds = g.process(&grinding(1, NO_MATERIAL), &t, &Fixed);
+        assert_eq!(cmds.len(), 1);
+        let Command::Post { class, words, .. } = &cmds[0] else { panic!() };
+        assert_eq!(*class, "Class_grind");
+        // speed = trunc(clamp01((6 − 0.5)/45·3.6)·10000) = 4400; surface 4 (no material); layer 0.
+        assert_eq!((words[7], words[9], words[10], words[11], words[16]), (4400, 4, 0, 32767, 5));
+        assert!(g.process(&grinding(1, NO_MATERIAL), &t, &Fixed).is_empty(), "held: no repost");
+        let up = g.update(&grinding(1, NO_MATERIAL), &t, &Fixed);
+        let Command::Redeliver { words, .. } = &up[0] else { panic!() };
+        assert_eq!((words[0], words[1], words[2], words[3], words[4], words[5], words[6]), (32767, 1001, 1005, 16384, 4096, 1003, 1004));
+        assert_eq!(g.process(&AudioState::default(), &t, &Fixed), vec![Command::Release { slot: Slot::Grind(0) }]);
+        // Family 0: layer 2 plus the layer-1 companion; the updater writes w10 = 1 on both.
+        let cmds = g.process(&grinding(0, NO_MATERIAL), &t, &Fixed);
+        assert_eq!(cmds.len(), 2);
+        let up = g.update(&grinding(0, NO_MATERIAL), &t, &Fixed);
+        assert!(up.iter().all(|c| matches!(c, Command::Redeliver { words, .. } if words[10] == 1)));
+        assert_eq!(g.process(&AudioState::default(), &t, &Fixed).len(), 2);
+    }
+
+    #[test]
+    fn skid_is_held_while_rolling_and_its_slip_word_follows_the_slip() {
+        use crate::player::state::slip;
+        let t = PlayerTuning::default();
+        let mut k = Skid::default();
+        // Straight rolling: slip = 0.75/45 (the vault's −0.75 offset), word trunc(90 × slip) = 1.
+        let mut s = AudioState { ground_speed: 5.0, wheel_count: 4, slip: slip(0.0), ..Default::default() };
+        let Command::Post { class, words, .. } = &k.process(&s, &t, &Fixed)[0] else { panic!() };
+        let speed = ((5.0f32 * f32::from_bits(0x3DA3_D70A)) * 10000.0) as i32;
+        assert_eq!((*class, words[7], words[10], words[11], words[12], words[17]), ("Class_wheels_skid", speed, 1, 23000, 32767, 5));
+        // A powerslide: 3 m/s lateral → (3 + 0.75) / 45 → word 7.
+        s.slip = slip(3.0);
+        let Command::Redeliver { words, .. } = &k.update(&s, &t, &Fixed)[0] else { panic!() };
+        assert_eq!((words[10], words[1], words[2], words[4]), (7, 1004, 1013, 4096));
+        // In the air (no wheel: slip 0) without a revert → released.
+        s.slip = 0.0;
+        assert_eq!(k.update(&s, &t, &Fixed), vec![Command::Release { slot: Slot::Skid }]);
+        // An audio trick other than a grab blocks it.
+        s.slip = slip(0.0);
+        s.audio_trick = 28;
+        assert!(k.process(&s, &t, &Fixed).is_empty());
+    }
+
+    #[test]
+    fn squeaks_post_past_15_degrees_and_repost_on_a_tilt_sign_change() {
+        let mut q = Squeaks::default();
+        let mut s = AudioState { ground_speed: 5.0, wheel_count: 4, feet_in_deck_box: [true; 2], deck_tilt: 0.2, deck_spin: 0.75, ..Default::default() };
+        // 0.2 rad × 114.59 = 22° ≥ 15: post; spin 0.75 / 1.5 → 500.
+        let Command::Post { class, words, .. } = &q.process(&s)[0] else { panic!() };
+        assert_eq!((*class, words[8], words[9], words[10]), ("Class_Squeaks", 15, 500, 0));
+        assert!(q.process(&s).is_empty(), "held");
+        s.deck_tilt = 0.1; // below 15°: stays held
+        assert!(q.process(&s).is_empty());
+        s.deck_tilt = -0.3; // sign change: release and repost
+        let cmds = q.process(&s);
+        assert!(matches!(cmds[0], Command::Release { .. }) && matches!(cmds[1], Command::Post { .. }));
+        s.feet_in_deck_box = [true, false];
+        assert_eq!(q.process(&s), vec![Command::Release { slot: Slot::Squeaks }]);
+        s.feet_in_deck_box = [true; 2];
+        s.deck_spin = 0.05; // 33 < 50 → 0
+        let Command::Post { words, .. } = &q.process(&s)[0] else { panic!() };
+        assert_eq!(words[9], 0);
+    }
+
+    #[test]
+    fn grind_speed_caps_at_9000() {
+        let t = PlayerTuning::default();
+        let mut g = Grind::default();
+        let mut s = grinding(1, NO_MATERIAL);
+        s.ground_speed = 30.0;
+        let Command::Post { words, .. } = &g.process(&s, &t, &Fixed)[0] else { panic!() };
+        assert_eq!(words[7], 9000);
+    }
+
+    #[test]
+    fn rattle_and_wind_post_above_their_speeds() {
+        let mut sos = SenseOfSpeed::default();
+        let mut s = AudioState { ground_speed: 20.0 / 3.6, com_velocity: [20.0 / 3.6, 0.0, 0.0], ..Default::default() };
+        let cmds = sos.process(&s);
+        assert_eq!(cmds.len(), 1, "wind only at 20 km/h");
+        let Command::Post { class, words, .. } = &cmds[0] else { panic!() };
+        assert_eq!((*class, words[3], &words[8..]), ("SenseOfSpeed_wind", 125, &[7, 32767, 17000, 17000, 6750][..]));
+        s.ground_speed = 55.0 / 3.6;
+        let cmds = sos.process(&s);
+        let Command::Post { class, words, .. } = &cmds[0] else { panic!() };
+        assert_eq!((*class, words[3], &words[8..]), ("SenseOfSpeed_rattle", 500, &[7, 32767, 23000][..]));
+        let up = sos.update(&s, &Fixed);
+        assert_eq!(up.len(), 2);
+        s.ground_speed = 1.0;
+        s.com_velocity = [1.0, 0.0, 0.0];
+        assert_eq!(sos.process(&s), vec![Command::Release { slot: Slot::Rattle }, Command::Release { slot: Slot::Wind }]);
+    }
+
+    #[test]
+    fn foot_drag_fires_on_brake_and_reads_contacts_outputs() {
+        let t = PlayerTuning::default();
+        let mut f = FootDrag::default();
+        let s = AudioState { brake: true, ground_speed: 5.0, ..Default::default() };
+        let Command::Post { words, .. } = &f.process(&s, &t)[0] else { panic!() };
+        // trunc(clamp01((5 − 0.5)/50·3.6)·10000) = 3240.
+        assert_eq!((words[7], words[8], &words[9..15]), (3240, 0, &[4000, 4500, 4000, 22500, 0, 7][..]));
+        let Command::Redeliver { words, .. } = &f.update(&s, &t, &Fixed)[0] else { panic!() };
+        assert_eq!((words[1], words[2], words[5], words[6], words[4]), (1004, 1018, 1016, 1017, 4096));
+        assert_eq!(f.update(&AudioState::default(), &t, &Fixed), vec![Command::Release { slot: Slot::FootDrag }]);
+    }
+}
diff --git a/crates/skate-audio/src/player/contacts.rs b/crates/skate-audio/src/player/contacts.rs
new file mode 100644
index 00000000..ab1c2afe
--- /dev/null
+++ b/crates/skate-audio/src/player/contacts.rs
@@ -0,0 +1,972 @@
+//! `SFXObj_Contacts`' board one-shots on the Splice player ([`crate::splice`]): the take-off pop,
+//! its roll layer and the ollie voice, the landing impact, the per-wheel touchdowns and the manual
+//! landing. Written from our reading of the retail code (TU3, reference only):
+//!
+//! - frame (`sub_824B8218`): manual landing `sub_824BB330` → touchdowns `sub_824B86E0` → process
+//!   `sub_824B90D8` (pop `sub_824B9CC8` on entering the air with a trick, landing `sub_824BA630`);
+//!   after the MixMap tick the update `sub_824BE1B8` rewrites every held sound's block;
+//! - pop: selector 2 / 1 / 0 by the jump velocity (`+468`) over 0.42 / 0.25 (boneless and no-comply
+//!   → 0); ids `[1097, 1098, 1099]`, `[1103, 1104, 1105]` on a hollow surface (`sub_824B9AD8` with
+//!   the tier `sub_824BA310`); gain = trunc(level(2) × K[sel]) / 32767, K = `[0.5, 0.75, 1.0]`
+//!   (`[0.58, 0.76, 0.99]` hollow); roll 1111 (above 4 m/s ground speed, or with an audio trick,
+//!   gain level(7)); ollie 1096 (local player, level(12));
+//! - landing: id 1095 (local player, level(13));
+//! - touchdowns: per wheel the conditioner's landed latch (`sub_82772FD8`: set at a touchdown after
+//!   more than 5 frames in the air) and the bridge's landing bucket (`+448`, 0..2); newly landed
+//!   wheels pick the kind (0 = all four, 1 = a pair from nothing, 2 = the last pair, 3 = one wheel),
+//!   the variant (the largest bucket) and the set `sub_824BA3F0` = `table[tier][3·kind + variant]`
+//!   (tier = 2 × hollow surface + soft wheels; variant 2 of kinds 0..2 reads tier 0), with a second
+//!   voice of variant 2 for bucket-2 landings; gain = trunc(level(3) × K[tier][3·kind + variant]) /
+//!   32767 (`sub_824BEA80`);
+//! - manual landing: after a manual, with 3–4 wheels down: kind 4, variant 0 (`sub_824BB330`);
+//! - the hands on the deck (`sub_824B85B0` → [`super::step_on`]): 1124 / 1125 / 1126.
+//!
+//! The block of every sound: [level/32767, pitch(1)/4096, raw(0) × 360/65535, dt, 1 for the local
+//! player's 3-D voices else 0, 1].
+//!
+//! Buses (`.claude/notes/aems-eqchain-buses-spec.md` §3, §5): the pop plays through an owner
+//! one-shot bus (`sub_82488DD0`: env send at Contacts level(14) as of the post, then eEQChain bus 0),
+//! the touchdowns and the manual landing through one at level(15) (bus 0); the landing impact goes
+//! to bus 1, the foot taps and scuffs to bus 1; each resolve may re-roll the bus's EQ (create =
+//! the local player, owner byte +72 — UNCERTAIN meaning). The roll and ollie voices' bus is not
+//! recovered (SFX Master here).
+//!
+//! Not modelled: the landing's collision-manager pair contact (`sub_82496C58`, the material landing flag),
+//! the foot taps / scuffs on the deck (`sub_824B95A0` / `sub_824B9948`), the grind start contact
+//! (`sub_824BB0E0`), the body and deck impacts (`sub_824BC188` / `sub_824BD000`), the cartoon DLC
+//! sets (bank 8), the step-on force (`+500..+503`: `+720` / `+814` are not published) and which
+//! update rewrites the manual-landing holder `+36` (taken as a touchdown voice of kind 4).
+use super::collision::Message;
+use super::state::NO_MATERIAL;
+use super::tuning::PlayerTuning;
+use super::{AudioState, Outputs};
+use crate::splice::SoundId;
+
+/// What the component needs from the Splice player (the host implements it over the runtime).
+pub trait SpliceHost {
+    /// The bus the following starts play into (the poster's eEQChain bus / owner bus).
+    fn set_route(&mut self, _route: crate::bus::Route) {}
+    /// The FootStep SubMix the next start plays through (`player::footsteps`: per foot sound
+    /// slot `Sub0 → HI20 → LI20 → PI20 → Sen0 env → Pn21 → Sen0` SFX Master, latched at the
+    /// start); applies to the next start only, like the route. Hosts without per-sound submixes
+    /// ignore it (the route's `owner_env` still carries the env send).
+    fn set_submix(&mut self, _submix: Option<super::footsteps::Submix>) {}
+    fn start(&mut self, bank: &str, id: u32, block: [f32; 6]) -> Option<SoundId>;
+    fn update(&mut self, sound: SoundId, block: [f32; 6]);
+    fn alive(&self, sound: SoundId) -> bool;
+    fn release(&mut self, sound: SoundId);
+}
+
+/// The Contacts tuning (vault class `0xC26949FCB638A2CA` `default`; the exported values are the
+/// retail ones, used when the install's tuning lacks them).
+#[derive(Clone, Debug, PartialEq)]
+pub struct ContactsTuning {
+    pub pop_ids: [u32; 3],
+    pub pop_ids_hollow: [u32; 3],
+    pub pop_gain: [f32; 3],
+    pub pop_gain_hollow: [f32; 3],
+    /// Jump-velocity thresholds of selectors 2 / 1 (`0xF2A1E273ABB8E9AB` / `0xD7758385CDB8DC26`).
+    pub pop_high: f32,
+    pub pop_low: f32,
+    /// Roll speed thresholds (m/s, `0x58523180E1AD61B4` / `0xA73073D3A33E35AE` / `0xFB71DF2C85928859`)
+    /// and ids (`0x7A745D81E4BCABC3` / `0x537C97E4F64A0EE2` / `0x9C4CDCF0DD84C281`).
+    pub roll_speeds: [f32; 3],
+    pub roll_ids: [u32; 3],
+    pub ollie_id: u32,
+    pub landing_id: u32,
+    /// Touchdown sets per tier (`0x5A93802D11B00173`, `0xA0F86FEEA9C2412F`, `0x797EC34502499EC3`,
+    /// `0xAB0D92058B4293A7`) and their gains (`0xCEA5AFA8BA170B07`, `0x951AD53718030327`,
+    /// `0x068C8C5EBEC1B45F`, `0x6823F4910A1882AD`), index 3·kind + variant.
+    pub touch_ids: [[u32; 13]; 4],
+    pub touch_gain: [[f32; 15]; 4],
+    /// The conditioner's wheel-impact divisor (`0x3D399FE04952B425`, not used by the sounds).
+    pub wheel_impact_divisor: f32,
+    /// Collision posters (`audio_export.collision_tuning` `posters`): the grind start
+    /// (`sub_824BB0E0`, Class_grind default `0x086B66C3D4FFEE8F` / `0xB2ACAFDBCD963C93`, cooldown
+    /// the image's 0.5 s), the landing pair (`sub_824BA630`: air divisor `0x6D68BC2D1A23C29A`, board
+    /// material `0x85FDC8BF696BCA5C`, tier split / high `0x3462CBB16DCA696E` / `0x590495E420B399E5`,
+    /// level scales `0x31DEEF8FA219950F` / `0x0EC6EEF5366FEA85`) and the deck impact (`sub_824BD000`:
+    /// cooldown `0x27D3C5DC3282B59D`, in frames).
+    pub grind_split: f32,
+    pub grind_high: f32,
+    pub grind_cooldown: f32,
+    pub landing_air: f32,
+    pub landing_board: i32,
+    pub landing_split: f32,
+    pub landing_high: f32,
+    pub landing_scale: [f32; 2],
+    pub deck_cooldown: f32,
+    /// Foot taps on the deck (`sub_824B95A0` / `sub_824B9268`, collection
+    /// `0x923CCB46EF5BF5BA`/`0xF1647BFB782BE97F`): minimum time out of the deck box (ms × 0.001),
+    /// minimum toe speed, variant thresholds, ids per kind (first foot, second foot, both,
+    /// special) and the soft variants (`+484`).
+    pub tap_off_ms: f32,
+    pub tap_speed: f32,
+    pub tap_mid: f32,
+    pub tap_high: f32,
+    pub tap_ids: [[u32; 3]; 4],
+    pub tap_ids_soft: [[u32; 3]; 3],
+    /// Shoe scuffs (`sub_824B9948` / `sub_824B97A8`, Contacts default): toe XZ speed threshold
+    /// (× 0.01) and the `sk8_foley` ids per foot (and soft).
+    pub scuff_speed: f32,
+    pub scuff_ids: [u32; 2],
+    pub scuff_ids_soft: [u32; 2],
+    /// The hands on the deck (`player::step_on`, `sub_824B85B0`).
+    pub step_on: super::step_on::StepOnTuning,
+}
+
+impl Default for ContactsTuning {
+    fn default() -> Self {
+        Self {
+            pop_ids: [1097, 1098, 1099],
+            pop_ids_hollow: [1103, 1104, 1105],
+            pop_gain: [0.5, 0.75, 1.0],
+            pop_gain_hollow: [0.58, 0.76, 0.99],
+            pop_high: 0.42,
+            pop_low: 0.25,
+            roll_speeds: [12.0, 8.0, 4.0],
+            roll_ids: [1111, 1111, 1111],
+            ollie_id: 1096,
+            landing_id: 1095,
+            touch_ids: [
+                [1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1127, 1050],
+                [1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1128, 1129, 1130],
+                [1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1131, 1132, 1072],
+                [1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1133, 1134, 1094],
+            ],
+            touch_gain: [
+                [0.84, 1.0, 0.89, 1.0, 0.78, 0.76, 1.0, 0.7, 0.79, 0.82, 0.88, 0.76, 0.26, 0.38, 0.47],
+                [1.0, 1.0, 0.72, 0.77, 0.98, 0.8, 0.9, 0.98, 0.73, 1.0, 0.88, 0.83, 0.88, 0.55, 0.4],
+                [0.65, 1.0, 0.94, 0.59, 1.0, 0.84, 0.81, 0.97, 0.73, 0.64, 0.68, 0.63, 0.42, 0.42, 0.01],
+                [0.73, 0.99, 0.56, 0.79, 0.99, 0.59, 0.74, 0.91, 0.55, 0.58, 0.61, 0.59, 0.4, 0.4, 0.4],
+            ],
+            wheel_impact_divisor: 9.0,
+            grind_split: 0.25,
+            grind_high: 0.5,
+            grind_cooldown: 0.5,
+            landing_air: 0.4,
+            landing_board: 95,
+            landing_split: 0.1,
+            landing_high: 0.3,
+            landing_scale: [0.65, 1.0],
+            deck_cooldown: 6.0,
+            tap_off_ms: 25.0,
+            tap_speed: 0.0,
+            tap_mid: 2.0,
+            tap_high: 5.0,
+            tap_ids: [[1112, 1113, 1114], [1115, 1116, 1117], [1118, 1119, 1120], [1176, 1177, 1178]],
+            tap_ids_soft: [[1159, 1160, 1161], [1162, 1163, 1164], [1165, 1166, 1167]],
+            scuff_speed: 35.0,
+            scuff_ids: [95, 94],
+            scuff_ids_soft: [97, 96],
+            step_on: super::step_on::StepOnTuning::default(),
+        }
+    }
+}
+
+/// The bank every Contacts sound plays from (the vault fields' type).
+pub const BANK: &str = "Skate_Collisions";
+/// The shoe scuffs' bank (retail Splice bank 7; the vault type `sk82_cloth_foley`).
+pub const FOLEY: &str = "sk8_foley";
+
+const DEGREES: f32 = f32::from_bits(0x3BB4_00B4); // 360 / 65535
+const PITCH: f32 = f32::from_bits(0x3980_0000); // 1 / 4096
+const LEVEL: f32 = f32::from_bits(0x3800_0100); // 1 / 32767
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+struct Touch {
+    sound: SoundId,
+    kind: usize,
+    variant: usize,
+    tier: usize,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Contacts {
+    /// `+424` frames since the last landing (`sub_824B9CC8` needs ≥ 2).
+    frames: u32,
+    /// `+120` airborne last frame, `+122` grinding last frame, `+121` in a manual.
+    was_air: bool,
+    was_grinding: bool,
+    in_manual: bool,
+    /// The conditioner (`sub_82772FD8`): previous contact, frames in the air, landed latch `+464`.
+    prev_contact: [bool; 4],
+    air_frames: [u32; 4],
+    landed: [bool; 4],
+    /// `+132..+135` wheels already counted, `+136` the second-voice memory.
+    counted: [bool; 4],
+    memory_136: bool,
+    /// Held sounds: pop `+60` (selector `+64`, hollow `+68`), roll `+96`, ollie `+52`, landing
+    /// `+56`, touchdowns `+140`.., second voice `+236`, manual landing `+36`.
+    pop: Option<(SoundId, usize, bool)>,
+    roll: Option<SoundId>,
+    ollie: Option<SoundId>,
+    landing: Option<SoundId>,
+    touch: [Option<Touch>; 4],
+    second: Option<Touch>,
+    manual: Option<Touch>,
+    /// Sounds started (diagnostics).
+    pub starts: u64,
+    /// `+340` the last air phase's time (state `+236` latched while airborne).
+    air_latched: f32,
+    /// `+124` grind-start cooldown (s), `+292` deck-impact cooldown (frames).
+    grind_cooldown: f32,
+    deck_cooldown: f32,
+    taps: FootTaps,
+    /// Shoe scuffs `+112` (foot 1) / `+116` (foot 0).
+    scuffs: [Option<SoundId>; 2],
+    /// Collision messages posted this frame (the host hands them to the
+    /// [`super::collision::CollisionManager`] before its process).
+    pub outbox: Vec<Message>,
+    /// The hands on the deck (`sub_824B85B0` / `sub_824BF728`).
+    pub step_on: super::step_on::StepOn,
+    /// Contacts level(14) / level(15) as of the last update: the owner buses' env sends.
+    owner_levels: [i32; 2],
+    /// The local player (the buses' create flag), as of the last process.
+    local: bool,
+}
+
+/// The route of a poster's sounds: eEQChain bus `bus` (re-rolled on first use by the local
+/// player), through an owner bus whose env send is `env` (Q15) when given.
+fn route(bus: u8, s: &AudioState, env: Option<i32>) -> crate::bus::Route {
+    crate::bus::Route {
+        output: crate::bus::Output::Eq(bus),
+        create: s.local,
+        owner_env: env.map_or(0.0, |l| l as f32 * crate::dsp::INV_32767),
+        mono: false,
+    }
+}
+
+/// `sub_824B95A0`'s memory: time out of the deck box per foot (`+360` foot 0, `+352` foot 1) and
+/// of both (`+368`), the step counter `+364`, last frame's feet (`+356` foot 0, `+348` foot 1), the
+/// hippy-jump latch `+476` with its bucket `+480`, and the tap sounds `+100..+108` by mode.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+struct FootTaps {
+    out_time: [f32; 2],
+    both_time: f32,
+    count: u32,
+    prev: [bool; 2],
+    special: bool,
+    bucket: u32,
+    sounds: [Option<SoundId>; 3],
+}
+
+fn start_block(dt: f32) -> [f32; 6] {
+    [0.0, 1.0, 0.0, dt, 1.0, 1.0]
+}
+
+impl Contacts {
+    /// `sub_824BA310`: 2 × hollow (AudioSurfaceMap word 2 of wheel 0's material) + soft wheels.
+    pub fn tier(s: &AudioState, t: &PlayerTuning) -> usize {
+        let material = s.wheel_material[0];
+        let hollow = material < NO_MATERIAL && t.surface_entry(material).is_some_and(|e| e[2] != 0);
+        let soft = s.local && s.soft_wheels;
+        usize::from(hollow) * 2 + usize::from(soft)
+    }
+
+    /// `sub_824BA3F0`: (set id, unmasked tier).
+    fn set(&self, s: &AudioState, t: &PlayerTuning, c: &ContactsTuning, kind: usize, variant: usize) -> (u32, usize) {
+        let tier = Self::tier(s, t);
+        let used = if kind <= 2 && variant >= 2 { 0 } else { tier };
+        let idx = (3 * kind + variant).min(12);
+        (c.touch_ids[used.min(3)][idx], tier)
+    }
+
+    /// The conditioner's per-wheel landed latches (+464), once per frame.
+    fn condition(&mut self, s: &AudioState) {
+        for w in 0..4 {
+            let now = s.wheel_contact[w];
+            if !self.prev_contact[w] && self.air_frames[w] > 5 {
+                self.landed[w] = false;
+            }
+            if now && !self.prev_contact[w] && self.air_frames[w] > 5 {
+                self.landed[w] = true;
+            }
+            self.prev_contact[w] = now;
+            self.air_frames[w] = if now { 0 } else { self.air_frames[w] + 1 };
+        }
+    }
+
+    /// One frame before the MixMap tick. `buckets` = the bridge's `+448` per wheel. Collision
+    /// messages land in [`Contacts::outbox`].
+    pub fn process(&mut self, s: &AudioState, buckets: [u32; 4], t: &PlayerTuning, c: &ContactsTuning, host: &mut dyn SpliceHost) {
+        self.local = s.local;
+        self.condition(s);
+        self.foot_taps(s, c, host);
+        self.scuffs(s, c, host);
+        let manual_landed = self.manual_landing(s, t, c, host);
+        self.touchdowns(s, buckets, manual_landed, t, c, host);
+        // sub_824B90D8
+        self.frames = self.frames.saturating_add(1);
+        let air = s.airborne;
+        if !self.was_air {
+            if air && s.trick_active && !matches!(s.audio_trick, -1 | 31 | 32 | 35 | 36) && !self.was_grinding {
+                self.pop(s, t, c, host);
+            }
+        } else if !air && !s.grinding {
+            self.land(s, t, c, host);
+        }
+        if air {
+            self.air_latched = s.air_time;
+        }
+        if s.grinding && !self.was_grinding {
+            self.grind_start(s, t, c);
+        }
+        self.was_air = air;
+        self.was_grinding = s.grinding;
+        self.deck(s, t, c);
+        self.step_on.process(s, &c.step_on, host);
+    }
+
+    /// `sub_824BB0E0`: the board (95: families 1, 2, 5) or truck (96) against the grind material
+    /// (`+692`, 10 without one), tier by the last grind impact `+228` over the Class_grind split;
+    /// 0.5 s cooldown.
+    fn grind_start(&mut self, s: &AudioState, t: &PlayerTuning, c: &ContactsTuning) {
+        if self.grind_cooldown > 0.0 {
+            return;
+        }
+        let b = if s.grind_material == NO_MATERIAL { 10 } else { s.grind_material as i32 };
+        let a = if matches!(s.grind_family, 1 | 2 | 5) { 95 } else { 96 };
+        let v = s.grind_impact;
+        let (tier, low, high) = if v > c.grind_split { (1, c.grind_split, c.grind_high) } else { (0, 0.0, c.grind_split) };
+        let ct = &t.collision;
+        let la = if a < 143 { ct.contact_level(a, b, tier, low, high, v) } else { 0 };
+        let lb = if b < 143 { ct.contact_level(b, a, tier, low, high, v) } else { 0 };
+        self.outbox.push(Message { material: [a, b], tier: [tier, tier], position: s.com_position, level: [la, lb], local: s.local });
+        self.grind_cooldown = c.grind_cooldown;
+    }
+
+    /// `sub_824BA630`'s pair contact: on a landing-flag material, the board (95) against the
+    /// first landed wheel's material, tier by the latched air time over the Contacts split.
+    fn land_pair(&mut self, s: &AudioState, t: &PlayerTuning, c: &ContactsTuning) {
+        let mut b = NO_MATERIAL as i32;
+        for w in 0..4 {
+            if self.landed[w] {
+                b = s.wheel_material[w] as i32;
+                if b != NO_MATERIAL as i32 {
+                    break;
+                }
+            }
+        }
+        let air = super::clamp01(self.air_latched / c.landing_air);
+        if !(0..143).contains(&b) || !t.collision.material(b).is_some_and(|m| m.landing) {
+            return;
+        }
+        let a = c.landing_board;
+        let (tier, low, high) = if air >= c.landing_split { (1, c.landing_split, c.landing_high) } else { (0, 0.0, c.landing_split) };
+        let ct = &t.collision;
+        let la = ct.contact_level(b, a, tier, low, high, air);
+        let lb = if a < 143 { ct.contact_level(a, b, tier, low, high, air) } else { 0 };
+        if la == 0 || lb == 0 {
+            return;
+        }
+        let la = (la as f32 * c.landing_scale[0]) as i32;
+        let lb = (lb as f32 * c.landing_scale[1]) as i32;
+        self.outbox.push(Message { material: [a, b], tier: [tier, tier], position: s.board_position, level: [la, lb], local: s.local });
+    }
+
+    /// `sub_824BD000`: a deck impact (`+668`) — the board (95; 113 on foot or bailing) against the
+    /// deck's material (`+660`), each by its impact band; a band-2 impact posts a second message
+    /// at tier 1 with the levels × the window record's `+40`. Cooldown in frames.
+    fn deck(&mut self, s: &AudioState, t: &PlayerTuning, c: &ContactsTuning) {
+        let impact = s.deck_impact;
+        if impact > 0.0 && !(self.deck_cooldown > 0.0) {
+            let ct = &t.collision;
+            let a = if s.on_foot || s.bail { 113 } else { 95 };
+            let b = s.deck_material as i32;
+            let (ta, la_lo, la_hi) = if a < 143 { ct.impact_band(a, impact) } else { (3, 0.0, 0.0) };
+            let (tb, lb_lo, lb_hi) = if b < 143 { ct.impact_band(b, impact) } else { (3, 0.0, 0.0) };
+            if !(ta == 3 && tb == 3) {
+                self.deck_cooldown = c.deck_cooldown;
+                let la = if a < 143 { ct.contact_level(a, b, ta, la_lo, la_hi, impact) } else { 0 };
+                let lb = if b < 143 { ct.contact_level(b, a, tb, lb_lo, lb_hi, impact) } else { 0 };
+                let msg = Message { material: [a, b], tier: [ta, tb], position: s.board_position, level: [la, lb], local: s.local };
+                self.outbox.push(msg);
+                let second = |tier: i32| if tier == 2 { 1 } else { 3 };
+                let (sa, sb) = (second(ta), second(tb));
+                if !(sa == 3 && sb == 3) {
+                    let la = (ct.level_scale(a) * la as f32) as i32;
+                    let lb = (ct.level_scale(b) * lb as f32) as i32;
+                    self.outbox.push(Message { tier: [sa, sb], level: [la, lb], ..msg });
+                }
+            }
+        }
+        if self.deck_cooldown > 0.0 {
+            // − min(state +220, 1): the time scale (1 at normal speed).
+            self.deck_cooldown -= 1.0;
+        }
+    }
+
+    /// `sub_824B95A0` (+ `sub_824B9508` / `sub_824B9268`): a foot coming back into the deck box
+    /// after more than 25 ms out taps the deck — first foot, second foot, or both at once.
+    fn foot_taps(&mut self, s: &AudioState, c: &ContactsTuning, host: &mut dyn SpliceHost) {
+        let [f0, f1] = s.feet_in_deck_box;
+        if !f0 {
+            self.taps.out_time[0] += s.dt;
+        }
+        if !f1 {
+            self.taps.out_time[1] += s.dt;
+        }
+        let rise1 = f1 && !self.taps.prev[1];
+        let rise0 = f0 && !self.taps.prev[0];
+        if rise1 {
+            if rise0 {
+                self.taps.count = 0;
+                let [t0, t1] = self.taps.out_time;
+                self.taps.both_time = if t1 - t0 >= 0.0 { t1 } else { t0 };
+                let [y0, y1] = s.foot_speed_y;
+                self.tap(2, if y0 - y1 >= 0.0 { y0 } else { y1 }, c, host);
+                self.taps.out_time = [0.0; 2];
+                self.taps.both_time = 0.0;
+            } else {
+                self.taps.count += 1;
+                self.tap(0, s.foot_speed_y[1], c, host);
+                self.taps.out_time[1] = 0.0;
+            }
+        } else if rise0 {
+            self.taps.count += 1;
+            self.tap(1, s.foot_speed_y[0], c, host);
+            self.taps.out_time[0] = 0.0;
+        }
+        self.taps.prev = [f0, f1];
+        // +676 bail, +725 / +724 the foot plants (push feet, brake).
+        if s.bail || s.push_planted || s.brake {
+            self.taps.special = false;
+        }
+        if !f1 && !f0 {
+            if s.hippy_jump {
+                if !self.taps.special {
+                    self.taps.bucket = s.jump_bucket;
+                }
+                self.taps.special = true;
+            }
+        } else if self.taps.special && f1 && f0 {
+            self.taps.special = false;
+        }
+    }
+
+    /// `sub_824B9508` → `sub_824B9268`. `mode` 0 = foot 1, 1 = foot 0, 2 = both.
+    fn tap(&mut self, mode: usize, speed: f32, c: &ContactsTuning, host: &mut dyn SpliceHost) {
+        let kind = match self.taps.count {
+            0 => 2,
+            1 => 0,
+            2 => {
+                self.taps.count = 0;
+                1
+            }
+            _ => return,
+        };
+        let timer = match mode {
+            0 => self.taps.out_time[1],
+            1 => self.taps.out_time[0],
+            _ => self.taps.both_time,
+        };
+        if !(timer > c.tap_off_ms * f32::from_bits(0x3A83_126F)) || speed < c.tap_speed {
+            return;
+        }
+        let (kind, variant) = if self.taps.special {
+            (3, match self.taps.bucket {
+                1 => 1,
+                2 => 2,
+                _ => 0,
+            })
+        } else {
+            (kind, if speed >= c.tap_high { 2 } else if speed >= c.tap_mid { 1 } else { 0 })
+        };
+        if self.taps.sounds[mode].is_some() {
+            return;
+        }
+        let id = c.tap_ids[kind.min(3)][variant];
+        host.set_route(crate::bus::Route { output: crate::bus::Output::Eq(1), create: self.local, owner_env: 0.0, mono: false });
+        self.taps.sounds[mode] = host.start(BANK, id, [0.0, 1.0, 0.0, 0.0, 1.0, 1.0]);
+        self.starts += u64::from(self.taps.sounds[mode].is_some());
+    }
+
+    /// `sub_824B9948` / `sub_824B97A8`: a foot in the deck box moving faster than 0.35 m/s across
+    /// the deck scuffs it (`sk8_foley`), with more than one wheel down.
+    fn scuffs(&mut self, s: &AudioState, c: &ContactsTuning, host: &mut dyn SpliceHost) {
+        if s.wheel_count <= 1 {
+            return;
+        }
+        let threshold = c.scuff_speed * f32::from_bits(0x3C23_D70A);
+        let [f0, f1] = s.feet_in_deck_box;
+        for (i, (down, speed)) in [(f1, s.foot_speed_xz[1]), (f0, s.foot_speed_xz[0])].into_iter().enumerate() {
+            if down && speed > threshold && self.scuffs[i].is_none() {
+                host.set_route(route(1, s, None));
+                self.scuffs[i] = host.start(FOLEY, c.scuff_ids[i], [0.0, 1.0, 0.0, s.dt, 1.0, 1.0]);
+                self.starts += u64::from(self.scuffs[i].is_some());
+            }
+        }
+    }
+
+    /// `sub_824B9CC8`.
+    fn pop(&mut self, s: &AudioState, t: &PlayerTuning, c: &ContactsTuning, host: &mut dyn SpliceHost) {
+        if let Some((p, ..)) = self.pop.take() {
+            host.release(p);
+        }
+        if self.frames < 2 {
+            return;
+        }
+        let mut sel = if s.jump_velocity > c.pop_high {
+            2
+        } else if s.jump_velocity > c.pop_low {
+            1
+        } else {
+            0
+        };
+        if matches!(s.audio_trick, 33 | 34) {
+            sel = 0;
+        }
+        let hollow = Self::tier(s, t) >= 2;
+        let id = if hollow { c.pop_ids_hollow[sel] } else { c.pop_ids[sel] };
+        host.set_route(route(0, s, Some(self.owner_levels[0])));
+        if let Some(p) = host.start(BANK, id, start_block(s.dt)) {
+            self.pop = Some((p, sel, hollow));
+            self.starts += 1;
+        }
+        if self.roll.is_none() {
+            let v = s.ground_speed;
+            let id = if v > c.roll_speeds[0] {
+                Some(c.roll_ids[0])
+            } else if v > c.roll_speeds[1] {
+                Some(c.roll_ids[1])
+            } else if v > c.roll_speeds[2] || s.audio_trick >= 0 {
+                Some(if s.audio_trick >= 0 { c.roll_ids[1] } else { c.roll_ids[2] })
+            } else {
+                None
+            };
+            if let Some(id) = id {
+                self.roll = host.start(BANK, id, start_block(s.dt));
+                self.starts += u64::from(self.roll.is_some());
+            }
+        }
+        if s.local {
+            if let Some(o) = self.ollie.take() {
+                host.release(o);
+            }
+            self.ollie = host.start(BANK, c.ollie_id, start_block(s.dt));
+            self.starts += u64::from(self.ollie.is_some());
+        }
+    }
+
+    /// `sub_824BA630`: the local landing impact, then the collision pair contact.
+    fn land(&mut self, s: &AudioState, t: &PlayerTuning, c: &ContactsTuning, host: &mut dyn SpliceHost) {
+        self.frames = 0;
+        if s.local {
+            if let Some(l) = self.landing.take() {
+                host.release(l);
+            }
+            host.set_route(route(1, s, None));
+            self.landing = host.start(BANK, c.landing_id, start_block(s.dt));
+            self.starts += u64::from(self.landing.is_some());
+        }
+        self.land_pair(s, t, c);
+    }
+
+    /// `sub_824BB330`: true when the manual landing played (all wheels then count as down).
+    fn manual_landing(&mut self, s: &AudioState, t: &PlayerTuning, c: &ContactsTuning, host: &mut dyn SpliceHost) -> bool {
+        if s.balance {
+            self.in_manual = true;
+            return false;
+        }
+        if !self.in_manual {
+            return false;
+        }
+        match s.wheel_count {
+            3 | 4 => {
+                if let Some(m) = self.manual.take() {
+                    host.release(m.sound);
+                }
+                let (id, tier) = self.set(s, t, c, 4, 0);
+                host.set_route(route(0, s, Some(self.owner_levels[1])));
+                if let Some(sound) = host.start(BANK, id, start_block(s.dt)) {
+                    self.manual = Some(Touch { sound, kind: 4, variant: 0, tier });
+                    self.starts += 1;
+                }
+                self.counted = [true; 4];
+                self.in_manual = false;
+                true
+            }
+            0 => {
+                self.in_manual = false;
+                false
+            }
+            _ => false,
+        }
+    }
+
+    /// `sub_824B8D48`: a touchdown voice (and the variant-2 second voice).
+    fn touch(&mut self, s: &AudioState, t: &PlayerTuning, c: &ContactsTuning, kind: usize, variant: usize, second_ok: bool, host: &mut dyn SpliceHost) {
+        let Some(free) = self.touch.iter().position(Option::is_none) else { return };
+        let (variant, second) = if variant > 1 { (1, !second_ok || !self.memory_136) } else { (variant, false) };
+        let second_set = second.then(|| self.set(s, t, c, kind, 2));
+        let (id, tier) = self.set(s, t, c, kind, variant);
+        host.set_route(route(0, s, Some(self.owner_levels[1])));
+        if let Some(sound) = host.start(BANK, id, start_block(s.dt)) {
+            self.touch[free] = Some(Touch { sound, kind, variant, tier });
+            self.starts += 1;
+        }
+        if let (Some((id2, tier2)), None) = (second_set, self.second) {
+            host.set_route(route(0, s, Some(self.owner_levels[1])));
+            if let Some(sound) = host.start(BANK, id2, start_block(s.dt)) {
+                self.second = Some(Touch { sound, kind, variant: 2, tier: tier2 });
+                self.starts += 1;
+            }
+        }
+    }
+
+    /// `sub_824B86E0`.
+    fn touchdowns(&mut self, s: &AudioState, buckets: [u32; 4], manual: bool, t: &PlayerTuning, c: &ContactsTuning, host: &mut dyn SpliceHost) {
+        let mut landed = self.landed;
+        let mut count = 0;
+        let mut class = 0u32;
+        for w in 0..4 {
+            if landed[w] {
+                if !self.counted[w] {
+                    count += 1;
+                    class = class.max(buckets[w]);
+                } else {
+                    landed[w] = false;
+                }
+            } else {
+                self.counted[w] = false;
+            }
+        }
+        let down = self.counted.iter().filter(|c| **c).count();
+        if !s.local && count > 0 && class == 2 {
+            class = 1;
+        }
+        let class = class as usize;
+        let latch_new = |me: &mut Self| {
+            for w in 0..4 {
+                if landed[w] {
+                    me.counted[w] = true;
+                }
+            }
+        };
+        match count {
+            0 => {}
+            4 => {
+                self.touch(s, t, c, 0, class, false, host);
+                self.counted = [true; 4];
+                self.memory_136 = false;
+            }
+            2 if down == 0 => {
+                self.memory_136 = class == 2;
+                self.touch(s, t, c, 1, class, false, host);
+                latch_new(self);
+            }
+            2 if down == 2 => {
+                if !manual && !self.in_manual {
+                    self.touch(s, t, c, 2, class, true, host);
+                }
+                latch_new(self);
+                self.memory_136 = false;
+            }
+            2 => {
+                self.touch(s, t, c, 0, class, true, host);
+                self.counted = [true; 4];
+                self.memory_136 = false;
+            }
+            3 => {
+                self.touch(s, t, c, 0, class, true, host);
+                self.counted = [true; 4];
+                self.memory_136 = false;
+            }
+            _ => match down {
+                3 => self.counted = [true; 4],
+                2 => {
+                    if !manual && !self.in_manual {
+                        self.touch(s, t, c, 2, class, true, host);
+                    }
+                    self.counted = [true; 4];
+                    self.memory_136 = false;
+                }
+                1 => {
+                    let m = self.memory_136;
+                    self.touch(s, t, c, 3, class, m, host);
+                    self.memory_136 = class == 2;
+                    latch_new(self);
+                }
+                _ => {
+                    self.memory_136 = class == 2;
+                    self.touch(s, t, c, 3, class, false, host);
+                    latch_new(self);
+                }
+            },
+        }
+    }
+
+    /// `sub_824BE1B8`: every held sound's block, after the MixMap tick (owner = Contacts).
+    pub fn update(&mut self, s: &AudioState, out: &dyn Outputs, c: &ContactsTuning, host: &mut dyn SpliceHost) {
+        self.owner_levels = [out.level(14), out.level(15)];
+        let spread = if s.local { 1.0 } else { 0.0 };
+        let block = |level: i32| -> [f32; 6] {
+            [level as f32 * LEVEL, out.pitch(1) as f32 * PITCH, out.raw(0) as f32 * DEGREES, s.dt, spread, 1.0]
+        };
+        // sub_824BEBD8 (taps, level 8) and sub_824BF4A8 (scuffs, level 9): no pan spread.
+        for (slots, level) in [(&mut self.taps.sounds[..], 8usize), (&mut self.scuffs[..], 9)] {
+            for slot in slots.iter_mut() {
+                let Some(sound) = *slot else { continue };
+                if host.alive(sound) {
+                    let mut b = block(out.level(level));
+                    b[4] = 0.0;
+                    host.update(sound, b);
+                } else {
+                    host.release(sound);
+                    *slot = None;
+                }
+            }
+        }
+        if let Some((p, sel, hollow)) = self.pop {
+            if host.alive(p) {
+                let k = if hollow { c.pop_gain_hollow[sel] } else { c.pop_gain[sel] };
+                host.update(p, block((out.level(2) as f32 * k) as i32));
+            } else {
+                host.release(p);
+                self.pop = None;
+            }
+        }
+        if let Some(r) = self.roll {
+            if host.alive(r) {
+                let mut b = block(out.level(7));
+                b[4] = 0.0;
+                host.update(r, b);
+            } else {
+                host.release(r);
+                self.roll = None;
+            }
+        }
+        for slot in self.touch.iter_mut().chain(std::iter::once(&mut self.second)).chain(std::iter::once(&mut self.manual)) {
+            let Some(t) = *slot else { continue };
+            if host.alive(t.sound) {
+                let k = c.touch_gain.get(t.tier).map_or(1.0, |g| g[(3 * t.kind + t.variant).min(14)]);
+                host.update(t.sound, block((out.level(3) as f32 * k) as i32));
+            } else {
+                host.release(t.sound);
+                *slot = None;
+            }
+        }
+        for (slot, id) in [(&mut self.ollie, 12usize), (&mut self.landing, 13)] {
+            let Some(o) = *slot else { continue };
+            if host.alive(o) {
+                host.update(o, block(out.level(id)));
+            } else {
+                host.release(o);
+                *slot = None;
+            }
+        }
+        self.step_on.update(s, &c.step_on, out, host);
+        if self.grind_cooldown > 0.0 {
+            self.grind_cooldown -= s.dt;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[derive(Default)]
+    struct Log {
+        started: Vec<u32>,
+        live: HashMap<SoundId, u32>,
+        next: SoundId,
+        updates: Vec<(u32, [f32; 6])>,
+    }
+    impl SpliceHost for Log {
+        fn start(&mut self, _: &str, id: u32, _: [f32; 6]) -> Option<SoundId> {
+            self.started.push(id);
+            self.next += 1;
+            self.live.insert(self.next, id);
+            Some(self.next)
+        }
+        fn update(&mut self, sound: SoundId, block: [f32; 6]) {
+            self.updates.push((self.live[&sound], block));
+        }
+        fn alive(&self, sound: SoundId) -> bool {
+            self.live.contains_key(&sound)
+        }
+        fn release(&mut self, sound: SoundId) {
+            self.live.remove(&sound);
+        }
+    }
+
+    struct Out;
+    impl Outputs for Out {
+        fn level(&self, id: usize) -> i32 {
+            10000 + id as i32
+        }
+        fn raw(&self, _: usize) -> i32 {
+            0
+        }
+        fn pitch(&self, _: usize) -> i32 {
+            4096
+        }
+    }
+
+    fn rolling() -> AudioState {
+        AudioState { ground_speed: 6.0, wheel_count: 4, wheel_contact: [true; 4], wheel_material: [2; 4], ..Default::default() }
+    }
+
+    #[test]
+    fn an_ollie_pops_rolls_and_lands_on_four_wheels() {
+        let (t, c) = (PlayerTuning::default(), ContactsTuning::default());
+        let mut k = Contacts::default();
+        let mut h = Log::default();
+        for _ in 0..10 {
+            k.process(&rolling(), [0; 4], &t, &c, &mut h);
+        }
+        assert!(h.started.is_empty(), "rolling alone makes no contact sound");
+        let air = AudioState { airborne: true, wheel_count: 0, wheel_contact: [false; 4], trick_active: true, audio_trick: 28, jump_velocity: 0.3, ..rolling() };
+        for _ in 0..30 {
+            k.process(&air, [0; 4], &t, &c, &mut h);
+        }
+        // selector 1 (0.25 < jv ≤ 0.42) → 1098, roll 1111 (6 m/s > 4), ollie 1096.
+        assert_eq!(h.started, [1098, 1111, 1096]);
+        k.update(&air, &Out, &c, &mut h);
+        let pop = h.updates.iter().find(|u| u.0 == 1098).unwrap().1;
+        assert!((pop[0] - (10002.0f32 * 0.75).trunc() / 32767.0).abs() < 1e-6, "pop gain = trunc(level(2) × 0.75) / 32767");
+        h.started.clear();
+        k.process(&rolling(), [2; 4], &t, &c, &mut h);
+        // Landing impact 1095, then the four-wheel touchdown kind 0 variant 1 (bucket 2 → 1 + second
+        // voice of variant 2): ids 1052 and 1053 (tier 0).
+        assert_eq!(h.started, [1052, 1053, 1095]);
+        h.started.clear();
+        for _ in 0..10 {
+            k.process(&rolling(), [2; 4], &t, &c, &mut h);
+        }
+        assert!(h.started.is_empty(), "each wheel counts once");
+    }
+
+    #[test]
+    fn staggered_landings_use_the_pair_kinds() {
+        let (t, c) = (PlayerTuning::default(), ContactsTuning::default());
+        let mut k = Contacts::default();
+        let mut h = Log::default();
+        let air = AudioState { airborne: true, wheel_count: 0, wheel_contact: [false; 4], ..rolling() };
+        for _ in 0..10 {
+            k.process(&air, [0; 4], &t, &c, &mut h);
+        }
+        let front = AudioState { wheel_count: 2, wheel_contact: [true, true, false, false], ..rolling() };
+        k.process(&front, [0; 4], &t, &c, &mut h);
+        k.process(&rolling(), [0; 4], &t, &c, &mut h);
+        // a pair from nothing (kind 1, 1054) then the last pair (kind 2, 1057), landing 1095 between.
+        assert_eq!(h.started, [1054, 1095, 1057]);
+    }
+
+    #[test]
+    fn the_tier_reads_hollow_and_soft() {
+        let mut t = PlayerTuning::default();
+        let mut row = [0i32; 18];
+        row[2] = 1;
+        t.surface_table = vec![[0; 18]; 95];
+        t.surface_table[40] = row;
+        let mut s = rolling();
+        s.wheel_material = [40; 4];
+        assert_eq!(Contacts::tier(&s, &t), 2);
+        s.soft_wheels = true;
+        assert_eq!(Contacts::tier(&s, &t), 3);
+    }
+
+    fn collision_tuning() -> PlayerTuning {
+        use crate::player::collision::{CollisionTuning, Material};
+        let mut materials = vec![Material::default(); 143];
+        let windows = [10000, 23000, 10000, 2000, 12000, 24000, 9000, 22000, 11000, 16000, 12000, 24000, 9000, 22000];
+        materials[9] = Material { kind: 1, landing: true, gain: 32767, windows, bands: [0.4, 2.0, 0.15, 0.025], ..Material::default() };
+        materials[95] = Material { kind: 0, gain: 28000, windows, bands: [0.4, 2.0, 0.15, 0.025], ..Material::default() };
+        materials[96] = Material { kind: 0, gain: 27000, windows, ..Material::default() };
+        PlayerTuning { collision: CollisionTuning { materials, surface_class: vec![2; 95], surface_eq: Vec::new() }, ..PlayerTuning::default() }
+    }
+
+    #[test]
+    fn a_grind_start_posts_the_truck_against_the_rail_once_per_half_second() {
+        let (t, c) = (collision_tuning(), ContactsTuning::default());
+        let mut k = Contacts::default();
+        let mut h = Log::default();
+        let grind = AudioState { grinding: true, grind_family: 0, grind_material: 9, grind_impact: 0.6, ..rolling() };
+        k.process(&rolling(), [0; 4], &t, &c, &mut h);
+        k.process(&grind, [0; 4], &t, &c, &mut h);
+        assert_eq!(k.outbox.len(), 1);
+        let m = k.outbox[0];
+        assert_eq!((m.material, m.tier), ([96, 9], [1, 1]), "family 0 → truck 96; impact 0.6 > 0.25 → tier 1");
+        // Clamped to the tier's high (0.5): the window's high word for class 2 (+48) = 24000.
+        assert_eq!(m.level, [24000, 24000]);
+        k.outbox.clear();
+        k.update(&grind, &Out, &c, &mut h);
+        k.process(&rolling(), [0; 4], &t, &c, &mut h);
+        k.process(&grind, [0; 4], &t, &c, &mut h);
+        assert!(k.outbox.is_empty(), "the 0.5 s cooldown holds");
+    }
+
+    #[test]
+    fn a_landing_on_a_landing_flag_material_posts_the_board_pair() {
+        let (t, c) = (collision_tuning(), ContactsTuning::default());
+        let mut k = Contacts::default();
+        let mut h = Log::default();
+        let metal = AudioState { wheel_material: [9; 4], ..rolling() };
+        let air = AudioState { airborne: true, wheel_count: 0, wheel_contact: [false; 4], ..metal };
+        for i in 0..30 {
+            k.process(&AudioState { air_time: i as f32 / 60.0, ..air }, [0; 4], &t, &c, &mut h);
+        }
+        k.process(&metal, [1; 4], &t, &c, &mut h);
+        assert_eq!(k.outbox.len(), 1);
+        let m = k.outbox[0];
+        // Air 29/60 s over 0.4 → clamp 1 ≥ 0.1 → tier 1 over [0.1, 0.3]: the high words (class 2,
+        // +48 = 24000), × 0.65 / × 1.
+        assert_eq!((m.material, m.tier), ([95, 9], [1, 1]));
+        assert_eq!(m.level, [(24000.0f32 * 0.65) as i32, 24000]);
+        // Concrete (no landing flag) posts nothing.
+        let mut k = Contacts::default();
+        k.process(&air, [0; 4], &t, &c, &mut h);
+        k.process(&rolling(), [1; 4], &t, &c, &mut h);
+        assert!(k.outbox.is_empty());
+    }
+
+    #[test]
+    fn feet_back_on_the_deck_tap_it() {
+        let (t, c) = (PlayerTuning::default(), ContactsTuning::default());
+        let mut k = Contacts::default();
+        let mut h = Log::default();
+        let on = AudioState { feet_in_deck_box: [true, true], foot_speed_y: [3.0, 1.0], ..rolling() };
+        let off = AudioState { feet_in_deck_box: [false, false], ..on };
+        k.process(&on, [0; 4], &t, &c, &mut h);
+        k.process(&off, [0; 4], &t, &c, &mut h);
+        // One frame out (16.7 ms) is under the 25 ms minimum: no tap.
+        k.process(&on, [0; 4], &t, &c, &mut h);
+        assert!(h.started.is_empty());
+        for _ in 0..3 {
+            k.process(&off, [0; 4], &t, &c, &mut h);
+        }
+        // Both feet together at 3 m/s (≥ 2): the "both" set, variant 1.
+        k.process(&on, [0; 4], &t, &c, &mut h);
+        assert_eq!(h.started, [1119]);
+        // Foot 0 alone: the first-foot set (count 1); foot 1 next: the second-foot set.
+        h.started.clear();
+        let only1 = AudioState { feet_in_deck_box: [false, true], ..on };
+        let only0 = AudioState { feet_in_deck_box: [true, false], ..on };
+        for _ in 0..3 {
+            k.process(&only1, [0; 4], &t, &c, &mut h);
+        }
+        k.process(&on, [0; 4], &t, &c, &mut h);
+        for _ in 0..3 {
+            k.process(&only0, [0; 4], &t, &c, &mut h);
+        }
+        k.update(&on, &Out, &c, &mut h);
+        k.process(&on, [0; 4], &t, &c, &mut h);
+        assert_eq!(h.started, [1113, 1115]);
+    }
+
+    #[test]
+    fn a_foot_sliding_on_the_deck_scuffs() {
+        let (t, c) = (PlayerTuning::default(), ContactsTuning::default());
+        let mut k = Contacts::default();
+        let mut h = Log::default();
+        let s = AudioState { feet_in_deck_box: [true, true], foot_speed_xz: [0.2, 0.5], ..rolling() };
+        k.process(&s, [0; 4], &t, &c, &mut h);
+        assert_eq!(h.started, [95], "foot 1 above 0.35 m/s → sk8_foley 95; foot 0 below");
+        k.process(&s, [0; 4], &t, &c, &mut h);
+        assert_eq!(h.started.len(), 1, "one scuff per foot at a time");
+    }
+}
diff --git a/crates/skate-audio/src/player/footsteps.rs b/crates/skate-audio/src/player/footsteps.rs
new file mode 100644
index 00000000..5874a871
--- /dev/null
+++ b/crates/skate-audio/src/player/footsteps.rs
@@ -0,0 +1,1153 @@
+//! The skater's footsteps: retail's `SFXObj_OffBoard` (controller `0x40010090`) foot sounds, on
+//! the board (push and brake plants) and off it (walking, running, jumping). Written from our
+//! reading of the retail code (TU3, reference only; spec `.claude/notes/aems-offboard-clothing-spec.md`):
+//!
+//! - process `sub_824E9270`: OffBoard.in0 = on foot (`inputs::write_off_board`); the curve words
+//!   (`sub_82481E10` over three `Sk8::PointNegGraphData16` records): `+408` = walk(|COM v|),
+//!   `+412` / `+416` = xz(foot A / B speed), `+420` / `+424` = vertical(foot A / B speed); the
+//!   foot-down copies (`+52` = state `+724`, `+236` = `+725`); on the footplant's falling edge
+//!   (state `+768`) the countdown of the foot that was down (A first) is set to 10; both count down;
+//!   then the poster, the walking voices (on foot), the jump voices, (remote players only:
+//!   `sub_824EBA08`, not modelled) and the water splash (`sub_824EBB58`, not ported here);
+//! - poster `sub_824E9FD8`: two `playercharacter_footstep` packets (25 words, constructor
+//!   `sub_824B73E0`), B (`+220`) then A (`+36`), posted once and held; for the local player, on a
+//!   foot-down edge: the foot's four Splice sounds stop (`sub_82494B80`) and up to four start, each
+//!   through its own "FootStep SubMix" (`sub_82494188`): the surface layers (`sub_82493E60`, layer 0
+//!   and 1; the material's AudioSurface record or the special surfaces 5 and 7) with their EQ
+//!   record (`sub_82493448` → class `370AF2704BFA6866`) and gain (`sub_824940F8`), and the step
+//!   layers (`sub_82493690`: `sk8_foley` by walk/run mode, step code and footstep surface; layer 1
+//!   `Skate_Collisions` on surfaces 3 and 4);
+//! - walking voices `sub_824E9D10` (on foot, both feet): `sk8_foley` 62/63/64 by |COM v| over
+//!   2.5 / 7.5 m/s, plus `Skate_Collisions` 1121/1122/1123 for the local player with state `+308`;
+//! - jump voices `sub_824E9678`: a take-off (`sk8_foley` 65 jumping off the feet, else 67/69/71
+//!   by the jump bucket `+304`) on entering OffboardAir on foot, a hippy jump (`+372`) or the
+//!   footplant's end, and the apex (66, else 68/70/72) when the COM starts falling with a take-off
+//!   sound held;
+//! - update `sub_824E9628`: the packets (`sub_824EAEA8`) and the foot sounds' blocks
+//!   (`sub_82494C08`), the walking (`sub_824EA9C8` level 3, `sub_824EAC38` level 12) and jump
+//!   voices (`sub_824E9AB8` levels 9 / 10), the splash (`sub_824EBE78`, not ported).
+//!
+//! The FootStep SubMix (per foot sound slot, mono): `Sub0 → HI20 → LI20 → PI20 → Sen0 (env bus,
+//! level) → Pn21 (azimuth) → Sen0 (SFX Master)`; its parameters are latched at each start of the
+//! slot's sound (`sub_82494550`): the slot's EQ record and the holder's env level (OffBoard
+//! level(8) / 32767 as of the last update) and azimuth (OffBoard raw(0) × 360/65536). The host gets
+//! them through [`SpliceHost::set_submix`] (default: ignored — the voices then play straight into
+//! SFX Master with the env send of [`crate::bus::Route::owner_env`]).
+use super::components::{Command, Slot};
+use super::contacts::SpliceHost;
+use super::state::NO_MATERIAL;
+use super::tuning::PlayerTuning;
+use super::{AudioState, Outputs, trunc_clamp};
+use crate::splice::SoundId;
+
+/// The AEMS class and bank of the two held packets.
+pub const CLASS: &str = "playercharacter_footstep";
+pub const BANK: &str = "fstep_skateshoe1_sm";
+pub const WORDS: usize = 25;
+
+const LEVEL: f32 = f32::from_bits(0x3800_0100); // 1/32767 (0x822F8898)
+const PITCH: f32 = f32::from_bits(0x3980_0000); // 1/4096 (0x822F890C)
+const DEGREES: f32 = f32::from_bits(0x3BB4_00B4); // 360/65535 (0x822F8C64)
+/// The submix panner's scale (`0x822F88E8` = 360/65536, not the voices' 360/65535).
+pub const PAN_DEGREES: f32 = f32::from_bits(0x3BB4_0000);
+/// `0x821BCD64`: the step code's height difference between the feet's last plants (m).
+pub const STEP_HEIGHT: f32 = f32::from_bits(0x3D8F_5C29);
+
+/// Retail's Splice bank table index → bank (the report's `SPLC bank indices`; 2 = HOM_Set_1, the
+/// collision table's kind 2).
+pub fn splice_bank(index: i32) -> Option<&'static str> {
+    match index {
+        0 => Some("Skate_Collisions"),
+        1 => Some("Skate_Metal"),
+        2 => Some("HOM_Set_1"),
+        7 => Some("sk8_foley"),
+        _ => None,
+    }
+}
+
+/// A vault `Sk8::PointNegGraphData16` curve (16 points: x at record `+16`, y at `+80`).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Curve {
+    pub x: [f32; 16],
+    pub y: [f32; 16],
+}
+
+impl Curve {
+    pub const fn from_bits(x: [u32; 16], y: [u32; 16]) -> Self {
+        let mut c = Curve { x: [0.0; 16], y: [0.0; 16] };
+        let mut i = 0;
+        while i < 16 {
+            c.x[i] = f32::from_bits(x[i]);
+            c.y[i] = f32::from_bits(y[i]);
+            i += 1;
+        }
+        c
+    }
+
+    /// `sub_82481E10`: below x0 → y0, from x15 on → y15, else the linear piece (y[i] where two x
+    /// coincide), `fmadds` order.
+    pub fn eval(&self, v: f32) -> f32 {
+        let (x, y) = (&self.x, &self.y);
+        if v < x[0] {
+            return y[0];
+        }
+        if !(v < x[15]) {
+            return y[15];
+        }
+        for i in 1..16 {
+            if v < x[i] {
+                let dx = x[i] - x[i - 1];
+                if dx > 0.0 {
+                    return ((y[i] - y[i - 1]) / dx).mul_add(v - x[i - 1], y[i - 1]);
+                }
+                return y[i];
+            }
+        }
+        y[0]
+    }
+
+    /// The word the owner stores (`fctiwz`).
+    pub fn word(&self, v: f32) -> i32 {
+        trunc_clamp(self.eval(v), i32::MIN, i32::MAX)
+    }
+}
+
+/// The FootStep SubMix's EQ of a sound (class `370AF2704BFA6866` record: `+20` HI20 cutoff,
+/// `+16` LI20 cutoff, `+12` / `+8` / `+4` PI20 centre / linear gain / Q, `+0` the slot gain).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SubmixEq {
+    pub high_pass: f32,
+    pub low_pass: f32,
+    pub peak_freq: f32,
+    pub peak_gain: f32,
+    pub peak_q: f32,
+    pub gain: f32,
+}
+
+impl SubmixEq {
+    /// The slot defaults `sub_824D7CE8` writes (filters open, PI20 flat, gain 1).
+    pub const SLOT: SubmixEq = SubmixEq { high_pass: 0.0, low_pass: 96_000.0, peak_freq: 96_000.0, peak_gain: 1.0, peak_q: 3.0, gain: 1.0 };
+    /// The class's `default` collection (key `D7EDBD362D7D2152`): the record of every sound
+    /// without its own entry.
+    pub const DEFAULT: SubmixEq =
+        SubmixEq { high_pass: 0.0, low_pass: 96_000.0, peak_freq: 96_000.0, peak_gain: 1.0, peak_q: 3.0, gain: f32::from_bits(0x3DB8_51EC) };
+}
+
+/// What the FootStep SubMix of a starting sound is set to (latched at the start).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Submix {
+    pub eq: SubmixEq,
+    /// Sen0 #1 → the env bus: OffBoard level(8) / 32767 as of the last update.
+    pub env: f32,
+    /// Pn21: OffBoard raw(0) × 360/65536 degrees as of the last update.
+    pub azimuth: f32,
+    /// The slot's graph (foot A slots 0..3, foot B 4..7; [`crate::bus::submix`]).
+    pub graph: u8,
+}
+
+impl Submix {
+    /// What `sub_82494550` posts to the slot's graph.
+    pub fn params(&self) -> crate::bus::submix::SubmixParams {
+        let e = &self.eq;
+        crate::bus::submix::SubmixParams {
+            high_pass: e.high_pass,
+            low_pass: e.low_pass,
+            peak_freq: e.peak_freq,
+            peak_gain: e.peak_gain,
+            peak_q: e.peak_q,
+            env: self.env,
+            azimuth: self.azimuth,
+        }
+    }
+}
+
+/// One material's footstep fields of its AudioSurface record (class `D40CB4C0FFE45676`, key from
+/// the image table `0x8302D6E8`).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct FootstepMaterial {
+    /// The image table's kind word (Splice bank: 0 Skate_Collisions, 1 Skate_Metal, 2 HOM_Set_1,
+    /// −1 none).
+    pub kind: i32,
+    /// `+125` (`B1CF62EA632CF13F`): the material has footstep sounds.
+    pub enabled: bool,
+    /// `+48` (`37320DF00471F91A`) and `9D6068AB16703650` (landings, bucket > 1): the slot gain × 32767.
+    pub gain: i32,
+    pub landing_gain: i32,
+    /// [walk, run, landing]: kind 0 `+64` / `+60` / `+104` (`BFABF634D2B1E45A`, `EF9BD81F9CFF725F`,
+    /// `A3ADCA7B19287B5D`), kind 1 `+80` / `+76` / `+84` (`66A95889604DED36`, `B722B88FE44B046E`,
+    /// `1411108A7E9CC74A`), kind 2 walk = `sub_824825D0` (the HOM_Set_1 tier-0 field
+    /// `137C683BFB506ECA` per the collision export, UNCERTAIN), run `5432B35224E4B1C1`, landing
+    /// `3FCBE0407F833721` (never selected: kind 2 ignores the bucket). The collision export's
+    /// `ids` hold them: see [`FootstepMaterial::from_collision`].
+    pub ids: [i32; 3],
+}
+
+impl FootstepMaterial {
+    /// From the collision manager's material row (`collision::Material`: kind, the seven sample ids
+    /// [tier 2, tier 0 × class 0..2, tier 1 × class 0..2]) and the three footstep fields setup must
+    /// add (`+125`, `+48`, `9D6068AB16703650`): walk = tier 0 class 0, run = tier 1 class 0,
+    /// landing = tier 1 class 1 — the same record offsets.
+    pub fn from_collision(kind: i32, ids: &[i32; 7], enabled: bool, gain: i32, landing_gain: i32) -> Self {
+        Self { kind, enabled, gain, landing_gain, ids: [ids[1], ids[4], ids[5]] }
+    }
+}
+
+/// The OffBoard owner's vault values (holder `0xC1831BDB6CB1B1EA`, collection `0x1ABD2984D7248589`
+/// unless named; the Clothing class `0xA867FBE3454326FF` `default` for the walking and jump ids).
+/// The defaults are the retail values.
+#[derive(Clone, Debug, PartialEq)]
+pub struct FootstepTuning {
+    /// `C3CD069BB1B16B58` (|COM v| → `+408`), `CF844597AB96EAF8` (foot xz speed → w10),
+    /// `236311604A3C1FB5` (foot vertical speed → w9).
+    pub walk_curve: Curve,
+    pub xz_curve: Curve,
+    pub vertical_curve: Curve,
+    /// `729D6290FB6A8E3B`: running for the surface layers when `+408` is above it; `E82237E2D18B5C5F`:
+    /// the step layers' run mode when `+408` reaches it.
+    pub run_threshold: i32,
+    pub mode_threshold: i32,
+    /// `636464FBAD0D71A3`: packet words 18..23.
+    pub tail: [i32; 6],
+    /// eEQChain `C014A21D0FF6EDBA` (holder `42AFE160E647167C`): the packets' w24 = this + 10.
+    pub eq_chain: i32,
+    /// `sub_82493690` layer 0 (`sk8_foley`) by [run mode][step code 2 or 4][footstep surface 1..7].
+    pub step_ids: [[[i32; 7]; 2]; 2],
+    /// Layer 1 (`Skate_Collisions`) on footstep surfaces 3 and 4, same indexing.
+    pub step_ids_hard: [[[i32; 2]; 2]; 2],
+    /// `sub_82493E60` on footstep surface 7 (`Skate_Collisions`) and 5 (`Skate_Metal`):
+    /// [landing (bucket > 1), walk, run][layer].
+    pub surface7_ids: [[i32; 2]; 3],
+    pub surface5_ids: [[i32; 2]; 3],
+    /// Clothing `E12AF885D3C3A168`: |COM v| thresholds [fast, mid] of the walking voices; ids
+    /// (slow, mid, fast) `6B61C043E53C44CB`, `EC3399A49055DD8D`, `9D6D2863CFE908C4` (`sk8_foley`) and
+    /// `F0292A62D280EB40`, `E420F7DD48E01E0E`, `67717E2388A836ED` (`Skate_Collisions`).
+    pub walk_speeds: [f32; 2],
+    pub walk_ids: [i32; 3],
+    pub walk_ids_hard: [i32; 3],
+    /// Clothing `default`: take-off [off the feet `200AB82413E0FF3D`, bucket 1 `65E8997F265A4191`,
+    /// bucket 2 `76DE6529A45AC896`, else `FCBAFB90598F3B83`] and apex [`A3A1BB4E3ACD6927`,
+    /// `9913D205D51E5F24`, `8AA9F40C9CEABCA6`, `F0F46BA2D527E511`] (`sk8_foley`).
+    pub jump_ids: [i32; 4],
+    pub apex_ids: [i32; 4],
+    /// `60B043CCA6F211C3` (Skate_Collisions ids) and `CA945189654051D3` (other banks): the sounds
+    /// with their own EQ record; everything else reads [`SubmixEq::DEFAULT`].
+    pub eq_collision: Vec<(i32, SubmixEq)>,
+    pub eq_other: Vec<(i32, SubmixEq)>,
+    /// Materials 0..142 (setup export; empty: no material footstep layer).
+    pub materials: Vec<FootstepMaterial>,
+}
+
+const fn eq(gain: u32, q: u32, peak_gain: u32, peak_freq: u32, low_pass: u32, high_pass: u32) -> SubmixEq {
+    SubmixEq {
+        gain: f32::from_bits(gain),
+        peak_q: f32::from_bits(q),
+        peak_gain: f32::from_bits(peak_gain),
+        peak_freq: f32::from_bits(peak_freq),
+        low_pass: f32::from_bits(low_pass),
+        high_pass: f32::from_bits(high_pass),
+    }
+}
+
+impl Default for FootstepTuning {
+    fn default() -> Self {
+        // The vault records (class 370AF2704BFA6866) as fields +0, +4, +8, +12, +16, +20.
+        let e962 = eq(0x0000_0000, 0x4040_0000, 0x3F80_0000, 0x44BB_8000, 0x459C_4000, 0x43AF_0000);
+        let e960 = eq(0x3F80_0000, 0x3F00_0000, 0x3DCC_CCCD, 0x45A2_8000, 0x45BB_8000, 0x437A_0000);
+        let e961 = eq(0x3CA3_D70A, 0x3ECC_CCCD, 0x3E99_999A, 0x45BB_8000, 0x45BB_8000, 0x437A_0000);
+        let e959 = eq(0x3F80_0000, 0x3F00_0000, 0x3DCC_CCCD, 0x45A2_8000, 0x45DA_C000, 0x4348_0000);
+        let e518 = eq(0x3F80_0000, 0x4040_0000, 0x3F80_0000, 0x44BB_8000, 0x459C_4000, 0x43AF_0000);
+        let e519 = eq(0x4000_0000, 0x3F00_0000, 0x3DCC_CCCD, 0x45A2_8000, 0x45BB_8000, 0x437A_0000);
+        let m459 = eq(0x3F99_999A, 0x3F00_0000, 0x3DCC_CCCD, 0x4396_0000, 0x4422_8000, 0x4396_0000);
+        let m460 = eq(0x3F80_0000, 0x3F00_0000, 0x3DCC_CCCD, 0x453B_8000, 0x44FA_0000, 0x4396_0000);
+        let m455 = eq(0x3F80_0000, 0x3F00_0000, 0x3DCC_CCCD, 0x4396_0000, 0x4422_8000, 0x43C8_0000);
+        let m456 = eq(0x3F40_0000, 0x3F00_0000, 0x3DCC_CCCD, 0x453B_8000, 0x44FA_0000, 0x43C8_0000);
+        let m323 = eq(0x4000_0000, 0x3F00_0000, 0x3DCC_CCCD, 0x4396_0000, 0x4422_8000, 0x4396_0000);
+        let m324 = eq(0x4000_0000, 0x3F00_0000, 0x3DCC_CCCD, 0x453B_8000, 0x44FA_0000, 0x4396_0000);
+        Self {
+            walk_curve: Curve::from_bits(
+                [
+                    0x0000_0000, 0x3EF1_D2F8, 0x3FCC_CCCD, 0x4000_0000, 0x4020_0000, 0x4060_0000, 0x4088_06AB, 0x40A4_2B5C, 0x40C0_D57A,
+                    0x40E0_1AAE, 0x40EB_0C82, 0x4103_DB4F, 0x410B_EF53, 0x4112_305E, 0x4117_A947, 0x411F_BD4A,
+                ],
+                [
+                    0x0000_0000, 0x42D2_0000, 0x434D_0000, 0x434D_0000, 0x437A_0000, 0x4398_8000, 0x43AF_0000, 0x43B1_AF9A, 0x43CC_8BA3,
+                    0x43CE_9C8F, 0x4400_1964, 0x4401_21D9, 0x4400_1964, 0x4400_1964, 0x4401_21D9, 0x4401_21D9,
+                ],
+            ),
+            xz_curve: Curve::from_bits(
+                [
+                    0x0000_0000, 0x3E99_999A, 0x3F85_6B90, 0x4008_8C15, 0x4057_C3F8, 0x4088_8C17, 0x40A3_2086, 0x40C5_8640, 0x40E3_C0A0,
+                    0x40F7_092D, 0x4107_3E8B, 0x4110_5D65, 0x4115_9399, 0x4118_B41E, 0x411B_0C82, 0x411F_7A94,
+                ],
+                [
+                    0x0000_0000, 0x4404_3B3D, 0x4402_2A51, 0x4400_1964, 0x4400_1964, 0x4401_21D9, 0x4401_21D9, 0x4402_2A51, 0x4401_21D9,
+                    0x4401_21D9, 0x4402_2A51, 0x4400_1964, 0x4402_2A51, 0x4402_2A51, 0x4400_1964, 0x4403_32C7,
+                ],
+            ),
+            vertical_curve: Curve::from_bits(
+                [
+                    0x0000_0000, 0x3F00_0000, 0x3F80_0000, 0x401C_5A0C, 0x405E_0503, 0x4094_88C0, 0x40B4_9618, 0x40DA_E47A, 0x40FE_DA79,
+                    0x4114_88C1, 0x4117_4535, 0x4122_370D, 0x4131_1188, 0x413E_BFD1, 0x414E_C67E, 0x415C_D8CD,
+                ],
+                [
+                    0x4000_0000, 0x4000_0000, 0, 0, 0, 0, 0, 0, 0, 0, 0x4060_CB1D, 0x4081_9637, 0x40A1_5283, 0x40DA_2E90, 0x40EE_043A,
+                    0x4104_E47E,
+                ],
+            ),
+            run_threshold: 400,
+            mode_threshold: 400,
+            tail: [32767, 10000, 15000, 25000, 32767, 28000],
+            eq_chain: 2,
+            step_ids: [
+                // walk mode: step codes 1/3/5, then 2/4
+                [[86, 82, 86, 91, 86, 78, 75], [87, 83, 87, 91, 107, 79, 110]],
+                // run mode
+                [[107, 102, 105, 105, 105, 99, 101], [104, 103, 104, 106, 104, 100, 100]],
+            ],
+            step_ids_hard: [[[963, 964], [963, 964]], [[963, 964], [522, 523]]],
+            surface7_ids: [[519, 518], [959, 961], [960, 962]],
+            surface5_ids: [[323, 324], [455, 458], [459, 460]],
+            walk_speeds: [7.5, 2.5],
+            walk_ids: [62, 63, 64],
+            walk_ids_hard: [1121, 1122, 1123],
+            jump_ids: [65, 69, 71, 67],
+            apex_ids: [66, 70, 72, 68],
+            eq_collision: vec![(962, e962), (960, e960), (961, e961), (959, e959), (518, e518), (519, e519)],
+            eq_other: vec![(459, m459), (460, m460), (455, m455), (456, m456), (457, m455), (458, m456), (323, m323), (324, m324)],
+            materials: Vec::new(),
+        }
+    }
+}
+
+impl FootstepTuning {
+    /// `sub_82493448`: the EQ record of a started sound (bank 0 searches the collision list,
+    /// any other bank the metal list; no entry → the `default` record).
+    pub fn eq_record(&self, bank: i32, id: i32) -> SubmixEq {
+        let list = if bank == 0 { &self.eq_collision } else { &self.eq_other };
+        list.iter().find(|(i, _)| *i == id).map_or(SubmixEq::DEFAULT, |(_, e)| *e)
+    }
+
+    fn material(&self, m: u32) -> Option<&FootstepMaterial> {
+        self.materials.get(m as usize)
+    }
+
+    /// `sub_824975D8`: (bank, id) of a material's footstep, id −1 = none.
+    pub fn material_sound(&self, m: u32, run: bool, bucket: i32) -> (i32, i32) {
+        let Some(r) = self.material(m) else { return (0, -1) };
+        if !r.enabled {
+            return (0, -1);
+        }
+        let id = match r.kind {
+            0 | 1 => {
+                if bucket > 1 {
+                    r.ids[2]
+                } else if run {
+                    r.ids[1]
+                } else {
+                    r.ids[0]
+                }
+            }
+            2 => {
+                if run {
+                    r.ids[1]
+                } else {
+                    r.ids[0]
+                }
+            }
+            // Kinds ≥ 3 (none on the disc) leave the id at 0; −1 reads as unsigned and does the same.
+            _ => 0,
+        };
+        (r.kind, id)
+    }
+
+    /// `sub_824977C8`: the slot gain of a material's footstep (`+48`, landings the
+    /// `9D6068AB16703650` field) × 1/32767.
+    pub fn material_gain(&self, m: u32, bucket: i32) -> f32 {
+        let Some(r) = self.material(m) else { return 0.0 };
+        let g = if bucket > 1 { r.landing_gain } else { r.gain };
+        g as f32 * LEVEL
+    }
+}
+
+/// AudioSurfaceMap word 6 (`+24`, `sub_82494F58`): the footstep surface of a material (1 without a
+/// table: the clamp floor of the packet word).
+pub fn footstep_surface(t: &PlayerTuning, m: u32) -> i32 {
+    t.surface_entry(m).map_or(1, |e| e[6])
+}
+
+/// `sub_82493E60`: (bank, id) of a surface layer (0 or 1), id −1 = none.
+pub fn surface_sound(t: &PlayerTuning, ft: &FootstepTuning, run: bool, bucket: i32, layer: usize, m: u32) -> (i32, i32) {
+    let s = footstep_surface(t, m);
+    if s == 7 || s == 5 {
+        let (bank, ids) = if s == 7 { (0, &ft.surface7_ids) } else { (1, &ft.surface5_ids) };
+        let row = if bucket > 1 {
+            0
+        } else if run {
+            2
+        } else {
+            1
+        };
+        return (bank, ids[row][layer.min(1)]);
+    }
+    if layer != 0 || m >= NO_MATERIAL {
+        return (0, -1);
+    }
+    ft.material_sound(m, run, bucket)
+}
+
+/// `sub_82493690`: (bank, id) of a step layer, id −1 = none. `run` = the run mode (2).
+pub fn step_sound(t: &PlayerTuning, ft: &FootstepTuning, run: bool, m: u32, code: i32, layer: usize) -> (i32, i32) {
+    let s = footstep_surface(t, m);
+    let uneven = !matches!(code, 1 | 3 | 5);
+    let (r, u) = (usize::from(run), usize::from(uneven));
+    if layer == 0 {
+        let id = if (1..=7).contains(&s) { ft.step_ids[r][u][(s - 1) as usize] } else { -1 };
+        (7, id)
+    } else {
+        let id = match s {
+            3 => ft.step_ids_hard[r][u][0],
+            4 => ft.step_ids_hard[r][u][1],
+            _ => -1,
+        };
+        (0, id)
+    }
+}
+
+/// `sub_824940F8`: the material's own slot gain, when its footstep record applies.
+pub fn material_override(t: &PlayerTuning, ft: &FootstepTuning, m: u32, bucket: i32) -> Option<f32> {
+    let s = footstep_surface(t, m);
+    if s == 7 || s == 5 || m >= NO_MATERIAL {
+        return None;
+    }
+    if ft.material_sound(m, false, bucket).1 == -1 {
+        return None;
+    }
+    Some(ft.material_gain(m, bucket))
+}
+
+/// One foot sound slot of a holder (`sub_824D7CE8`: sound, EQ floats, gain; its submix graph).
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct FootSlot {
+    sound: Option<SoundId>,
+    eq: SubmixEq,
+}
+
+impl Default for FootSlot {
+    fn default() -> Self {
+        Self { sound: None, eq: SubmixEq::SLOT }
+    }
+}
+
+/// `SFXObj_OffBoard`'s footstep state (owner offsets in the field docs).
+#[derive(Clone, Debug, PartialEq)]
+pub struct Footsteps {
+    /// `+54` / `+238`: last frame's foot-down copies (A, B).
+    was_down: [bool; 2],
+    /// `+460` last frame's footplant (`+768`), `+404` on foot, `+405` OffboardAir.
+    was_footplant: bool,
+    was_on_foot: bool,
+    was_offboard_air: bool,
+    /// `+464` / `+468`.
+    countdown: [i32; 2],
+    /// `+408` walk word, `+412` / `+416` xz words (A, B), `+420` / `+424` vertical words (A, B).
+    walk: i32,
+    xz: [i32; 2],
+    vertical: [i32; 2],
+    /// `+56` / `+240`: the feet's materials (143 → 3).
+    material: [u32; 2],
+    /// Holders `+36` (A) / `+220` (B): the packet, its env level (`+8`) and azimuth (`+12`), and
+    /// the four sound slots.
+    packets: [Option<Vec<i32>>; 2],
+    env: [f32; 2],
+    azimuth: [i32; 2],
+    slots: [[FootSlot; 4]; 2],
+    /// Walking voices: `sk8_foley` `+432` (A) / `+428` (B), `Skate_Collisions` `+440` / `+436`.
+    walking: [Option<SoundId>; 2],
+    walking_hard: [Option<SoundId>; 2],
+    /// Jump voices: take-off `+444` (kept after it ends: its slot is only cleared by a restart or
+    /// the apex), apex `+448`; `+456` last frame's "falling" (2 at start), `+452` last hippy jump,
+    /// `+472` the take-off's jump bucket, `+476` it was off the feet.
+    jump: Option<SoundId>,
+    apex: Option<SoundId>,
+    falling: i32,
+    was_hippy: bool,
+    jump_bucket: u32,
+    from_feet: bool,
+    /// Sounds started (diagnostics).
+    pub starts: u64,
+}
+
+impl Default for Footsteps {
+    fn default() -> Self {
+        Self {
+            was_down: [false; 2],
+            was_footplant: false,
+            was_on_foot: false,
+            was_offboard_air: false,
+            countdown: [0; 2],
+            walk: 0,
+            xz: [0; 2],
+            vertical: [0; 2],
+            material: [3; 2],
+            packets: [None, None],
+            env: [0.0; 2],
+            azimuth: [0; 2],
+            slots: [[FootSlot::default(); 4]; 2],
+            walking: [None; 2],
+            walking_hard: [None; 2],
+            jump: None,
+            apex: None,
+            falling: 2,
+            was_hippy: false,
+            jump_bucket: 0,
+            from_feet: false,
+            starts: 0,
+        }
+    }
+}
+
+fn start_block(dt: f32, spread: f32) -> [f32; 6] {
+    [0.0, 1.0, 0.0, dt, spread, 1.0]
+}
+
+fn master() -> crate::bus::Route {
+    crate::bus::Route::default()
+}
+
+impl Footsteps {
+    /// The constructor's words (`sub_824B73E0` as the poster calls it).
+    pub fn post_words(ft: &FootstepTuning) -> Vec<i32> {
+        let mut w = vec![0i32; WORDS];
+        w[2] = 4096;
+        w[4] = 25000;
+        w[7] = 32767;
+        w[12] = 1;
+        w[13] = 1;
+        w[16] = 1;
+        w[17] = 1;
+        w[24] = (ft.eq_chain + 10).clamp(0, 32767);
+        w
+    }
+
+    /// One frame before the MixMap tick (`sub_824E9270`). OffBoard.in0 is written by
+    /// [`super::inputs::write_off_board`].
+    pub fn process(&mut self, s: &AudioState, t: &PlayerTuning, ft: &FootstepTuning, host: &mut dyn SpliceHost) -> Vec<Command> {
+        let footplant_ended = !s.footplant && self.was_footplant;
+        self.walk = ft.walk_curve.word(s.com_speed());
+        self.xz = [ft.xz_curve.word(s.foot_xz_speed[0]), ft.xz_curve.word(s.foot_xz_speed[1])];
+        self.vertical = [ft.vertical_curve.word(s.foot_vertical_speed[0]), ft.vertical_curve.word(s.foot_vertical_speed[1])];
+        if footplant_ended {
+            if self.was_down[0] {
+                self.countdown[0] = 10;
+            } else if self.was_down[1] {
+                self.countdown[1] = 10;
+            }
+        }
+        for c in &mut self.countdown {
+            if *c > 0 {
+                *c -= 1;
+            }
+        }
+        let cmds = self.poster(s, t, ft, host);
+        if s.on_foot {
+            self.walking_voices(s, ft, host);
+        }
+        self.jump_voices(s, ft, footplant_ended, host);
+        self.was_on_foot = s.on_foot;
+        self.was_footplant = s.footplant;
+        self.was_down = s.foot_down;
+        self.was_offboard_air = s.offboard_air;
+        cmds
+    }
+
+    /// `sub_824E9FD8`.
+    fn poster(&mut self, s: &AudioState, t: &PlayerTuning, ft: &FootstepTuning, host: &mut dyn SpliceHost) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        let rising = [s.foot_down[0] && !self.was_down[0], s.foot_down[1] && !self.was_down[1]];
+        self.material = s.foot_material.map(|m| if m == NO_MATERIAL { 3 } else { m });
+        for foot in [1usize, 0] {
+            if self.packets[foot].is_none() {
+                let words = Self::post_words(ft);
+                cmds.push(Command::Post { slot: Slot::Footstep(foot as u8), class: CLASS, words: words.clone() });
+                self.packets[foot] = Some(words);
+            }
+        }
+        let run = self.walk > ft.run_threshold;
+        let run_mode = self.walk >= ft.mode_threshold;
+        for foot in 0..2 {
+            if !(rising[foot] && s.local) {
+                continue;
+            }
+            self.foot_down(foot, s, t, ft, run, run_mode, host);
+        }
+        cmds
+    }
+
+    /// The local player's sounds of a foot that came down.
+    #[allow(clippy::too_many_arguments)]
+    fn foot_down(&mut self, foot: usize, s: &AudioState, t: &PlayerTuning, ft: &FootstepTuning, run: bool, run_mode: bool, host: &mut dyn SpliceHost) {
+        for slot in &mut self.slots[foot] {
+            if let Some(sound) = slot.sound.take() {
+                host.release(sound);
+            }
+        }
+        let m = self.material[foot];
+        let bucket = s.landing_bucket;
+        let block = start_block(s.dt, 1.0);
+        let (bank, id) = surface_sound(t, ft, run, bucket, 0, m);
+        if id != -1 {
+            let rec = ft.eq_record(bank, id);
+            let gain = material_override(t, ft, m, bucket).unwrap_or(rec.gain);
+            self.slots[foot][0].eq = SubmixEq { gain, ..rec };
+            self.start_slot(foot, 0, bank, id, block, host);
+            let (bank, id) = surface_sound(t, ft, run, bucket, 1, m);
+            if id != -1 {
+                self.slots[foot][1].eq = ft.eq_record(bank, id);
+                self.start_slot(foot, 1, bank, id, block, host);
+            }
+        }
+        let code = s.step_code;
+        for layer in 0..2 {
+            let (bank, id) = step_sound(t, ft, run_mode, m, code, layer);
+            if id != -1 {
+                self.start_slot(foot, 2 + layer, bank, id, block, host);
+            }
+        }
+    }
+
+    fn start_slot(&mut self, foot: usize, slot: usize, bank: i32, id: i32, block: [f32; 6], host: &mut dyn SpliceHost) {
+        let Some(name) = splice_bank(bank) else { return };
+        let eq = self.slots[foot][slot].eq;
+        let env = self.env[foot];
+        host.set_route(crate::bus::Route { output: crate::bus::Output::Master, create: false, owner_env: env, mono: false });
+        host.set_submix(Some(Submix { eq, env, azimuth: self.azimuth[foot] as f32 * PAN_DEGREES, graph: (foot * 4 + slot) as u8 }));
+        self.slots[foot][slot].sound = host.start(name, id as u32, block);
+        self.starts += u64::from(self.slots[foot][slot].sound.is_some());
+    }
+
+    /// `sub_824E9D10` (on foot): `sk8_foley` by |COM v| for each foot that came down, plus the
+    /// `Skate_Collisions` layer for the local player with `+308`.
+    fn walking_voices(&mut self, s: &AudioState, ft: &FootstepTuning, host: &mut dyn SpliceHost) {
+        let rising = [s.foot_down[0] && !self.was_down[0], s.foot_down[1] && !self.was_down[1]];
+        let hard = s.local && s.on_foot && s.offboard_308;
+        let v = s.com_speed();
+        let pick = if v > ft.walk_speeds[0] {
+            2
+        } else if v > ft.walk_speeds[1] {
+            1
+        } else {
+            0
+        };
+        let block = start_block(s.dt, 1.0);
+        for foot in 0..2 {
+            if !rising[foot] {
+                continue;
+            }
+            if let Some(old) = self.walking[foot].take() {
+                host.release(old);
+            }
+            host.set_route(master());
+            self.walking[foot] = host.start("sk8_foley", ft.walk_ids[pick] as u32, block);
+            self.starts += u64::from(self.walking[foot].is_some());
+            if hard {
+                if let Some(old) = self.walking_hard[foot].take() {
+                    host.release(old);
+                }
+                host.set_route(master());
+                self.walking_hard[foot] = host.start("Skate_Collisions", ft.walk_ids_hard[pick] as u32, block);
+                self.starts += u64::from(self.walking_hard[foot].is_some());
+            }
+        }
+    }
+
+    /// `sub_824E9678`.
+    fn jump_voices(&mut self, s: &AudioState, ft: &FootstepTuning, footplant_ended: bool, host: &mut dyn SpliceHost) {
+        let off_feet = s.on_foot && s.offboard_air && !self.was_offboard_air;
+        let vy = s.com_velocity[1];
+        let (falling, began) = if vy <= 0.0 { (1, self.falling == 0) } else { (0, false) };
+        self.falling = falling;
+        let apex = self.jump.is_some() && began;
+        let hippy = !self.was_hippy && s.hippy_jump;
+        let spread = if s.local { 1.0 } else { 0.0 };
+        let block = start_block(s.dt, spread);
+        let bucket_id = |ids: &[i32; 4], bucket: u32| match bucket {
+            1 => ids[1],
+            2 => ids[2],
+            _ => ids[3],
+        };
+        if off_feet || hippy || footplant_ended {
+            if let Some(old) = self.jump.take() {
+                host.release(old);
+            }
+            self.jump_bucket = s.jump_bucket;
+            let id = if off_feet { ft.jump_ids[0] } else { bucket_id(&ft.jump_ids, self.jump_bucket) };
+            host.set_route(master());
+            self.jump = host.start("sk8_foley", id as u32, block);
+            self.starts += u64::from(self.jump.is_some());
+            self.from_feet = off_feet;
+        }
+        if apex {
+            if let Some(old) = self.jump.take() {
+                host.release(old);
+            }
+            if let Some(old) = self.apex.take() {
+                host.release(old);
+            }
+            let id = if self.from_feet { ft.apex_ids[0] } else { bucket_id(&ft.apex_ids, self.jump_bucket) };
+            host.set_route(master());
+            self.apex = host.start("sk8_foley", id as u32, block);
+            self.starts += u64::from(self.apex.is_some());
+        }
+        self.was_hippy = s.hippy_jump;
+    }
+
+    /// The packet words of foot `foot` (`sub_824EAEA8`).
+    fn packet_words(&self, foot: usize, w: &mut [i32], s: &AudioState, t: &PlayerTuning, ft: &FootstepTuning, out: &dyn Outputs) {
+        w[0] = 32767;
+        w[1] = out.raw(0).clamp(0, 65535);
+        w[2] = out.pitch(1).clamp(0, 8192);
+        w[4] = out.level(4).clamp(0, 25001);
+        w[5] = out.level(5).clamp(0, 25001);
+        w[6] = out.level(6).clamp(0, 32767);
+        w[7] = out.level(2).clamp(0, 32767);
+        w[8] = i32::from(s.foot_down[foot]);
+        w[9] = self.vertical[foot].clamp(0, 1000);
+        w[10] = self.xz[foot].clamp(0, 1000);
+        w[11] = i32::from(self.countdown[foot] > 0 || self.jump.is_some());
+        w[12] = s.landing_bucket.clamp(1, 4);
+        w[13] = trunc_clamp(s.footstep_strength, i32::MIN, i32::MAX).clamp(1, 99);
+        w[14] = self.walk.clamp(0, 1000);
+        w[15] = 1;
+        w[16] = footstep_surface(t, self.material[foot]).clamp(1, 7);
+        w[17] = s.step_code.clamp(1, 5);
+        for (i, v) in ft.tail.iter().enumerate() {
+            w[18 + i] = (*v).clamp(0, 32767);
+        }
+    }
+
+    /// One frame after the MixMap tick (`sub_824E9628`); `out` = the OffBoard outputs.
+    pub fn update(&mut self, s: &AudioState, t: &PlayerTuning, ft: &FootstepTuning, out: &dyn Outputs, host: &mut dyn SpliceHost) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if self.packets[0].is_some() && self.packets[1].is_some() {
+            for foot in 0..2 {
+                let mut w = self.packets[foot].take().unwrap();
+                self.packet_words(foot, &mut w, s, t, ft, out);
+                cmds.push(Command::Redeliver { slot: Slot::Footstep(foot as u8), words: w.clone() });
+                self.packets[foot] = Some(w);
+            }
+            if s.local {
+                // The level of every foot sound: level(7), level(11) when foot A's material has
+                // its own footstep record.
+                let id = if material_override(t, ft, self.material[0], s.landing_bucket).is_some() { 11 } else { 7 };
+                let level = out.level(id) as f32 * LEVEL;
+                let env = out.level(8) as f32 * LEVEL;
+                let block = [0.0, out.pitch(1) as f32 * PITCH, 0.0, s.dt, 1.0, 1.0];
+                for foot in 0..2 {
+                    self.azimuth[foot] = out.raw(0);
+                    self.env[foot] = env;
+                    // sub_82494C08 walks slots 0, 2, 1, 3.
+                    for slot in [0usize, 2, 1, 3] {
+                        let FootSlot { sound, eq } = self.slots[foot][slot];
+                        let Some(sound) = sound else { continue };
+                        if host.alive(sound) {
+                            let mut b = block;
+                            b[0] = eq.gain * level;
+                            host.update(sound, b);
+                        } else {
+                            host.release(sound);
+                            self.slots[foot][slot].sound = None;
+                        }
+                    }
+                }
+            }
+        }
+        let spread = if s.local { 1.0 } else { 0.0 };
+        let block = |level: i32| -> [f32; 6] {
+            [level as f32 * LEVEL, out.pitch(1) as f32 * PITCH, out.raw(0) as f32 * DEGREES, s.dt, spread, 1.0]
+        };
+        // sub_824EA9C8 (level 3, A then B) and sub_824EAC38 (level 12).
+        for (voices, level) in [(&mut self.walking, 3usize), (&mut self.walking_hard, 12)] {
+            for foot in [0usize, 1] {
+                let Some(sound) = voices[foot] else { continue };
+                if host.alive(sound) {
+                    host.update(sound, block(out.level(level)));
+                } else {
+                    host.release(sound);
+                    voices[foot] = None;
+                }
+            }
+        }
+        // sub_824E9AB8: the take-off keeps its slot when it ends; the apex is freed.
+        if let Some(sound) = self.jump {
+            if host.alive(sound) {
+                host.update(sound, block(out.level(9)));
+            }
+        }
+        if let Some(sound) = self.apex {
+            if host.alive(sound) {
+                host.update(sound, block(out.level(10)));
+            } else {
+                host.release(sound);
+                self.apex = None;
+            }
+        }
+        cmds
+    }
+}
+
+/// The audio conditioner's step code (`sub_827729B8` → state `+740`): which foot planted higher
+/// than the other (by more than 7 cm) at their last plants, and whether the surface under foot
+/// B is physics class 8. Feed it every frame.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct StepCode {
+    /// `+736` / `+738`: the feet's retained surface tags (OffBoard `+52` / `+56`).
+    tags: [u32; 2],
+    /// `+740` / `+742` the support flags (OffBoard 306 / 307) of this and `+741` / `+743` last frame.
+    support: [bool; 2],
+    /// `+708` / `+724`: the plant heights (Skeleton `+144` / `+160` y at the last 306 / 307 plant).
+    heights: [f32; 2],
+    /// B40 bytes 212 / 213 (kept until the feet plant level).
+    up: bool,
+    down: bool,
+}
+
+impl StepCode {
+    /// One frame. `support` = OffBoard 306 / 307, `tags` = OffBoard `+52` / `+56` (raw u16 surface
+    /// tags, 0 = keep the last), `heights` = Skeleton `+144` / `+160` y. Returns the code 1..5.
+    pub fn update(&mut self, support: [bool; 2], tags: [u32; 2], heights: [f32; 2]) -> i32 {
+        for i in 0..2 {
+            if tags[i] & 0xFFFF != 0 {
+                self.tags[i] = tags[i] & 0xFFFF;
+            }
+        }
+        let class8 = (self.tags[0] >> 7) & 31 == 8;
+        let was = self.support;
+        self.support = support;
+        if support[1] && !was[1] {
+            self.heights[1] = heights[1];
+        }
+        if support[0] && !was[0] {
+            self.heights[0] = heights[0];
+        }
+        let d = self.heights[1] - self.heights[0];
+        if !(d.abs() <= STEP_HEIGHT) {
+            if support[1] {
+                if d <= 0.0 {
+                    self.down = true;
+                } else {
+                    self.up = true;
+                }
+            } else if support[0] {
+                if d <= 0.0 {
+                    self.up = true;
+                } else {
+                    self.down = true;
+                }
+            }
+        } else {
+            self.up = false;
+            self.down = false;
+        }
+        if self.up {
+            if class8 { 2 } else { 4 }
+        } else if self.down {
+            if class8 { 3 } else { 5 }
+        } else {
+            1
+        }
+    }
+}
+
+/// The landing bucket (state `+300`): the conditioner's 4-frame minimum of the COM's vertical
+/// velocity (`sub_82772B88`, vault `7385078DD3C063BA` = [1.5, 2.6, 3.45] m/s → 2 / 3 / 4, else
+/// 1), forced to 1 by the bridge with a trick (other than audio trick 31) or more than 20 frames
+/// after OffboardAir (`+718`, countdown `+720`).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct LandingBucket {
+    ring: [f32; 4],
+    at: usize,
+    countdown: i32,
+    pub thresholds: [f32; 3],
+}
+
+impl Default for LandingBucket {
+    fn default() -> Self {
+        Self { ring: [0.0; 4], at: 0, countdown: 0, thresholds: [1.5, 2.6, 3.45] }
+    }
+}
+
+fn fsel(a: f32, b: f32, c: f32) -> f32 {
+    if a >= 0.0 { b } else { c }
+}
+
+impl LandingBucket {
+    /// One frame: the COM's vertical velocity (Reckoning `+20`), OffboardAir, the trick flags.
+    pub fn update(&mut self, com_vy: f32, offboard_air: bool, trick_active: bool, audio_trick: i32) -> i32 {
+        self.ring[self.at] = com_vy;
+        let [r0, r1, r2, r3] = self.ring;
+        let m = fsel(-r0, r0, 0.0);
+        let m = fsel(m - r1, r1, m);
+        let m = fsel(m - r2, r2, m);
+        let m = fsel(m - r3, r3, m);
+        let a = m.abs();
+        let t = self.thresholds;
+        let bucket = if a > t[2] {
+            4
+        } else if a > t[1] {
+            3
+        } else if a > t[0] {
+            2
+        } else {
+            1
+        };
+        self.at = (self.at + 1) % 4;
+        let forced = (trick_active && audio_trick != 31) || self.countdown == 0;
+        if offboard_air {
+            self.countdown = 20;
+        } else if self.countdown > 0 {
+            self.countdown -= 1;
+        }
+        if forced { 1 } else { bucket }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[derive(Default)]
+    struct Log {
+        started: Vec<(String, u32)>,
+        submixes: Vec<Option<Submix>>,
+        live: HashMap<SoundId, (String, u32)>,
+        next: SoundId,
+        updates: Vec<(u32, [f32; 6])>,
+        pending: Option<Submix>,
+    }
+    impl SpliceHost for Log {
+        fn set_submix(&mut self, submix: Option<Submix>) {
+            self.pending = submix;
+        }
+        fn start(&mut self, bank: &str, id: u32, _: [f32; 6]) -> Option<SoundId> {
+            self.started.push((bank.to_owned(), id));
+            self.submixes.push(self.pending.take());
+            self.next += 1;
+            self.live.insert(self.next, (bank.to_owned(), id));
+            Some(self.next)
+        }
+        fn update(&mut self, sound: SoundId, block: [f32; 6]) {
+            self.updates.push((self.live[&sound].1, block));
+        }
+        fn alive(&self, sound: SoundId) -> bool {
+            self.live.contains_key(&sound)
+        }
+        fn release(&mut self, sound: SoundId) {
+            self.live.remove(&sound);
+        }
+    }
+
+    struct Out;
+    impl Outputs for Out {
+        fn level(&self, id: usize) -> i32 {
+            10000 + id as i32
+        }
+        fn raw(&self, _: usize) -> i32 {
+            16384
+        }
+        fn pitch(&self, _: usize) -> i32 {
+            4096
+        }
+    }
+
+    /// Materials 2 (concrete-like: footstep surface 1, no own record), 9 (surface 7) and 46 (its
+    /// own Skate_Collisions record 904 / 905 / 907, gain 8000 / 22000).
+    fn tuning() -> (PlayerTuning, FootstepTuning) {
+        let mut t = PlayerTuning::default();
+        t.surface_table = vec![[0; 18]; 95];
+        t.surface_table[2][6] = 1;
+        t.surface_table[9][6] = 7;
+        t.surface_table[46][6] = 1;
+        t.surface_table[30][6] = 4;
+        let mut ft = FootstepTuning::default();
+        ft.materials = vec![FootstepMaterial { kind: 0, ..Default::default() }; 143];
+        ft.materials[46] = FootstepMaterial { kind: 0, enabled: true, gain: 8000, landing_gain: 22000, ids: [904, 905, 907] };
+        (t, ft)
+    }
+
+    fn walking(foot: [bool; 2], m: u32) -> AudioState {
+        AudioState { on_foot: true, com_velocity: [1.5, 0.0, 0.0], foot_down: foot, foot_material: [m; 2], ..Default::default() }
+    }
+
+    #[test]
+    fn the_curves_interpolate_like_retail() {
+        let ft = FootstepTuning::default();
+        assert_eq!(ft.walk_curve.word(-1.0), 0);
+        assert_eq!(ft.walk_curve.word(2.0), 205);
+        // Between 2.0 (205) and 2.5 (250): 205 + 90 × 0.25 = 227.5 → 227.
+        assert_eq!(ft.walk_curve.word(2.25), 227);
+        assert_eq!(ft.walk_curve.word(50.0), 516);
+        assert_eq!(ft.vertical_curve.word(0.25), 2);
+        assert_eq!(ft.vertical_curve.word(3.0), 0);
+        // Running begins where the walk word passes 400 (≈ 5.88 m/s).
+        assert!(ft.walk_curve.word(5.8) < 400 && ft.walk_curve.word(6.0) >= 400);
+    }
+
+    #[test]
+    fn the_packets_post_once_with_the_constructor_words_and_update_from_the_outputs() {
+        let (t, ft) = tuning();
+        let mut f = Footsteps::default();
+        let mut h = Log::default();
+        let cmds = f.process(&walking([false; 2], 2), &t, &ft, &mut h);
+        assert_eq!(cmds.len(), 2);
+        let Command::Post { slot, class, words } = &cmds[0] else { panic!() };
+        assert_eq!((*slot, *class), (Slot::Footstep(1), CLASS));
+        assert_eq!(words, &vec![0, 0, 4096, 0, 25000, 0, 0, 32767, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 12]);
+        assert!(matches!(cmds[1], Command::Post { slot: Slot::Footstep(0), .. }));
+        assert!(f.process(&walking([false; 2], 2), &t, &ft, &mut h).is_empty(), "held");
+        let s = AudioState { footstep_strength: 2.7, step_code: 4, landing_bucket: 2, foot_vertical_speed: [0.25, 3.0], foot_xz_speed: [2.0, 0.0], ..walking([true, false], 2) };
+        f.process(&s, &t, &ft, &mut h);
+        let up = f.update(&s, &t, &ft, &Out, &mut h);
+        let Command::Redeliver { slot: Slot::Footstep(0), words } = &up[0] else { panic!() };
+        // w1 raw(0), w2 pitch(1), w4/w5 filters 4/5, w6 level(6), w7 level(2), w8 foot down,
+        // w9 vertical(0.25) = 2, w10 xz(2.0), w12 bucket, w13 trunc(2.7) = 2, w14 walk(1.5),
+        // w15 1, w16 surface 1, w17 code 4, w18.. the vault tail, w24 kept.
+        let xz = ft.xz_curve.word(2.0);
+        let walk = ft.walk_curve.word(1.5);
+        assert_eq!(
+            words,
+            &vec![32767, 16384, 4096, 0, 10004, 10005, 10006, 10002, 1, 2, xz, 0, 2, 2, walk, 1, 1, 4, 32767, 10000, 15000, 25000, 32767, 28000, 12]
+        );
+        let Command::Redeliver { slot: Slot::Footstep(1), words } = &up[1] else { panic!() };
+        assert_eq!((words[8], words[9], words[10]), (0, 0, 0));
+    }
+
+    #[test]
+    fn a_step_on_concrete_plays_the_walk_set_and_the_walking_foley() {
+        let (t, ft) = tuning();
+        let mut f = Footsteps::default();
+        let mut h = Log::default();
+        f.process(&walking([false; 2], 2), &t, &ft, &mut h);
+        f.process(&walking([true, false], 2), &t, &ft, &mut h);
+        // Surface 1 has no surface layer (the material's record has none); step layer 0, walk
+        // mode, step code 1 → sk8_foley 86; the walking foley at 1.5 m/s → 62.
+        assert_eq!(h.started, [("sk8_foley".to_owned(), 86), ("sk8_foley".to_owned(), 62)]);
+        let sub = h.submixes[0].unwrap();
+        assert_eq!(sub.eq, SubmixEq::SLOT, "step slots keep the constructor's open EQ");
+        assert!(h.submixes[1].is_none(), "the walking foley goes straight to SFX Master");
+        // Held foot: no new step; the other foot comes down → its own set.
+        h.started.clear();
+        f.process(&walking([true, false], 2), &t, &ft, &mut h);
+        assert!(h.started.is_empty());
+        f.process(&walking([true, true], 2), &t, &ft, &mut h);
+        assert_eq!(h.started.len(), 2);
+    }
+
+    #[test]
+    fn a_material_with_its_own_record_adds_the_surface_layer_at_its_gain() {
+        let (t, ft) = tuning();
+        let mut f = Footsteps::default();
+        let mut h = Log::default();
+        f.process(&walking([false; 2], 46), &t, &ft, &mut h);
+        f.process(&walking([true, false], 46), &t, &ft, &mut h);
+        assert_eq!(h.started[0], ("Skate_Collisions".to_owned(), 904));
+        let sub = h.submixes[0].unwrap();
+        assert_eq!(sub.eq.gain, 8000.0 * LEVEL);
+        assert_eq!(sub.eq.low_pass, 96_000.0, "no own EQ record: the default one");
+        // The update scales by level(11) (the material's record applies) × the slot gain.
+        f.update(&walking([true, false], 46), &t, &ft, &Out, &mut h);
+        let b = h.updates.iter().find(|u| u.0 == 904).unwrap().1;
+        assert_eq!(b[0], 8000.0 * LEVEL * (10011.0 * LEVEL));
+        assert_eq!((b[2], b[4]), (0.0, 1.0), "centred: the submix pans");
+    }
+
+    #[test]
+    fn surface_seven_plays_both_layers_with_their_records() {
+        let (t, ft) = tuning();
+        let mut f = Footsteps::default();
+        let mut h = Log::default();
+        f.process(&walking([false; 2], 9), &t, &ft, &mut h);
+        f.process(&walking([false, true], 9), &t, &ft, &mut h);
+        let ids: Vec<u32> = h.started.iter().map(|s| s.1).collect();
+        // 959 (layer 0, walk), 961 (layer 1), then step layer 0 on surface 7 (walk, code 1) = 75,
+        // then the walking foley 62.
+        assert_eq!(ids, [959, 961, 75, 62]);
+        assert_eq!(h.submixes[0].unwrap().eq.high_pass, 200.0);
+        assert_eq!(h.submixes[1].unwrap().eq.gain, f32::from_bits(0x3CA3_D70A));
+    }
+
+    #[test]
+    fn surface_four_adds_the_hard_step_and_running_switches_sets() {
+        let (t, ft) = tuning();
+        let mut f = Footsteps::default();
+        let mut h = Log::default();
+        let run = |down| AudioState { com_velocity: [8.0, 0.0, 0.0], ..walking(down, 30) };
+        f.process(&run([false; 2]), &t, &ft, &mut h);
+        f.process(&run([true, false]), &t, &ft, &mut h);
+        // Surface 4, run mode, code 1: sk8_foley 105 and Skate_Collisions 964; walking foley at
+        // 8 m/s → 64 (no hard layer without +308).
+        let got: Vec<(&str, u32)> = h.started.iter().map(|(b, i)| (b.as_str(), *i)).collect();
+        assert_eq!(got, [("sk8_foley", 105), ("Skate_Collisions", 964), ("sk8_foley", 64)]);
+    }
+
+    #[test]
+    fn jumping_off_the_feet_plays_the_take_off_then_the_apex() {
+        let (t, ft) = tuning();
+        let mut f = Footsteps::default();
+        let mut h = Log::default();
+        let mut s = walking([true, true], 2);
+        s.com_velocity = [1.0, 3.0, 0.0];
+        f.process(&s, &t, &ft, &mut h);
+        h.started.clear();
+        s.offboard_air = true;
+        s.foot_down = [false; 2];
+        f.process(&s, &t, &ft, &mut h);
+        assert_eq!(h.started, [("sk8_foley".to_owned(), 65)]);
+        s.com_velocity[1] = 1.0;
+        f.process(&s, &t, &ft, &mut h);
+        s.com_velocity[1] = -0.5;
+        f.process(&s, &t, &ft, &mut h);
+        assert_eq!(h.started.last().unwrap(), &("sk8_foley".to_owned(), 66));
+        assert!(f.jump.is_none() && f.apex.is_some());
+    }
+
+    #[test]
+    fn the_footplant_end_counts_down_the_foot_flag() {
+        let (t, ft) = tuning();
+        let mut f = Footsteps::default();
+        let mut h = Log::default();
+        let mut s = AudioState { footplant: true, foot_down: [true, false], ..Default::default() };
+        f.process(&s, &t, &ft, &mut h);
+        s.footplant = false;
+        f.process(&s, &t, &ft, &mut h);
+        assert_eq!(f.countdown, [9, 0], "set to 10 and counted down the same frame");
+        // ... and the end of the footplant plays a take-off (bucket 0 → 67).
+        assert!(h.started.contains(&("sk8_foley".to_owned(), 67)));
+    }
+
+    #[test]
+    fn step_code_compares_the_plant_heights() {
+        let mut c = StepCode::default();
+        assert_eq!(c.update([true, false], [0, 0], [0.0, 0.0]), 1);
+        // Foot 307 plants 10 cm higher: up (212) → 4 on a plain surface.
+        assert_eq!(c.update([true, true], [0, 0], [0.0, 0.1]), 4);
+        // Level again: back to 1.
+        c.update([false, true], [0, 0], [0.0, 0.1]);
+        assert_eq!(c.update([true, true], [0, 0], [0.1, 0.1]), 1);
+        // Physics class 8 under foot B (tag bits 7..11 = 8): codes 2 / 3.
+        let tag = 8 << 7;
+        let mut c = StepCode::default();
+        c.update([true, false], [tag, 0], [0.0, 0.0]);
+        assert_eq!(c.update([true, true], [tag, 0], [0.0, -0.2]), 3);
+    }
+
+    #[test]
+    fn the_landing_bucket_follows_the_fall_speed_after_offboard_air() {
+        let mut b = LandingBucket::default();
+        assert_eq!(b.update(-3.0, false, false, -1), 1, "no OffboardAir: forced 1");
+        b.update(-1.0, true, false, -1);
+        assert_eq!(b.update(-3.0, false, false, -1), 4 - 1 + 0, "|-3.0| > 2.6 → 3");
+        assert_eq!(b.update(-4.0, false, false, -1), 4);
+        assert_eq!(b.update(-4.0, false, true, 28), 1, "a trick forces 1");
+    }
+}
diff --git a/crates/skate-audio/src/player/globals.rs b/crates/skate-audio/src/player/globals.rs
new file mode 100644
index 00000000..1621e720
--- /dev/null
+++ b/crates/skate-audio/src/player/globals.rs
@@ -0,0 +1,35 @@
+//! Game-global words the trick and treatment components read outside the per-player audio state
+//! (`AudioState`): the audio game block `G = *(0x83083C38) + 0x2F070` word `G+96` and the game-flow
+//! object `X = *(0x830CFDC4)` field `X+1060`. Free-skate values as the defaults (spec
+//! `.claude/notes/aems-tricks-treatment-spec.md` §4).
+
+/// `G+96` bit read by `Class_Treatment`'s process (with `sub_8279E180` false and the time scale
+/// below 1.0 it posts the slow-motion companion).
+pub const SLO_MO_BIT: u32 = 0x0400_0000;
+/// `G+96` bits of the Tricks slew (`sub_824CD170`): the first set one picks the target.
+pub const SLEW_BITS: [u32; 3] = [0x8000, 0x4000, 0x2000];
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Globals {
+    /// `G+96`. Its writer was not located; 0 in free skate (no bit set: the Tricks slew target is 0
+    /// and the slow-motion companion is not posted — retail's free-skate sessions post neither).
+    pub flags_96: u32,
+    /// `X+1060`, the game-flow mode: 7 in free skate (the Treatment process posts
+    /// `hall_of_meat_slo_mo` whenever it is not 7, with w14 = mode − 7; `sub_824898C8` takes 8 as
+    /// "slew to full"). None of the clean retail sessions posts the companion, so free skate is 7.
+    pub mode_1060: i32,
+}
+
+impl Default for Globals {
+    fn default() -> Self {
+        Self { flags_96: 0, mode_1060: 7 }
+    }
+}
+
+impl Globals {
+    /// `sub_824898C8`: `G+96` bit 13, or `X+932` with the copied `X+476` byte (not modelled:
+    /// false), or mode 8.
+    pub fn slew_full(&self) -> bool {
+        self.flags_96 & 0x2000 != 0 || self.mode_1060 == 8
+    }
+}
diff --git a/crates/skate-audio/src/player/inputs.rs b/crates/skate-audio/src/player/inputs.rs
new file mode 100644
index 00000000..1b5dc7b7
--- /dev/null
+++ b/crates/skate-audio/src/player/inputs.rs
@@ -0,0 +1,189 @@
+//! The game-side MixMap input writers of the local player (mixmap-spec §7): the audio state's
+//! controller `PlayerPhysics` (`0x60010000`, `sub_824B19C8`), `Contacts` (`0x40010010`, process
+//! `sub_824B90D8` / landing `sub_824BA630`), `Rail` (`0x40010030`, `sub_824C28B0`) and
+//! `OffBoard` (`0x40010090`, `sub_824E9270`). Pure functions of the [`AudioState`] plus the little
+//! memory each writer keeps.
+use super::AudioState;
+use super::tuning::PlayerTuning;
+use crate::mixmap::{MixMap, keys};
+
+/// The image's PlayerPhysics speed scales (`0x822F9520..`): ids 0 (5 km/h full), 1 (30 km/h), 7
+/// (50 km/h), 8 and 14 (70 km/h).
+pub const SPEED_SCALES: [u32; 4] = [0x46B8_507A, 0x4575_C0A3, 0x4513_7395, 0x44D2_A51E];
+/// `PlayerPhysics.in11` after a bail: held this many 60 Hz frames (see [`Physics`]).
+pub const BAIL_FLAG_FRAMES: u32 = 110;
+
+/// clamp(trunc(min(max(v × scale, 0), 32767)), 0, 32767).
+pub fn speed_word(speed: f32, scale_bits: u32) -> i32 {
+    super::trunc_clamp((speed * f32::from_bits(scale_bits)).clamp(0.0, 32767.0), 0, 32767)
+}
+
+fn on(b: bool) -> i32 {
+    if b { 32767 } else { 0 }
+}
+
+/// `PlayerPhysics` writer memory.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Physics {
+    was_bail: bool,
+    bail_frames: u32,
+}
+
+impl Physics {
+    /// Ids 2, 10, 4, 5, 0, 1, 7, 8, 14, 6, 9, 11, 13 in retail's order, plus 3 and 12.
+    ///
+    /// - 0/1/7/8 from |ground speed| (retail's word is signed and clamps reverse speeds to 0; our
+    ///   engine's ground speed changes sign riding fakie, so its magnitude is used), 14 from |COM v|.
+    /// - 9 = 0 for the local player (`[[state+16]+72]` set), 32767 otherwise.
+    /// - 11 = the global "G+16" byte, writer not identified (UNCERTAIN, mixmap-spec §10): in PR #4's
+    ///   retail capture it rises with each bail (`+676`) and holds for about 110 frames; we write
+    ///   that measured shape.
+    /// - 13 = |state+96 − record₀+32| slewed (100 /s, cap 35 m, /35 × 32767): both are the COM
+    ///   velocity of the player itself for the local player (the record array `*(G+0x2F078)` holds
+    ///   player 0 first), so it is 0 here.
+    /// - 3 = `sub_824B2088`'s listener-facing factor of two PhysOut slot-0 vectors whose meaning we
+    ///   have not recovered: 0. Only A25 reads it, as a factor of the combo emphasis A4 (Music.in3,
+    ///   0 outside combos).
+    /// - 12 = `sub_824B23C8` = state `+684` (soft wheels) for the local player.
+    pub fn write(&mut self, m: &mut MixMap, s: &AudioState) {
+        let key = keys::player_physics(0);
+        let v = s.ground_speed.abs();
+        m.set_input(key, 2, on(s.wheel_count == 0));
+        let wheels = match s.wheel_count {
+            1 => 8191,
+            2 => 16383,
+            3 => 24575,
+            4 => 32767,
+            _ => 0,
+        };
+        m.set_input(key, 10, wheels);
+        m.set_input(key, 4, on(s.brake));
+        m.set_input(key, 5, on(s.manual_brake));
+        m.set_input(key, 0, speed_word(v, SPEED_SCALES[0]));
+        m.set_input(key, 1, speed_word(v, SPEED_SCALES[1]));
+        m.set_input(key, 7, speed_word(v, SPEED_SCALES[2]));
+        m.set_input(key, 8, speed_word(v, SPEED_SCALES[3]));
+        m.set_input(key, 14, speed_word(s.com_speed(), SPEED_SCALES[3]));
+        m.set_input(key, 6, on(s.trick_active));
+        m.set_input(key, 9, if s.local { 0 } else { 32767 });
+        if s.bail && !self.was_bail {
+            self.bail_frames = BAIL_FLAG_FRAMES;
+        }
+        self.was_bail = s.bail;
+        m.set_input(key, 11, on(self.bail_frames > 0));
+        self.bail_frames = self.bail_frames.saturating_sub(1);
+        m.set_input(key, 13, 0);
+        m.set_input(key, 3, 0);
+        m.set_input(key, 12, on(s.local && s.soft_wheels));
+    }
+}
+
+/// `Contacts` writer memory (`+120` last frame's airborne) and the audio state's per-wheel landing
+/// buckets (`+244` stored air factor, `+448` bucket; bridge `sub_824B2350` / `sub_824B2268`).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Contacts {
+    was_airborne: bool,
+    air_factor: [f32; 4],
+    bucket: [u32; 4],
+}
+
+impl Contacts {
+    /// The bridge's per-wheel landing buckets (`+448`) as of the last [`Contacts::write`].
+    pub fn buckets(&self) -> [u32; 4] {
+        self.bucket
+    }
+
+    /// The bridge's per-wheel landing buckets: factor = clamp(air time × 0.5, 0, 1) in the air,
+    /// else 0; per wheel, while the factor is > 0, the wheel is down or grinding: bucket = 2 if the
+    /// stored factor ≥ high, 1 if ≥ low, else 0; then store the factor. So on the landing frame the
+    /// bucket reads the last airborne factor: ≥ 1 s of air → 2, ≥ 0.62 s → 1.
+    fn update_buckets(&mut self, s: &AudioState, t: &PlayerTuning) {
+        let factor = if s.airborne { super::clamp01(s.air_time * 0.5) } else { 0.0 };
+        for w in 0..4 {
+            if factor > 0.0 || s.wheel_contact[w] || s.grinding {
+                let f = self.air_factor[w];
+                self.bucket[w] = if !(f < t.wheel_bucket_high) {
+                    2
+                } else if f >= t.wheel_bucket_low {
+                    1
+                } else {
+                    0
+                };
+                self.air_factor[w] = factor;
+            }
+        }
+    }
+
+    /// Ids 0, 1, 6 cleared each frame; on a landing (was airborne, now neither airborne nor
+    /// grinding): 1 = 32767 (the bed's landing swell, Player F1/F30), 6 = 32767 for the local player
+    /// when the first contacting wheel with a material is on a landing-flag material, 2 = the
+    /// largest bucket of the contacting wheels (1 → 16000, 2 → 32767, else 0; 0 with no wheel down),
+    /// held until the next landing. Ids 0, 3–5, 7–9 reach no MixMap output and are not written.
+    pub fn write(&mut self, m: &mut MixMap, s: &AudioState, t: &PlayerTuning) -> bool {
+        self.update_buckets(s, t);
+        let key = keys::contacts(0);
+        m.set_input(key, 0, 0);
+        m.set_input(key, 1, 0);
+        m.set_input(key, 6, 0);
+        let landed = self.was_airborne && !s.airborne && !s.grinding;
+        if landed {
+            m.set_input(key, 1, 32767);
+            let material = s.contact_material();
+            if s.local && t.landing_materials.contains(&material) {
+                m.set_input(key, 6, 32767);
+            }
+            let down: Vec<u32> = (0..4).filter(|&w| s.wheel_contact[w]).map(|w| self.bucket[w]).collect();
+            let class = match down.iter().max() {
+                Some(1) => 16000,
+                Some(2) => 32767,
+                _ => 0,
+            };
+            m.set_input(key, 2, class);
+        }
+        self.was_airborne = s.airborne;
+        landed
+    }
+}
+
+/// `Rail` ids 0 = grinding (`+341`), 1 = the grind ended this frame (`+342 && !+341`).
+pub fn write_rail(m: &mut MixMap, grinding: bool, was_grinding: bool) {
+    let key = keys::rail(0);
+    m.set_input(key, 0, on(grinding));
+    m.set_input(key, 1, on(was_grinding && !grinding));
+}
+
+/// `OffBoard` id 0 = on foot (`+716`, state 500), for the local player. `HandGrabs` id 0 (the
+/// object's grab byte) is 0 in retail's free-skate capture and left at 0.
+pub fn write_off_board(m: &mut MixMap, s: &AudioState) {
+    m.set_input(keys::off_board(0), 0, on(s.local && s.on_foot));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn speed_words_clamp_like_retail() {
+        assert_eq!(speed_word(0.0, SPEED_SCALES[0]), 0);
+        assert_eq!(speed_word(-3.0, SPEED_SCALES[1]), 0);
+        assert_eq!(speed_word(5.0, SPEED_SCALES[1]), (5.0 * f32::from_bits(SPEED_SCALES[1])) as i32);
+        assert_eq!(speed_word(30.0, SPEED_SCALES[0]), 32767);
+    }
+
+    #[test]
+    fn landing_buckets_follow_the_air_time() {
+        let t = PlayerTuning::default();
+        let mut c = Contacts::default();
+        let mut s = AudioState { airborne: true, ..Default::default() };
+        for (air, want) in [(0.2, 0), (0.7, 1), (1.3, 2)] {
+            s.airborne = true;
+            s.air_time = air;
+            s.wheel_contact = [false; 4];
+            c.update_buckets(&s, &t);
+            s.airborne = false;
+            s.wheel_contact = [true, true, false, false];
+            c.update_buckets(&s, &t);
+            assert_eq!(&c.bucket[..2], &[want, want], "air {air}");
+        }
+    }
+}
diff --git a/crates/skate-audio/src/player/jitter.rs b/crates/skate-audio/src/player/jitter.rs
new file mode 100644
index 00000000..d3eae2b8
--- /dev/null
+++ b/crates/skate-audio/src/player/jitter.rs
@@ -0,0 +1,126 @@
+//! `SFXObj_Jitter` (MixMap controller `0x400000E0`): bounded random walks written into the
+//! Jitter inputs every frame (process `sub_824EF378`, step `sub_824EF4C8`, channels built by
+//! `sub_824EF0B8` from the vault's leaf collections). Several Player sums scale small ducks with
+//! them (e.g. A63: −300 mB at a crawl × Jitter.in0, the rolling bed's gain A), so leaving them at
+//! 0 removes those ducks.
+//!
+//! Each frame, per channel: one draw r of the title generator; s = r mod 2001 − 1000;
+//! d = (max − min)·(s·0.001); the step is d pushed away from zero by `min`; velocity += step,
+//! clamped to ±max; value += velocity, reflected off centre ± range (the velocity flips), then
+//! clamped there. Enabled channels write clamp(trunc(clamp(value, 0, 32767)), 0, 32767) to their
+//! input id. Every channel starts at its centre with zero velocity.
+//!
+//! Retail draws from the title-wide generator (shared with ~100 call sites, seeded with the time
+//! base), so sequences are not reproducible; we use our own instance of the same add-with-carry
+//! generator, seeded with the image constants.
+use super::tuning::JitterParams;
+use crate::eval::rng::Rng;
+
+/// `0x82063A48` 0.001.
+const UNIT: f32 = f32::from_bits(0x3A83_126F);
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Channel {
+    pub params: JitterParams,
+    pub value: f32,
+    pub velocity: f32,
+}
+
+impl Channel {
+    pub fn new(params: JitterParams) -> Self {
+        Self { params, value: params.centre, velocity: 0.0 }
+    }
+
+    /// One random-walk step with the draw `r`.
+    pub fn step(&mut self, r: u32) {
+        let p = self.params;
+        let s = (r % 2001) as i32 - 1000;
+        let d = (p.max_step - p.min_step) * (s as f32 * UNIT);
+        let push = if d < 0.0 { d - p.min_step } else { p.min_step + d };
+        let v = (push + self.velocity).clamp(-p.max_step, p.max_step);
+        self.velocity = v;
+        let (upper, lower) = (p.centre + p.range, p.centre - p.range);
+        let mut x = v + self.value;
+        if x > upper {
+            self.velocity = -v;
+            x = upper - (x - upper);
+        } else if x < lower {
+            self.velocity = -v;
+            x = (lower - x) + lower;
+        }
+        self.value = x.clamp(lower, upper);
+    }
+
+    /// The input word: clamp(trunc(clamp(value, 0, 32767)), 0, 32767).
+    pub fn word(&self) -> i32 {
+        super::trunc_clamp(self.value.clamp(0.0, 32767.0), 0, 32767)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Jitter {
+    pub channels: Vec<Channel>,
+    pub rng: Rng,
+}
+
+impl Jitter {
+    pub fn new(params: &[JitterParams], seed: [u32; 6]) -> Self {
+        Self { channels: params.iter().map(|&p| Channel::new(p)).collect(), rng: Rng::new(seed) }
+    }
+
+    /// One frame: advance every channel, return the enabled ones' (input id, word) in order (a
+    /// later channel on the same id overwrites an earlier one, as retail's writes do).
+    pub fn process(&mut self) -> Vec<(usize, i32)> {
+        let mut out = Vec::new();
+        for ch in &mut self.channels {
+            let r = self.rng.draw();
+            ch.step(r);
+            if ch.params.enabled {
+                out.push((ch.params.id, ch.word()));
+            }
+        }
+        out
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn params(centre: f32, range: f32, max: f32, min: f32) -> JitterParams {
+        JitterParams { enabled: true, id: 2, centre, range, max_step: max, min_step: min }
+    }
+
+    #[test]
+    fn the_walk_stays_inside_centre_plus_minus_range() {
+        let mut j = Jitter::new(&[params(16384.0, 16383.0, 31000.0, 19000.0), params(16384.0, 16383.0, 100.0, 1.0)], [1, 2, 3, 4, 5, 6]);
+        let mut seen = [i32::MAX, i32::MIN];
+        for _ in 0..10_000 {
+            for (id, w) in j.process() {
+                assert_eq!(id, 2);
+                assert!((1..=32767).contains(&w), "{w}");
+                seen = [seen[0].min(w), seen[1].max(w)];
+            }
+            for c in &j.channels {
+                assert!(c.velocity.abs() <= c.params.max_step);
+            }
+        }
+        assert!(seen[0] < 2000 && seen[1] > 30000, "{seen:?}");
+    }
+
+    #[test]
+    fn one_step_by_hand() {
+        // r = 2001·k + 1500 → s = 500: d = (100 − 1)·0.5 = 49.5, push = 50.5 (from rest).
+        let mut c = Channel::new(params(1000.0, 10.0, 100.0, 1.0));
+        c.step(2001 * 7 + 1500);
+        // 1000 + 50.5 > 1010: reflected to 1010 − 40.5 = 969.5 (velocity flipped), then clamped
+        // into 990..1010.
+        assert!((c.value - 990.0).abs() < 1e-3, "{}", c.value);
+        assert!((c.velocity + 50.5).abs() < 1e-3);
+        // s = −1000: d = −99, push = −100, velocity −150.5 → clamped −100; 890 is below 990:
+        // reflected to 1090 (velocity +100), then clamped to the top, 1010.
+        c.step(0);
+        assert!((c.velocity - 100.0).abs() < 1e-3);
+        assert!((c.value - 1010.0).abs() < 1e-3, "{}", c.value);
+    }
+}
diff --git a/crates/skate-audio/src/player/mod.rs b/crates/skate-audio/src/player/mod.rs
new file mode 100644
index 00000000..53d6ea91
--- /dev/null
+++ b/crates/skate-audio/src/player/mod.rs
@@ -0,0 +1,77 @@
+//! The local player's audio objects on the native runtime (retail's `SFXObj_*` player components
+//! and the per-frame audio state they read), engine independent: the game fills an
+//! [`AudioState`] from its physics each 60 Hz frame; this module turns it into MixMap inputs
+//! ([`inputs`], [`jitter`], [`objpos`]) and into the AEMS packets of the player classes
+//! ([`components`]).
+//!
+//! Retail order per frame (spec `.claude/notes/mixmap-spec.md` §1, upstream PR #4's driver notes):
+//! audio-state bridge → state-controller inputs → every component's *process* (owner inputs,
+//! posts and releases) → one MixMap evaluation → every component's *update* (the held packets
+//! rewritten from the MixMap outputs and redelivered). [`components::Player`] follows that split:
+//! `process` before the tick, `update` after it.
+//!
+//! Written from our specs and our reading of the retail code (addresses in the docs); upstream PR
+//! #4 / #1 (no licence) were read for behaviour only. Values the vault holds come in as
+//! [`tuning::PlayerTuning`] (exported by setup, `tools/asset_pipeline/audio_export.py`
+//! `player_tuning`).
+pub mod clothing;
+pub mod collision;
+pub mod components;
+pub mod contacts;
+pub mod globals;
+pub mod footsteps;
+pub mod inputs;
+pub mod jitter;
+pub mod objpos;
+pub mod rolling;
+pub mod seams;
+pub mod state;
+pub mod treatment;
+pub mod tricks;
+pub mod step_on;
+pub mod tuning;
+pub mod wheels;
+
+pub use state::AudioState;
+
+/// What a component reads from its owner's MixMap output block (owner vfuncs 52/56/60/64).
+pub trait Outputs {
+    /// vfunc60 / vfunc64: level (Q15) or filter cutoff (Hz), `& 0x7FFF`.
+    fn level(&self, id: usize) -> i32;
+    /// vfunc52: raw u16 (azimuth, 65536 = 360°).
+    fn raw(&self, id: usize) -> i32;
+    /// vfunc56: pitch, 4096 = 1.0.
+    fn pitch(&self, id: usize) -> i32;
+}
+
+/// One owner's output block of a [`crate::mixmap::MixMap`].
+pub struct Owner<'a> {
+    pub mixmap: &'a crate::mixmap::MixMap,
+    pub key: u32,
+}
+
+impl Outputs for Owner<'_> {
+    fn level(&self, id: usize) -> i32 {
+        self.mixmap.level(self.key, id)
+    }
+    fn raw(&self, id: usize) -> i32 {
+        self.mixmap.raw(self.key, id)
+    }
+    fn pitch(&self, id: usize) -> i32 {
+        self.mixmap.pitch_4096(self.key, id)
+    }
+}
+
+/// Retail's float → word conversions: `fctiwz` (truncate toward zero) then an integer clamp.
+pub fn trunc_clamp(x: f32, low: i32, high: i32) -> i32 {
+    if x.is_nan() {
+        return low.max(0.min(high));
+    }
+    (x as i32).clamp(low, high)
+}
+
+/// `clamp01(x)` as the owners spell it (`fsel` pairs: NaN → 1 like retail's second select).
+pub fn clamp01(x: f32) -> f32 {
+    let lo = if -x >= 0.0 { 0.0 } else { x };
+    if 1.0 - lo >= 0.0 { lo } else { 1.0 }
+}
diff --git a/crates/skate-audio/src/player/objpos.rs b/crates/skate-audio/src/player/objpos.rs
new file mode 100644
index 00000000..93d40a86
--- /dev/null
+++ b/crates/skate-audio/src/player/objpos.rs
@@ -0,0 +1,159 @@
+//! `SFXCTL_3DObjPos` (`sub_824AEC70` → `sub_824AEB28` / `sub_824AE6E0`, rates `sub_824AEE60`): the
+//! 3-D input block a MixMap B lookup reads (mixmap-spec §7.3). Two listener frames:
+//! - frame A, the camera: origin = camera position pulled back 0.25 m along the horizontal view
+//!   direction (vault `camera` collection), direction = the view;
+//! - frame B, the followed point (the skater's SystemReckoning position) with its facing.
+//!
+//! Inputs written: 0 = f32 |skater − emitter|, 1 = f32 |camera − emitter| (the camera itself, not
+//! the pulled-back origin), 2 / 3 = azimuth of the emitter in frame B / A, 13 / 14 = f32 signed
+//! relative speed against the skater's / the camera's velocity (|v_emitter − v_listener|, negated
+//! while the distance shrinks), 15 = bit 0 active, bit 31 / bit 30 set when the sign of 13 / 14
+//! flips (the MixMap's Doppler slew resets and clears them). Inactive: 0 = 1 = −1.0, 2 = 3 = 0,
+//! bit 0 cleared. Input 10 (facing difference, `sub_824AE418`) is not written: no MixMap record
+//! reads it.
+//!
+//! Azimuths are measured in the horizontal plane (retail drops the height) from the frame's
+//! direction, clockwise seen from above, 65535 = 360°. Retail takes an `acos` of the normalised dot
+//! product and mirrors it by the cross product's sign; we compute the same angle with `atan2`
+//! (not bit-exact in the last unit).
+use crate::mixmap::{MixMap, keys::pos};
+
+/// Vault `camera` collection, field `0xA6F853B935E46E5F`: the frame-A pull-back (m).
+pub const PULLBACK: f32 = 0.25;
+
+/// The listener as the position controllers see it (`*(0x830CFDD4)`, `sub_8248CC08`): the camera
+/// (position, view direction, velocity) and the followed point (position, facing, velocity).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Listener {
+    pub camera: [f32; 3],
+    pub view: [f32; 3],
+    pub camera_velocity: [f32; 3],
+    pub followed: [f32; 3],
+    pub facing: [f32; 3],
+    pub followed_velocity: [f32; 3],
+}
+
+/// One position controller's own memory (last distances and rates).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct ObjPos {
+    dist: [f32; 2],
+    rate: [f32; 2],
+    primed: bool,
+}
+
+fn sub(a: [f32; 3], b: [f32; 3]) -> [f32; 3] {
+    [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
+}
+
+fn length(v: [f32; 3]) -> f32 {
+    (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt()
+}
+
+/// Clockwise azimuth (65535 = 360°) of `target` seen from `origin` facing `dir`, in the
+/// horizontal (x, z) plane; 0 when either vector has no horizontal length (retail: < 0.0001).
+pub fn azimuth(dir: [f32; 3], origin: [f32; 3], target: [f32; 3]) -> i32 {
+    let (dx, dz) = (dir[0], dir[2]);
+    let (rx, rz) = (target[0] - origin[0], target[2] - origin[2]);
+    if (dx * dx + dz * dz).sqrt() < 1e-4 || (rx * rx + rz * rz).sqrt() < 1e-4 {
+        return 0;
+    }
+    // Right of the direction (y up): (−dz, 0, dx).
+    let ahead = rx * dx + rz * dz;
+    let right = rx * -dz + rz * dx;
+    let mut turns = right.atan2(ahead) / std::f32::consts::TAU;
+    if turns < 0.0 {
+        turns += 1.0;
+    }
+    ((turns * 65535.0) as i32).clamp(0, 65535)
+}
+
+impl ObjPos {
+    /// Write the block for an emitter (`None`: inactive). `flags15` is the controller's current
+    /// input 15 (retail reads it back and ors in the new bits).
+    pub fn write(&mut self, m: &mut MixMap, key: u32, l: &Listener, emitter: Option<([f32; 3], [f32; 3])>) {
+        let flags15 = m.input(key, pos::FLAGS) as u32;
+        let Some((position, velocity)) = emitter else {
+            m.set_input(key, pos::AZ_CAMERA, 0);
+            m.set_input_f32(key, pos::DIST_CAMERA, -1.0);
+            m.set_input(key, pos::AZ_SKATER, 0);
+            m.set_input_f32(key, pos::DIST_SKATER, -1.0);
+            m.set_input(key, pos::FLAGS, (flags15 & !1) as i32);
+            self.primed = false;
+            return;
+        };
+        let mut w15 = flags15 | 1;
+        m.set_input(key, pos::FLAGS, w15 as i32);
+        m.set_input(key, 11, 0);
+        // Frame A: the camera, origin pulled back along the horizontal view.
+        let h = (l.view[0] * l.view[0] + l.view[2] * l.view[2]).sqrt();
+        let origin_a = if h > 1e-4 {
+            [l.camera[0] - l.view[0] / h * PULLBACK, l.camera[1], l.camera[2] - l.view[2] / h * PULLBACK]
+        } else {
+            l.camera
+        };
+        m.set_input(key, pos::AZ_CAMERA, azimuth(l.view, origin_a, position));
+        m.set_input_f32(key, pos::DIST_CAMERA, length(sub(l.camera, position)));
+        m.set_input(key, pos::AZ_SKATER, azimuth(l.facing, l.followed, position));
+        m.set_input_f32(key, pos::DIST_SKATER, length(sub(l.followed, position)));
+        // Rates.
+        let d = [length(sub(l.followed, position)), length(sub(l.camera, position))];
+        let mut s = [length(sub(velocity, l.followed_velocity)), length(sub(velocity, l.camera_velocity))];
+        for i in 0..2 {
+            if self.primed && self.dist[i] > d[i] {
+                s[i] = -s[i];
+            }
+            let (p, n) = (self.rate[i], s[i]);
+            if self.primed && ((p < 0.0 && n > 0.0) || (p > 0.0 && n < 0.0)) {
+                w15 |= if i == 0 { 0x8000_0000 } else { 0x4000_0000 };
+                m.set_input(key, pos::FLAGS, w15 as i32);
+            }
+        }
+        self.dist = d;
+        // Retail's first active frame compares against uninitialised memory; we start from 0
+        // (no flip on the frame after activation).
+        self.rate = if self.primed { s } else { [0.0; 2] };
+        self.primed = true;
+        m.set_input_f32(key, pos::SPEED_SKATER, s[0]);
+        m.set_input_f32(key, pos::SPEED_CAMERA, s[1]);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn azimuth_is_clockwise_in_the_horizontal_plane() {
+        let ahead = [0.0, 0.0, -1.0];
+        assert_eq!(azimuth(ahead, [0.0; 3], [0.0, 5.0, -5.0]), 0);
+        assert_eq!(azimuth(ahead, [0.0; 3], [5.0, 0.0, 0.0]), 16383);
+        assert_eq!(azimuth(ahead, [0.0; 3], [-5.0, 0.0, 0.0]), 49151);
+        assert_eq!(azimuth(ahead, [0.0; 3], [0.0, 0.0, 5.0]), 32767);
+        assert_eq!(azimuth(ahead, [0.0; 3], [0.0, 3.0, 0.0]), 0, "straight above: no horizontal offset");
+    }
+
+    #[test]
+    fn rates_are_signed_by_closing_and_flag_their_sign_flips() {
+        let bytes = match std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/private/audio/aems/MixMapSK8.mxb")) {
+            Ok(b) => b,
+            Err(_) => return eprintln!("skipped: no MixMap"),
+        };
+        let mut m = MixMap::from_bytes(&bytes).unwrap();
+        let key = crate::mixmap::keys::obj_pos2(0);
+        let mut o = ObjPos::default();
+        let l = Listener { view: [0.0, 0.0, -1.0], ..Default::default() };
+        // Approaching the camera at 5 m/s along z.
+        o.write(&mut m, key, &l, Some(([0.0, 0.0, -10.0], [0.0, 0.0, 5.0])));
+        o.write(&mut m, key, &l, Some(([0.0, 0.0, -9.9], [0.0, 0.0, 5.0])));
+        assert_eq!(f32::from_bits(m.input(key, pos::SPEED_CAMERA) as u32), -5.0);
+        assert_eq!(m.input(key, pos::FLAGS) as u32, 1);
+        // Receding: the sign flips, bit 30 (camera) and bit 31 (skater) set.
+        o.write(&mut m, key, &l, Some(([0.0, 0.0, -10.0], [0.0, 0.0, -5.0])));
+        assert_eq!(f32::from_bits(m.input(key, pos::SPEED_CAMERA) as u32), 5.0);
+        assert_eq!(m.input(key, pos::FLAGS) as u32, 0xC000_0001);
+        assert!((f32::from_bits(m.input(key, pos::DIST_CAMERA) as u32) - 10.0).abs() < 1e-6);
+        o.write(&mut m, key, &l, None);
+        assert_eq!(m.input(key, pos::FLAGS) as u32 & 1, 0);
+        assert_eq!(f32::from_bits(m.input(key, pos::DIST_SKATER) as u32), -1.0);
+    }
+}
diff --git a/crates/skate-audio/src/player/rolling.rs b/crates/skate-audio/src/player/rolling.rs
new file mode 100644
index 00000000..79118515
--- /dev/null
+++ b/crates/skate-audio/src/player/rolling.rs
@@ -0,0 +1,859 @@
+//! `SFXObj_SkateBoard`'s rolling layers besides the grain bed, skid and squeaks, as pure state
+//! machines (process before the MixMap tick, update after it, [`Command`]s for the host). Spec:
+//! `.claude/notes/aems-board-layers-spec.md`. Written from our reading of the retail code (TU3
+//! recompilation, reference only):
+//!
+//! - [`Rolling`]: the owner's **surface routing** (`sub_824C5CA8`, two trucks, one sounding truck
+//!   per distinct surface; surface of a truck `sub_824C82A8`, member key `sub_824C8370`) with its
+//!   `Class_rolling` patch for the non-grain rolling surfaces 7, 8, 10, 11, 12, 13 (constructor
+//!   `sub_824C4C18`, selectors 1, 2, 10, 12, 11, 9; updater in `sub_824C6BD8`), the grain binds and
+//!   stops it asks the bed for ([`GrainEvent`]), SkateBoard inputs 0 (surface-change pulse) and 6
+//!   (truck 0 on metal); the **held layers** 0 and 3 of the local player (start `sub_824C9830`,
+//!   update `sub_824C9948`); **layer 5** while wheel 0 is on the spidercrack pattern (`sub_824C9F68`
+//!   / `sub_824CA038`).
+//! - [`Rattle`]: `Rolling_Rattle_Class` (`Rolling_Rattles.abk`), re-posted on every push plant
+//!   while the primary truck routes a grain surface (`sub_824C6198`, constructor `sub_824B0248`,
+//!   updater `sub_824C80C0`).
+//! - [`BoardSlide`]: `c_board_slide` (`board_scrapes.abk`), held while the loose-board state
+//!   (`+780`) is set (`sub_824CB3C8`, constructor `sub_824B0670`, updater `sub_824CB4C0`).
+//!
+//! Every Class_rolling post reaches all four banks bound to the class (`PatchBank_Rolling_Surfaces`,
+//! `_SpiderCracks`, `_Objects`, `_RocksBounce`); the selector word decides which program plays.
+use super::components::{Command, Slot};
+use super::state::NO_MATERIAL;
+use super::tuning::PlayerTuning;
+use super::{AudioState, Outputs, clamp01, trunc_clamp};
+
+pub const CLASS: &str = "Class_rolling";
+pub const RATTLE_CLASS: &str = "Rolling_Rattle_Class";
+pub const SLIDE_CLASS: &str = "c_board_slide";
+/// The banks these classes bind in (all four Class_rolling banks must be loaded: a post reaches each).
+pub const BANKS: &[&str] = &["PatchBank_Rolling_Surfaces", "PatchBank_SpiderCracks", "PatchBank_Objects", "PatchBank_RocksBounce", "Rolling_Rattles", "board_scrapes"];
+/// "No contact" rolling surface: the truck's sound stops.
+pub const NO_SURFACE: i32 = 14;
+
+/// The vault values these layers read (setup exports them; the defaults are the user's vault).
+#[derive(Clone, Debug, PartialEq)]
+pub struct RollingTuning {
+    /// Class_rolling max km/h per selector 0..15 (`sub_824C97B8`: holder `[0x830CFDA4]+56`, class
+    /// `C1831BDB6CB1B1EA` collection `7B0ED922C779B74C` field `880C82E8EF647EC4`, 16 floats).
+    pub layer_kmh: [f32; 16],
+    /// The rattle's speed range (grain class `7AB23C11B6ADA2DE` of the primary truck's collection,
+    /// field `12275AA8AC4A63FB`; 30 in `default`, no member overrides it).
+    pub rattle_kmh: f32,
+    /// eEQChain tweaks (class `42AFE160E647167C` `default`): rattle `C04832978CDED925` = 8, board
+    /// slide `F2B44F93BD91662E` = 7.
+    pub rattle_eq: i32,
+    pub slide_eq: i32,
+    /// The board slide's speed range and level words (class `C1831BDB6CB1B1EA` collection
+    /// `621090620F4F936A`: `9635B780C7472A6E` = 15 (m/s·3.6 divisor), loose mode 1
+    /// `662CEE73D2E3FE2F` = 15000, mode 2 `AB87C3D1EDDDDCBC` = 15000).
+    pub slide_kmh: f32,
+    pub slide_level: [i32; 2],
+}
+
+impl Default for RollingTuning {
+    fn default() -> Self {
+        Self {
+            layer_kmh: [70.0, 65.0, 65.0, 70.0, 100.0, 45.0, 45.0, 45.0, 45.0, 35.0, 45.0, 45.0, 45.0, 45.0, 45.0, 45.0],
+            rattle_kmh: 30.0,
+            rattle_eq: 8,
+            slide_eq: 7,
+            slide_kmh: 15.0,
+            slide_level: [15000, 15000],
+        }
+    }
+}
+
+impl RollingTuning {
+    fn kmh(&self, selector: i32) -> f32 {
+        self.layer_kmh[selector.clamp(0, 15) as usize]
+    }
+}
+
+/// What the owner's other modulators hand in.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct RollingInputs {
+    /// The push speed-scale envelope's value while it runs (owner `+912`, idle byte `+1032`,
+    /// value `+1028`; `grain::board::PushEnvelope::value`): scales the speed of the per-surface
+    /// patch and layer 5 (`sub_824C6B30`), not of the held layers 0 / 3.
+    pub speed_scale: Option<f32>,
+}
+
+/// A grain the routing binds or stops on a truck (the bed does the binding, spec §1.4 / §2.5).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum GrainEvent {
+    /// Bind both players of `truck` to [`member`]`(surface, soft)` (surfaces 1..6, 9 their own
+    /// member; 0 asphalt_rough_hard with the `default` tuning).
+    Bind { truck: usize, surface: i32, soft: bool },
+    Stop { truck: usize },
+}
+
+/// The routing's per-frame outputs for the host.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Routed {
+    /// SkateBoard input 0 = 32767 this frame (a truck left a real surface).
+    pub surface_pulse: bool,
+    /// SkateBoard input 6 = 32767 (truck 0 on rolling surface 9, metal).
+    pub on_metal: bool,
+    pub grains: Vec<GrainEvent>,
+    /// `+1500` the primary truck (reads wheel 0; the other reads wheel 3).
+    pub primary: usize,
+}
+
+/// `sub_824C8370`'s grain member of a rolling surface: (stem, owner slots A/B) and its tuning
+/// collection (`None` = the member's own; the vault keys are listed in the grain spec §1.4).
+/// Surfaces without a member (0, and 7, 8, 10..13 which post Class_rolling instead) return the
+/// `default` key with the caller's slots left at 0 / 1: a grain bind there plays
+/// **asphalt_rough_hard** (slots 0 / 1) with the `default` collection's tuning — what retail does
+/// on rolling surface 0 (tag 90).
+pub fn member(surface: i32, soft: bool) -> Member {
+    let (stem, slots) = match (surface, soft) {
+        (1, true) => ("asphalt_rough_soft", [14, 15]),
+        (1, false) => ("asphalt_rough_hard", [0, 1]),
+        (2, true) => ("concrete_rough_soft", [16, 17]),
+        (2, false) => ("concrete_rough_hard", [2, 3]),
+        (3, true) => ("asphalt_smooth_soft", [18, 19]),
+        (3, false) => ("asphalt_smooth_hard", [4, 5]),
+        (4, true) => ("concrete_smooth_soft", [20, 21]),
+        (4, false) => ("concrete_smooth_hard", [6, 7]),
+        (5, true) => ("wood_ramp_soft", [22, 23]),
+        (5, false) => ("wood_ramp_hard", [8, 9]),
+        (6, true) => ("concrete_aggregate_soft", [24, 25]),
+        (6, false) => ("concrete_aggregate_hard", [10, 11]),
+        (9, _) => ("metal_smooth_hard", [12, 13]),
+        _ => return Member { stem: "asphalt_rough_hard", slots: [0, 1], default_tuning: true },
+    };
+    Member { stem, slots, default_tuning: false }
+}
+
+/// A grain member as the owner binds it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Member {
+    pub stem: &'static str,
+    pub slots: [u32; 2],
+    /// The key is `default` (`D7EDBD362D7D2152`): the `default` collection's tuning.
+    pub default_tuning: bool,
+}
+
+/// Whether a rolling surface plays a grain (`sub_824C5CA8`'s switch: 7, 8, 10..13 post Class_rolling).
+pub fn grain_surface(surface: i32) -> bool {
+    !matches!(surface, 7 | 8 | 10..=13)
+}
+
+/// The Class_rolling selector (w4) of a non-grain surface: 7 → 1, 8 → 2, 10 → 10, 11 → 12, 12 → 11,
+/// 13 → 9 (−1 elsewhere, never posted).
+pub fn selector(surface: i32) -> i32 {
+    match surface {
+        7 => 1,
+        8 => 2,
+        10 => 10,
+        11 => 12,
+        12 => 11,
+        13 => 9,
+        _ => -1,
+    }
+}
+
+/// `sub_824C4C18`: a Class_rolling packet (12 words).
+pub fn class_rolling_words(speed: i32, selector: i32, surface: i32) -> Vec<i32> {
+    let mut w = vec![0i32; 12];
+    w[2] = 4096;
+    w[3] = speed.clamp(0, 10000);
+    w[4] = selector.clamp(0, 15);
+    w[6] = surface.clamp(0, 13);
+    w[9] = 25000;
+    w[11] = 32767;
+    w
+}
+
+/// `sub_824C6B30`: trunc(clamp01((v·scale / max km/h)·3.6)·10000), v = state `+208` (signed),
+/// scaled by the push envelope while it runs.
+fn scaled_speed(s: &AudioState, t: &RollingTuning, selector: i32, scale: Option<f32>) -> i32 {
+    let v = scale.map_or(s.ground_speed, |k| k * s.ground_speed);
+    trunc_clamp(clamp01((v / t.kmh(selector)) * 3.6) * 10000.0, i32::MIN, i32::MAX)
+}
+
+/// The held layers' speed (`sub_824C9830` / `sub_824C9948`): as [`scaled_speed`] without the
+/// push scale.
+fn layer_speed(s: &AudioState, t: &RollingTuning, layer: i32) -> i32 {
+    trunc_clamp(clamp01((s.ground_speed / t.kmh(layer)) * 3.6) * 10000.0, i32::MIN, i32::MAX)
+}
+
+/// The bridge's per-wheel landed latch (`+464` wheel 0, `+467` wheel 3; the conditioner
+/// `sub_82772FD8`): set at a touchdown after more than 5 frames in the air, cleared once in the air
+/// for more than 5 frames. Starts clear.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+struct Landed {
+    prev: bool,
+    air: u32,
+    latch: bool,
+}
+
+impl Landed {
+    fn step(&mut self, now: bool) {
+        if !self.prev && self.air > 5 {
+            self.latch = now;
+        }
+        self.prev = now;
+        self.air = if now { 0 } else { self.air + 1 };
+    }
+}
+
+/// The routing and the Class_rolling layers of one board owner.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Rolling {
+    /// `+768 + 4·truck` the routed surface (14 at start).
+    surface: [i32; 2],
+    /// `+1320 + 4·truck` the truck's sound kind: true = grain (1, the start value), false =
+    /// Class_rolling (0). Kept when the surface becomes 14.
+    grain: [bool; 2],
+    /// `+1496 + truck` a sound was started on the truck.
+    live: [bool; 2],
+    /// `+1328 + truck` its grain players run.
+    playing: [bool; 2],
+    /// `+1500`.
+    primary: usize,
+    /// `+760` the member key of the last routed surface (`None` = `default`): (surface, soft).
+    key: Option<(i32, bool)>,
+    /// `+1488 + 4·truck` the posted selector, `+1312 + 4·truck` the per-surface patch.
+    selector: [i32; 2],
+    patch: [Option<Vec<i32>>; 2],
+    /// `+1304` layer 0, `+1308` layer 3 (local player, posted at create).
+    held: [Option<Vec<i32>>; 2],
+    created: bool,
+    /// `+1332` layer 5 (spidercrack).
+    spider: Option<Vec<i32>>,
+    /// `+1504` the manual latch (`sub_824CA688`).
+    manual: bool,
+    landed: [Landed; 2],
+}
+
+impl Default for Rolling {
+    fn default() -> Self {
+        Self {
+            surface: [NO_SURFACE; 2],
+            grain: [true; 2],
+            live: [false; 2],
+            playing: [false; 2],
+            primary: 0,
+            key: None,
+            selector: [0; 2],
+            patch: [None, None],
+            held: [None, None],
+            created: false,
+            spider: None,
+            manual: false,
+            landed: [Landed::default(); 2],
+        }
+    }
+}
+
+/// The held layers' slots: layer 0, layer 3, layer 5.
+const LAYERS: [i32; 2] = [0, 3];
+
+impl Rolling {
+    /// `+1500` the primary truck.
+    pub fn primary(&self) -> usize {
+        self.primary
+    }
+
+    /// The primary truck routes a grain surface (`+1320 + 4·primary` == 1; the rattle's gate).
+    pub fn primary_is_grain(&self) -> bool {
+        self.grain[self.primary]
+    }
+
+    /// `+760`: the member key of the last routed surface.
+    pub fn last_key(&self) -> Option<(i32, bool)> {
+        self.key
+    }
+
+    /// `sub_824CA688` (idempotent within a frame).
+    fn manual_latch(&mut self, s: &AudioState) -> bool {
+        if s.balance {
+            self.manual = true;
+        } else if self.manual && (s.wheel_count == 0 || s.wheel_count == 4) {
+            self.manual = false;
+        }
+        self.manual
+    }
+
+    /// `sub_824C82A8`: the rolling surface under `truck` (the primary truck reads wheel 0's
+    /// material, the other wheel 3's): 14 while grinding, or for the local player while the manual
+    /// latch holds and the truck's wheel has not landed; material 143 → 3; else AudioSurfaceMap
+    /// word 1 (3 without a table).
+    pub fn surface_of(&self, s: &AudioState, t: &PlayerTuning, truck: usize) -> i32 {
+        let primary = truck == self.primary;
+        if s.local && self.manual && !self.landed[usize::from(!primary)].latch {
+            return NO_SURFACE;
+        }
+        if s.grinding {
+            return NO_SURFACE;
+        }
+        let material = s.wheel_material[if primary { 0 } else { 3 }];
+        if material >= NO_MATERIAL {
+            return 3;
+        }
+        t.surface_entry(material).map_or(3, |e| e[1])
+    }
+
+    /// The held layers' / layer 5's surface word w6 (`sub_824C9948`): the primary truck's surface,
+    /// else the other's, else (both 14) 13 while grinding, else unchanged.
+    fn layer_surface(&self, s: &AudioState, t: &PlayerTuning, w6: i32) -> i32 {
+        let p = self.surface_of(s, t, self.primary);
+        let p = if p == NO_SURFACE { self.surface_of(s, t, 1 - self.primary) } else { p };
+        if p != NO_SURFACE {
+            p.clamp(0, 13)
+        } else if s.grinding {
+            13
+        } else {
+            w6
+        }
+    }
+
+    /// `sub_824C5CA8` (process): the routing of both trucks.
+    fn route(&mut self, s: &AudioState, t: &PlayerTuning, cmds: &mut Vec<Command>, out: &mut Routed) {
+        let passes = if s.local { 2 } else { 1 };
+        for pass in 0..passes {
+            let mut truck = if pass == 0 { self.primary } else { 1 - self.primary };
+            let mut other = 1 - truck;
+            let new = self.surface_of(s, t, truck);
+            if new == self.surface[truck] {
+                continue;
+            }
+            if self.surface[truck] != NO_SURFACE {
+                out.surface_pulse = true;
+                if s.local && !self.live[other] {
+                    // Hand the sound to the other truck: it becomes the primary one.
+                    self.primary = 1 - self.primary;
+                    std::mem::swap(&mut truck, &mut other);
+                } else {
+                    if !self.grain[truck] {
+                        if self.patch[truck].take().is_some() {
+                            cmds.push(Command::Release { slot: Slot::RollingSurface(truck as u8) });
+                        }
+                    } else if self.playing[truck] {
+                        out.grains.push(GrainEvent::Stop { truck });
+                        self.playing[truck] = false;
+                    }
+                    self.live[truck] = false;
+                }
+            }
+            self.surface[truck] = new;
+            if new == NO_SURFACE {
+                continue;
+            }
+            let m = member(new, s.soft_wheels);
+            self.key = (!m.default_tuning).then_some((new, s.soft_wheels));
+            let grain = grain_surface(new);
+            if new != self.surface[other] {
+                if !grain {
+                    let sel = selector(new);
+                    self.selector[truck] = sel;
+                    let w = class_rolling_words(0, sel, new);
+                    cmds.push(Command::Post { slot: Slot::RollingSurface(truck as u8), class: CLASS, words: w.clone() });
+                    self.patch[truck] = Some(w);
+                } else {
+                    out.grains.push(GrainEvent::Bind { truck, surface: new, soft: s.soft_wheels });
+                    self.playing[truck] = true;
+                }
+                self.live[truck] = true;
+            }
+            self.grain[truck] = grain;
+        }
+    }
+
+    /// Process (before the tick): the held layers' create (first call, local player), the
+    /// routing (`sub_824C5CA8`) and layer 5 (`sub_824C9F68`). The host writes SkateBoard input 0
+    /// / 6 from [`Routed`] and hands its grain events to the bed.
+    pub fn process(&mut self, s: &AudioState, t: &PlayerTuning, inp: &RollingInputs) -> (Vec<Command>, Routed) {
+        let r = &t.rolling;
+        let mut cmds = Vec::new();
+        if !self.created {
+            self.created = true;
+            if s.local {
+                for (i, layer) in LAYERS.into_iter().enumerate() {
+                    let w = class_rolling_words(layer_speed(s, r, layer), layer, 3);
+                    cmds.push(Command::Post { slot: Slot::RollingLayer(layer as u8), class: CLASS, words: w.clone() });
+                    self.held[i] = Some(w);
+                }
+            }
+        }
+        self.landed[0].step(s.wheel_contact[0]);
+        self.landed[1].step(s.wheel_contact[3]);
+        self.manual_latch(s);
+        let mut out = Routed::default();
+        self.route(s, t, &mut cmds, &mut out);
+        out.on_metal = self.surface_of(s, t, 0) == 9;
+        out.primary = self.primary;
+        // Layer 5 (sub_824C9F68): wheel 0's seam pattern (wheel 3's while the manual latch holds
+        // and wheel 0 has not landed); 1 = spidercrack.
+        let pattern = if self.manual && !self.landed[0].latch { s.seam_pattern[3] } else { s.seam_pattern[0] };
+        if self.spider.is_none() {
+            if pattern == 1 {
+                let w = class_rolling_words(scaled_speed(s, r, 5, inp.speed_scale), 5, 3);
+                cmds.push(Command::Post { slot: Slot::RollingLayer(5), class: CLASS, words: w.clone() });
+                self.spider = Some(w);
+            }
+        } else if pattern != 1 {
+            self.spider = None;
+            cmds.push(Command::Release { slot: Slot::RollingLayer(5) });
+        }
+        (cmds, out)
+    }
+
+    /// Update (after the tick): the per-surface patches (in `sub_824C6BD8`'s truck loop), layers 0
+    /// / 3 (`sub_824C9948`) and layer 5 (`sub_824CA038`), from the SkateBoard owner's outputs.
+    pub fn update(&mut self, s: &AudioState, t: &PlayerTuning, inp: &RollingInputs, out: &dyn Outputs) -> Vec<Command> {
+        let r = &t.rolling;
+        let mut cmds = Vec::new();
+        let manual_flag = i32::from(s.balance || s.manual_brake);
+        for truck in 0..2 {
+            if !self.live[truck] || self.grain[truck] {
+                continue;
+            }
+            let sel = self.selector[truck];
+            let Some(w) = self.patch[truck].as_mut() else { continue };
+            let speed = scaled_speed(s, r, sel, inp.speed_scale);
+            w[0] = 32767;
+            w[11] = out.level(1).clamp(0, 32767);
+            w[1] = out.raw(0).clamp(0, 65536);
+            w[2] = out.pitch(3).clamp(0, 8192);
+            w[3] = speed.clamp(0, 10000);
+            w[5] = 0;
+            w[8] = if sel == 1 { 0 } else { out.level(13).clamp(0, 32767) };
+            w[9] = out.level(11).clamp(0, 25000);
+            w[10] = out.level(12).clamp(0, 25000);
+            w[7] = manual_flag;
+            cmds.push(Command::Redeliver { slot: Slot::RollingSurface(truck as u8), words: w.clone() });
+        }
+        for (i, layer) in LAYERS.into_iter().enumerate() {
+            let Some(w6) = self.held[i].as_ref().map(|w| w[6]) else { continue };
+            let surface = self.layer_surface(s, t, w6);
+            let w = self.held[i].as_mut().unwrap();
+            w[0] = 32767;
+            w[11] = out.level(if layer == 0 { 7 } else { 9 }).clamp(0, 32767);
+            w[1] = out.raw(0).clamp(0, 65536);
+            w[2] = out.pitch(8).clamp(0, 8192);
+            w[3] = layer_speed(s, r, layer).clamp(0, 10000);
+            w[5] = 0;
+            w[6] = surface;
+            w[7] = manual_flag;
+            w[8] = out.level(19).clamp(0, 32767);
+            w[9] = out.level(17).clamp(0, 25000);
+            w[10] = out.level(18).clamp(0, 25000);
+            cmds.push(Command::Redeliver { slot: Slot::RollingLayer(layer as u8), words: w.clone() });
+        }
+        if let Some(w6) = self.spider.as_ref().map(|w| w[6]) {
+            let surface = self.layer_surface(s, t, w6);
+            let w = self.spider.as_mut().unwrap();
+            w[0] = 32767;
+            w[11] = out.level(10).clamp(0, 32767);
+            w[1] = out.raw(0).clamp(0, 65536);
+            w[2] = out.pitch(8).clamp(0, 8192);
+            w[3] = scaled_speed(s, r, 5, inp.speed_scale).clamp(0, 10000);
+            w[5] = 0;
+            w[6] = surface;
+            w[7] = manual_flag;
+            w[8] = out.level(19).clamp(0, 32767);
+            w[9] = out.level(17).clamp(0, 25000);
+            w[10] = out.level(18).clamp(0, 25000);
+            cmds.push(Command::Redeliver { slot: Slot::RollingLayer(5), words: w.clone() });
+        }
+        cmds
+    }
+}
+
+// ------------------------------------------------------------------------------------- rattle
+
+/// `Rolling_Rattle_Class` (12 words), owner holder `+1300`.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Rattle {
+    held: Option<Vec<i32>>,
+}
+
+/// The rattle's surface code from the last routed member key (`+760`): the hard members of
+/// asphalt_smooth 1, concrete_rough 2, concrete_smooth 3, wood_ramp 4, concrete_aggregate 5;
+/// anything else (soft members, asphalt_rough, metal, `default`) 0.
+pub fn rattle_surface(key: Option<(i32, bool)>) -> i32 {
+    match key {
+        Some((3, false)) => 1,
+        Some((2, false)) => 2,
+        Some((4, false)) => 3,
+        Some((5, false)) => 4,
+        Some((6, false)) => 5,
+        _ => 0,
+    }
+}
+
+/// `sub_824B0248`: w2 4096, w3 speed (0..10000), w4 surface (0..8), w6 1, w8 25000, w10 32767, w11
+/// the eEQChain tweak (0..32767).
+pub fn rattle_words(speed: i32, surface: i32, eq: i32) -> Vec<i32> {
+    let mut w = vec![0i32; 12];
+    w[2] = 4096;
+    w[3] = speed.clamp(0, 10000);
+    w[4] = surface.clamp(0, 8);
+    w[6] = 1;
+    w[8] = 25000;
+    w[10] = 32767;
+    w[11] = eq.clamp(0, 32767);
+    w
+}
+
+impl Rattle {
+    /// In `sub_824C6198` (process, after the routing): on a push plant (`+335`) the held rattle is
+    /// released; if the primary truck routes a grain surface a new one is posted with speed
+    /// trunc(clamp01(((v − 1)·3.6) / 30)·10000).
+    pub fn process(&mut self, s: &AudioState, routing: &Rolling, t: &RollingTuning) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if !s.push_trigger {
+            return cmds;
+        }
+        if self.held.take().is_some() {
+            cmds.push(Command::Release { slot: Slot::RollingRattle });
+        }
+        if routing.primary_is_grain() {
+            let speed = trunc_clamp(clamp01(((s.ground_speed - 1.0) * 3.6) / t.rattle_kmh) * 10000.0, i32::MIN, i32::MAX);
+            let w = rattle_words(speed, rattle_surface(routing.last_key()), t.rattle_eq);
+            cmds.push(Command::Post { slot: Slot::RollingRattle, class: RATTLE_CLASS, words: w.clone() });
+            self.held = Some(w);
+        }
+        cmds
+    }
+
+    /// `sub_824C80C0`: w0 32767, w10 level(6), w1 raw(0), w2 pitch(3), w7 level(16), w8 / w9
+    /// filters 14 / 15.
+    pub fn update(&mut self, out: &dyn Outputs) -> Vec<Command> {
+        let Some(w) = self.held.as_mut() else { return Vec::new() };
+        w[0] = 32767;
+        w[10] = out.level(6).clamp(0, 32767);
+        w[1] = out.raw(0).clamp(0, 65535);
+        w[2] = out.pitch(3).clamp(0, 8192);
+        w[7] = out.level(16).clamp(0, 32767);
+        w[8] = out.level(14).clamp(0, 25000);
+        w[9] = out.level(15).clamp(0, 25000);
+        vec![Command::Redeliver { slot: Slot::RollingRattle, words: w.clone() }]
+    }
+}
+
+// --------------------------------------------------------------------------------- board slide
+
+/// `c_board_slide` (12 words), owner holder `+1884`: held while the loose-board state (`+780`:
+/// 0 none, 1 or 2; written by the conditioner `sub_827A1B78`, see the spec) is set.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct BoardSlide {
+    held: Option<Vec<i32>>,
+}
+
+/// The conditioner's loose-board state (audio record `+156` bits 5–6 → state `+780`;
+/// `sub_827A1B78` at `0x827A2A60..0x827A2B14`, cleared every frame): with the rider bailing (State
+/// `+59` → record `+148` bit 5) or on foot (state 500 → `+152` bit 30), the deck contact byte
+/// (`[rec+24]+3475` → `+148` bit 8) and a deck material below 94 (`[rec+24]+12` − 1 → `+476`):
+/// 1 when `up_dot` < −0.9 (upside down), 2 when −0.1 < `up_dot` < 0.1 (on its side), else 0.
+/// `up_dot` = `[rec+0]+80` · `[rec+32]+80` (copied to `+496`): taken as the deck's up axis against
+/// the contact's up — which two vectors these are is UNCERTAIN (spec §4).
+pub fn loose_board(bail_or_on_foot: bool, deck_contact: bool, deck_material: u32, up_dot: f32) -> u32 {
+    if !(bail_or_on_foot && deck_contact && deck_material < 94) {
+        return 0;
+    }
+    if up_dot < f32::from_bits(0xBF66_6666) {
+        1
+    } else if up_dot < f32::from_bits(0x3DCC_CCCD) && up_dot > f32::from_bits(0xBDCC_CCCD) {
+        2
+    } else {
+        0
+    }
+}
+
+/// `sub_824B0670`: w2 4096, w4 25000, w8 the eEQChain tweak, w10 the mode (`+780` == 2).
+pub fn slide_words(eq: i32, mode: i32) -> Vec<i32> {
+    let mut w = vec![0i32; 12];
+    w[2] = 4096;
+    w[4] = 25000;
+    w[8] = eq.clamp(0, 32767);
+    w[10] = mode.clamp(0, 3);
+    w
+}
+
+impl BoardSlide {
+    /// `sub_824CB3C8` (process).
+    pub fn process(&mut self, loose: u32, t: &RollingTuning) -> Vec<Command> {
+        if self.held.is_none() {
+            if loose != 0 {
+                let w = slide_words(t.slide_eq, i32::from(loose == 2));
+                self.held = Some(w.clone());
+                return vec![Command::Post { slot: Slot::BoardSlide, class: SLIDE_CLASS, words: w }];
+            }
+        } else if loose == 0 {
+            self.held = None;
+            return vec![Command::Release { slot: Slot::BoardSlide }];
+        }
+        Vec::new()
+    }
+
+    /// `sub_824CB4C0`: w0 32767, w1 raw(0), w2 pitch(23), w3 trunc(clamp01(((v − 0.5) / 15)·3.6)·
+    /// 10000), w4 / w5 filters 25 / 26, w6 level(27), w7 level(24), w11 the mode's level word.
+    pub fn update(&mut self, s: &AudioState, loose: u32, t: &RollingTuning, out: &dyn Outputs) -> Vec<Command> {
+        let Some(w) = self.held.as_mut() else { return Vec::new() };
+        w[0] = 32767;
+        w[1] = out.raw(0).clamp(0, 65535);
+        w[2] = out.pitch(23).clamp(0, 8192);
+        w[3] = trunc_clamp(clamp01(((s.ground_speed - 0.5) / t.slide_kmh) * 3.6) * 10000.0, i32::MIN, i32::MAX).clamp(0, 10000);
+        w[4] = out.level(25).clamp(0, 25000);
+        w[5] = out.level(26).clamp(0, 25000);
+        w[6] = out.level(27).clamp(0, 32767);
+        w[7] = out.level(24).clamp(0, 32767);
+        w[11] = t.slide_level[usize::from(loose == 2)].clamp(0, 32767);
+        vec![Command::Redeliver { slot: Slot::BoardSlide, words: w.clone() }]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Fixed;
+    impl Outputs for Fixed {
+        fn level(&self, id: usize) -> i32 {
+            1000 + id as i32
+        }
+        fn raw(&self, _: usize) -> i32 {
+            70000
+        }
+        fn pitch(&self, _: usize) -> i32 {
+            4096
+        }
+    }
+
+    /// A surface table with word 1 = the rolling surface per material: material m → surface
+    /// `map[m]` for the listed ones, 3 otherwise.
+    fn tuning(map: &[(u32, i32)]) -> PlayerTuning {
+        let mut rows = vec![[0i32; 18]; 95];
+        for r in rows.iter_mut() {
+            r[1] = 3;
+        }
+        for &(m, s) in map {
+            rows[m as usize][1] = s;
+        }
+        PlayerTuning { surface_table: rows, ..Default::default() }
+    }
+
+    fn roll(kmh: f32, front: u32, rear: u32) -> AudioState {
+        AudioState {
+            ground_speed: kmh / 3.6,
+            wheel_count: 4,
+            wheel_contact: [true; 4],
+            wheel_material: [front, front, rear, rear],
+            ..Default::default()
+        }
+    }
+
+    fn posts(cmds: &[Command]) -> Vec<(Slot, Vec<i32>)> {
+        cmds.iter().filter_map(|c| match c {
+            Command::Post { slot, words, .. } => Some((*slot, words.clone())),
+            _ => None,
+        }).collect()
+    }
+
+    #[test]
+    fn held_layers_post_at_create_with_the_layer_speed() {
+        let t = tuning(&[]);
+        let mut r = Rolling::default();
+        let (cmds, routed) = r.process(&roll(35.0, 0, 0), &t, &RollingInputs::default());
+        let p = posts(&cmds);
+        // Layer 0: 35 / 70 → 5000; layer 3: 35 / 70 → 5000 (both max 70 km/h); surface word 3.
+        assert_eq!(p[0], (Slot::RollingLayer(0), vec![0, 0, 4096, 5000, 0, 0, 3, 0, 0, 25000, 0, 32767]));
+        assert_eq!(p[1].0, Slot::RollingLayer(3));
+        assert_eq!((p[1].1[3], p[1].1[4]), (5000, 3));
+        // Asphalt smooth (surface 3): a grain bind on the primary truck, no Class_rolling patch.
+        assert_eq!(routed.grains, vec![GrainEvent::Bind { truck: 0, surface: 3, soft: false }]);
+        assert_eq!(p.len(), 2);
+        assert!(!routed.surface_pulse, "from 14: no pulse");
+        // Not created twice.
+        let (cmds, _) = r.process(&roll(35.0, 0, 0), &t, &RollingInputs::default());
+        assert!(posts(&cmds).is_empty());
+        // Update: w11 level(7) / level(9), w2 pitch(8), w8 level(19), filters 17/18, raw clamped to 65536.
+        let up = r.update(&roll(35.0, 0, 0), &t, &RollingInputs::default(), &Fixed);
+        let Command::Redeliver { words, .. } = &up[0] else { panic!() };
+        assert_eq!(words, &vec![32767, 65536, 4096, 5000, 0, 0, 3, 0, 1019, 1017, 1018, 1007]);
+        let Command::Redeliver { words, .. } = &up[1] else { panic!() };
+        assert_eq!(words[11], 1009);
+    }
+
+    #[test]
+    fn non_grain_surfaces_post_their_patch_and_release_it_on_leaving() {
+        // Material 9 (tag 10) → surface 7, material 36 (tag 37) → 13.
+        let t = tuning(&[(9, 7), (36, 13)]);
+        let mut r = Rolling::default();
+        let inp = RollingInputs::default();
+        let (cmds, routed) = r.process(&roll(20.0, 9, 9), &t, &inp);
+        let p = posts(&cmds);
+        assert_eq!(p[2], (Slot::RollingSurface(0), vec![0, 0, 4096, 0, 1, 0, 7, 0, 0, 25000, 0, 32767]));
+        assert!(routed.grains.is_empty());
+        assert!(!r.primary_is_grain());
+        // Update with a push scale: speed (v·1.4 / 65)·3.6.
+        let inp = RollingInputs { speed_scale: Some(1.4) };
+        let up = r.update(&roll(20.0, 9, 9), &t, &inp, &Fixed);
+        let Command::Redeliver { slot, words } = &up[0] else { panic!() };
+        let speed = (((20.0f32 / 3.6 * 1.4) / 65.0) * 3.6 * 10000.0) as i32;
+        assert_eq!(*slot, Slot::RollingSurface(0));
+        // Selector 1: the env send word w8 stays 0.
+        assert_eq!(words, &vec![32767, 65536, 4096, speed, 1, 0, 7, 0, 0, 1011, 1012, 1001]);
+        // Rear truck (local, second pass) also on 7: same surface as the primary → no second patch.
+        // Front onto surface 13: the rear truck has no live sound → the sound is handed over: the
+        // other truck becomes primary and posts selector 9, the old patch keeps playing on the rear.
+        let (cmds, routed) = r.process(&roll(20.0, 36, 9), &t, &RollingInputs::default());
+        assert!(routed.surface_pulse);
+        assert_eq!(routed.primary, 1);
+        let p = posts(&cmds);
+        assert_eq!(p.len(), 1);
+        assert_eq!((p[0].0, p[0].1[4], p[0].1[6]), (Slot::RollingSurface(1), 9, 13));
+        assert!(!cmds.iter().any(|c| matches!(c, Command::Release { .. })));
+        // The rear reaches 13: the rear (now non-primary truck 0) stops its patch, nothing new.
+        let (cmds, _) = r.process(&roll(20.0, 36, 36), &t, &RollingInputs::default());
+        assert_eq!(cmds, vec![Command::Release { slot: Slot::RollingSurface(0) }]);
+        // Grinding: both trucks route 14. The live truck hands its sound to the silent one (which
+        // stores 14), then the second pass hands it back: retail never stops the local player's
+        // last sounding truck (the MixMap mutes it). Layers report 13.
+        let mut g = roll(20.0, 36, 36);
+        g.grinding = true;
+        let (cmds, routed) = r.process(&g, &t, &RollingInputs::default());
+        assert!(cmds.is_empty(), "{cmds:?}");
+        assert!(routed.surface_pulse);
+        assert_eq!(routed.primary, 1);
+        assert!(r.live[1] && r.patch[1].is_some());
+        let up = r.update(&g, &t, &RollingInputs::default(), &Fixed);
+        let layers: Vec<&Command> = up.iter().filter(|c| matches!(c, Command::Redeliver { slot: Slot::RollingLayer(_), .. })).collect();
+        assert_eq!(layers.len(), 2);
+        assert!(layers.iter().all(|c| matches!(c, Command::Redeliver { words, .. } if words[6] == 13)));
+        assert!(up.iter().any(|c| matches!(c, Command::Redeliver { slot: Slot::RollingSurface(1), .. })), "the patch keeps updating");
+    }
+
+    #[test]
+    fn a_grain_change_stops_and_binds_and_metal_sets_input_6() {
+        // Material 8 (tag 9) → metal 9; material 3 (tag 4) → 2.
+        let t = tuning(&[(8, 9), (3, 2)]);
+        let mut r = Rolling::default();
+        let inp = RollingInputs::default();
+        let (_, routed) = r.process(&roll(20.0, 3, 3), &t, &inp);
+        assert_eq!(routed.grains, vec![GrainEvent::Bind { truck: 0, surface: 2, soft: false }]);
+        // Both trucks change at once to metal: the primary hands over to truck 1 (not live).
+        let (_, routed) = r.process(&roll(20.0, 8, 8), &t, &inp);
+        assert_eq!(routed.grains, vec![GrainEvent::Bind { truck: 1, surface: 9, soft: false }, GrainEvent::Stop { truck: 0 }]);
+        assert!(routed.surface_pulse);
+        // Truck 0 now reads wheel 3 (non-primary): metal → input 6.
+        assert!(routed.on_metal);
+        assert_eq!(r.last_key(), Some((9, false)));
+        assert_eq!(member(9, true), Member { stem: "metal_smooth_hard", slots: [12, 13], default_tuning: false });
+        assert_eq!(member(0, false), Member { stem: "asphalt_rough_hard", slots: [0, 1], default_tuning: true });
+        assert_eq!(member(3, true).stem, "asphalt_smooth_soft");
+    }
+
+    #[test]
+    fn spidercrack_layer_follows_wheel_0_pattern() {
+        let t = tuning(&[]);
+        let mut r = Rolling::default();
+        let mut s = roll(20.0, 0, 0);
+        s.seam_pattern = [1, 0, 0, 0];
+        let (cmds, _) = r.process(&s, &t, &RollingInputs::default());
+        let p = posts(&cmds);
+        // Layer 5 max 45 km/h: (20 / 3.6 / 45)·3.6 → 4444.
+        assert_eq!(p.last().unwrap(), &(Slot::RollingLayer(5), vec![0, 0, 4096, 4444, 5, 0, 3, 0, 0, 25000, 0, 32767]));
+        let up = r.update(&s, &t, &RollingInputs::default(), &Fixed);
+        let Command::Redeliver { words, .. } = up.last().unwrap() else { panic!() };
+        assert_eq!(words[11], 1010);
+        s.seam_pattern = [11, 1, 1, 1];
+        let (cmds, _) = r.process(&s, &t, &RollingInputs::default());
+        assert!(cmds.contains(&Command::Release { slot: Slot::RollingLayer(5) }));
+    }
+
+    #[test]
+    fn manual_lifts_the_front_truck_and_its_sound_follows_wheel_3() {
+        let t = tuning(&[]);
+        let mut r = Rolling::default();
+        let inp = RollingInputs::default();
+        // Land first so the latches are set (more than 5 frames in the air, then down).
+        let mut air = roll(20.0, 0, 0);
+        air.wheel_contact = [false; 4];
+        air.wheel_count = 0;
+        for _ in 0..8 {
+            r.process(&air, &t, &inp);
+        }
+        r.process(&roll(20.0, 0, 0), &t, &inp);
+        assert!(r.landed[0].latch && r.landed[1].latch);
+        assert_eq!(r.primary(), 0);
+        // A manual on the rear wheels: wheel 0 lifts; after > 5 frames its latch clears → the
+        // primary truck routes 14. The silent truck 1 becomes primary (storing 14) and truck 0
+        // keeps its grain, now reading wheel 3: no stop, no rebind.
+        let mut manual = roll(20.0, 0, 0);
+        manual.balance = true;
+        manual.wheel_contact = [false, false, true, true];
+        manual.wheel_count = 2;
+        let mut events = Vec::new();
+        let mut pulses = 0;
+        for _ in 0..8 {
+            let (_, routed) = r.process(&manual, &t, &inp);
+            events.extend(routed.grains);
+            pulses += usize::from(routed.surface_pulse);
+        }
+        assert_eq!(r.primary(), 1);
+        assert!(events.is_empty(), "{events:?}");
+        assert_eq!(pulses, 1);
+        assert_eq!(r.surface, [3, NO_SURFACE]);
+        // Back on four wheels: truck 1 (wheel 0) stores 3 again without a pulse; truck 0 still sounds.
+        let (_, routed) = r.process(&roll(20.0, 0, 0), &t, &inp);
+        assert!(routed.grains.is_empty() && !routed.surface_pulse);
+        assert_eq!(r.surface, [3, 3]);
+    }
+
+    #[test]
+    fn rattle_reposts_on_each_push_on_a_grain_surface() {
+        let t = tuning(&[(9, 7)]);
+        let mut r = Rolling::default();
+        let mut k = Rattle::default();
+        let mut s = roll(20.0, 0, 0);
+        r.process(&s, &t, &RollingInputs::default());
+        assert!(k.process(&s, &r, &t.rolling).is_empty(), "no push");
+        s.push_trigger = true;
+        let cmds = k.process(&s, &r, &t.rolling);
+        // ((20/3.6 − 1)·3.6 / 30)·10000 = 5466; asphalt_smooth hard → 1; eq 8.
+        let speed = (clamp01(((20.0f32 / 3.6 - 1.0) * 3.6) / 30.0) * 10000.0) as i32;
+        assert_eq!(cmds, vec![Command::Post { slot: Slot::RollingRattle, class: RATTLE_CLASS, words: vec![0, 0, 4096, speed, 1, 0, 1, 0, 25000, 0, 32767, 8] }]);
+        let up = k.update(&Fixed);
+        let Command::Redeliver { words, .. } = &up[0] else { panic!() };
+        assert_eq!(words, &vec![32767, 65535, 4096, speed, 1, 0, 1, 1016, 1014, 1015, 1006, 8]);
+        let cmds = k.process(&s, &r, &t.rolling);
+        assert!(matches!(cmds[0], Command::Release { .. }) && matches!(cmds[1], Command::Post { .. }));
+        // Soft wheels: the soft member key → surface code 0.
+        assert_eq!(rattle_surface(Some((3, true))), 0);
+        // On a Class_rolling surface the primary truck is not grain: released, not reposted.
+        let mut c = roll(20.0, 9, 9);
+        r.process(&c, &t, &RollingInputs::default());
+        c.push_trigger = true;
+        assert_eq!(k.process(&c, &r, &t.rolling), vec![Command::Release { slot: Slot::RollingRattle }]);
+    }
+
+    #[test]
+    fn loose_board_needs_a_bail_or_on_foot_deck_contact_and_an_orientation() {
+        assert_eq!(loose_board(true, true, 3, -0.95), 1);
+        assert_eq!(loose_board(true, true, 3, 0.05), 2);
+        assert_eq!(loose_board(true, true, 3, 0.95), 0, "wheels down");
+        assert_eq!(loose_board(false, true, 3, -0.95), 0);
+        assert_eq!(loose_board(true, false, 3, -0.95), 0);
+        assert_eq!(loose_board(true, true, NO_MATERIAL, -0.95), 0);
+    }
+
+    #[test]
+    fn board_slide_holds_while_loose() {
+        let t = RollingTuning::default();
+        let mut b = BoardSlide::default();
+        assert!(b.process(0, &t).is_empty());
+        assert_eq!(b.process(2, &t), vec![Command::Post { slot: Slot::BoardSlide, class: SLIDE_CLASS, words: vec![0, 0, 4096, 0, 25000, 0, 0, 0, 7, 0, 1, 0] }]);
+        let s = AudioState { ground_speed: 5.0, ..Default::default() };
+        let up = b.update(&s, 2, &t, &Fixed);
+        let Command::Redeliver { words, .. } = &up[0] else { panic!() };
+        // ((5 − 0.5) / 15)·3.6 → 10000 (clamped); filters 25/26, levels 27/24, level word 15000.
+        assert_eq!(words, &vec![32767, 65535, 4096, 10000, 1025, 1026, 1027, 1024, 7, 0, 1, 15000]);
+        assert_eq!(b.process(0, &t), vec![Command::Release { slot: Slot::BoardSlide }]);
+    }
+}
diff --git a/crates/skate-audio/src/player/seams.rs b/crates/skate-audio/src/player/seams.rs
new file mode 100644
index 00000000..e2b0a459
--- /dev/null
+++ b/crates/skate-audio/src/player/seams.rs
@@ -0,0 +1,660 @@
+//! `Class_Seams` (`Seams_Bank.abk`, owner = the Cracks controller `0x40010040`): the per-wheel
+//! seam and crack hits as the wheels roll over the pattern of the surface under them. Written from
+//! our reading of the retail code (TU3, reference only):
+//!
+//! - constructor `sub_824C1198`: grid cells `+72..+100` = `0x7FFFFFFF`, front/rear distance
+//!   accumulators `+104` = 0 / `+108` = 999, previous materials `+112..+124` = 143, latch `+128`,
+//!   frame counter `+132` and last-hit frames `+136..+148` = 0;
+//! - create `sub_824C13D0`: one 20-word packet per wheel (`sub_824AFDD0`: w1 32767, w4 4096, w5
+//!   25000, w10 = the wheel's seam surface 0..8, w11 = soft wheels, w14 = wheel, w19 = eEQChain
+//!   `5A837C613E3F41DC` = 8), held for the component's life, toggle bytes `+68..+71` = 1;
+//! - process `sub_824C14C8`: Cracks.in0 := 0 and w7 := 0 on every packet; the material history is
+//!   cleared in the air; a wheel whose material (`+620`) changed fires a hit with the transition
+//!   surface (AudioSurfaceMap word 9 + 5); otherwise, above the pattern's speed threshold (state
+//!   `+208`, signed), the pattern trigger `sub_824C1698` runs for axis 0 then axis 1; then every
+//!   packet is redelivered;
+//! - pattern trigger: wheel 0's seam pattern (`+636`; wheel 3's `+648` while balancing or
+//!   manual-braking with wheel 0's landed latch clear) selects the pattern record (none → w13 := 0);
+//!   mode 1 (grid): a wheel crossing a grid line on this axis (`sub_824C1CA0`: its world position
+//!   `+384 + 16·w` rotated by the record's angle, ÷ (grid × scale), floored, against the stored
+//!   cell; never in the air or grinding) fires — per axle one hit (the left wheel's when it crossed,
+//!   else the right's) when more than the record's minimum frames passed since the other wheel's
+//!   last hit, single (w9 = 1) unless both crossed; the rear axle is skipped while balancing or
+//!   manual-braking. Mode 2 (distance; axis 0, on the ground): ground speed × 100 × dt accumulates
+//!   front and (below 50) rear distance; past the spacing both front wheels fire and the rear
+//!   counter restarts at 50, at 0 both rear wheels fire;
+//! - hit `sub_824C1DF8`: w9 = single, w7 = 2 or 1 by the wheel's toggle (flipped each hit: the
+//!   program sees a change), w10 = the surface (word 8 of the material's AudioSurfaceMap entry, or
+//!   word 9 + 5 for a material change), w11 = soft wheels, Cracks.in0 := 32767;
+//! - update `sub_824C1F18` (each packet): w0 32767, w1 = level(1) (level(6) on soft wheels), w2 =
+//!   level(5), w3 = raw(0), w4 = pitch(2), w5/w6 = filters 3/4, w8 = clamp01((v − 0.5)·0.08)·10000,
+//!   w11 soft, w12 push planted, w13 = the record's class, w15 = |turn·1000| slewed ±100 per packet
+//!   write, w16 = record gain × 32767, w17 = balancing or manual-braking, w18 = record level ×
+//!   32767; redelivered.
+//!
+//! Inputs not in the engine: the global time scale of the distance mode (1.0 here) and the
+//! owner's active byte (always on).
+use super::state::NO_MATERIAL;
+use super::tuning::{PlayerTuning, SeamPattern};
+use super::{AudioState, Outputs, clamp01, trunc_clamp};
+use crate::mixmap::{MixMap, keys};
+
+/// The four held packets' slot ids are 0..3 (one per wheel).
+pub const CLASS: &str = "Class_Seams";
+/// The boot utility the Seams program needs (`Common.abk`, class `Start_up_Play_ctl`, posted once at
+/// audio boot after `c_emitter_utility` and before `c_foley_utility`): it implements the function
+/// `rnd_call` that the Seams program calls on a hit and answers with three RandomShuffle draws
+/// (0..9) into the globals `send_random_0_to_9a` / `9b` / `9c`. The program adds those globals to
+/// every player's sample index, so without the utility each (surface, speed, soft) word set plays
+/// one sample (index 0 of its eight); with it a hit picks among the eight, as retail does
+/// (Listening test 8).
+pub const UTILITY_BANK: &str = "Common";
+pub const UTILITY: &str = "Start_up_Play_ctl";
+/// eEQChain `default` field `5A837C613E3F41DC` (the user's vault: 8 = SFX Master).
+pub const EQ_CHAIN: i32 = 8;
+const WORDS: usize = 20;
+const IDLE_CELL: i32 = i32::MAX;
+/// `0x82324510` 999.0 and `0x8220E13C` 50.0 (rear distance), `0x820ED57C` 100.0 (distance scale).
+const REAR_IDLE: f32 = 999.0;
+const REAR_START: f32 = 50.0;
+const DISTANCE_SCALE: f32 = 100.0;
+/// `0x8206D110` degrees → radians.
+const DEG: f32 = f32::from_bits(0x3C8E_FA35);
+
+/// What a step asks of the host.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum SeamCommand {
+    Post { wheel: usize, words: Vec<i32> },
+    Redeliver { wheel: usize, words: Vec<i32> },
+    /// Redeliver at an audio block (the end of a hit's one-console-frame pulse,
+    /// `Runtime::redeliver_at`).
+    RedeliverAt { wheel: usize, words: Vec<i32>, block: u64 },
+}
+
+#[derive(Clone, Debug)]
+pub struct Seams {
+    held: [Option<Vec<i32>>; 4],
+    toggle: [bool; 4],
+    /// Grid cells per (axis, wheel): `+72 + 4·(wheel + 4·axis)`.
+    cells: [i32; 8],
+    front: f32,
+    rear: f32,
+    prev_material: [u32; 4],
+    latch: bool,
+    frame: i32,
+    last: [i32; 4],
+    turn: i32,
+    /// The pattern record in use (`+36` / `+40`).
+    record: SeamPattern,
+    /// Wheel 0's landed latch (`+464`, the Contacts conditioner `sub_82772FD8`): set at a touchdown
+    /// after more than 5 frames in the air.
+    landed0: bool,
+    prev0: bool,
+    air0: u32,
+    /// A hit fired since the last MixMap write (Cracks.in0).
+    cracks: bool,
+    /// Packets that fired in the current step.
+    fired_now: [bool; 4],
+    /// The console cadence ([`Seams::frame`]): real time (s), the next virtual call, the wheel
+    /// positions at the end of the last real frame, per packet the audio block at which a hit's w7
+    /// ends, and the pulse length's fractional block.
+    clock: f64,
+    next_call: f64,
+    last_wheels: Option<[[f32; 3]; 4]>,
+    pulse_due: [u64; 4],
+    pulse_frac: f64,
+    /// Virtual process calls run under the console cadence ([`Seams::frame`]).
+    pub calls: u64,
+    /// Hits fired, and those of them that were material changes (diagnostics).
+    pub hits: u64,
+    pub transitions: u64,
+}
+
+impl Default for Seams {
+    fn default() -> Self {
+        Self {
+            held: Default::default(),
+            toggle: [true; 4],
+            cells: [IDLE_CELL; 8],
+            front: 0.0,
+            rear: REAR_IDLE,
+            prev_material: [NO_MATERIAL; 4],
+            latch: false,
+            frame: 0,
+            last: [0; 4],
+            turn: 0,
+            record: SeamPattern::default(),
+            landed0: false,
+            prev0: false,
+            air0: 0,
+            cracks: false,
+            fired_now: [false; 4],
+            clock: 0.0,
+            next_call: 0.0,
+            last_wheels: None,
+            pulse_due: [0; 4],
+            pulse_frac: 0.0,
+            calls: 0,
+            hits: 0,
+            transitions: 0,
+        }
+    }
+}
+
+/// `sub_824C2428`: the seam surface of a wheel's material (word 8 of its AudioSurfaceMap entry), or
+/// with `transition` word 9 + 5; 0 without contact.
+pub fn surface(s: &AudioState, t: &PlayerTuning, wheel: usize, transition: bool) -> i32 {
+    let m = s.wheel_material[wheel];
+    if m >= NO_MATERIAL {
+        return 0;
+    }
+    t.surface_entry(m).map_or(0, |e| if transition { e[9] + 5 } else { e[8] })
+}
+
+/// `sub_824C1BA8` + the floor in `sub_824C1CA0`: the grid cell of a world position on one axis.
+pub fn cell(position: [f32; 3], record: &SeamPattern, scale: f32, axis: usize) -> i32 {
+    let a = (record.angle as f32) * DEG;
+    let (c, s) = ((a as f64).cos() as f32, (a as f64).sin() as f32);
+    let [x, _, z] = position;
+    let (value, grid) = if axis == 0 { (c * x - s * z, record.grid_x) } else { (c * z + s * x, record.grid_z) };
+    let v = f64::from(value / (grid * scale)).floor() as f32;
+    if v.is_nan() { 0 } else { v as i32 }
+}
+
+impl Seams {
+    fn words(s: &AudioState, t: &PlayerTuning, wheel: usize) -> Vec<i32> {
+        let mut w = vec![0i32; WORDS];
+        w[1] = 32767;
+        w[4] = 4096;
+        w[5] = 25000;
+        w[10] = surface(s, t, wheel, false).clamp(0, 8);
+        w[11] = i32::from(s.local && s.soft_wheels);
+        w[14] = wheel as i32;
+        w[19] = EQ_CHAIN;
+        w
+    }
+
+    fn pattern(t: &PlayerTuning, p: u32) -> SeamPattern {
+        t.seam_patterns.get(p as usize).copied().unwrap_or_default()
+    }
+
+    /// `sub_824C1DF8`.
+    fn fire(&mut self, s: &AudioState, t: &PlayerTuning, wheel: usize, single: bool, transition: bool) {
+        let toggle = self.toggle[wheel];
+        if let Some(w) = self.held[wheel].as_mut() {
+            w[9] = i32::from(single);
+            w[7] = if toggle { 1 } else { 2 };
+            w[10] = surface(s, t, wheel, transition).clamp(0, 8);
+            w[11] = i32::from(s.local && s.soft_wheels);
+        }
+        self.toggle[wheel] = !toggle;
+        self.fired_now[wheel] = true;
+        // Cracks.in0 := 32767 (written to the MixMap by the next process before its tick).
+        self.cracks = true;
+        self.hits += 1;
+        self.transitions += u64::from(transition);
+    }
+
+    /// `sub_824C1CA0`.
+    fn crossed(&mut self, s: &AudioState, t: &PlayerTuning, wheel: usize, axis: usize) -> bool {
+        if s.airborne || s.grinding {
+            return false;
+        }
+        let mut scale = 1.0;
+        if surface(s, t, wheel, false) == 3 && self.record.class == 10 {
+            scale = t.seam_surface3_scale;
+        }
+        let c = cell(s.wheel_position[wheel], &self.record, scale, axis);
+        let slot = &mut self.cells[wheel + 4 * axis];
+        if *slot == c {
+            return false;
+        }
+        *slot = c;
+        true
+    }
+
+    /// `sub_824C1698` for one axis.
+    fn trigger(&mut self, s: &AudioState, t: &PlayerTuning, axis: usize) {
+        let manual = s.balance || s.manual_brake;
+        let p = if manual && !self.landed0 { s.seam_pattern[3] } else { s.seam_pattern[0] };
+        if p == 0 {
+            for w in self.held.iter_mut().flatten() {
+                w[13] = 0;
+            }
+            return;
+        }
+        self.record = Self::pattern(t, p);
+        if self.record.mode == 0 {
+            for w in self.held.iter_mut().flatten() {
+                w[13] = 0;
+            }
+            return;
+        }
+        self.frame += 1;
+        if self.frame > 32767 {
+            self.frame = 0;
+            self.last = [0; 4];
+        }
+        let min = self.record.min_frames;
+        match self.record.mode {
+            1 => {
+                let (c0, c1) = (self.crossed(s, t, 0, axis), self.crossed(s, t, 1, axis));
+                let (c2, c3) = if manual { (false, false) } else { (self.crossed(s, t, 2, axis), self.crossed(s, t, 3, axis)) };
+                for (a, b) in [(0usize, 1usize), (2, 3)] {
+                    let (ca, cb) = if a == 0 { (c0, c1) } else { (c2, c3) };
+                    let both = ca && cb;
+                    if ca {
+                        if self.frame - self.last[b] > min {
+                            self.fire(s, t, a, !both, false);
+                            self.last[a] = self.frame;
+                        }
+                    } else if cb && self.frame - self.last[a] > min {
+                        self.fire(s, t, b, !both, false);
+                        self.last[b] = self.frame;
+                    }
+                }
+            }
+            2 if !s.airborne && axis == 0 => {
+                let d = s.ground_speed * DISTANCE_SCALE * 1.0 * s.dt;
+                self.front += d;
+                if self.rear <= REAR_START {
+                    self.rear -= d;
+                }
+                if self.front > self.record.spacing {
+                    self.fire(s, t, 0, false, false);
+                    self.fire(s, t, 1, false, false);
+                    self.front = 0.0;
+                    self.rear = REAR_START;
+                }
+                if self.rear <= 0.0 {
+                    self.fire(s, t, 2, false, false);
+                    self.fire(s, t, 3, false, false);
+                    self.rear = REAR_IDLE;
+                }
+            }
+            _ => {}
+        }
+    }
+
+    /// Process (before the MixMap tick): the create on the first call, then `sub_824C14C8`.
+    pub fn process(&mut self, s: &AudioState, t: &PlayerTuning, m: &mut MixMap) -> Vec<SeamCommand> {
+        let mut cmds = Vec::new();
+        if !s.local {
+            return cmds;
+        }
+        for wheel in 0..4 {
+            if self.held[wheel].is_none() {
+                let w = Self::words(s, t, wheel);
+                cmds.push(SeamCommand::Post { wheel, words: w.clone() });
+                self.held[wheel] = Some(w);
+            }
+        }
+        // The conditioner's landed latch of wheel 0 (sub_82772FD8).
+        let now = s.wheel_contact[0];
+        if !self.prev0 && self.air0 > 5 {
+            self.landed0 = now;
+        }
+        self.prev0 = now;
+        self.air0 = if now { 0 } else { self.air0 + 1 };
+
+        // Cracks.in0 := 0, then 32767 if a hit fires now or fired on a call between ticks (the
+        // MixMap ticks only here; retail ticks on every call).
+        self.step(s, t);
+        m.set_input(keys::cracks(0), 0, if std::mem::take(&mut self.cracks) { 32767 } else { 0 });
+        for (wheel, w) in self.held.iter().enumerate() {
+            if let Some(w) = w {
+                cmds.push(SeamCommand::Redeliver { wheel, words: w.clone() });
+            }
+        }
+        cmds
+    }
+
+    /// The body of `sub_824C14C8` after the create and the landed latch: w7 := 0 on every packet,
+    /// the material history (cleared in the air), a transition hit per changed material, else the
+    /// pattern trigger on both axes.
+    fn step(&mut self, s: &AudioState, t: &PlayerTuning) {
+        self.fired_now = [false; 4];
+        for w in self.held.iter_mut().flatten() {
+            w[7] = 0;
+        }
+        if s.airborne {
+            self.latch = false;
+        }
+        let mut fired = false;
+        if self.latch {
+            for wheel in 0..4 {
+                if self.prev_material[wheel] != s.wheel_material[wheel] {
+                    self.fire(s, t, wheel, false, true);
+                    fired = true;
+                }
+            }
+        }
+        self.prev_material = s.wheel_material;
+        self.latch = true;
+        if !fired && s.ground_speed > self.record.speed_threshold {
+            self.trigger(s, t, 0);
+            self.trigger(s, t, 1);
+        }
+    }
+
+    /// The console's process cadence, in Hz (Listening test 9): shipped Skate 3 renders at about 30
+    /// fps and its audio manager (`sub_82485190`) runs every SFX object's process, the MixMap tick
+    /// and the update once per rendered frame (both halves, dt > 0.02).
+    pub const CONSOLE_HZ: f64 = 30.0;
+
+    /// The tick's part of the process under the console cadence ([`Seams::frame`] does the rest):
+    /// the create, wheel 0's landed latch, and Cracks.in0 (32767 if a hit fired since the last
+    /// tick). No packet changes here, so nothing is redelivered.
+    pub fn process_tick(&mut self, s: &AudioState, t: &PlayerTuning, m: &mut MixMap) -> Vec<SeamCommand> {
+        let mut cmds = Vec::new();
+        if !s.local {
+            return cmds;
+        }
+        for wheel in 0..4 {
+            if self.held[wheel].is_none() {
+                let w = Self::words(s, t, wheel);
+                cmds.push(SeamCommand::Post { wheel, words: w.clone() });
+                self.held[wheel] = Some(w);
+            }
+        }
+        let now = s.wheel_contact[0];
+        if !self.prev0 && self.air0 > 5 {
+            self.landed0 = now;
+        }
+        self.prev0 = now;
+        self.air0 = if now { 0 } else { self.air0 + 1 };
+        m.set_input(keys::cracks(0), 0, if std::mem::take(&mut self.cracks) { 32767 } else { 0 });
+        cmds
+    }
+
+    /// The audio blocks (256 frames at 48 kHz) one console frame lasts: 1/30 s = 6.25 blocks.
+    pub const PULSE_BLOCKS: f64 = 48_000.0 / 256.0 / Self::CONSOLE_HZ;
+
+    /// Clear the copy's w7 of every pulse that has ended by audio block `block` (the runtime has
+    /// already redelivered the cleared words then; later redeliveries must not set it again).
+    pub fn expire(&mut self, block: u64) {
+        for (wheel, w) in self.held.iter_mut().enumerate() {
+            if let Some(w) = w {
+                if w[7] != 0 && self.pulse_due[wheel] <= block {
+                    w[7] = 0;
+                }
+            }
+        }
+    }
+
+    /// One rendered frame of `dt` seconds under the console cadence (Listening test 9); `block` is
+    /// the audio block the runtime renders next.
+    ///
+    /// Retail runs `sub_824C14C8` once per rendered frame: on the 30 fps console every 33.3 ms,
+    /// reading the wheel positions of that frame (`+384 + 16·w`), and a hit's w7 stays set until
+    /// the next call clears it — one console frame, 6.25 audio blocks, a little longer than the
+    /// 32 ms walk, so the program sees every hit once (twice about one time in 24). (The recomp
+    /// renders uncapped, ~345 fps, so its seams differ.) This keeps the console's behaviour at any
+    /// real frame rate:
+    /// - virtual process calls on a fixed 30 Hz grid of real time, each at the wheel positions
+    ///   interpolated along the rendered trajectory (`s.wheel_position` = this frame's rendered
+    ///   wheels; the last frame's are kept): the crossings the console samples, none lost or
+    ///   counted twice between real frames;
+    /// - a hit's w7 is redelivered now and cleared on the audio clock after 6 or 7 blocks (6.25 on
+    ///   average, [`SeamCommand::RedeliverAt`]), whatever the real frame times;
+    /// - below 30 fps several virtual calls run in one real frame; the program then sees only the
+    ///   last hit of each packet in that frame.
+    ///
+    /// Materials, air and the pattern come from `s` (the physics step's). The distance mode uses
+    /// dt = 1/30 per call. Only changed packets are redelivered.
+    pub fn frame(&mut self, s: &AudioState, t: &PlayerTuning, dt: f32, block: u64) -> Vec<SeamCommand> {
+        let mut cmds = Vec::new();
+        if !s.local || self.held.iter().any(Option::is_none) {
+            return cmds;
+        }
+        self.expire(block);
+        let before: Vec<Vec<i32>> = self.held.iter().flatten().cloned().collect();
+        let start = self.clock;
+        self.clock += f64::from(dt.max(0.0));
+        let now = s.wheel_position;
+        let last = self.last_wheels.unwrap_or(now);
+        let period = 1.0 / Self::CONSOLE_HZ;
+        // A long stall (pause, load): resume the grid at this frame instead of a burst of calls.
+        if self.clock - self.next_call > 8.0 * period {
+            self.next_call = self.clock;
+        }
+        let mut fired = [false; 4];
+        while self.next_call <= self.clock {
+            let u = if self.clock > start { ((self.next_call - start) / (self.clock - start)).clamp(0.0, 1.0) as f32 } else { 1.0 };
+            let mut v = *s;
+            v.dt = period as f32;
+            v.wheel_position = std::array::from_fn(|w| std::array::from_fn(|c| last[w][c] + (now[w][c] - last[w][c]) * u));
+            let kept: Vec<i32> = self.held.iter().flatten().map(|w| w[7]).collect();
+            self.step(&v, t);
+            for (wheel, w) in self.held.iter_mut().enumerate() {
+                let Some(w) = w else { continue };
+                if self.fired_now[wheel] {
+                    fired[wheel] = true;
+                } else if self.pulse_due[wheel] > block {
+                    w[7] = kept[wheel];
+                }
+            }
+            self.next_call += period;
+            self.calls += 1;
+        }
+        self.last_wheels = Some(now);
+        for (wheel, (w, old)) in self.held.iter().flatten().zip(&before).enumerate() {
+            if w != old {
+                cmds.push(SeamCommand::Redeliver { wheel, words: w.clone() });
+            }
+            if fired[wheel] && w[7] != 0 {
+                self.pulse_frac += Self::PULSE_BLOCKS;
+                let n = self.pulse_frac.floor();
+                self.pulse_frac -= n;
+                let mut clear = w.clone();
+                clear[7] = 0;
+                cmds.push(SeamCommand::RedeliverAt { wheel, words: clear, block: block + n as u64 });
+            }
+        }
+        for (wheel, f) in fired.iter().enumerate() {
+            if *f && self.held[wheel].as_ref().is_some_and(|w| w[7] != 0) {
+                if let Some(SeamCommand::RedeliverAt { block: due, .. }) = cmds.iter().rev().find(|c| matches!(c, SeamCommand::RedeliverAt { wheel: x, .. } if *x == wheel)) {
+                    self.pulse_due[wheel] = *due;
+                }
+            }
+        }
+        cmds
+    }
+
+    /// `sub_824C1F18` (after the tick).
+    pub fn update(&mut self, s: &AudioState, out: &dyn Outputs) -> Vec<SeamCommand> {
+        let mut cmds = Vec::new();
+        if !s.local {
+            return cmds;
+        }
+        let soft = s.local && s.soft_wheels;
+        let speed = trunc_clamp(clamp01((s.ground_speed - 0.5) * f32::from_bits(0x3DA3_D70A)) * 10000.0, 0, 10000);
+        let target = trunc_clamp(s.turn * 1000.0, i32::MIN, i32::MAX);
+        for wheel in 0..4 {
+            let Some(w) = self.held[wheel].as_mut() else { continue };
+            w[0] = 32767;
+            w[1] = out.level(if soft { 6 } else { 1 }).clamp(0, 32767);
+            w[2] = out.level(5).clamp(0, 32767);
+            w[5] = out.level(3).clamp(0, 25000);
+            w[6] = out.level(4).clamp(0, 25000);
+            w[3] = out.raw(0).clamp(0, 65536);
+            w[4] = out.pitch(2).clamp(0, 8192);
+            w[8] = speed;
+            w[11] = i32::from(soft);
+            // The turn word slews by at most 100 per packet write (four writes per frame).
+            let v = if target > self.turn { target.min(self.turn + 100) } else { target.max(self.turn - 100) };
+            self.turn = v;
+            w[15] = v.abs().clamp(0, 1000);
+            w[16] = trunc_clamp(self.record.gain * 32767.0, 0, 32767);
+            w[17] = i32::from(s.balance || s.manual_brake);
+            w[18] = trunc_clamp(self.record.level * 32767.0, 0, 32767);
+            w[12] = i32::from(s.push_planted);
+            w[13] = self.record.class.clamp(0, 15);
+            cmds.push(SeamCommand::Redeliver { wheel, words: w.clone() });
+        }
+        cmds
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Zero;
+    impl Outputs for Zero {
+        fn level(&self, _: usize) -> i32 {
+            20000
+        }
+        fn raw(&self, _: usize) -> i32 {
+            0
+        }
+        fn pitch(&self, _: usize) -> i32 {
+            4096
+        }
+    }
+
+    fn tuning() -> PlayerTuning {
+        let mut t = PlayerTuning::default();
+        let mut row = [0i32; 18];
+        row[8] = 2;
+        row[9] = 1;
+        t.surface_table = vec![row; 95];
+        let grid = SeamPattern { gain: 0.63, angle: 0, grid_z: 3.0, grid_x: 3.0, class: 2, mode: 1, min_frames: 1, speed_threshold: 0.05, spacing: 75.0, level: 1.0 };
+        t.seam_patterns = vec![grid; 16];
+        t.seam_patterns[10].mode = 2;
+        t
+    }
+
+    fn rolling(x: f32, pattern: u32) -> AudioState {
+        let mut s = AudioState { ground_speed: 6.0, wheel_count: 4, wheel_contact: [true; 4], wheel_material: [3; 4], seam_pattern: [pattern; 4], ..AudioState::default() };
+        // Front wheels 0.6 m ahead of the rear ones, along x.
+        s.wheel_position = [[x + 0.3, 0.0, 0.1], [x + 0.3, 0.0, -0.1], [x - 0.3, 0.0, 0.1], [x - 0.3, 0.0, -0.1]];
+        s
+    }
+
+    fn mixmap() -> Option<MixMap> {
+        let path = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/private/audio/aems/MixMapSK8.mxb"));
+        MixMap::from_bytes(&std::fs::read(path).ok()?).ok()
+    }
+
+    #[test]
+    fn grid_hits_once_per_axle_per_line_and_toggle_the_trigger_word() {
+        let Some(mut m) = mixmap() else { return eprintln!("skipped: no MixMap in the install") };
+        let t = tuning();
+        let mut k = Seams::default();
+        let first = k.process(&rolling(0.1, 1), &t, &mut m);
+        assert_eq!(first.iter().filter(|c| matches!(c, SeamCommand::Post { .. })).count(), 4);
+        // Retail quirk kept: the cells start at 0x7FFFFFFF, so the first evaluation "crosses" on
+        // both axes; the frame counter runs per axis, so axis 1 already passes the minimum and one
+        // hit per axle fires on the first frame at speed.
+        assert_eq!(k.hits, 2);
+        let toggled = k.toggle[0];
+        // Ride 3 m (one grid line on axis 0) at 0.1 m per frame.
+        let hits_before = k.hits;
+        let mut sevens = Vec::new();
+        for f in 1..=30 {
+            let cmds = k.process(&rolling(0.1 + 0.1 * f as f32, 1), &t, &mut m);
+            for c in cmds {
+                if let SeamCommand::Redeliver { wheel: 0, words } = c {
+                    sevens.push(words[7]);
+                }
+            }
+        }
+        // The front axle and the rear axle each cross x = 3 once: two hits, wheel 0 and wheel 2
+        // (both wheels of an axle cross together → not single).
+        assert_eq!(k.hits - hits_before, 2);
+        assert_eq!(sevens.iter().filter(|&&v| v != 0).count(), 1, "w7 is set only on the hit frame");
+        assert_eq!(*sevens.iter().find(|&&v| v != 0).unwrap(), if toggled { 1 } else { 2 }, "w7 follows the toggle");
+        // In the air nothing fires; no pattern → w13 0.
+        let mut air = rolling(10.0, 1);
+        air.airborne = true;
+        let before = k.hits;
+        k.process(&air, &t, &mut m);
+        assert_eq!(k.hits, before);
+        let cmds = k.update(&rolling(10.0, 1), &Zero);
+        let SeamCommand::Redeliver { words, .. } = &cmds[0] else { panic!() };
+        assert_eq!((words[0], words[13], words[16], words[19]), (32767, 2, 20643, EQ_CHAIN));
+    }
+
+    #[test]
+    fn a_material_change_fires_with_the_transition_surface_and_skips_the_grid() {
+        let Some(mut m) = mixmap() else { return eprintln!("skipped: no MixMap in the install") };
+        let t = tuning();
+        let mut k = Seams::default();
+        k.process(&rolling(0.1, 1), &t, &mut m);
+        let before = k.hits;
+        let mut s = rolling(0.2, 1);
+        s.wheel_material[1] = 5;
+        let cmds = k.process(&s, &t, &mut m);
+        assert_eq!(k.hits - before, 1);
+        let words = cmds.iter().find_map(|c| match c {
+            SeamCommand::Redeliver { wheel: 1, words } => Some(words.clone()),
+            _ => None,
+        });
+        assert_eq!(words.unwrap()[10], 6, "word 9 + 5");
+    }
+
+    #[test]
+    fn distance_mode_fires_front_then_rear() {
+        let Some(mut m) = mixmap() else { return eprintln!("skipped: no MixMap in the install") };
+        let t = tuning();
+        let mut k = Seams::default();
+        k.process(&rolling(0.0, 10), &t, &mut m);
+        // 6 m/s × 100 × 1/60 = 10 per frame: the front fires once past 75 (the create frame counts), the rear 50 later.
+        let mut fired = Vec::new();
+        for f in 0..20 {
+            let before = k.hits;
+            k.process(&rolling(0.0, 10), &t, &mut m);
+            if k.hits > before {
+                fired.push((f, k.hits - before));
+            }
+        }
+        assert_eq!(fired[0], (6, 2));
+        assert_eq!(fired[1], (11, 2));
+    }
+
+    /// Listening test 9: the console cadence gives the same hits at any real frame rate, and every
+    /// hit's w7 ends on the audio clock after one console frame (6 or 7 blocks, 6.25 on average).
+    #[test]
+    fn console_cadence_is_frame_rate_independent() {
+        let t = tuning();
+        let v = 30.0f32 / 3.6;
+        let mut results = Vec::new();
+        for fps in [30.0f32, 60.0, 144.0, 365.0, 20.0] {
+            let mut k = Seams::default();
+            let s0 = rolling(0.0, 7);
+            for w in 0..4 {
+                k.held[w] = Some(Seams::words(&s0, &t, w));
+            }
+            let dt = 1.0 / fps;
+            let mut lengths = Vec::new();
+            let frames = (10.0 * fps) as usize;
+            for f in 1..=frames {
+                let x = v * f as f32 * dt;
+                // Heading 20° off the x axis so both grid axes are crossed.
+                let mut s = rolling(0.0, 7);
+                let (c, sn) = (20f32.to_radians().cos(), 20f32.to_radians().sin());
+                s.wheel_position = s.wheel_position.map(|p| [p[0] * c + x * c, 0.0, p[2] + x * sn]);
+                let block = (f64::from(f as f32 * dt) * 187.5) as u64;
+                for cmd in k.frame(&s, &t, dt, block) {
+                    if let SeamCommand::RedeliverAt { words, block: due, .. } = cmd {
+                        assert_eq!(words[7], 0);
+                        lengths.push(due - block);
+                    }
+                }
+            }
+            assert!(lengths.iter().all(|&n| n == 6 || n == 7), "{fps} fps: {lengths:?}");
+            let mean = lengths.iter().sum::<u64>() as f64 / lengths.len() as f64;
+            assert!((mean - 6.25).abs() < 0.05, "{fps} fps: mean pulse {mean} blocks");
+            results.push((fps, k.hits));
+        }
+        let hits30 = results[0].1;
+        assert!(hits30 > 50);
+        for (fps, hits) in &results {
+            let d = (*hits as f64 - hits30 as f64).abs() / hits30 as f64;
+            // Below 30 fps the real frames no longer line up with the virtual grid (f32 dt), so a
+            // call can land a little off: a looser bound there.
+            assert!(d < if *fps >= 30.0 { 0.02 } else { 0.05 }, "{fps} fps: {hits} hits vs {hits30} at 30 fps");
+        }
+    }
+}
diff --git a/crates/skate-audio/src/player/state.rs b/crates/skate-audio/src/player/state.rs
new file mode 100644
index 00000000..ce7eb00c
--- /dev/null
+++ b/crates/skate-audio/src/player/state.rs
@@ -0,0 +1,277 @@
+//! The per-frame player audio state: what retail's audio-state bridge (`sub_824B0DA8`, record
+//! `*(0x82083C38) + 0x2F070 + 240 + 544·player`) gathers from the physics output for the audio
+//! components. Field docs name the state offsets the components read. The game fills it.
+
+/// Material value of a wheel with no contact (`+620..+632`).
+pub const NO_MATERIAL: u32 = 143;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct AudioState {
+    /// Frame time (s).
+    pub dt: f32,
+    /// `+208` board ground speed (m/s, SkateboardMotion+164; signed).
+    pub ground_speed: f32,
+    /// `+96` centre-of-mass velocity (SystemReckoning+16); `+212` is its length.
+    pub com_velocity: [f32; 3],
+    /// Record `+0` = SystemReckoning+64: the followed point (the skater).
+    pub com_position: [f32; 3],
+    /// The board (deck) position and linear velocity: what the second position controller
+    /// (`60010020`) follows (record `+48` / `+80`, Motion+80).
+    pub board_position: [f32; 3],
+    pub board_velocity: [f32; 3],
+    /// `+200` wheels in contact (0..4).
+    pub wheel_count: u32,
+    /// Per wheel (FL, FR, BL, BR as the engine orders them): in contact, material (`+620`:
+    /// audio surface tag − 1, [`NO_MATERIAL`] without contact) and seam pattern (`+636`).
+    pub wheel_contact: [bool; 4],
+    pub wheel_material: [u32; 4],
+    pub seam_pattern: [u32; 4],
+    /// `+384 + 16·w` the wheels' world positions (the engine's wheel bodies), read by `Class_Seams`
+    /// for its grid crossings.
+    pub wheel_position: [[f32; 3]; 4],
+    /// `+204` turn input (Ground+264 = ProcessedPhysIn+2676), −1..1.
+    pub turn: f32,
+    /// `+712` (Skeleton+516: the pumping absorption), read by the bed's slope inputs. Negative =
+    /// downhill. What retail means by it is UNCERTAIN (grain spec §2.7).
+    pub slope: f32,
+    /// `+332` in the air (KnownAir in retail: 200 ≤ state < 300 with no wheel down) and `+236` the
+    /// time in that air phase (s).
+    pub airborne: bool,
+    pub air_time: f32,
+    /// `+336` brake planted, `+339` manual brake, `+340` balance (manual), `+341` grinding,
+    /// `+343` trick active, `+372` the hippy-jump trick flag, `+676` bail, `+677` end of bail,
+    /// `+716` on foot (state 500), `+684` soft wheels (wheel hardness < 0.5).
+    pub brake: bool,
+    pub manual_brake: bool,
+    pub balance: bool,
+    pub grinding: bool,
+    pub trick_active: bool,
+    pub hippy_jump: bool,
+    pub bail: bool,
+    pub bail_end: bool,
+    pub on_foot: bool,
+    pub soft_wheels: bool,
+    /// `+333 || +334` the push foot is planted; `+335` a new push plant this frame.
+    pub push_planted: bool,
+    pub push_trigger: bool,
+    /// `+615` / `+616` feet inside the deck box (Skeleton 600 / 601).
+    pub feet_in_deck_box: [bool; 2],
+    /// `+192` grind family (Grinds+136 latched while grinding; −1 before the first grind) and
+    /// `+692` grind material (Grinds+216 latched; [`NO_MATERIAL`] before the first grind).
+    pub grind_family: i32,
+    pub grind_material: u32,
+    /// `[[state+16]+72]`: this is the local player.
+    pub local: bool,
+    /// `+468` jump velocity: the conditioner's |Air+112| / 2.65 (1 above 2.65 m/s), written while
+    /// Air440 (Processed2468 bit 22) holds (`sub_82772748`).
+    pub jump_velocity: f32,
+    /// `+348` the audio trick id of the current scorable (vault `eSk8AudioTricks`, −1 none); the
+    /// host resolves it from [`AudioState::scorable`] with `PlayerTuning::audio_trick`.
+    pub audio_trick: i32,
+    /// The score packet's EScorableID (B60+152, −1 none).
+    pub scorable: i32,
+    /// `+232` slip: clamp((|deck velocity · deck right| + 0.75) / 45, 0, 1), 0 with no wheel down
+    /// (`sub_82772E18`; vault holder `0xBA9837A6CF4C26ED`: 45 and −0.75). See [`slip`].
+    pub slip: f32,
+    /// `+690` reverting (RevertGround with State+66), `+308` the off-board byte the skid and the
+    /// walking voices read: OffBoard 311, the board held in hand (packed record `+164` bit 1,
+    /// `sub_827A1B78`; the engine's `off_board.flag_311`).
+    pub revert: bool,
+    pub offboard_308: bool,
+    /// `+264` the signed deck tilt (rad, SkateboardBody+256 filtered steering) and `+488` the deck's
+    /// angular velocity about its At axis (rad/s; `+480` = Motion+64 projected on the deck rows).
+    pub deck_tilt: f32,
+    pub deck_spin: f32,
+    /// `+228` the last positive grind impact speed (m/s; B40+32 = Grinds+128 latched while > 0),
+    /// read by the grind-start contact.
+    pub grind_impact: f32,
+    /// `+668` the deck impact: the conditioner's max over the last 4 frames of
+    /// clamp01(|deck acceleration · deck contact normal| × 0.00125) with the deck in contact
+    /// (`sub_82C02A80` Collision+24, B40+36); `+660` the deck contact's material (tag − 1, 143 none).
+    pub deck_impact: f32,
+    pub deck_material: u32,
+    /// `+272` / `+268`: |local toe velocity Y| of foot 0 (Skeleton+196) / foot 1 (+212);
+    /// `+280` / `+276`: max(|x|, |z|) of the same velocities (m/s, the physical board's frame).
+    pub foot_speed_y: [f32; 2],
+    pub foot_speed_xz: [f32; 2],
+    /// `+304` the jump bucket (0..2, B40+48; not published: 0).
+    pub jump_bucket: u32,
+    /// `+352` the scorable's second eSk8AudioTricks field (record `+184` = vault class
+    /// `0x6918469984A8C596` field `0xA2C5C22C5BE725F8` at +172; −1 none): 28 for flips and most
+    /// tricks, 35 for grabs, −1 for the ollie, the nollie and footplants. The host resolves it from
+    /// [`AudioState::scorable`] with `PlayerTuning::audio_trick_2`. The Tricks component plays it
+    /// as the second cloth_trick when the trick ends.
+    pub audio_trick_2: i32,
+    /// `+310` the off-board hold has run out (record +164 bit 0 held longer than a speed-dependent
+    /// time, `sub_824B0DA8`); not published by the engine: false. With it on the ground the Tricks
+    /// component posts Class_Flips with trick id 34.
+    pub offboard_310: bool,
+    /// `+480` / `+484`: the deck's angular velocity about its Ri and Up rows (rad/s; `+488` is
+    /// [`AudioState::deck_spin`]), the conditioner's B40+0 = rows · Motion+64 (`sub_82772748`).
+    pub deck_spin_xy: [f32; 2],
+    /// `+240` the predicted time until landing (s, Air+184) and `+260` the jump height (m,
+    /// Air+200): KnownAir's outputs (skate-core `KnownAirOutput::time_until_collision_184` /
+    /// `jump_height_200`), streamed by `Class_Treatment`.
+    pub air_until_landing: f32,
+    pub jump_height: f32,
+    /// `+220` the game time scale (G+0 of the audio game block, 1.0 at normal speed, below 1.0 in
+    /// slow motion) and `+224` the block's G+4 byte (also the c_tazer post's input; 0 in free skate).
+    pub time_scale: f32,
+    pub global_224: bool,
+    // ---- off-board and clothing inputs (`player::footsteps`, `player::clothing`,
+    // `player::step_on`; spec `.claude/notes/aems-offboard-clothing-spec.md`). Foot A is the
+    // packet at OffBoard `+36` (OffBoard foot side 1, toe part 19), foot B the one at `+220`
+    // (side 0, toe part 15).
+    /// `+724` / `+725`: foot A / B down: (OffBoard 307 || Air 450 || `+334` || `+336`) /
+    /// (OffBoard 306 || Air 449 || `+333`) — on the board the push plants and the brake count.
+    pub foot_down: [bool; 2],
+    /// `+732` / `+728`: the surface material under foot A / B (OffBoard `+56` / `+52` u16 tag & 0x7F,
+    /// − 1, [`NO_MATERIAL`] without one; the footplant's Air `+224` tag while Air 448).
+    pub foot_material: [u32; 2],
+    /// `+288` / `+284`: max(|vx|, |vz|) of the world velocity of toe part 19 / 15 (Skeleton
+    /// `+240` / `+224`, m/s).
+    pub foot_xz_speed: [f32; 2],
+    /// `+296` / `+292`: |Skeleton `+308`| / |Skeleton `+324`| (the y lanes of Skeleton `+304` /
+    /// `+320`, per-foot vertical speeds, m/s).
+    pub foot_vertical_speed: [f32; 2],
+    /// `+740` the step code 1..5 ([`super::footsteps::StepCode`]).
+    pub step_code: i32,
+    /// `+796` Interaction+0 `AudibleFootStepStrength`.
+    pub footstep_strength: f32,
+    /// `+300` the landing bucket 1..4 ([`super::footsteps::LandingBucket`]).
+    pub landing_bucket: i32,
+    /// `+768` Air 448 (the footplant) and `+718` OffboardAir (filtered state 7).
+    pub footplant: bool,
+    pub offboard_air: bool,
+    /// `+337` State56: the push stroke (the push animation's flag ahead of the plant `+333`).
+    pub push_stroke: bool,
+    /// `+328` |Skeleton `+288`| (the ragdoll body speed, m/s) and `+672` 0.25 × Σ Skeleton
+    /// `+560..+572` (the limb speeds).
+    pub body_speed: f32,
+    pub limb_speed: f32,
+    /// `+528..+548` the six body-part slide speeds, `+560..+580` their surface tags (1-based, 0 =
+    /// none) and `+593` the flag that makes every slide type 4 (Collision `+80..+195` via
+    /// `sub_82773298`).
+    pub body_slide: [f32; 6],
+    pub body_tag: [u32; 6],
+    pub body_slide_flag: bool,
+    /// `+688` / `+689`: hand limb 2 (part 3) / 3 (part 7) on the deck: Skeleton `+602` / `+603`
+    /// ([`super::step_on::hands_on_deck`]).
+    pub hands_on_deck: [bool; 2],
+}
+
+impl Default for AudioState {
+    fn default() -> Self {
+        Self {
+            dt: 1.0 / 60.0,
+            ground_speed: 0.0,
+            com_velocity: [0.0; 3],
+            com_position: [0.0; 3],
+            board_position: [0.0; 3],
+            board_velocity: [0.0; 3],
+            wheel_count: 0,
+            wheel_contact: [false; 4],
+            wheel_material: [NO_MATERIAL; 4],
+            seam_pattern: [0; 4],
+            wheel_position: [[0.0; 3]; 4],
+            turn: 0.0,
+            slope: 0.0,
+            airborne: false,
+            air_time: 0.0,
+            brake: false,
+            manual_brake: false,
+            balance: false,
+            grinding: false,
+            trick_active: false,
+            hippy_jump: false,
+            bail: false,
+            bail_end: false,
+            on_foot: false,
+            soft_wheels: false,
+            push_planted: false,
+            push_trigger: false,
+            feet_in_deck_box: [false; 2],
+            grind_family: -1,
+            grind_material: NO_MATERIAL,
+            local: true,
+            jump_velocity: 0.0,
+            audio_trick: -1,
+            scorable: -1,
+            slip: 0.0,
+            revert: false,
+            offboard_308: false,
+            deck_tilt: 0.0,
+            deck_spin: 0.0,
+            grind_impact: 0.0,
+            deck_impact: 0.0,
+            deck_material: NO_MATERIAL,
+            foot_speed_y: [0.0; 2],
+            foot_speed_xz: [0.0; 2],
+            jump_bucket: 0,
+            audio_trick_2: -1,
+            offboard_310: false,
+            deck_spin_xy: [0.0; 2],
+            air_until_landing: 0.0,
+            jump_height: 0.0,
+            time_scale: 1.0,
+            global_224: false,
+            foot_down: [false; 2],
+            foot_material: [NO_MATERIAL; 2],
+            foot_xz_speed: [0.0; 2],
+            foot_vertical_speed: [0.0; 2],
+            step_code: 1,
+            footstep_strength: 0.0,
+            landing_bucket: 1,
+            footplant: false,
+            offboard_air: false,
+            push_stroke: false,
+            body_speed: 0.0,
+            limb_speed: 0.0,
+            body_slide: [0.0; 6],
+            body_tag: [0; 6],
+            body_slide_flag: false,
+            hands_on_deck: [false; 2],
+        }
+    }
+}
+
+impl AudioState {
+    /// `+212`: |COM velocity|.
+    pub fn com_speed(&self) -> f32 {
+        let [x, y, z] = self.com_velocity;
+        (x * x + y * y + z * z).sqrt()
+    }
+
+    /// The material of the first wheel in contact that has one (`NO_MATERIAL` if none).
+    pub fn contact_material(&self) -> u32 {
+        (0..4)
+            .filter(|&i| self.wheel_contact[i])
+            .map(|i| self.wheel_material[i])
+            .find(|&m| m != NO_MATERIAL)
+            .unwrap_or(NO_MATERIAL)
+    }
+}
+
+/// `sub_82772E18`: the slip from the deck's lateral speed |Motion+80 · deck Ri| (m/s), for a board
+/// with a wheel down (0 otherwise).
+pub fn slip(lateral: f32) -> f32 {
+    let x = lateral.abs() - f32::from_bits(0xBF40_0000); // − (−0.75)
+    let x = if x >= 0.0 { x } else { 0.0 } / f32::from_bits(0x4234_0000); // / 45
+    x.min(1.0)
+}
+
+/// `sub_82772748`'s jump-velocity word from |Air+112| (m/s): ×0.37735847 below 2.65, else 1.
+pub fn jump_velocity(delta: f32) -> f32 {
+    if delta < 0.0 {
+        0.0
+    } else if delta > f32::from_bits(0x4029_999A) {
+        1.0
+    } else {
+        delta * f32::from_bits(0x3EC1_3521)
+    }
+}
+
+/// The engine's 7-bit audio surface tag → the audio state's material (`tag − 1`, 0 = none).
+pub fn material_of_tag(tag: u32) -> u32 {
+    if tag == 0 { NO_MATERIAL } else { (tag - 1).min(NO_MATERIAL) }
+}
diff --git a/crates/skate-audio/src/player/step_on.rs b/crates/skate-audio/src/player/step_on.rs
new file mode 100644
index 00000000..e8bd6909
--- /dev/null
+++ b/crates/skate-audio/src/player/step_on.rs
@@ -0,0 +1,184 @@
+//! `SFXObj_Contacts`' hand-on-deck sounds (`sub_824B85B0`, run by the Contacts process after the
+//! deck impact; spec `.claude/notes/aems-offboard-clothing-spec.md`). Written from our reading of
+//! the retail code (TU3, reference only):
+//!
+//! - inputs: state `+688` / `+689` = Skeleton `+602` / `+603` (`sub_82BF20C8`, Skeleton::FillPhysOut
+//!   `sub_82BE1AE8`): the IK's animated target of hand limb 2 (part 3) / limb 3 (part 7) relative to
+//!   the animated board (SkeletonIK `+1792` / `+1856`, translation at `+1840` / `+1904`) strictly
+//!   inside the deck box (DeckWidth / 2, 0, DeckFrontEndSize + DeckMidLength / 2) padded by
+//!   `physics_skeleton` `A28E50D30B0506A4` = (0.03, 0.03, 0); the bridge clears both while on foot
+//!   (category 500) without the board in hand (OffBoard 311) — see [`hands_on_deck`];
+//! - a hand coming onto the deck (`sub_824B8310`): the slot's sound restarts, `Skate_Collisions`
+//!   1124 in the air (`+332`) or 1125 on the ground (class `923CCB46EF5BF5BA` collection
+//!   `E0C3B44AB44F7B90`: `A7B32EC5FF4997F5` / `F17EEB71F18CEAF3`); a hand leaving it
+//!   (`sub_824B8448`): 1126 (`A7B7AE2A6C25670F`); both on eEQChain bus 2 (`ED52262DABB5DE4C`,
+//!   created by the local player), start block [0, 1, 0, dt, 1, 1];
+//! - update (`sub_824BF728`, Contacts): per hand, the on sound at trunc(level(10) × 0.5) / 32767,
+//!   the off sound at trunc(level(10) × 0.3) / 32767 (`25DCB888413D570D` = [0.5, 0.3]), pitch(11),
+//!   raw(0), no pan spread; a sound that ended is freed.
+use super::contacts::SpliceHost;
+use super::{AudioState, Outputs, trunc_clamp};
+use crate::splice::SoundId;
+
+pub const BANK: &str = "Skate_Collisions";
+const LEVEL: f32 = f32::from_bits(0x3800_0100); // 1/32767
+const PITCH: f32 = f32::from_bits(0x3980_0000); // 1/4096
+const DEGREES: f32 = f32::from_bits(0x3BB4_00B4); // 360/65535
+
+/// The vault values (defaults = retail).
+#[derive(Clone, Debug, PartialEq)]
+pub struct StepOnTuning {
+    /// [in the air, on the ground, hand off].
+    pub ids: [u32; 3],
+    /// Level scales of the on / off sounds.
+    pub levels: [f32; 2],
+    pub eq: u8,
+}
+
+impl Default for StepOnTuning {
+    fn default() -> Self {
+        Self { ids: [1124, 1125, 1126], levels: [0.5, 0.3], eq: 2 }
+    }
+}
+
+/// The bridge's `+688` / `+689` from Skeleton `+602` / `+603` (`sub_824B0DA8`: cleared while on
+/// foot (state 500) unless the board is held, OffBoard 311).
+pub fn hands_on_deck(skeleton_602_603: [bool; 2], on_foot: bool, board_held: bool) -> [bool; 2] {
+    if on_foot && !board_held { [false; 2] } else { skeleton_602_603 }
+}
+
+/// Skeleton `+602` / `+603` (`sub_82BF20C8`) from the hands' board-relative IK targets: strict
+/// containment in the deck box padded by `physics_skeleton` `A28E50D30B0506A4`.
+pub fn hand_in_deck_box(position: [f32; 3], deck_half_width: f32, deck_half_length: f32, padding: [f32; 3]) -> bool {
+    let bounds = [deck_half_width + padding[0], 0.0 + padding[1], deck_half_length + padding[2]];
+    (0..3).all(|i| bounds[i] > position[i] && position[i] > -bounds[i])
+}
+
+/// The default padding (`physics_skeleton` `default` `A28E50D30B0506A4`).
+pub const HAND_PADDING: [f32; 3] = [f32::from_bits(0x3CF5_C28F), f32::from_bits(0x3CF5_C28F), 0.0];
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct StepOn {
+    /// `+376` / `+384` (and the identical `+392` / `+400`): last frame's `+688` / `+689`.
+    was: [bool; 2],
+    /// `+372` / `+380` the on sounds, `+388` / `+396` the off sounds.
+    on: [Option<SoundId>; 2],
+    off: [Option<SoundId>; 2],
+    pub starts: u64,
+}
+
+impl StepOn {
+    /// `sub_824B85B0` (rising `+689`, rising `+688`, falling `+689`, falling `+688`).
+    pub fn process(&mut self, s: &AudioState, c: &StepOnTuning, host: &mut dyn SpliceHost) {
+        let now = s.hands_on_deck;
+        let route = crate::bus::Route { output: crate::bus::Output::Eq(c.eq), create: s.local, owner_env: 0.0, mono: false };
+        let block = [0.0, 1.0, 0.0, s.dt, 1.0, 1.0];
+        for hand in [1usize, 0] {
+            if now[hand] && !self.was[hand] {
+                if let Some(old) = self.on[hand].take() {
+                    host.release(old);
+                }
+                let id = if s.airborne { c.ids[0] } else { c.ids[1] };
+                host.set_route(route);
+                self.on[hand] = host.start(BANK, id, block);
+                self.starts += u64::from(self.on[hand].is_some());
+            }
+        }
+        for hand in [1usize, 0] {
+            if !now[hand] && self.was[hand] {
+                if let Some(old) = self.off[hand].take() {
+                    host.release(old);
+                }
+                host.set_route(route);
+                self.off[hand] = host.start(BANK, c.ids[2], block);
+                self.starts += u64::from(self.off[hand].is_some());
+            }
+        }
+        self.was = now;
+    }
+
+    /// `sub_824BF728` (after the MixMap tick; `out` = the Contacts outputs).
+    pub fn update(&mut self, s: &AudioState, c: &StepOnTuning, out: &dyn Outputs, host: &mut dyn SpliceHost) {
+        let block = |k: f32| -> [f32; 6] {
+            let level = trunc_clamp(out.level(10) as f32 * k, i32::MIN, i32::MAX) as f32 * LEVEL;
+            [level, out.pitch(11) as f32 * PITCH, out.raw(0) as f32 * DEGREES, s.dt, 0.0, 1.0]
+        };
+        for hand in 0..2 {
+            for (slot, k) in [(&mut self.on[hand], c.levels[0]), (&mut self.off[hand], c.levels[1])] {
+                let Some(sound) = *slot else { continue };
+                if host.alive(sound) {
+                    host.update(sound, block(k));
+                } else {
+                    host.release(sound);
+                    *slot = None;
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Default)]
+    struct Log {
+        started: Vec<u32>,
+        updates: Vec<[f32; 6]>,
+    }
+    impl SpliceHost for Log {
+        fn start(&mut self, _: &str, id: u32, _: [f32; 6]) -> Option<SoundId> {
+            self.started.push(id);
+            Some(self.started.len())
+        }
+        fn update(&mut self, _: SoundId, block: [f32; 6]) {
+            self.updates.push(block);
+        }
+        fn alive(&self, _: SoundId) -> bool {
+            true
+        }
+        fn release(&mut self, _: SoundId) {}
+    }
+
+    struct Out;
+    impl Outputs for Out {
+        fn level(&self, id: usize) -> i32 {
+            if id == 10 { 20001 } else { 0 }
+        }
+        fn raw(&self, _: usize) -> i32 {
+            0
+        }
+        fn pitch(&self, _: usize) -> i32 {
+            4096
+        }
+    }
+
+    #[test]
+    fn a_hand_on_the_deck_plays_1125_on_the_ground_1124_in_the_air_and_1126_off() {
+        let c = StepOnTuning::default();
+        let mut k = StepOn::default();
+        let mut h = Log::default();
+        let mut s = AudioState { hands_on_deck: [false, true], ..Default::default() };
+        k.process(&s, &c, &mut h);
+        s.airborne = true;
+        s.hands_on_deck = [true, true];
+        k.process(&s, &c, &mut h);
+        s.hands_on_deck = [false, false];
+        k.process(&s, &c, &mut h);
+        assert_eq!(h.started, [1125, 1124, 1126, 1126]);
+        k.update(&s, &c, &Out, &mut h);
+        // trunc(20001 × 0.5) = 10000; trunc(20001 × 0.3) = 6000.
+        assert_eq!(h.updates[0][0], 10000.0 * LEVEL);
+        assert!(h.updates.iter().any(|b| b[0] == 6000.0 * LEVEL));
+        assert!(h.updates.iter().all(|b| b[4] == 0.0));
+    }
+
+    #[test]
+    fn the_bridge_clears_the_hands_on_foot_without_the_board() {
+        assert_eq!(hands_on_deck([true, true], true, false), [false; 2]);
+        assert_eq!(hands_on_deck([true, false], true, true), [true, false]);
+        // 3 cm above the deck plane is still on it; 4 cm is not.
+        assert!(hand_in_deck_box([0.0, 0.029, 0.0], 0.1, 0.4, HAND_PADDING));
+        assert!(!hand_in_deck_box([0.0, 0.04, 0.0], 0.1, 0.4, HAND_PADDING));
+    }
+}
diff --git a/crates/skate-audio/src/player/treatment.rs b/crates/skate-audio/src/player/treatment.rs
new file mode 100644
index 00000000..8ba25452
--- /dev/null
+++ b/crates/skate-audio/src/player/treatment.rs
@@ -0,0 +1,243 @@
+//! `Class_Treatment` (component vtable `0x822FCDA0`, owner = the Treatments controller
+//! `0x40010070`, `Treatments.abk`): one packet posted for the player's life that streams the air
+//! words (time in the air, predicted time to the landing, jump height); its program plays the
+//! pre-landing treatment (retail session 164620: Treatments streams 13 and 14 start a median ~230 ms
+//! before the wheels touch down). Written from our reading of the retail code (TU3, reference only);
+//! spec `.claude/notes/aems-tricks-treatment-spec.md`.
+//!
+//! - process `sub_824DD408`, local player only (`[this+28]+72`): while `+36` is empty, the
+//!   constructor `sub_824B0080` builds and posts the 92-byte object (never released); then the
+//!   `hall_of_meat_slo_mo` companion (`+40`, constructor `sub_824AF368`, 15 words) is held while
+//!   (`G+96` bit 26 and not `sub_8279E180(G)` and the time scale `+220` < 1.0) or the game-flow mode
+//!   `X+1060` ≠ 7, and released otherwise — never in free skate (no retail session posts it);
+//! - update `sub_824DD6F0`: rewrites the Treatment packet (and the companion) from the Treatments
+//!   owner's outputs and redelivers them.
+use super::globals::{Globals, SLO_MO_BIT};
+use super::tricks::time_scale_word;
+use super::{AudioState, Outputs, clamp01, trunc_clamp};
+use crate::player::components::{Command, Slot};
+
+pub const CLASS: &str = "Class_Treatment";
+pub const HOM_CLASS: &str = "hall_of_meat_slo_mo";
+/// The bank `Class_Treatment` binds to (not exported by setup before this port; add it to
+/// `audio_export.BANKS`). The companion's bank was not identified (not posted in free skate).
+pub const BANKS: &[&str] = &["Treatments"];
+
+const WORDS: usize = 22;
+const HOM_WORDS: usize = 15;
+/// `0x82256FE8` 1000.0, `0x821161A0` 10000.0, `0x822F9408` 166.66667 (jump height → 1000 at 6 m),
+/// `0x8231A844` 1.0.
+const THOUSAND: f32 = f32::from_bits(0x447A_0000);
+const TEN_THOUSAND: f32 = f32::from_bits(0x461C_4000);
+const HEIGHT_SCALE: f32 = f32::from_bits(0x4326_AAAB);
+const ONE: f32 = f32::from_bits(0x3F80_0000);
+
+/// Vault words: the audio tuning holder `*(0x830CFDA4)+68` = class `0xC1831BDB6CB1B1EA`
+/// collection `0xEE7B8A8A893A4E30`. Defaults: the user's vault.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct TreatmentTuning {
+    /// w15 `32F9111CBF746F34` = 7000, w16 `E4BC6FE030A553C4` = 28000, w17 `1F11951C2AF58CC7` = 32767.
+    pub levels: [i32; 3],
+    /// The companion's speed divisor `5A49D603680EE3FF` = 40.0 (m/s of `+212` → w12).
+    pub hom_speed: f32,
+}
+
+impl Default for TreatmentTuning {
+    fn default() -> Self {
+        Self { levels: [7000, 28000, 32767], hom_speed: 40.0 }
+    }
+}
+
+/// The block `B = *(*(0x83083C38) + 0x2FCB4)` whose `+16` sub-object (reset by `sub_827AB6E0`)
+/// the updater reads: `B+16` (the byte PlayerPhysics.in11 also reads, set for a while after a bail
+/// in upstream PR #4's capture), `B+24` (f32), `B+164` (byte), `B+168` (f32). Its writer was not
+/// located; the defaults are the reset values (w11 = w12 = 0, w13 keeps 0). UNCERTAIN: PR #4's
+/// capture reports `B+164` set with `B+168` ≈ 1.0 for most of play.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct TreatmentGlobals {
+    pub flag_16: bool,
+    pub value_24: f32,
+    pub flag_164: bool,
+    pub value_168: f32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Treatment {
+    held: Option<Vec<i32>>,
+    hom: Option<Vec<i32>>,
+}
+
+impl Treatment {
+    /// `sub_824B0080`.
+    fn words(s: &AudioState, t: &TreatmentTuning) -> Vec<i32> {
+        let mut w = vec![0i32; WORDS];
+        w[1] = 32767;
+        w[4] = 4096;
+        w[5] = 25000;
+        w[10] = 500;
+        w[15] = t.levels[0].clamp(0, 32767);
+        w[16] = t.levels[1].clamp(0, 32767);
+        w[17] = t.levels[2].clamp(0, 32767);
+        w[18] = 0; // bool class 0x11A631878B239355 through sub_82484460 (global setting, not modelled)
+        w[19] = i32::from(s.local); // local && [[owner+28]+64] == 0
+        w[20] = i32::from(s.local);
+        w[21] = 8;
+        w
+    }
+
+    fn hom_words(level3: i32, mode: i32) -> Vec<i32> {
+        // sub_824AF368.
+        let mut w = vec![0i32; HOM_WORDS];
+        w[2] = 4096;
+        w[3] = 25000;
+        w[6] = 32767;
+        w[9] = 1;
+        w[10] = level3.clamp(0, 32767);
+        w[11] = 8;
+        w[14] = (mode - 7).clamp(0, 3);
+        w
+    }
+
+    /// Process (before the MixMap tick). `out` = the Treatments owner's outputs.
+    pub fn process(&mut self, s: &AudioState, t: &TreatmentTuning, g: &Globals, out: &dyn Outputs) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if !s.local {
+            return cmds;
+        }
+        if self.held.is_none() {
+            let w = Self::words(s, t);
+            cmds.push(Command::Post { slot: Slot::Treatment, class: CLASS, words: w.clone() });
+            self.held = Some(w);
+        }
+        // sub_8279E180(G) (the world's +112 child through its vfunc 16) is taken as false.
+        let slo_mo = g.flags_96 & SLO_MO_BIT != 0 && s.time_scale < ONE;
+        if slo_mo || g.mode_1060 != 7 {
+            if self.hom.is_none() {
+                let w = Self::hom_words(out.level(3), g.mode_1060);
+                cmds.push(Command::Post { slot: Slot::HomSloMo, class: HOM_CLASS, words: w.clone() });
+                self.hom = Some(w);
+            }
+        } else if self.hom.take().is_some() {
+            cmds.push(Command::Release { slot: Slot::HomSloMo });
+        }
+        cmds
+    }
+
+    /// Update (after the tick), `sub_824DD6F0`.
+    pub fn update(&mut self, s: &AudioState, b: &TreatmentGlobals, t: &TreatmentTuning, out: &dyn Outputs) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if let Some(w) = self.held.as_mut() {
+            w[0] = out.level(2).clamp(0, 32767);
+            w[3] = out.raw(0).clamp(0, 65535);
+            w[4] = out.pitch(1).clamp(0, 8192);
+            w[10] = time_scale_word(s);
+            w[14] = i32::from(!s.global_224);
+            w[7] = trunc_clamp(s.air_time * THOUSAND, i32::MIN, i32::MAX).clamp(0, 10000);
+            w[8] = trunc_clamp(s.air_until_landing * THOUSAND, i32::MIN, i32::MAX).clamp(0, 10000);
+            // trunc(min(max(h × 166.67, 0), 1000)): fsel pairs, NaN passes through.
+            let h = s.jump_height * HEIGHT_SCALE;
+            let h = if -h >= 0.0 { 0.0 } else { h };
+            let h = if THOUSAND - h >= 0.0 { h } else { THOUSAND };
+            w[9] = trunc_clamp(h, i32::MIN, i32::MAX).clamp(0, 10000);
+            w[12] = 0;
+            w[11] = 0;
+            if b.flag_16 {
+                w[11] = trunc_clamp(b.value_24 * THOUSAND, i32::MIN, i32::MAX).clamp(0, 1000);
+            }
+            if b.flag_164 {
+                w[12] = 1;
+                w[13] = trunc_clamp(b.value_168 * TEN_THOUSAND, i32::MIN, i32::MAX).clamp(0, 10000);
+            }
+            cmds.push(Command::Redeliver { slot: Slot::Treatment, words: w.clone() });
+        }
+        if let Some(w) = self.hom.as_mut() {
+            w[0] = 32767;
+            w[7] = out.level(4).clamp(0, 32767);
+            w[8] = out.level(5).clamp(0, 32767);
+            w[13] = out.level(6).clamp(0, 32767);
+            w[10] = out.level(3).clamp(0, 32767);
+            w[12] = trunc_clamp(clamp01(s.com_speed() / t.hom_speed) * TEN_THOUSAND, i32::MIN, i32::MAX).clamp(0, 10000);
+            cmds.push(Command::Redeliver { slot: Slot::HomSloMo, words: w.clone() });
+        }
+        cmds
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Fixed;
+    impl Outputs for Fixed {
+        fn level(&self, id: usize) -> i32 {
+            1000 + id as i32
+        }
+        fn raw(&self, _: usize) -> i32 {
+            70000
+        }
+        fn pitch(&self, _: usize) -> i32 {
+            4096
+        }
+    }
+
+    #[test]
+    fn posts_once_for_the_local_player_and_never_releases() {
+        let (t, g) = (TreatmentTuning::default(), Globals::default());
+        let mut k = Treatment::default();
+        let s = AudioState::default();
+        let cmds = k.process(&s, &t, &g, &Fixed);
+        let [Command::Post { slot: Slot::Treatment, class, words }] = &cmds[..] else { panic!("{cmds:?}") };
+        assert_eq!(*class, "Class_Treatment");
+        assert_eq!(words.len(), 22);
+        assert_eq!(
+            words[..],
+            [0, 32767, 0, 0, 4096, 25000, 0, 0, 0, 0, 500, 0, 0, 0, 0, 7000, 28000, 32767, 0, 1, 1, 8]
+        );
+        for _ in 0..10 {
+            assert!(k.process(&s, &t, &g, &Fixed).is_empty(), "held, no companion in free skate");
+        }
+        let remote = AudioState { local: false, ..Default::default() };
+        assert!(Treatment::default().process(&remote, &t, &g, &Fixed).is_empty());
+    }
+
+    #[test]
+    fn update_streams_the_air_words() {
+        let (t, g) = (TreatmentTuning::default(), Globals::default());
+        let mut k = Treatment::default();
+        let s = AudioState { airborne: true, air_time: 0.4, air_until_landing: 0.25, jump_height: 1.2, ..Default::default() };
+        k.process(&s, &t, &g, &Fixed);
+        let cmds = k.update(&s, &TreatmentGlobals::default(), &t, &Fixed);
+        let [Command::Redeliver { words: w, .. }] = &cmds[..] else { panic!() };
+        // 1.2 m × 166.67 = 200; 0.4 s → 400; 0.25 s → 250.
+        assert_eq!((w[0], w[3], w[4], w[7], w[8], w[9], w[10], w[14]), (1002, 65535, 4096, 400, 250, 200, 500, 1));
+        assert_eq!((w[11], w[12], w[13]), (0, 0, 0));
+        // The height word saturates at 1000 (6 m); the time words at 10000.
+        let s = AudioState { jump_height: 9.0, air_time: 20.0, ..s };
+        let cmds = k.update(&s, &TreatmentGlobals { flag_16: true, value_24: 0.5, flag_164: true, value_168: 1.0 }, &t, &Fixed);
+        let [Command::Redeliver { words: w, .. }] = &cmds[..] else { panic!() };
+        assert_eq!((w[7], w[9], w[11], w[12], w[13]), (10000, 1000, 500, 1, 10000));
+    }
+
+    #[test]
+    fn the_slow_motion_companion_follows_mode_and_time_scale() {
+        let t = TreatmentTuning::default();
+        let mut k = Treatment::default();
+        let mut s = AudioState::default();
+        let slo = Globals { flags_96: SLO_MO_BIT, mode_1060: 7 };
+        k.process(&s, &t, &slo, &Fixed);
+        s.time_scale = 0.25;
+        let cmds = k.process(&s, &t, &slo, &Fixed);
+        let [Command::Post { slot: Slot::HomSloMo, class, words }] = &cmds[..] else { panic!("{cmds:?}") };
+        assert_eq!((*class, words[10], words[14]), ("hall_of_meat_slo_mo", 1003, 0));
+        s.time_scale = 1.0;
+        assert_eq!(k.process(&s, &t, &slo, &Fixed), vec![Command::Release { slot: Slot::HomSloMo }]);
+        let hom = Globals { flags_96: 0, mode_1060: 9 };
+        let cmds = k.process(&s, &t, &hom, &Fixed);
+        let [Command::Post { words, .. }] = &cmds[..] else { panic!() };
+        assert_eq!(words[14], 2);
+        s.com_velocity = [20.0, 0.0, 0.0];
+        let up = k.update(&s, &TreatmentGlobals::default(), &t, &Fixed);
+        let Command::Redeliver { slot: Slot::HomSloMo, words } = &up[1] else { panic!() };
+        assert_eq!((words[0], words[7], words[8], words[10], words[12], words[13]), (32767, 1004, 1005, 1003, 5000, 1006));
+    }
+}
diff --git a/crates/skate-audio/src/player/tricks.rs b/crates/skate-audio/src/player/tricks.rs
new file mode 100644
index 00000000..67f23c35
--- /dev/null
+++ b/crates/skate-audio/src/player/tricks.rs
@@ -0,0 +1,338 @@
+//! The Tricks component (component vtable `0x822FC7B8`, owner = the Tricks controller
+//! `0x40010050`): the trick whoosh `Class_Flips` (`Sk8_Air_Flip_Tricks.abk`) and the two clothing
+//! rustles `cloth_trick` (`Foley_Cloth.abk`). Written from our reading of the retail code (TU3,
+//! reference only); spec `.claude/notes/aems-tricks-treatment-spec.md`.
+//!
+//! - constructor `sub_824CBD98`: `+48..+60` = −1 (last trick id, flips id, cloth id, second id),
+//!   `+64` / `+68` / `+84` = 0.0, `+72` = 0, the held objects `+36` / `+40` / `+44` empty;
+//! - process `sub_824CBEB0(dt)`, only for the local player (`[this+28]+72`): `+60 := +352` while
+//!   `+348 ≠ −1`; the flip poster `sub_824CBFB8`; cloth A `sub_824CC590`; cloth B `sub_824CC680`;
+//!   `+48 := +348`; `+68` counts down by dt to 0; the slew `sub_824CD170`; `sub_824CD390` (game
+//!   events 24685…24697 to the trick-event system, no audio: not modelled);
+//! - update `sub_824CBF78`: the flip keep/rewrite `sub_824CC7D8`, cloth A `sub_824CCE48`, cloth B
+//!   `sub_824CCFE8`.
+//!
+//! When retail posts (recomp session 164620, 65 Class_Flips / 50 + 31 cloth_trick posts): cloth A
+//! as soon as the scorable's audio trick (`+348`) is set — about 215 ms (13 frames) before the
+//! board leaves the ground; Class_Flips on the first frame in the air (`+332`) with the trick active
+//! (`+343`), one frame (median 16.7 ms) after the pop's jump-velocity write; it is held while in the
+//! air with the same trick and released at the landing (or rewritten for a new trick in the air);
+//! cloth B when `+348` returns to −1 (the trick's end), held for as long as the trick lasted.
+use super::globals::Globals;
+use super::{AudioState, Outputs, trunc_clamp};
+use crate::player::components::{Command, Slot};
+
+pub const FLIPS: &str = "Class_Flips";
+pub const CLOTH: &str = "cloth_trick";
+/// The banks the component posts into. `Foley_Cloth`'s `c_foley_utility` is posted once at boot
+/// in retail (session posts: object 20 once), like `c_emitter_utility`.
+pub const BANKS: &[&str] = &["Sk8_Air_Flip_Tricks", "Foley_Cloth"];
+pub const FOLEY_UTILITY: &str = "c_foley_utility";
+
+const FLIP_WORDS: usize = 28;
+const CLOTH_WORDS: usize = 11;
+/// `0x82256FE8` 1000.0 and `0x820BD5C4` 500.0 (the time-scale word).
+const THOUSAND: f32 = f32::from_bits(0x447A_0000);
+const TIME_SCALE_WORD: f32 = f32::from_bits(0x43FA_0000);
+
+/// Vault words: the audio tuning holder `*(0x830CFDA4)+72` = class `0xC1831BDB6CB1B1EA` collection
+/// `tricks` (`0x1FA8AC006CABEF59`), the slew collection `0x47EC76B4F9FC79F6` of the same class
+/// (`sub_824CD170`), and eEQChain (`*(0x830CFDA4)+140` = class `0x42AFE160E647167C` `default`).
+/// Defaults: the user's vault.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct TricksTuning {
+    /// Per deck axis (`+480` Ri, `+484` Up, `+488` At) the spin word threshold (int; below it the
+    /// word is 0) and divisor (rad/s → 1000): Ri `5C73CF6A0D50C8D8` = 297 / `1494BB20854C155C` = 3.0,
+    /// Up `EE157886DE5D3C97` = 703 / `02D39586635FB1A3` = 4.4, At `9A0316625B63CD99` = 603 /
+    /// `8EDBACCBA6FE46AD` = 10.2.
+    pub spin_threshold: [i32; 3],
+    pub spin_divisor: [f32; 3],
+    /// Class_Flips w17 `99E6FF024834E4C7` = 27646, w18 `D2D0EBAC43842F6D` = 14848, w19
+    /// `13C155A181A55BA4` = 6656, w21 `B565D4D763128252` = 10000.
+    pub levels: [i32; 4],
+    /// The slew targets by `G+96` bit 15 / 14 / 13 (`B601DFAB3AF7DE66` = 250, `08441EA8E8019665` =
+    /// 700, `36F8D12486A929D1` = 1000) and its rates per second down `6B57BD44C0E0B267` = 1000.0 and
+    /// up `57AED5FBC374D8F1` = 10000.0.
+    pub slew_targets: [i32; 3],
+    pub slew_down: f32,
+    pub slew_up: f32,
+    /// eEQChain `D9BE1F2F1A72FEE8` (Class_Flips w27) = 6, `4B6E2D79A8452D9B` (cloth_trick w10) = 0.
+    pub flips_eq: i32,
+    pub cloth_eq: i32,
+}
+
+impl Default for TricksTuning {
+    fn default() -> Self {
+        Self {
+            spin_threshold: [297, 703, 603],
+            spin_divisor: [f32::from_bits(0x4040_0000), f32::from_bits(0x408C_CCCD), f32::from_bits(0x4123_3333)],
+            levels: [27646, 14848, 6656, 10000],
+            slew_targets: [250, 700, 1000],
+            slew_down: 1000.0,
+            slew_up: 10000.0,
+            flips_eq: 6,
+            cloth_eq: 0,
+        }
+    }
+}
+
+/// The audio trick ids Class_Flips is never posted for: none, 35 and 36 (grabs, coffin).
+const NO_FLIPS: [i32; 3] = [-1, 35, 36];
+/// The flip id while the off-board hold has run out on the ground (`+310`).
+const OFFBOARD_TRICK: i32 = 34;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Tricks {
+    flips: Option<Vec<i32>>,
+    cloth_a: Option<Vec<i32>>,
+    cloth_b: Option<Vec<i32>>,
+    /// `+48` last frame's `+348`, `+52` the posted flip id, `+56` cloth A's id, `+60` the latched
+    /// `+352`.
+    last_id: i32,
+    flips_id: i32,
+    cloth_a_id: i32,
+    id_352: i32,
+    /// `+64` the running trick's time, `+68` cloth B's remaining time.
+    trick_time: f32,
+    cloth_b_time: f32,
+    /// `+72` the slewed w12.
+    slew: i32,
+}
+
+impl Default for Tricks {
+    fn default() -> Self {
+        Self {
+            flips: None,
+            cloth_a: None,
+            cloth_b: None,
+            last_id: -1,
+            flips_id: -1,
+            cloth_a_id: -1,
+            id_352: -1,
+            trick_time: 0.0,
+            cloth_b_time: 0.0,
+            slew: 0,
+        }
+    }
+}
+
+/// One spin word of the deck's angular velocity about an axis: trunc(|v| / divisor × 1000), capped
+/// at 1000, then 0 below the threshold (retail's subf / xoris / addc / subfe select).
+pub fn spin_word(v: f32, divisor: f32, threshold: i32) -> i32 {
+    let x = trunc_clamp((v.abs() / divisor) * THOUSAND, i32::MIN, i32::MAX).min(1000);
+    let carry = (u64::from(x.wrapping_sub(threshold) as u32) + u64::from(threshold as u32 ^ 0x8000_0000)) >> 32;
+    if carry != 0 { 0 } else { x }
+}
+
+/// The time-scale word (w10 of Class_Flips and Class_Treatment): trunc(`+220` × 500), 0..1000.
+pub fn time_scale_word(s: &AudioState) -> i32 {
+    trunc_clamp(s.time_scale * TIME_SCALE_WORD, i32::MIN, i32::MAX).clamp(0, 1000)
+}
+
+fn cloth_words(id: i32, eq: i32) -> Vec<i32> {
+    // sub_824B71C0.
+    let mut w = vec![0i32; CLOTH_WORDS];
+    w[2] = 4096;
+    w[4] = 25000;
+    w[8] = 1;
+    w[9] = id.clamp(0, 40);
+    w[10] = eq.clamp(0, 32767);
+    w
+}
+
+impl Tricks {
+    fn spins(s: &AudioState, t: &TricksTuning) -> [i32; 3] {
+        let v = [s.deck_spin_xy[0], s.deck_spin_xy[1], s.deck_spin];
+        std::array::from_fn(|i| spin_word(v[i], t.spin_divisor[i], t.spin_threshold[i]))
+    }
+
+    /// `+310` on the ground for the local player: the flip id becomes 34.
+    fn offboard(s: &AudioState) -> bool {
+        !s.airborne && s.local && s.offboard_310
+    }
+
+    /// `sub_824CBFB8` + the constructor `sub_824AFAD8`.
+    fn flip_poster(&mut self, s: &AudioState, t: &TricksTuning, out: &dyn Outputs, cmds: &mut Vec<Command>) {
+        let off = Self::offboard(s);
+        let go = if s.airborne { s.trick_active } else { off };
+        if !go || self.flips.is_some() {
+            return;
+        }
+        self.flips_id = if off { OFFBOARD_TRICK } else { s.audio_trick };
+        if NO_FLIPS.contains(&self.flips_id) {
+            return;
+        }
+        let [x, y, z] = Self::spins(s, t);
+        let mut w = vec![0i32; FLIP_WORDS];
+        w[1] = 32767;
+        w[4] = 4096;
+        w[5] = 25000;
+        w[7] = z.clamp(0, 1000);
+        w[8] = y.clamp(0, 1000);
+        w[9] = x.clamp(0, 1000);
+        w[10] = time_scale_word(s);
+        w[11] = self.flips_id.clamp(0, 40);
+        w[16] = i32::from(!s.global_224);
+        w[17] = t.levels[0].clamp(0, 32767);
+        w[18] = t.levels[1].clamp(0, 32767);
+        w[19] = t.levels[2].clamp(0, 32767);
+        w[21] = t.levels[3].clamp(0, 32767);
+        w[23] = 0; // bool class 0x11A631878B239355 (global setting, not modelled)
+        w[24] = i32::from(s.local); // local && [[owner+16]+64] == 0
+        w[25] = i32::from(s.local);
+        w[26] = if s.local { out.level(6).clamp(0, 32767) } else { 0 };
+        w[27] = t.flips_eq.clamp(0, 32767);
+        cmds.push(Command::Post { slot: Slot::Flips, class: FLIPS, words: w.clone() });
+        self.flips = Some(w);
+    }
+
+    /// `sub_824CC590`: cloth A follows `+348` (a new id releases it; the next frame posts again).
+    fn cloth_a(&mut self, id: i32, t: &TricksTuning, cmds: &mut Vec<Command>) {
+        if id == -1 {
+            return;
+        }
+        if self.cloth_a.is_none() {
+            let w = cloth_words(id, t.cloth_eq);
+            cmds.push(Command::Post { slot: Slot::Cloth(0), class: CLOTH, words: w.clone() });
+            self.cloth_a = Some(w);
+            self.cloth_a_id = id;
+        } else if id != self.cloth_a_id {
+            self.cloth_a = None;
+            cmds.push(Command::Release { slot: Slot::Cloth(0) });
+        }
+    }
+
+    /// `sub_824CC680`: cloth B with the latched second id when the trick ends, held for the
+    /// trick's duration.
+    fn cloth_b(&mut self, id: i32, dt: f32, t: &TricksTuning, cmds: &mut Vec<Command>) {
+        let mut ended = false;
+        if id != -1 {
+            self.trick_time += dt;
+        } else if self.last_id != -1 {
+            self.cloth_b_time = self.trick_time;
+            self.trick_time = 0.0;
+            ended = true;
+        }
+        if self.cloth_b_time > 0.0 {
+            if self.id_352 == -1 || !ended {
+                return;
+            }
+            if self.cloth_b.take().is_some() {
+                cmds.push(Command::Release { slot: Slot::Cloth(1) });
+            }
+            let w = cloth_words(self.id_352, t.cloth_eq);
+            cmds.push(Command::Post { slot: Slot::Cloth(1), class: CLOTH, words: w.clone() });
+            self.cloth_b = Some(w);
+        } else if self.cloth_b.take().is_some() {
+            cmds.push(Command::Release { slot: Slot::Cloth(1) });
+        }
+    }
+
+    /// `sub_824CD170`: w12 slews toward the `G+96` target (down 1000/s, up 10000/s; 0 with dt ≤ 0).
+    fn slew(&mut self, dt: f32, t: &TricksTuning, g: &Globals) {
+        if dt <= 0.0 {
+            self.slew = 0;
+            return;
+        }
+        let target = if g.slew_full() {
+            t.slew_targets[2]
+        } else {
+            super::globals::SLEW_BITS.iter().position(|&b| g.flags_96 & b != 0).map_or(0, |i| t.slew_targets[i])
+        };
+        let down = trunc_clamp(t.slew_down * dt, i32::MIN, i32::MAX);
+        let up = trunc_clamp(t.slew_up * dt, i32::MIN, i32::MAX);
+        let cur = self.slew;
+        self.slew = if target < cur {
+            if cur - target > down { cur - down } else { target }
+        } else if target > cur && target - cur > up {
+            cur + up
+        } else {
+            target
+        };
+    }
+
+    /// Process (before the MixMap tick), `sub_824CBEB0`. `out` = the Tricks owner's outputs.
+    pub fn process(&mut self, s: &AudioState, t: &TricksTuning, g: &Globals, out: &dyn Outputs) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        if !s.local {
+            return cmds;
+        }
+        let id = s.audio_trick;
+        if id != -1 {
+            self.id_352 = s.audio_trick_2;
+        }
+        self.flip_poster(s, t, out, &mut cmds);
+        self.cloth_a(id, t, &mut cmds);
+        self.cloth_b(id, s.dt, t, &mut cmds);
+        self.last_id = id;
+        self.cloth_b_time = if self.cloth_b_time > 0.0 { self.cloth_b_time - s.dt } else { 0.0 };
+        self.slew(s.dt, t, g);
+        cmds
+    }
+
+    fn cloth_update(w: &mut [i32], out: &dyn Outputs) {
+        w[0] = 32767;
+        w[4] = 25000;
+        w[5] = 0;
+        w[6] = 0;
+        w[7] = out.level(4).clamp(0, 32767);
+        w[1] = out.raw(0).clamp(0, 65535);
+        w[2] = out.pitch(5).clamp(0, 8192);
+    }
+
+    /// Update (after the tick), `sub_824CBF78`.
+    pub fn update(&mut self, s: &AudioState, t: &TricksTuning, out: &dyn Outputs) -> Vec<Command> {
+        let mut cmds = Vec::new();
+        // sub_824CC7D8: keep the flip while in the air (or off board) with the same id.
+        let off = Self::offboard(s);
+        let id = if off { OFFBOARD_TRICK } else { s.audio_trick };
+        if !(s.airborne || off) || id != self.flips_id {
+            if self.flips.take().is_some() {
+                cmds.push(Command::Release { slot: Slot::Flips });
+            }
+        } else if let Some(w) = self.flips.as_mut() {
+            let [x, y, z] = Self::spins(s, t);
+            w[9] = x.clamp(0, 1000);
+            w[8] = y.clamp(0, 1000);
+            w[7] = z.clamp(0, 1000);
+            w[10] = time_scale_word(s);
+            w[4] = out.pitch(2).clamp(0, 8192);
+            w[0] = out.level(1).clamp(0, 32767);
+            w[3] = out.raw(0).clamp(0, 65536);
+            w[1] = 32767;
+            w[2] = 0;
+            w[5] = out.level(3).clamp(0, 25000);
+            w[6] = 0;
+            w[16] = i32::from(!s.global_224);
+            w[26] = if s.local { out.level(6).clamp(0, 32767) } else { 0 };
+            w[20] = out.level(8).clamp(0, 32767);
+            w[22] = out.level(7).clamp(0, 32767);
+            w[12] = self.slew.clamp(0, 1000);
+            cmds.push(Command::Redeliver { slot: Slot::Flips, words: w.clone() });
+        }
+        // sub_824CCE48: cloth A ends with a bail, or with no trick on the ground.
+        if self.cloth_a.is_some() {
+            if s.bail || (s.audio_trick == -1 && !s.airborne) {
+                self.cloth_a = None;
+                cmds.push(Command::Release { slot: Slot::Cloth(0) });
+            } else if let Some(w) = self.cloth_a.as_mut() {
+                Self::cloth_update(w, out);
+                cmds.push(Command::Redeliver { slot: Slot::Cloth(0), words: w.clone() });
+            }
+        }
+        // sub_824CCFE8: cloth B ends with a bail (or its time, in the process).
+        if self.cloth_b.is_some() {
+            if s.bail {
+                self.cloth_b = None;
+                cmds.push(Command::Release { slot: Slot::Cloth(1) });
+            } else if let Some(w) = self.cloth_b.as_mut() {
+                Self::cloth_update(w, out);
+                cmds.push(Command::Redeliver { slot: Slot::Cloth(1), words: w.clone() });
+            }
+        }
+        cmds
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/skate-audio/src/player/tricks/tests.rs b/crates/skate-audio/src/player/tricks/tests.rs
new file mode 100644
index 00000000..da1faee4
--- /dev/null
+++ b/crates/skate-audio/src/player/tricks/tests.rs
@@ -0,0 +1,192 @@
+use super::*;
+
+struct Fixed;
+impl Outputs for Fixed {
+    fn level(&self, id: usize) -> i32 {
+        1000 + id as i32
+    }
+    fn raw(&self, _: usize) -> i32 {
+        70000
+    }
+    fn pitch(&self, id: usize) -> i32 {
+        4000 + id as i32
+    }
+}
+
+fn kickflip(airborne: bool) -> AudioState {
+    AudioState { airborne, trick_active: true, audio_trick: 0, audio_trick_2: 28, ..Default::default() }
+}
+
+fn posts(cmds: &[Command]) -> Vec<(Slot, &'static str)> {
+    cmds.iter().filter_map(|c| if let Command::Post { slot, class, .. } = c { Some((*slot, *class)) } else { None }).collect()
+}
+
+fn releases(cmds: &[Command]) -> Vec<Slot> {
+    cmds.iter().filter_map(|c| if let Command::Release { slot } = c { Some(*slot) } else { None }).collect()
+}
+
+#[test]
+fn spin_words_scale_cap_and_gate() {
+    let t = TricksTuning::default();
+    // Ri: |v| / 3 × 1000, 0 below 297.
+    assert_eq!(spin_word(1.0, t.spin_divisor[0], t.spin_threshold[0]), 333);
+    assert_eq!(spin_word(-1.0, t.spin_divisor[0], t.spin_threshold[0]), 333);
+    assert_eq!(spin_word(0.8, t.spin_divisor[0], t.spin_threshold[0]), 0);
+    assert_eq!(spin_word(0.891, t.spin_divisor[0], t.spin_threshold[0]), 297, "the threshold itself passes");
+    assert_eq!(spin_word(40.0, t.spin_divisor[0], t.spin_threshold[0]), 1000);
+    // Up 4.4 / 703, At 10.2 / 603.
+    assert_eq!(spin_word(4.0, t.spin_divisor[1], t.spin_threshold[1]), 909);
+    assert_eq!(spin_word(3.0, t.spin_divisor[1], t.spin_threshold[1]), 0);
+    assert_eq!(spin_word(7.0, t.spin_divisor[2], t.spin_threshold[2]), 686);
+}
+
+#[test]
+fn class_flips_posts_in_the_air_with_the_retail_words() {
+    let (t, g) = (TricksTuning::default(), Globals::default());
+    let mut k = Tricks::default();
+    // On the ground with the trick registered: only cloth A.
+    let cmds = k.process(&kickflip(false), &t, &g, &Fixed);
+    assert_eq!(posts(&cmds), vec![(Slot::Cloth(0), "cloth_trick")]);
+    let Command::Post { words, .. } = &cmds[0] else { panic!() };
+    assert_eq!(words[..], [0, 0, 4096, 0, 25000, 0, 0, 0, 1, 0, 0]);
+    // First air frame: Class_Flips.
+    let mut s = kickflip(true);
+    s.deck_spin_xy = [6.0, 0.5];
+    s.deck_spin = 7.0;
+    let cmds = k.process(&s, &t, &g, &Fixed);
+    assert_eq!(posts(&cmds), vec![(Slot::Flips, "Class_Flips")]);
+    let Command::Post { words, .. } = &cmds[0] else { panic!() };
+    #[rustfmt::skip]
+    let want = [0, 32767, 0, 0, 4096, 25000, 0, 686, 0, 1000, 500, 0, 0, 0, 0, 0, 1, 27646, 14848, 6656, 0, 10000, 0, 0, 1, 1, 1006, 6];
+    assert_eq!(words[..], want);
+    // Held through the air: no repost, the update rewrites it.
+    assert!(posts(&k.process(&s, &t, &g, &Fixed)).is_empty());
+    let up = k.update(&s, &t, &Fixed);
+    let Command::Redeliver { slot: Slot::Flips, words: w } = &up[0] else { panic!("{up:?}") };
+    assert_eq!((w[0], w[1], w[2], w[3], w[4], w[5], w[6]), (1001, 32767, 0, 65536, 4002, 1003, 0));
+    assert_eq!((w[12], w[20], w[22], w[26]), (0, 1008, 1007, 1006));
+    let Command::Redeliver { slot: Slot::Cloth(0), words: c } = &up[1] else { panic!("{up:?}") };
+    assert_eq!((c[0], c[1], c[2], c[4], c[7]), (32767, 65535, 4005, 25000, 1004));
+    // Landing: released by the update.
+    let land = AudioState { airborne: false, ..s };
+    k.process(&land, &t, &g, &Fixed);
+    assert!(releases(&k.update(&land, &t, &Fixed)).contains(&Slot::Flips));
+}
+
+#[test]
+fn grabs_none_and_coffin_post_no_flip_and_a_new_trick_reposts() {
+    let (t, g) = (TricksTuning::default(), Globals::default());
+    for id in [-1, 35, 36] {
+        let mut k = Tricks::default();
+        let s = AudioState { audio_trick: id, ..kickflip(true) };
+        assert!(!posts(&k.process(&s, &t, &g, &Fixed)).contains(&(Slot::Flips, "Class_Flips")));
+    }
+    // Ollie (28) does post; the trick turning into another one in the air releases and reposts.
+    let mut k = Tricks::default();
+    let s = AudioState { audio_trick: 28, ..kickflip(true) };
+    assert!(posts(&k.process(&s, &t, &g, &Fixed)).contains(&(Slot::Flips, "Class_Flips")));
+    let s2 = AudioState { audio_trick: 10, ..s };
+    let cmds = k.process(&s2, &t, &g, &Fixed);
+    assert_eq!(releases(&cmds), vec![Slot::Cloth(0)], "cloth A releases on the new id");
+    assert_eq!(releases(&k.update(&s2, &t, &Fixed)), vec![Slot::Flips]);
+    let cmds = k.process(&s2, &t, &g, &Fixed);
+    assert_eq!(posts(&cmds), vec![(Slot::Flips, "Class_Flips"), (Slot::Cloth(0), "cloth_trick")]);
+    let Command::Post { words, .. } = &cmds[0] else { panic!() };
+    assert_eq!(words[11], 10);
+    // Without +343 a new flip is not posted in the air.
+    let mut k = Tricks::default();
+    let s = AudioState { trick_active: false, ..kickflip(true) };
+    assert!(!posts(&k.process(&s, &t, &g, &Fixed)).iter().any(|p| p.0 == Slot::Flips));
+}
+
+#[test]
+fn cloth_b_plays_the_second_id_for_the_tricks_duration() {
+    let (t, g) = (TricksTuning::default(), Globals::default());
+    let mut k = Tricks::default();
+    // 20 frames of trick (1/3 s), then the trick ends.
+    for f in 0..20 {
+        let s = kickflip(f > 2);
+        k.process(&s, &t, &g, &Fixed);
+        k.update(&s, &t, &Fixed);
+    }
+    let end = AudioState { airborne: false, ..Default::default() };
+    let cmds = k.process(&end, &t, &g, &Fixed);
+    assert_eq!(posts(&cmds), vec![(Slot::Cloth(1), "cloth_trick")]);
+    let Command::Post { words, .. } = &cmds[0] else { panic!() };
+    assert_eq!(words[9], 28, "the latched +352");
+    let up = k.update(&end, &t, &Fixed);
+    assert!(releases(&up).contains(&Slot::Cloth(0)), "cloth A ends with the trick on the ground");
+    // Held for the trick's 20 frames, then released by the process.
+    let mut held = 1;
+    loop {
+        let cmds = k.process(&end, &t, &g, &Fixed);
+        if releases(&cmds).contains(&Slot::Cloth(1)) {
+            break;
+        }
+        k.update(&end, &t, &Fixed);
+        held += 1;
+        assert!(held < 40);
+    }
+    // 20 frames of dt summed up, then counted down in f32: a residue above 0 keeps it one more frame.
+    assert_eq!(held, 21);
+    // An ollie's second id is −1: no cloth B.
+    let mut k = Tricks::default();
+    let ollie = AudioState { audio_trick: 28, audio_trick_2: -1, ..kickflip(true) };
+    for _ in 0..10 {
+        k.process(&ollie, &t, &g, &Fixed);
+    }
+    assert!(posts(&k.process(&end, &t, &g, &Fixed)).is_empty());
+}
+
+#[test]
+fn a_bail_releases_both_cloths() {
+    let (t, g) = (TricksTuning::default(), Globals::default());
+    let mut k = Tricks::default();
+    for _ in 0..5 {
+        k.process(&kickflip(true), &t, &g, &Fixed);
+    }
+    let end = AudioState::default();
+    k.process(&end, &t, &g, &Fixed);
+    let bail = AudioState { bail: true, ..Default::default() };
+    let r = releases(&k.update(&bail, &t, &Fixed));
+    assert!(r.contains(&Slot::Cloth(0)) && r.contains(&Slot::Cloth(1)), "{r:?}");
+}
+
+#[test]
+fn the_offboard_hold_posts_trick_34_on_the_ground() {
+    let (t, g) = (TricksTuning::default(), Globals::default());
+    let mut k = Tricks::default();
+    let s = AudioState { offboard_310: true, ..Default::default() };
+    let cmds = k.process(&s, &t, &g, &Fixed);
+    let Command::Post { slot: Slot::Flips, words, .. } = &cmds[0] else { panic!("{cmds:?}") };
+    assert_eq!(words[11], 34);
+    assert!(releases(&k.update(&s, &t, &Fixed)).is_empty());
+    assert_eq!(releases(&k.update(&AudioState::default(), &t, &Fixed)), vec![Slot::Flips]);
+}
+
+#[test]
+fn the_slew_follows_the_global_bits() {
+    let t = TricksTuning::default();
+    let mut k = Tricks::default();
+    let s = kickflip(true);
+    // No bit (free skate): 0.
+    k.process(&s, &t, &Globals::default(), &Fixed);
+    assert_eq!(k.slew, 0);
+    // Bit 14 → 700, rising 10000/s = 166 per frame.
+    let g = Globals { flags_96: 0x4000, mode_1060: 7 };
+    let mut seen = Vec::new();
+    for _ in 0..6 {
+        k.process(&s, &t, &g, &Fixed);
+        seen.push(k.slew);
+    }
+    assert_eq!(seen, [166, 332, 498, 664, 700, 700]);
+    // Back to 0 at 1000/s = 16 per frame; mode 8 slews to 1000.
+    k.process(&s, &t, &Globals::default(), &Fixed);
+    assert_eq!(k.slew, 684);
+    let mut k = Tricks::default();
+    k.process(&s, &t, &Globals { flags_96: 0, mode_1060: 8 }, &Fixed);
+    assert_eq!(k.slew, 166);
+    let up = k.update(&s, &t, &Fixed);
+    let Command::Redeliver { words, .. } = &up[0] else { panic!() };
+    assert_eq!(words[12], 166);
+}
diff --git a/crates/skate-audio/src/player/tuning.rs b/crates/skate-audio/src/player/tuning.rs
new file mode 100644
index 00000000..7ddb4c1b
--- /dev/null
+++ b/crates/skate-audio/src/player/tuning.rs
@@ -0,0 +1,227 @@
+//! Vault tuning the player components read (exported by setup into the manifest's
+//! `player_tuning`; `tools/asset_pipeline/audio_export.py` `player_tuning`). Every table is
+//! optional: a missing one leaves its input or word at the retail default named in the docs.
+
+/// One `Sk8::Audio::eJitterParams` channel of `SFXObj_Jitter` (class `0x0AB9F005A2C8FBC7`, one
+/// leaf collection each, fields resolved through `default`).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct JitterParams {
+    /// Field `0x8F956FBAD301AE26`: the channel writes its value to the Jitter controller.
+    pub enabled: bool,
+    /// Field `0xE7D491E2EB228F54`: the controller input id.
+    pub id: usize,
+    /// Field `0xB66AAD957873A8B3`: centre, range, largest and smallest velocity step.
+    pub centre: f32,
+    pub range: f32,
+    pub max_step: f32,
+    pub min_step: f32,
+}
+
+/// A seam pattern's gain wobble (class `0x7242F32831ED3332`, collections `hash64(name)` of
+/// spidercrack … special_2 = patterns 1..15, index 0 = `default`): gain low / high (fields
+/// `0xFA3A57801765A2F8` / `0x32A9692F1B826274`) and duration low / high in ms
+/// (`0xF713CB547B1DF920` / `0x0608B3129FF81F12`).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SeamWobble {
+    pub gain_low: f32,
+    pub gain_high: f32,
+    pub ms_low: i32,
+    pub ms_high: i32,
+}
+
+impl Default for SeamWobble {
+    fn default() -> Self {
+        Self { gain_low: 1.0, gain_high: 1.0, ms_low: 0, ms_high: 0 }
+    }
+}
+
+/// One grind surface's levels (class `0x049861E8F9A8D16B`, collection from the image's key table
+/// at `0x82249F90` by grind surface 0..13): per layer 0..3 the post level V (fields
+/// `0x0ECECDAC28B2B979`, `0x58070BF511809903`, `0x72BA0780A8FA25D6`, `0x721A50C80028AD69`) and
+/// the update factor F on Rail level(1) (`0x69969AF1BE6BB367`, `0x0555484D6D4A3128`,
+/// `0xC21983A2160ED3AC`, `0x69A5FC53091ED1F8`). Missing fields read 1.0 (the image's default).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct GrindSurface {
+    pub v: [f32; 4],
+    pub f: [f32; 4],
+}
+
+impl Default for GrindSurface {
+    fn default() -> Self {
+        Self { v: [1.0; 4], f: [1.0; 4] }
+    }
+}
+
+/// A seam pattern record for `Class_Seams` (class `0x7242F32831ED3332`, collections as
+/// [`SeamWobble`]): +0 gain (w16), +4 grid angle (degrees), +8 grid z, +12 grid x, +16 class (w13),
+/// and the attributes mode (`CA81764BF5A85E34`: 0 none, 1 grid, 2 distance), minimum frames
+/// between hits (`DAE803A0CBD286D1`), speed threshold (`F7BCA67F0A1FC92E`, m/s of `+208`),
+/// distance spacing (`A3BC1976039FA00A`) and level (`2F29F40384863C8C`, w18).
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct SeamPattern {
+    pub gain: f32,
+    pub angle: i32,
+    pub grid_z: f32,
+    pub grid_x: f32,
+    pub class: i32,
+    pub mode: i32,
+    pub min_frames: i32,
+    pub speed_threshold: f32,
+    pub spacing: f32,
+    pub level: f32,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct PlayerTuning {
+    /// `Sk8::AudioSurfaceMap` (holder `0xC1831BDB6CB1B1EA` / `0xC489459A0C07D154`, field
+    /// `0x4CA607558B1CF440`): 95 entries of 18 words, by material (≥ 94 → entry 94). Word 1 (+4)
+    /// rolling surface, 3 (+12) skid, 4 (+16) grind surface, 5 (+20) foot drag, 8 (+32) seams, 9 (+36)
+    /// seams transition, 10 (+40) body slide.
+    pub surface_table: Vec<[i32; 18]>,
+    pub jitter: Vec<JitterParams>,
+    pub seam_wobbles: Vec<SeamWobble>,
+    /// Grind surfaces 0..13.
+    pub grind: Vec<GrindSurface>,
+    /// Materials whose AudioSurface collection (class `0xD40CB4C0FFE45676`) sets the landing flag
+    /// `0x1EBF9D2EB0DD56BA` (Contacts input 6). Needs the TU3 image's material key table
+    /// (`0x8302D6E8`); empty when the install was set up without it.
+    pub landing_materials: Vec<u32>,
+    /// Class `0xC26949FCB638A2CA` `default`: the per-wheel landing bucket thresholds on the stored
+    /// air factor (fields `0x6D3D91A9BA7ADCDC` = 0.5 → bucket 2, `0x2A70BB8A382574E4` = 0.31 → 1).
+    pub wheel_bucket_high: f32,
+    pub wheel_bucket_low: f32,
+    /// eSk8AudioTricks (class `0x6918469984A8C596`, field `0x8C3025DB4D1761AF`): the audio trick id
+    /// (state `+348`) by collection key = [`name_hash`] of the lowercase scorable name.
+    pub audio_tricks: std::collections::HashMap<u64, i32>,
+    /// The collision manager's material table (`audio_export.collision_tuning`); empty: the
+    /// collision contacts stay silent.
+    pub collision: super::collision::CollisionTuning,
+    /// `Class_Seams` patterns: index 0 = `default`, 1..15 = spidercrack … special_2.
+    pub seam_patterns: Vec<SeamPattern>,
+    /// The pattern holder's `default` field `1911176187FB9B1F`: the grid scale on rolling surface 3
+    /// for class-10 patterns (`sub_824C1CA0`), 1.0 without it.
+    pub seam_surface3_scale: f32,
+    /// The jitter channels (indices into [`PlayerTuning::jitter`]) that the jittered eEQChain
+    /// buses 5–7 read (`sub_82491180`): PI20#1 freq `E17029CE4388E1E8`, gain `C27373E7FD2DCE47`,
+    /// Q `EA2ED27D25247927`, PI20#2 freq `816A58ECCCD4112D`, gain `8802BC5475904597`, Q
+    /// `D4ED2F0BA77ACAB5`.
+    pub eq_jitter: [Option<usize>; 6],
+    /// The board's rolling layers (`player::rolling`: Class_rolling speeds, rattle, board slide).
+    pub rolling: super::rolling::RollingTuning,
+    /// The scorable class's second audio trick field `0xA2C5C22C5BE725F8` (state `+352`), keyed
+    /// like [`PlayerTuning::audio_tricks`].
+    pub audio_tricks_2: std::collections::HashMap<u64, i32>,
+    /// The Tricks component's vault words (`player::tricks`).
+    pub tricks: super::tricks::TricksTuning,
+    /// `Class_Treatment`'s vault words (`player::treatment`).
+    pub treatment: super::treatment::TreatmentTuning,
+}
+
+/// The jitter keys of [`PlayerTuning::eq_jitter`], in order.
+pub const EQ_JITTER_KEYS: [u64; 6] =
+    [0xE170_29CE_4388_E1E8, 0xC273_73E7_FD2D_CE47, 0xEA2E_D27D_2524_7927, 0x816A_58EC_CCD4_112D, 0x8802_BC54_7590_4597, 0xD4ED_2F0B_A77A_CAB5];
+
+impl Default for PlayerTuning {
+    fn default() -> Self {
+        Self {
+            surface_table: Vec::new(),
+            jitter: Vec::new(),
+            seam_wobbles: Vec::new(),
+            grind: Vec::new(),
+            landing_materials: Vec::new(),
+            wheel_bucket_high: 0.5,
+            wheel_bucket_low: f32::from_bits(0x3E9E_B852),
+            audio_tricks: Default::default(),
+            collision: Default::default(),
+            seam_patterns: Vec::new(),
+            seam_surface3_scale: 1.0,
+            eq_jitter: [None; 6],
+            rolling: Default::default(),
+            audio_tricks_2: Default::default(),
+            tricks: Default::default(),
+            treatment: Default::default(),
+        }
+    }
+}
+
+/// The vault's name hash (Bob Jenkins' lookup8, public domain; level 0xABCDEF0011223344).
+pub fn name_hash(bytes: &[u8]) -> u64 {
+    fn mix(a: &mut u64, b: &mut u64, c: &mut u64) {
+        *a = a.wrapping_sub(*b).wrapping_sub(*c) ^ (*c >> 43);
+        *b = b.wrapping_sub(*c).wrapping_sub(*a) ^ (*a << 9);
+        *c = c.wrapping_sub(*a).wrapping_sub(*b) ^ (*b >> 8);
+        *a = a.wrapping_sub(*b).wrapping_sub(*c) ^ (*c >> 38);
+        *b = b.wrapping_sub(*c).wrapping_sub(*a) ^ (*a << 23);
+        *c = c.wrapping_sub(*a).wrapping_sub(*b) ^ (*b >> 5);
+        *a = a.wrapping_sub(*b).wrapping_sub(*c) ^ (*c >> 35);
+        *b = b.wrapping_sub(*c).wrapping_sub(*a) ^ (*a << 49);
+        *c = c.wrapping_sub(*a).wrapping_sub(*b) ^ (*b >> 11);
+        *a = a.wrapping_sub(*b).wrapping_sub(*c) ^ (*c >> 12);
+        *b = b.wrapping_sub(*c).wrapping_sub(*a) ^ (*a << 18);
+        *c = c.wrapping_sub(*a).wrapping_sub(*b) ^ (*b >> 22);
+    }
+    if bytes.is_empty() {
+        return 0;
+    }
+    let (mut a, mut b, mut c) = (0xABCD_EF00_1122_3344u64, 0xABCD_EF00_1122_3344u64, 0x9E37_79B9_7F4A_7C13u64);
+    let mut blocks = bytes.chunks_exact(24);
+    for k in &mut blocks {
+        a = a.wrapping_add(u64::from_le_bytes(k[..8].try_into().unwrap()));
+        b = b.wrapping_add(u64::from_le_bytes(k[8..16].try_into().unwrap()));
+        c = c.wrapping_add(u64::from_le_bytes(k[16..24].try_into().unwrap()));
+        mix(&mut a, &mut b, &mut c);
+    }
+    c = c.wrapping_add(bytes.len() as u64);
+    for (i, &byte) in blocks.remainder().iter().enumerate() {
+        match i {
+            0..=7 => a = a.wrapping_add(u64::from(byte) << (8 * i)),
+            8..=15 => b = b.wrapping_add(u64::from(byte) << (8 * (i - 8))),
+            _ => c = c.wrapping_add(u64::from(byte) << (8 * (i - 15))),
+        }
+    }
+    mix(&mut a, &mut b, &mut c);
+    c
+}
+
+impl PlayerTuning {
+    /// The audio trick id of a scorable name (−1 without a record).
+    pub fn audio_trick(&self, name: &str) -> i32 {
+        self.audio_tricks.get(&name_hash(name.to_ascii_lowercase().as_bytes())).copied().unwrap_or(-1)
+    }
+
+    /// The second audio trick id (state `+352`) of a scorable name (−1 without a record).
+    pub fn audio_trick_2(&self, name: &str) -> i32 {
+        self.audio_tricks_2.get(&name_hash(name.to_ascii_lowercase().as_bytes())).copied().unwrap_or(-1)
+    }
+
+    /// AudioSurfaceMap entry of a material (`sub_82494E18` and siblings: ≥ 94 → entry 94).
+    pub fn surface_entry(&self, material: u32) -> Option<&[i32; 18]> {
+        if self.surface_table.is_empty() {
+            return None;
+        }
+        self.surface_table.get((material as usize).min(94)).or_else(|| self.surface_table.last())
+    }
+
+    /// The grind surface of a grind material (`+692`): 4 without one (143), else the entry's
+    /// `+16`; 14 = "no grind sound" (the poster skips it). Without a table: 4.
+    pub fn grind_surface(&self, material: u32) -> i32 {
+        if material == super::state::NO_MATERIAL {
+            return 4;
+        }
+        self.surface_entry(material).map_or(4, |e| e[4])
+    }
+
+    pub fn grind_levels(&self, surface: i32) -> GrindSurface {
+        let s = if (0..14).contains(&surface) { surface as usize } else { 4 };
+        self.grind.get(s).copied().unwrap_or_default()
+    }
+
+    /// Seam wobble of a pattern (1..15; anything else reads the image's zero block).
+    pub fn seam_wobble(&self, pattern: u32) -> SeamWobble {
+        if (1..=15).contains(&pattern) {
+            self.seam_wobbles.get(pattern as usize).or_else(|| self.seam_wobbles.first()).copied().unwrap_or_default()
+        } else {
+            SeamWobble { gain_low: 0.0, gain_high: 0.0, ms_low: 0, ms_high: 0 }
+        }
+    }
+}
diff --git a/crates/skate-audio/src/player/wheels.rs b/crates/skate-audio/src/player/wheels.rs
new file mode 100644
index 00000000..fbc9dfc5
--- /dev/null
+++ b/crates/skate-audio/src/player/wheels.rs
@@ -0,0 +1,203 @@
+//! `SFXObj_Wheels`: the free-spinning wheels — a spin-down recording started part-way in, so a
+//! faster board starts nearer the full spin and a slow one near the end. Written from our reading
+//! of the retail code (TU3, reference only):
+//!
+//! - constructor `sub_824CD6F8`: two streams from the wheels collection (class
+//!   `0xC1831BDB6CB1B1EA` key `0x03B710C80E1AC13E`): `Whls_spins_Jump_1.snr` (field
+//!   `0x044FB3ECB9FCB35F`, length word `0xFD874514FD49261E` = 14 s) and `Whls_spins_Man_1.snr`
+//!   (`0x243117D2CD2EDC70`, `0x8CC31309D10F1763` = 14 s);
+//! - update `sub_824CDC70` → `sub_824CDD28` per slot: slot 0 while in the air (`+332`), slot 1
+//!   while balancing (`+340`), slot 2 for the local player on foot with the off-board byte `+308`
+//!   or the loose-board slide `+760` (neither is published by our engine: slot 2 stays off);
+//! - on a rising trigger: start the next stream of the two (they alternate, `+96`; the first is
+//!   the manual one) at t0 = length × (1 − clamp01(|ground speed| × 3.6 / 50)) seconds (field
+//!   `0x4890392C91829954` = 50 km/h; slot 2 clamps the fraction to 0.26), gain 0, pitch 1
+//!   (`sub_824CEAF0` → `sub_824CEE00`);
+//! - while the trigger holds: a stream that ended stops (and stays stopped); else gain = Wheels
+//!   level(1) (level(5) while balancing, (6) with `+308`, (7) with `+760`) / 32767 and pitch =
+//!   pitch(2) / 4096; when the trigger drops the stream stops (`sub_824CEF60`).
+//!
+//! Not modelled: the owner bus (`sub_824CEAF0`'s chain, send level(4)) — the voices mix dry.
+use super::{AudioState, Outputs};
+
+/// What the component needs from a stream player (the host plays the two recordings).
+pub trait StreamHost {
+    /// Start recording `stream` (0 = jump, 1 = manual) at `seek` seconds with gain 0, pitch 1.
+    fn start(&mut self, stream: usize, seek: f64) -> Option<u32>;
+    fn set(&mut self, voice: u32, gain: f32, pitch: f32);
+    fn alive(&self, voice: u32) -> bool;
+    fn stop(&mut self, voice: u32);
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct WheelsTuning {
+    /// `0x4890392C91829954`: the speed (km/h) at which a stream starts at its beginning.
+    pub full_kmh: f32,
+    /// Start-offset span (s) of the jump / manual streams.
+    pub lengths: [f32; 2],
+}
+
+impl Default for WheelsTuning {
+    fn default() -> Self {
+        Self { full_kmh: 50.0, lengths: [14.0, 14.0] }
+    }
+}
+
+const INV_32767: f32 = f32::from_bits(0x3800_0100);
+const INV_4096: f32 = f32::from_bits(0x3980_0000);
+/// `0x822F8628`: m/s → km/h.
+const KMH: f32 = f32::from_bits(0x4066_6666);
+/// `0x8208ECFC`: slot 2's cap on the speed fraction.
+const SLOT2_CAP: f32 = f32::from_bits(0x3E85_1EB8);
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Wheels {
+    /// `+60..+62` per-slot held flags, the slots' voices, `+96` the stream toggle.
+    held: [bool; 3],
+    voices: [Option<u32>; 3],
+    toggle: bool,
+    /// Streams started (diagnostics).
+    pub starts: u64,
+}
+
+impl Wheels {
+    /// The start offset (s) of a stream for a board at `speed` m/s.
+    pub fn offset(t: &WheelsTuning, stream: usize, speed: f32, slot: usize) -> f32 {
+        let x = speed.abs() / t.full_kmh * KMH;
+        let x = if -x >= 0.0 { 0.0 } else { x };
+        let mut x = if 1.0 - x >= 0.0 { x } else { 1.0 };
+        if slot == 2 && x > SLOT2_CAP {
+            x = SLOT2_CAP;
+        }
+        t.lengths[stream] * (1.0 - x)
+    }
+
+    /// `sub_824CDC70`, after the MixMap tick (Wheels owner outputs).
+    pub fn update(&mut self, s: &AudioState, out: &dyn Outputs, t: &WheelsTuning, host: &mut dyn StreamHost) {
+        let slot2 = s.local && s.on_foot && s.offboard_308;
+        for (slot, trigger) in [s.airborne, s.balance, slot2].into_iter().enumerate() {
+            self.slot(slot, trigger, s, out, t, host);
+        }
+    }
+
+    fn slot(&mut self, slot: usize, trigger: bool, s: &AudioState, out: &dyn Outputs, t: &WheelsTuning, host: &mut dyn StreamHost) {
+        if !self.held[slot] {
+            if !trigger {
+                return;
+            }
+            self.held[slot] = true;
+            let stream = if self.toggle { 0 } else { 1 };
+            self.toggle = !self.toggle;
+            let seek = Self::offset(t, stream, s.ground_speed, slot);
+            if self.voices[slot].is_none() {
+                self.voices[slot] = host.start(stream, f64::from(seek));
+                self.starts += u64::from(self.voices[slot].is_some());
+            }
+            return;
+        }
+        if !trigger {
+            if let Some(v) = self.voices[slot].take() {
+                host.stop(v);
+            }
+            self.held[slot] = false;
+            return;
+        }
+        let Some(v) = self.voices[slot] else { return };
+        if !host.alive(v) {
+            host.stop(v);
+            self.voices[slot] = None;
+            return;
+        }
+        let id = if s.balance {
+            5
+        } else if s.offboard_308 {
+            6
+        } else {
+            1
+        };
+        host.set(v, out.level(id) as f32 * INV_32767, out.pitch(2) as f32 * INV_4096);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Default)]
+    struct Log {
+        started: Vec<(usize, f64)>,
+        live: Vec<u32>,
+        sets: Vec<(u32, f32, f32)>,
+    }
+    impl StreamHost for Log {
+        fn start(&mut self, stream: usize, seek: f64) -> Option<u32> {
+            self.started.push((stream, seek));
+            let id = self.started.len() as u32;
+            self.live.push(id);
+            Some(id)
+        }
+        fn set(&mut self, voice: u32, gain: f32, pitch: f32) {
+            self.sets.push((voice, gain, pitch));
+        }
+        fn alive(&self, voice: u32) -> bool {
+            self.live.contains(&voice)
+        }
+        fn stop(&mut self, voice: u32) {
+            self.live.retain(|v| *v != voice);
+        }
+    }
+    struct Out;
+    impl Outputs for Out {
+        fn level(&self, id: usize) -> i32 {
+            1000 * id as i32
+        }
+        fn raw(&self, _: usize) -> i32 {
+            0
+        }
+        fn pitch(&self, _: usize) -> i32 {
+            4096
+        }
+    }
+
+    #[test]
+    fn the_offset_follows_the_speed() {
+        let t = WheelsTuning::default();
+        assert_eq!(Wheels::offset(&t, 0, 0.0, 0), 14.0);
+        assert!((Wheels::offset(&t, 0, 25.0 / 3.6, 0) - 7.0).abs() < 1e-3);
+        assert_eq!(Wheels::offset(&t, 0, 20.0, 0), 0.0, "above 50 km/h the spin starts at the top");
+        assert!((Wheels::offset(&t, 0, 20.0, 2) - 14.0 * (1.0 - SLOT2_CAP)).abs() < 1e-5);
+    }
+
+    #[test]
+    fn a_jump_spins_the_wheels_down_until_landing() {
+        let t = WheelsTuning::default();
+        let mut w = Wheels::default();
+        let mut h = Log::default();
+        let roll = AudioState { ground_speed: 25.0 / 3.6, wheel_count: 4, ..Default::default() };
+        let air = AudioState { airborne: true, wheel_count: 0, ..roll };
+        w.update(&roll, &Out, &t, &mut h);
+        assert!(h.started.is_empty());
+        w.update(&air, &Out, &t, &mut h);
+        // The first stream is the manual one, 7 s in at 25 km/h.
+        assert_eq!(h.started.len(), 1);
+        assert_eq!(h.started[0].0, 1);
+        assert!((h.started[0].1 - 7.0).abs() < 1e-3);
+        w.update(&air, &Out, &t, &mut h);
+        assert_eq!(h.sets.last().copied(), Some((1, 1000.0 * INV_32767, 1.0)), "level(1), pitch(2)");
+        w.update(&roll, &Out, &t, &mut h);
+        assert!(h.live.is_empty(), "landing stops it");
+        w.update(&air, &Out, &t, &mut h);
+        assert_eq!(h.started[1].0, 0, "the streams alternate");
+    }
+
+    #[test]
+    fn a_manual_spins_the_lifted_wheels() {
+        let t = WheelsTuning::default();
+        let mut w = Wheels::default();
+        let mut h = Log::default();
+        let manual = AudioState { ground_speed: 4.0, wheel_count: 2, balance: true, ..Default::default() };
+        w.update(&manual, &Out, &t, &mut h);
+        w.update(&manual, &Out, &t, &mut h);
+        assert_eq!(h.sets.last().map(|s| s.1), Some(5000.0 * INV_32767), "level(5) while balancing");
+    }
+}
diff --git a/crates/skate-audio/src/runtime.rs b/crates/skate-audio/src/runtime.rs
new file mode 100644
index 00000000..01324119
--- /dev/null
+++ b/crates/skate-audio/src/runtime.rs
@@ -0,0 +1,242 @@
+//! Evaluator + mixer on one 256-frame block clock.
+//!
+//! Per block: the mixer renders the block with the voice parameters as they stand, then the
+//! evaluator ticks (every 6th block it walks the programs). Voice commands issued by a walk
+//! therefore apply from the next block boundary, as retail drains its command ring at the start of
+//! each block. Game-side posts, redeliveries and releases happen between blocks (the host holds
+//! the runtime's lock while it calls them), so a walk sees the last value before it.
+//!
+//! The granular rolling bed ([`crate::grain::GrainBed`]) runs on the same clock: its scheduler
+//! (retail's phase-1 plug-in), voices and chains render first (their env sends feed the
+//! environment bus with the voices'), and the dry mix is added into the default bus after the
+//! AEMS voices and buses.
+use std::sync::Arc;
+
+use crate::eval::{Evaluator, NodeId};
+use crate::formats::{Bank, Project};
+use crate::grain::GrainBed;
+use crate::mixer::{Mixer, Pcm};
+use crate::splice::{SoundId, SplicePlayer};
+use crate::{BLOCK, dsp::routes};
+
+pub struct Runtime {
+    pub eval: Evaluator,
+    pub mixer: Mixer,
+    pub grains: GrainBed,
+    /// The Splice one-shot player (`SPLC` banks); its voices live in [`Runtime::mixer`].
+    pub splice: SplicePlayer,
+    /// Our own user-volume scales (1 = retail level): AEMS voices of world banks and of the
+    /// player's banks ([`crate::mixer::GROUP_PLAYER`]); the bed has its own.
+    pub aems_gain: f32,
+    pub player_gain: f32,
+    bus: Box<[[f32; BLOCK]; 6]>,
+    stereo: Vec<f32>,
+    read: usize,
+    /// Blocks rendered.
+    pub blocks: u64,
+    /// Redeliveries scheduled for a block ([`Runtime::redeliver_at`]).
+    scheduled: Vec<(u64, NodeId, Vec<i32>)>,
+}
+
+impl Default for Runtime {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Runtime {
+    pub fn new() -> Self {
+        Self {
+            eval: Evaluator::new(),
+            mixer: Mixer::new(),
+            grains: GrainBed::new(),
+            splice: SplicePlayer::new(),
+            aems_gain: 1.0,
+            player_gain: 1.0,
+            bus: Box::new([[0.0; BLOCK]; 6]),
+            stereo: vec![0.0; 2 * BLOCK],
+            read: 2 * BLOCK,
+            blocks: 0,
+            scheduled: Vec::new(),
+        }
+    }
+
+    pub fn install_project(&mut self, project: &Project) {
+        self.eval.install_project(project);
+    }
+
+    /// Install a bank and its decoded samples (by S10A slot; None plays silence of the right
+    /// length). Returns the bank id.
+    pub fn load_bank(&mut self, bank: Bank, pcm: Vec<Option<Arc<Pcm>>>) -> usize {
+        let headers = bank.samples.iter().map(|s| s.1).collect();
+        let id = self.eval.load_bank(bank);
+        self.mixer.add_bank(id, headers, pcm);
+        id
+    }
+
+    pub fn unload_bank(&mut self, id: usize) {
+        self.eval.unload_bank(id, &mut self.mixer);
+        self.mixer.remove_bank(id);
+    }
+
+    pub fn post(&mut self, class: usize, payload: &[i32]) -> NodeId {
+        self.eval.post(class, payload)
+    }
+
+    pub fn redeliver(&mut self, node: NodeId, payload: &[i32]) {
+        self.eval.redeliver(node, payload);
+    }
+
+    pub fn release(&mut self, node: NodeId) {
+        self.scheduled.retain(|e| e.1 != node);
+        self.eval.release(node);
+    }
+
+    /// Redeliver `payload` to `node` just before the evaluator step of block `block` (a block index
+    /// as [`Runtime::blocks`] counts them; past blocks apply at the next one). Replaces any earlier
+    /// schedule for the node. For words that must change on the audio clock, not the game's frame
+    /// (Class_Seams' one-console-frame trigger pulse, Listening test 9).
+    pub fn redeliver_at(&mut self, node: NodeId, payload: &[i32], block: u64) {
+        self.scheduled.retain(|e| e.1 != node);
+        self.scheduled.push((block, node, payload.to_vec()));
+    }
+
+    /// Install the player's streamed recordings (`SFXObj_Wheels`: 0 = jump spin, 1 = manual
+    /// spin), decoded up front, in the player volume group.
+    pub fn load_streams(&mut self, pcm: Vec<Option<Arc<Pcm>>>) {
+        let headers = pcm
+            .iter()
+            .map(|p| {
+                p.as_ref().map(|p| crate::formats::SampleHeader {
+                    codec: 3,
+                    channels: p.channels.len() as u8,
+                    rate: p.rate,
+                    frames: p.channels.first().map_or(0, |c| c.len() as u32),
+                    loop_start: None,
+                })
+            })
+            .collect();
+        self.mixer.add_bank(STREAM_BANK, headers, pcm);
+        self.mixer.set_bank_group(STREAM_BANK, crate::mixer::GROUP_PLAYER);
+    }
+
+    /// The streamed recordings as `SFXObj_Wheels` sees them.
+    pub fn stream_host(&mut self) -> StreamAccess<'_> {
+        StreamAccess { mixer: &mut self.mixer }
+    }
+
+    /// The Splice player as the player components see it (bank by name).
+    pub fn splice_host(&mut self) -> SpliceAccess<'_> {
+        SpliceAccess { player: &mut self.splice, mixer: &mut self.mixer }
+    }
+
+    /// Render one block: returns the 6-channel default bus (L, C, R, Ls, Rs, LFE).
+    pub fn render_block(&mut self) -> &[[f32; BLOCK]; 6] {
+        self.mixer.group_gain[usize::from(crate::mixer::GROUP_WORLD)] = self.aems_gain;
+        self.mixer.group_gain[usize::from(crate::mixer::GROUP_PLAYER)] = self.player_gain;
+        // The bed renders first so that its chains' env sends reach this block's environment
+        // network; its dry mix is added after the mixer's buses, as before.
+        let bed = self.grains.render_block();
+        self.mixer.render_with_env(&mut self.bus, if bed { self.grains.env_send() } else { None });
+        if bed {
+            self.grains.add_to(&mut self.bus);
+        }
+        if !self.scheduled.is_empty() {
+            let now = self.blocks;
+            let mut i = 0;
+            while i < self.scheduled.len() {
+                if self.scheduled[i].0 <= now {
+                    let (_, node, payload) = self.scheduled.swap_remove(i);
+                    self.eval.redeliver(node, &payload);
+                } else {
+                    i += 1;
+                }
+            }
+        }
+        self.eval.block(&mut self.mixer);
+        self.blocks += 1;
+        &self.bus
+    }
+
+    /// Fill `out` with interleaved stereo at 48 kHz through the output stage's stereo table
+    /// (0.707·L + 0.5·C + 0.5·Ls, mirrored; clamped to ±1).
+    pub fn fill_stereo(&mut self, out: &mut [f32]) {
+        let mut at = 0;
+        while at < out.len() {
+            if self.read >= self.stereo.len() {
+                self.render_block();
+                routes::output_stereo(&self.bus, &mut self.stereo);
+                self.read = 0;
+            }
+            let n = (self.stereo.len() - self.read).min(out.len() - at);
+            out[at..at + n].copy_from_slice(&self.stereo[self.read..self.read + n]);
+            self.read += n;
+            at += n;
+        }
+    }
+}
+
+/// The mixer bank of the player's streamed recordings ([`Runtime::load_streams`]).
+pub const STREAM_BANK: usize = 1 << 21;
+
+/// [`crate::player::wheels::StreamHost`] over the runtime's mixer (direct voices, dry).
+pub struct StreamAccess<'a> {
+    pub mixer: &'a mut Mixer,
+}
+
+impl crate::player::wheels::StreamHost for StreamAccess<'_> {
+    fn start(&mut self, stream: usize, seek: f64) -> Option<u32> {
+        self.mixer.open_direct(STREAM_BANK, stream as u16, seek, 1.0, 0.0, Some(0.0))
+    }
+    fn set(&mut self, voice: u32, gain: f32, pitch: f32) {
+        self.mixer.set_direct(voice, pitch, gain, None);
+    }
+    fn alive(&self, voice: u32) -> bool {
+        self.mixer.direct_alive(voice)
+    }
+    fn stop(&mut self, voice: u32) {
+        crate::eval::VoiceHost::release(self.mixer, voice);
+    }
+}
+
+/// [`crate::player::contacts::SpliceHost`] over the runtime's Splice player and mixer.
+pub struct SpliceAccess<'a> {
+    pub player: &'a mut SplicePlayer,
+    pub mixer: &'a mut Mixer,
+}
+
+impl crate::player::contacts::SpliceHost for SpliceAccess<'_> {
+    fn set_route(&mut self, route: crate::bus::Route) {
+        self.player.route = route;
+    }
+    /// With the FootStep SubMix on ([`crate::bus::submix::FootSubmixes::enabled`]) the next start
+    /// plays into the slot's graph (built on first use, its parameters posted now as
+    /// `sub_82494550` does); off, the route set before stays (SFX Master with the env tap).
+    fn set_submix(&mut self, submix: Option<crate::player::footsteps::Submix>) {
+        let Some(sub) = submix else { return };
+        let graphs = &mut self.mixer.buses.submix;
+        if !graphs.enabled {
+            return;
+        }
+        graphs.set(sub.graph, &sub.params());
+        self.player.route = crate::bus::Route { output: crate::bus::Output::Submix(sub.graph), create: false, owner_env: 0.0, mono: true };
+    }
+    fn start(&mut self, bank: &str, id: u32, block: [f32; 6]) -> Option<SoundId> {
+        // A route applies to the next start only.
+        let route = std::mem::take(&mut self.player.route);
+        let b = self.player.bank_index(bank)?;
+        self.player.route = route;
+        let sound = self.player.start(b, id, block, self.mixer);
+        self.player.route = crate::bus::Route::default();
+        sound
+    }
+    fn update(&mut self, sound: SoundId, block: [f32; 6]) {
+        self.player.update(sound, block, self.mixer);
+    }
+    fn alive(&self, sound: SoundId) -> bool {
+        self.player.alive(sound)
+    }
+    fn release(&mut self, sound: SoundId) {
+        self.player.release(sound, self.mixer);
+    }
+}
diff --git a/crates/skate-audio/src/splice/format.rs b/crates/skate-audio/src/splice/format.rs
new file mode 100644
index 00000000..18720bff
--- /dev/null
+++ b/crates/skate-audio/src/splice/format.rs
@@ -0,0 +1,155 @@
+//! `SPLC` bank patch trees (the `.bnk` banks' header part; layout verified on all 20 disc banks,
+//! `.claude/skills/aems-port/tools/splc_fields.py`): a 60-byte header (+8 sample-table offset from
+//! byte 60, +12 record count, +16 container count, +20 extras (0), +24 sample count), 36-byte
+//! records, 72-byte containers, then per record its groups (12-byte header) of 72-byte members.
+//! Field roles from the retail Splice code (`super` docs); offsets are facts.
+use crate::be::{f32_at, u8_at, u16_at, u32_at};
+
+/// One member of a group: a sample and how it plays.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Member {
+    /// `+0` sample index (= the bank's n-th stream).
+    pub sample: u16,
+    /// `+3` output route byte (255 = none; not modelled).
+    pub route: u8,
+    /// `+4` gain, `+8` pitch ratio, `+12` second rate factor (1.0 on every disc member).
+    pub gain: f32,
+    pub pitch: f32,
+    pub rate2: f32,
+    /// `+16` pan offset (degrees, × block[4]); −127 = not panned.
+    pub pan: f32,
+    /// `+20` delay (s), `+24` start (s of elapsed time), `+28` length (s at the nominal pitch).
+    pub delay: f32,
+    pub start: f32,
+    pub length: f32,
+    /// `+32` fade-in end, `+36` fade-out start (0 = none); `+40` & 15 the curve.
+    pub fade_in_end: f32,
+    pub fade_out_start: f32,
+    pub curve: u8,
+    /// `+44` gain spread, `+48` pitch randomisation, `+52` delay randomisation.
+    pub gain_spread: f32,
+    pub pitch_rand: f32,
+    pub delay_rand: f32,
+    /// `+64` probability of playing.
+    pub probability: f32,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Group {
+    /// `+9` pick mode, `+4` state word (live), the members.
+    pub mode: u8,
+    pub state: u32,
+    pub members: Vec<Member>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Record {
+    /// `+8` gain, `+12` pitch factor base, `+16` its randomisation.
+    pub gain: f32,
+    pub pitch_base: f32,
+    pub pitch_rand: f32,
+    pub groups: Vec<Group>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Container {
+    /// `+69` pick mode, `+0` state word (live), `+4…` record ids (`+68` count).
+    pub mode: u8,
+    pub state: u32,
+    pub ids: Vec<u16>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct SpliceBank {
+    pub records: Vec<Record>,
+    pub containers: Vec<Container>,
+    pub samples: usize,
+}
+
+impl SpliceBank {
+    /// Parse a bank's patch tree (the whole `.bnk`, or its first `60 + table + 4·samples` bytes).
+    pub fn parse(d: &[u8]) -> Result<Self, String> {
+        if d.get(..4) != Some(b"SPLC") {
+            return Err("not an SPLC bank".into());
+        }
+        let table = 60 + u32_at(d, 8) as usize;
+        let records = u32_at(d, 12) as usize;
+        let containers = u32_at(d, 16) as usize;
+        let samples = u32_at(d, 24) as usize;
+        if u32_at(d, 20) != 0 {
+            return Err("SPLC bank with extras".into());
+        }
+        if table > d.len() || records > 65_536 || containers > 65_536 {
+            return Err("SPLC header out of range".into());
+        }
+        let cbase = 60 + 36 * records;
+        let mut out_containers = Vec::with_capacity(containers);
+        for c in 0..containers {
+            let at = cbase + 72 * c;
+            let count = usize::from(u8_at(d, at + 68)).min(32);
+            out_containers.push(Container {
+                mode: u8_at(d, at + 69),
+                state: u32_at(d, at),
+                ids: (0..count).map(|k| u16_at(d, at + 4 + 2 * k)).collect(),
+            });
+        }
+        let mut cursor = cbase + 72 * containers;
+        let mut out_records = Vec::with_capacity(records);
+        for r in 0..records {
+            let at = 60 + 36 * r;
+            let mut groups = Vec::new();
+            for _ in 0..u8_at(d, at + 7) {
+                let count = u8_at(d, cursor + 8);
+                let mode = u8_at(d, cursor + 9);
+                let state = u32_at(d, cursor + 4);
+                cursor += 12;
+                let mut members = Vec::with_capacity(usize::from(count));
+                for _ in 0..count {
+                    let m = cursor;
+                    let sample = u16_at(d, m);
+                    if usize::from(sample) >= samples {
+                        return Err(format!("record {r}: member names sample {sample} of {samples}"));
+                    }
+                    members.push(Member {
+                        sample,
+                        route: u8_at(d, m + 3),
+                        gain: f32_at(d, m + 4),
+                        pitch: f32_at(d, m + 8),
+                        rate2: f32_at(d, m + 12),
+                        pan: f32_at(d, m + 16),
+                        delay: f32_at(d, m + 20),
+                        start: f32_at(d, m + 24),
+                        length: f32_at(d, m + 28),
+                        fade_in_end: f32_at(d, m + 32),
+                        fade_out_start: f32_at(d, m + 36),
+                        curve: u8_at(d, m + 40) & 15,
+                        gain_spread: f32_at(d, m + 44),
+                        pitch_rand: f32_at(d, m + 48),
+                        delay_rand: f32_at(d, m + 52),
+                        probability: f32_at(d, m + 64),
+                    });
+                    cursor += 72;
+                }
+                if members.is_empty() {
+                    return Err(format!("record {r}: empty group"));
+                }
+                groups.push(Group { mode, state, members });
+            }
+            out_records.push(Record { gain: f32_at(d, at + 8), pitch_base: f32_at(d, at + 12), pitch_rand: f32_at(d, at + 16), groups });
+        }
+        if cursor != table {
+            return Err(format!("patch tree ends at {cursor:#x}, sample table at {table:#x}"));
+        }
+        Ok(Self { records: out_records, containers: out_containers, samples })
+    }
+
+    /// The patch-tree part of a bank file (what setup keeps): header, records, containers and
+    /// groups, up to the sample table.
+    pub fn tree_len(d: &[u8]) -> Option<usize> {
+        if d.get(..4) != Some(b"SPLC") {
+            return None;
+        }
+        let n = 60 + u32_at(d, 8) as usize;
+        (n <= d.len()).then_some(n)
+    }
+}
diff --git a/crates/skate-audio/src/splice/mod.rs b/crates/skate-audio/src/splice/mod.rs
new file mode 100644
index 00000000..15c59d48
--- /dev/null
+++ b/crates/skate-audio/src/splice/mod.rs
@@ -0,0 +1,432 @@
+//! The Splice one-shot player for the `SPLC` banks (`Skate_Collisions.bnk`, `sk8_foley.bnk`,
+//! `Skate_Metal.bnk` …): retail's per-sound records of layered, randomised sample members, played
+//! by gameplay owners (the board's contacts, the collision manager, the off-board foley) with a
+//! 6-float block they rewrite every frame.
+//!
+//! Written from our reading of the retail code (TU3; reference only, addresses are facts):
+//! - `sub_82975700` start: bank index, sound id → record (ids below the record count), container
+//!   (`id − records`, one record picked by [`pick`]) or, past both, the last record;
+//! - `sub_829757D0` voices: one per group of the record, member by [`pick`], skipped unless
+//!   `U × 1/32768 ≤ member +64` (probability); `sub_82975A60`: the container pitch factor
+//!   `record +12 + U·record +16`, then per voice `sub_82975CC8`: gain spread `+44`, pitch
+//!   `+8 + U·+48`, delay `+20 + U·+52`;
+//! - `sub_82975B08` per frame: block[0] × record `+8`, block[1] × the pitch factor, each voice
+//!   `sub_82976860`: delay countdown, start (`sub_82976360`: elapsed = `+24`, seek
+//!   `+8/+12 × +24` s), then pitch = factor·block[1], gain = `+4` × spread × block[0] × fade
+//!   (`sub_82976CF0` / `sub_82976FF0`, fade-in `+24 → +32`, fade-out `+36 → +28`, curve byte `+40`),
+//!   azimuth = block[2] + `+16` × block[4] (no panner when `+16` = −127), the elapsed clock
+//!   advancing by the previous frame's block[1] × dt, stop once elapsed > `+8 / pitch × +28 + 0.16`
+//!   or the sample ended.
+//!
+//! Block (what the owners pass, `sub_824BE1B8`): [0] gain (level / 32767), [1] pitch ratio
+//! (pitch / 4096), [2] azimuth (degrees, raw × 360/65535), [3] dt (s), [4] pan spread (1 for the
+//! local player's 3-D voices, else 0), [5] second rate factor (1).
+//!
+//! Not modelled (values not recovered or not used by any disc member): the per-voice output route
+//! (`member +3`, the owner's bus objects `sub_82488DD0` with their eEQChain preset and level — the
+//! voices mix dry into the default bus), the second rate stage (`member +12` is 1.0 on every member
+//! and owners pass block[5] = 1), the no-resample path (`member +68` is 0 everywhere), and the
+//! exact rounding of retail's cosine polynomial in the fade curves.
+pub mod format;
+
+use std::sync::Arc;
+
+use crate::mixer::{Mixer, Pcm};
+pub use format::{Member, SpliceBank};
+
+/// The CRT `rand()` retail's Splice code calls (`sub_82F4EAF0`): the MS LCG, 15-bit results.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct CrtRand(pub u32);
+
+impl Default for CrtRand {
+    fn default() -> Self {
+        Self(1)
+    }
+}
+
+impl CrtRand {
+    pub fn next(&mut self) -> u32 {
+        self.0 = self.0.wrapping_mul(214_013).wrapping_add(2_531_011);
+        (self.0 >> 16) & 0x7FFF
+    }
+    /// `rand() × 1/32768` as retail computes it (int → double → single, × f32 2⁻¹⁵).
+    pub fn unit(&mut self) -> f32 {
+        (self.next() as f64) as f32 * f32::from_bits(0x3800_0000)
+    }
+}
+
+/// `sub_82976DD8`: pick an index of `count` items with `mode` (0 random, 2 shuffled halves, else
+/// sequential) and the item's state word.
+pub fn pick(count: u8, mode: u8, state: &mut u32, rng: &mut CrtRand) -> u8 {
+    let count = u32::from(count);
+    if count == 1 {
+        return 0;
+    }
+    match mode {
+        // trunc((rand() × 2⁻¹⁵) × count), single precision.
+        0 => trunc(rng.unit() * count as f32) as u8,
+        2 => shuffle(count, state, rng),
+        _ => {
+            if count == 0 {
+                return 0;
+            }
+            let next = ((*state as i32).wrapping_add(1) as u32 % count) as u32;
+            *state = next;
+            next as u8
+        }
+    }
+}
+
+fn trunc(x: f32) -> i32 {
+    if x.is_nan() { 0 } else { x as i32 }
+}
+
+/// Mode 2: the state's high half is the bitmask of the current half's unplayed items, bit 0 the
+/// half (0: items 0..count/2, 1: the rest). A draw starts the search at a random offset; an
+/// exhausted half refills the other one (mask 2^size − 1).
+fn shuffle(count: u32, state: &mut u32, rng: &mut CrtRand) -> u8 {
+    let parity = *state & 1;
+    let mask = *state >> 16;
+    let half = count >> 1;
+    let size = half + u32::from(parity != 0 && count & 1 != 0);
+    let r = rng.next();
+    let start = trunc((r as f64) as f32 * f32::from_bits(0x3800_0000) * (size + 1) as f32) as u32;
+    if size == 0 {
+        return 0;
+    }
+    for k in 0..size {
+        let idx = (k + start) % size;
+        let bit = 1u32 << idx;
+        if bit & mask != 0 {
+            let index = parity * half + idx;
+            let mut rest = mask & !bit;
+            let mut p = parity;
+            if rest == 0 {
+                p = u32::from(parity == 0);
+                let other = half + u32::from(p != 0 && count & 1 != 0);
+                rest = (2f64.powi(other as i32) as f32 as i64 - 1) as u32;
+            }
+            *state = (rest << 16) | u32::from(p != 0);
+            return index as u8;
+        }
+    }
+    0
+}
+
+/// `sub_82976FF0`: the fade curve of a member (`+40` & 15) at x ∈ [0, 1].
+pub fn curve(kind: u8, x: f32) -> f32 {
+    let x = x.clamp(0.0, 1.0);
+    let k = f32::from_bits(0x3FC9_0FD0); // π/2 as stored
+    match kind {
+        0 => 1.0 - (x * k).cos(),
+        1 => {
+            let v = 1.0 - (x * k).cos();
+            v * v
+        }
+        2 => x,
+        3 => ((x - 1.0) * k).cos(),
+        4 => {
+            let v = ((x - 1.0) * k).cos();
+            v * v
+        }
+        _ => x,
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum State {
+    /// Waiting for its delay (`+76` = 1).
+    Delay,
+    /// Playing (`+76` = 3).
+    Playing,
+    /// Stopped (`+76` = 4).
+    Done,
+}
+
+#[derive(Clone, Debug)]
+struct Voice {
+    member: Member,
+    state: State,
+    /// `+64` pitch factor, `+68` gain spread, `+72` last block[1], `+80` delay, `+84` elapsed.
+    pitch: f32,
+    spread: f32,
+    last_rate: f32,
+    delay: f32,
+    elapsed: f32,
+    mixer: Option<u32>,
+}
+
+/// One started sound (`sub_82975700`'s 92-byte object).
+#[derive(Clone, Debug)]
+pub struct Sound {
+    bank: usize,
+    record: usize,
+    /// `+88`: the container pitch factor.
+    factor: f32,
+    voices: Vec<Option<Voice>>,
+    /// The bus its voices play into (the poster's route when it started).
+    route: crate::bus::Route,
+}
+
+/// A loaded bank: its patch tree (with the live pick states) and the mixer bank its samples sit in.
+pub struct LoadedBank {
+    pub name: String,
+    pub bank: SpliceBank,
+    mixer_bank: usize,
+}
+
+/// Mixer bank ids the Splice banks use (above any evaluator bank id).
+pub const MIXER_BANK_BASE: usize = 1 << 20;
+
+#[derive(Default)]
+pub struct SplicePlayer {
+    pub banks: Vec<LoadedBank>,
+    sounds: Vec<Option<Sound>>,
+    pub rng: CrtRand,
+    /// Voices started (diagnostics).
+    pub started: u64,
+    /// The route the next [`SplicePlayer::start`] uses (the poster sets it: its eEQChain bus and
+    /// owner bus env send); SFX Master by default.
+    pub route: crate::bus::Route,
+}
+
+pub type SoundId = usize;
+
+impl SplicePlayer {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Install a bank and its decoded samples (sample index n = the bank's n-th stream). Returns
+    /// the bank index used by [`SplicePlayer::start`]. The samples are decoded before any start, so
+    /// the first trigger of a sample sounds exactly like the later ones.
+    pub fn load_bank(&mut self, name: &str, bank: SpliceBank, pcm: Vec<Option<Arc<Pcm>>>, mixer: &mut Mixer) -> usize {
+        if let Some(i) = self.banks.iter().position(|b| b.name == name) {
+            return i;
+        }
+        let index = self.banks.len();
+        let mixer_bank = MIXER_BANK_BASE + index;
+        let headers = pcm
+            .iter()
+            .map(|p| {
+                p.as_ref().map(|p| crate::formats::SampleHeader {
+                    codec: 3,
+                    channels: p.channels.len() as u8,
+                    rate: p.rate,
+                    frames: p.channels.first().map_or(0, |c| c.len() as u32),
+                    loop_start: None,
+                })
+            })
+            .collect();
+        mixer.add_bank(mixer_bank, headers, pcm);
+        mixer.set_bank_group(mixer_bank, crate::mixer::GROUP_PLAYER);
+        self.banks.push(LoadedBank { name: name.to_owned(), bank, mixer_bank });
+        index
+    }
+
+    pub fn bank_index(&self, name: &str) -> Option<usize> {
+        self.banks.iter().position(|b| b.name == name)
+    }
+
+    /// `sub_82975700` + `sub_82975A60`: start sound `id` of a bank with the owner's first block.
+    pub fn start(&mut self, bank: usize, id: u32, block: [f32; 6], mixer: &mut Mixer) -> Option<SoundId> {
+        let b = self.banks.get_mut(bank)?;
+        let records = b.bank.records.len();
+        let containers = b.bank.containers.len();
+        if records == 0 {
+            return None;
+        }
+        let id = id as usize;
+        let record = if id < records {
+            id
+        } else if id < records + containers {
+            let c = &mut b.bank.containers[id - records];
+            let k = pick(c.ids.len() as u8, c.mode, &mut c.state, &mut self.rng);
+            usize::from(c.ids.get(usize::from(k)).copied().unwrap_or(0)).min(records - 1)
+        } else {
+            records - 1
+        };
+        // sub_829757D0: one voice per group.
+        let mut voices = Vec::new();
+        let groups = b.bank.records[record].groups.len();
+        for g in 0..groups {
+            let group = &mut b.bank.records[record].groups[g];
+            let k = pick(group.members.len() as u8, group.mode, &mut group.state, &mut self.rng);
+            let member = group.members[usize::from(k).min(group.members.len().saturating_sub(1))];
+            let u = self.rng.unit();
+            if u > member.probability {
+                voices.push(None);
+                continue;
+            }
+            voices.push(Some(Voice { member, state: State::Delay, pitch: 0.0, spread: 1.0, last_rate: 0.0, delay: -1.0, elapsed: 0.0, mixer: None }));
+        }
+        let rec = &b.bank.records[record];
+        // sub_82975A60: the container pitch factor, then each voice's random draws.
+        let factor = self.rng.unit().mul_add(rec.pitch_rand, rec.pitch_base);
+        let mut sound = Sound { bank, record, factor, voices, route: self.route };
+        for v in sound.voices.iter_mut().flatten() {
+            init_voice(v, &mut self.rng);
+        }
+        // Voices without a delay start at once with the start block as the owner passed it to
+        // sub_82975A60 (no record gain / pitch factor yet: sub_82975668 → sub_82976360).
+        let mixer_bank = b.mixer_bank;
+        let route = sound.route;
+        for v in sound.voices.iter_mut().flatten() {
+            if v.delay == 0.0 {
+                begin(v, &block, mixer_bank, route, mixer);
+                self.started += 1;
+            }
+        }
+        let slot = self.sounds.iter().position(Option::is_none).unwrap_or_else(|| {
+            self.sounds.push(None);
+            self.sounds.len() - 1
+        });
+        self.sounds[slot] = Some(sound);
+        Some(slot)
+    }
+
+    /// `sub_82975B08`: the owner's per-frame block.
+    pub fn update(&mut self, id: SoundId, block: [f32; 6], mixer: &mut Mixer) {
+        let Some(Some(sound)) = self.sounds.get_mut(id) else { return };
+        let b = &self.banks[sound.bank];
+        let rec = &b.bank.records[sound.record];
+        let mut block = block;
+        block[0] *= rec.gain;
+        block[1] *= sound.factor;
+        let route = sound.route;
+        for slot in sound.voices.iter_mut() {
+            let Some(v) = slot else { continue };
+            if step(v, &block, b.mixer_bank, route, mixer) {
+                self.started += 1;
+            }
+            if v.state == State::Done {
+                if let Some(m) = v.mixer.take() {
+                    crate::eval::VoiceHost::release(mixer, m);
+                }
+                *slot = None;
+            }
+        }
+    }
+
+    /// `sub_82975BF0`: any voice still delaying or playing.
+    pub fn alive(&self, id: SoundId) -> bool {
+        matches!(self.sounds.get(id), Some(Some(s)) if s.voices.iter().flatten().any(|v| v.state != State::Done))
+    }
+
+    /// The owner's release (`sub_824836B8`): stop every voice.
+    pub fn release(&mut self, id: SoundId, mixer: &mut Mixer) {
+        if let Some(slot) = self.sounds.get_mut(id) {
+            if let Some(sound) = slot.take() {
+                for v in sound.voices.into_iter().flatten() {
+                    if let Some(m) = v.mixer {
+                        crate::eval::VoiceHost::release(mixer, m);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Diagnostics: (bank name, record, member sample, gain, pitch) of every playing voice.
+    pub fn voices(&self) -> Vec<(String, usize, u16, f32, f32)> {
+        let mut out = Vec::new();
+        for s in self.sounds.iter().flatten() {
+            for v in s.voices.iter().flatten() {
+                if v.state == State::Playing {
+                    out.push((self.banks[s.bank].name.clone(), s.record, v.member.sample, v.spread * v.member.gain, v.pitch));
+                }
+            }
+        }
+        out
+    }
+}
+
+/// `sub_82975CC8`: the per-voice draws (gain spread, pitch, delay).
+fn init_voice(v: &mut Voice, rng: &mut CrtRand) {
+    let m = &v.member;
+    let u = rng.unit();
+    let x = u.mul_add(2.0, -1.0); // fmsubs: U·2 − 1
+    v.spread = if x > 0.0 {
+        if m.gain_spread == 0.0 {
+            4.0
+        } else {
+            let s = 1.0 - (1.0 - m.gain_spread);
+            (1.0 / s - 1.0).mul_add(x, 1.0)
+        }
+    } else {
+        -((x * -1.0) * (1.0 - m.gain_spread) - 1.0)
+    };
+    let u = rng.unit();
+    v.pitch = u.mul_add(m.pitch_rand, m.pitch);
+    v.last_rate = v.pitch;
+    v.delay = if m.delay == 0.0 { 0.0 } else { m.delay };
+    if m.delay_rand != 0.0 {
+        let u = rng.unit();
+        v.delay = u.mul_add(m.delay_rand, v.delay);
+    }
+}
+
+/// `sub_82976CF0`: the member's fade envelope applied to a gain.
+fn fade(m: &Member, elapsed: f32, gain: f32) -> f32 {
+    if m.fade_in_end != 0.0 && elapsed < m.fade_in_end {
+        return gain * curve(m.curve, (elapsed - m.start) / (m.fade_in_end - m.start));
+    }
+    if m.fade_out_start != 0.0 && elapsed > m.fade_out_start {
+        return gain * curve(m.curve, 1.0 - (elapsed - m.fade_out_start) / (m.length - m.fade_out_start));
+    }
+    gain
+}
+
+/// The azimuth (degrees) of a voice for a block.
+fn azimuth(m: &Member, block: &[f32; 6]) -> Option<f32> {
+    if m.pan == -127.0 { None } else { Some(m.pan.mul_add(block[4], block[2])) }
+}
+
+/// `sub_82976360`: start the sample.
+fn begin(v: &mut Voice, block: &[f32; 6], mixer_bank: usize, route: crate::bus::Route, mixer: &mut Mixer) {
+    let m = v.member;
+    v.state = State::Playing;
+    v.elapsed = m.start;
+    let seek = if m.start != 0.0 { f64::from(m.pitch / m.rate2) * f64::from(m.start) } else { 0.0 };
+    let gain = fade(&m, v.elapsed, v.spread * m.gain * block[0]);
+    v.mixer = mixer.open_routed(mixer_bank, m.sample, seek, v.pitch * block[1], gain, azimuth(&m, block), route);
+    if v.mixer.is_none() {
+        v.state = State::Done;
+    }
+}
+
+/// `sub_82976860`: one frame of a voice. Returns true when it started this frame.
+fn step(v: &mut Voice, block: &[f32; 6], mixer_bank: usize, route: crate::bus::Route, mixer: &mut Mixer) -> bool {
+    let dt = block[3];
+    if v.state == State::Delay {
+        if v.delay > 0.0 {
+            v.delay -= dt;
+            if v.delay > 0.0 {
+                return false;
+            }
+        }
+        begin(v, block, mixer_bank, route, mixer);
+        return v.state == State::Playing;
+    }
+    if v.state != State::Playing {
+        return false;
+    }
+    let m = v.member;
+    let elapsed = v.last_rate.mul_add(dt, v.elapsed);
+    v.last_rate = block[1];
+    v.elapsed = elapsed;
+    let pitch = v.pitch * block[1];
+    let gain = fade(&m, elapsed, (m.gain * v.spread) * block[0]);
+    let limit = (m.pitch / v.pitch).mul_add(m.length, f32::from_bits(0x3E23_D70A));
+    let ended = v.mixer.is_none_or(|id| !mixer.direct_alive(id));
+    if limit < elapsed || ended {
+        v.state = State::Done;
+        return false;
+    }
+    if let Some(id) = v.mixer {
+        mixer.set_direct(id, pitch, gain, azimuth(&m, block));
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/skate-audio/src/splice/tests.rs b/crates/skate-audio/src/splice/tests.rs
new file mode 100644
index 00000000..cf11b3ba
--- /dev/null
+++ b/crates/skate-audio/src/splice/tests.rs
@@ -0,0 +1,139 @@
+use super::*;
+
+#[test]
+fn crt_rand_is_the_ms_lcg() {
+    let mut r = CrtRand::default();
+    // MS CRT rand() from seed 1: 41, 18467, 6334, 26500, 19169.
+    assert_eq!([r.next(), r.next(), r.next(), r.next(), r.next()], [41, 18467, 6334, 26500, 19169]);
+}
+
+#[test]
+fn sequential_pick_advances_from_the_state_word() {
+    let mut rng = CrtRand::default();
+    let mut state = 0x0001_0000; // the disc's initial word
+    let picks: Vec<u8> = (0..4).map(|_| pick(3, 1, &mut state, &mut rng)).collect();
+    // (65536 + 1) % 3 = 2, then 0, 1, 2.
+    assert_eq!(picks, [2, 0, 1, 2]);
+}
+
+#[test]
+fn shuffle_plays_each_half_without_repeats_then_refills_the_other() {
+    let mut rng = CrtRand::default();
+    let mut state = 0x0001_0000; // mask 1 in half 0
+    let mut seen = Vec::new();
+    for _ in 0..7 {
+        seen.push(pick(5, 2, &mut state, &mut rng));
+    }
+    // First the one item the disc state allows (index 0), then half 1 (items 2..4) in some
+    // order, then half 0 (items 0, 1) again.
+    assert_eq!(seen[0], 0);
+    let mut h1 = seen[1..4].to_vec();
+    h1.sort();
+    assert_eq!(h1, [2, 3, 4]);
+    let mut h0 = seen[4..6].to_vec();
+    h0.sort();
+    assert_eq!(h0, [0, 1]);
+    assert!((2..5).contains(&seen[6]));
+}
+
+#[test]
+fn random_pick_stays_in_range() {
+    let mut rng = CrtRand::default();
+    let mut state = 0;
+    for _ in 0..1000 {
+        assert!(pick(7, 0, &mut state, &mut rng) < 7);
+    }
+}
+
+#[test]
+fn fade_curves_run_from_zero_to_one() {
+    for kind in 0..5 {
+        assert!(curve(kind, 0.0).abs() < 1e-5, "curve {kind} at 0");
+        assert!((curve(kind, 1.0) - 1.0).abs() < 1e-5, "curve {kind} at 1");
+    }
+    assert!((curve(2, 0.25) - 0.25).abs() < 1e-7);
+    assert!((curve(3, 0.5) - (std::f32::consts::FRAC_PI_4).sin()).abs() < 1e-5);
+}
+
+fn disc_bank(name: &str) -> Option<Vec<u8>> {
+    let p = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../.local/audio-re/splc-banks")).join(format!("{name}.bnk"));
+    std::fs::read(p).ok()
+}
+
+#[test]
+fn disc_banks_parse_and_the_contact_ids_resolve() {
+    let Some(d) = disc_bank("Skate_Collisions") else { return eprintln!("skipped: no extracted SPLC banks") };
+    let bank = SpliceBank::parse(&d).unwrap();
+    assert!(bank.records.len() > 800 && !bank.containers.is_empty());
+    let records = bank.records.len();
+    // The Contacts vault ids (pop 1097..1099, touchdowns 1051.., ollie 1096, landing 1095, roll 1111)
+    // are containers.
+    for id in [1095usize, 1096, 1097, 1098, 1099, 1051, 1060, 1111] {
+        assert!(id >= records && id < records + bank.containers.len(), "id {id}");
+    }
+    // Every bank on the disc parses.
+    let dir = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../.local/audio-re/splc-banks"));
+    let mut n = 0;
+    for e in std::fs::read_dir(dir).unwrap() {
+        let p = e.unwrap().path();
+        let d = std::fs::read(&p).unwrap();
+        SpliceBank::parse(&d).unwrap_or_else(|e| panic!("{}: {e}", p.display()));
+        let tree = SpliceBank::tree_len(&d).unwrap();
+        assert_eq!(SpliceBank::parse(&d[..tree]).unwrap(), SpliceBank::parse(&d).unwrap());
+        n += 1;
+    }
+    assert_eq!(n, 20);
+}
+
+fn tone(seconds: f32) -> Arc<Pcm> {
+    let n = (seconds * 48000.0) as usize;
+    Arc::new(Pcm { rate: 48000, channels: vec![(0..n).map(|i| (i as f32 * 0.05).sin() * 0.5).collect()] })
+}
+
+#[test]
+fn a_record_plays_its_layers_and_ends_after_its_length() {
+    let Some(d) = disc_bank("Skate_Collisions") else { return eprintln!("skipped: no extracted SPLC banks") };
+    let bank = SpliceBank::parse(&d).unwrap();
+    let pcm = (0..bank.samples).map(|_| Some(tone(0.5))).collect();
+    let mut mixer = Mixer::new();
+    let mut p = SplicePlayer::new();
+    let b = p.load_bank("Skate_Collisions", bank, pcm, &mut mixer);
+    let s = p.start(b, 1097, [0.0, 1.0, 0.0, 1.0 / 60.0, 1.0, 1.0], &mut mixer).unwrap();
+    let mut bus = [[0.0f32; crate::BLOCK]; 6];
+    let mut frames = 0;
+    while p.alive(s) && frames < 600 {
+        p.update(s, [0.5, 1.0, 0.0, 1.0 / 60.0, 1.0, 1.0], &mut mixer);
+        for _ in 0..3 {
+            mixer.render(&mut bus);
+        }
+        frames += 1;
+    }
+    assert!(frames < 600, "the pop ends by itself");
+    assert!(p.started >= 1);
+}
+
+/// The user's crack/seam report (a first trigger that sounded different): every trigger of a
+/// sample renders the same samples — PCM is decoded before any start, and a voice's first block
+/// (the format change), resampler, gain ramp and panner start from the same state each time.
+#[test]
+fn the_first_trigger_of_a_sample_renders_like_the_next() {
+    let mut mixer = Mixer::new();
+    let pcm = tone(0.2);
+    let header = crate::formats::SampleHeader { codec: 3, channels: 1, rate: 48000, frames: pcm.channels[0].len() as u32, loop_start: None };
+    mixer.add_bank(7, vec![Some(header)], vec![Some(pcm)]);
+    let mut takes = Vec::new();
+    for _ in 0..2 {
+        let id = mixer.open_direct(7, 0, 0.0, 1.0, 0.5, Some(30.0)).unwrap();
+        let mut out = Vec::new();
+        let mut bus = [[0.0f32; crate::BLOCK]; 6];
+        while mixer.direct_alive(id) {
+            mixer.render(&mut bus);
+            out.extend(bus.iter().flatten().copied());
+        }
+        crate::eval::VoiceHost::release(&mut mixer, id);
+        mixer.render(&mut bus); // the stop fold of the finished voice
+        takes.push(out);
+    }
+    assert!(takes[0].iter().any(|&x| x != 0.0));
+    assert_eq!(takes[0], takes[1]);
+}
diff --git a/crates/skate-audio/tests/disc_banks.rs b/crates/skate-audio/tests/disc_banks.rs
new file mode 100644
index 00000000..95d7a813
--- /dev/null
+++ b/crates/skate-audio/tests/disc_banks.rs
@@ -0,0 +1,236 @@
+//! Checks the format layer and the evaluator's load step against every bank on the disc, using the
+//! census numbers in `.claude/notes/aems-evaluator-spec.md` §1. Needs the disc's `.abk`/`.csi`
+//! files extracted locally (`py -3.13 .claude/skills/aems-port/tools/bank_layout_check.py --extract
+//! .local/audio-re/aems-banks`, or `SKATE_AEMS_BANKS=<dir>`); skipped when they are absent (retail
+//! data is never committed).
+use std::path::PathBuf;
+
+use skate_audio::be::{u8_at, u16_at};
+use skate_audio::eval::{Evaluator, OpenRequest, VoiceHost, VoiceStatus};
+use skate_audio::formats::{Bank, Project};
+
+fn banks_dir() -> Option<PathBuf> {
+    let dir = std::env::var_os("SKATE_AEMS_BANKS")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../.local/audio-re/aems-banks"));
+    dir.join("csi_order.txt").is_file().then_some(dir)
+}
+
+fn load(dir: &PathBuf) -> (Vec<Project>, Vec<Bank>) {
+    let order = std::fs::read_to_string(dir.join("csi_order.txt")).unwrap();
+    let projects = order.lines().map(|n| Project::parse(n, &std::fs::read(dir.join(n)).unwrap()).unwrap()).collect();
+    let mut names: Vec<String> = std::fs::read_dir(dir)
+        .unwrap()
+        .filter_map(|e| e.ok()?.file_name().into_string().ok())
+        .filter(|n| n.to_ascii_lowercase().ends_with(".abk"))
+        .collect();
+    names.sort();
+    let banks = names.iter().map(|n| Bank::parse(n, std::fs::read(dir.join(n)).unwrap()).unwrap_or_else(|e| panic!("{e}"))).collect();
+    (projects, banks)
+}
+
+#[test]
+fn every_disc_bank_parses_and_matches_the_spec_census() {
+    let Some(dir) = banks_dir() else {
+        eprintln!("skipped: no extracted banks");
+        return;
+    };
+    let (projects, banks) = load(&dir);
+    assert_eq!(projects.len(), 9);
+    assert_eq!(banks.len(), 376);
+    let modules: usize = banks.iter().map(|b| b.modules.len()).sum();
+    assert_eq!(modules, 385);
+
+    // Opcode census (§1.5).
+    let mut census = [0usize; 40];
+    let mut records = 0;
+    for m in banks.iter().flat_map(|b| &b.modules) {
+        for op in &m.program {
+            census[op.opcode as usize] += 1;
+            records += 1;
+        }
+    }
+    let want = [
+        385, 385, 252, 385, 385, 182, 50, 630, 599, 3, 2545, 1186, 1902, 837, 12, 3126, 190, 2653, 171, 0, 42, 366, 51, 969,
+        863, 709, 267, 1527, 372, 800, 1958, 1450, 49, 310, 1145, 2093, 1927, 129, 1, 110,
+    ];
+    assert_eq!(census, want);
+    assert_eq!(records, want.iter().sum::<usize>());
+
+    // Subscription-state layout (§1.4): ops 0/2/1/37 read exactly the states we laid out, and the
+    // Destroy state is the last op's block at datasize − 16.
+    for (bank, m) in banks.iter().flat_map(|b| b.modules.iter().map(move |m| (b, m))) {
+        let blocks = |opcode: u8| m.program.iter().filter(move |o| o.opcode == opcode).map(|o| o.block);
+        for b in blocks(0) {
+            assert_eq!(Some(b), m.destructor_state, "{} op 0", bank.name);
+        }
+        for b in blocks(1) {
+            assert_eq!(Some(b), m.class_data_state, "{} op 1", bank.name);
+        }
+        for b in blocks(2) {
+            assert!(m.global_states.contains(&b), "{} op 2 at {b}", bank.name);
+        }
+        for b in blocks(37) {
+            assert!(m.function_states.contains(&b), "{} op 37 at {b}", bank.name);
+        }
+        assert_eq!(m.destroy_offset, m.data_size - 16, "{}", bank.name);
+        assert_eq!(m.program.last().map(|o| (o.opcode, o.block)), Some((4, m.data_size - 16)), "{}", bank.name);
+        // Ops 5 and 38: the clamp ranges are present exactly when the flag is set (block sizes).
+        let t = m.template(&bank.data);
+        for (i, op) in m.program.iter().enumerate() {
+            let next = m.program.get(i + 1).map_or(m.data_size, |o| o.block);
+            let size = next - op.block;
+            let b = op.block as usize;
+            match op.opcode {
+                5 => {
+                    let (flag, n) = (u8_at(t, b + 8) != 0, u32::from(u8_at(t, b + 9)));
+                    assert_eq!(size, 12 + if flag { 8 * n } else { 0 } + 4 + 4 * n, "{} op 5", bank.name);
+                }
+                38 => {
+                    let (flag, n) = (u8_at(t, b + 12) != 0, u32::from(u8_at(t, b + 13)));
+                    assert_eq!(size, 16 + if flag { 8 * n } else { 0 } + 8 + 4 * n, "{} op 38", bank.name);
+                }
+                27 => {
+                    // Player inputs: 12 B records after +28, then the outputs.
+                    let n = u32::from(u8_at(t, b + 14));
+                    let update = u8_at(t, b + 15) != 0;
+                    assert_eq!(size, 28 + 12 * n + if update { 8 } else { 0 }, "{} op 27", bank.name);
+                    let _ = u16_at(t, b);
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+#[test]
+fn exports_resolve_like_retail() {
+    let Some(dir) = banks_dir() else {
+        eprintln!("skipped: no extracted banks");
+        return;
+    };
+    let (projects, banks) = load(&dir);
+    let mut eval = Evaluator::new();
+    for p in &projects {
+        eval.install_project(p);
+    }
+    let mut unresolved = Vec::new();
+    let mut total = 0;
+    for b in &banks {
+        for e in &b.exports {
+            total += 1;
+            if eval.registry.lookup(e.kind, e.project, e.name_id, &e.name).is_none() {
+                unresolved.push(e.name.clone());
+            }
+        }
+    }
+    unresolved.sort();
+    assert_eq!(total, 1059);
+    // §1.8: 4 of 1,059 exports find nothing.
+    assert_eq!(unresolved, ["pa_announce_a_glb", "pa_announce_a_glb", "pa_announce_b_glb", "semi_horns_msg"]);
+    for b in banks {
+        eval.load_bank(b);
+    }
+    let emitter = eval.class_id("c_emitter").unwrap();
+    // §1.10: 291 banks bind to c_emitter.
+    assert_eq!(eval.registry.classes[emitter].constructors.len(), 291);
+}
+
+/// A device whose voices live for a fixed number of queries.
+#[derive(Default)]
+struct Timed {
+    next: u32,
+    left: std::collections::HashMap<u32, u32>,
+}
+
+impl VoiceHost for Timed {
+    fn open(&mut self, _: &OpenRequest) -> Option<u32> {
+        self.next += 1;
+        self.left.insert(self.next, 20);
+        Some(self.next)
+    }
+    fn release(&mut self, v: u32) {
+        self.left.remove(&v);
+    }
+    fn pause(&mut self, _: u32) {}
+    fn resume(&mut self, _: u32) {}
+    fn set(&mut self, _: u32, _: u8, _: i32) {}
+    fn set_azimuth(&mut self, _: u32, _: i32) {}
+    fn query(&mut self, v: u32) -> VoiceStatus {
+        match self.left.get_mut(&v) {
+            Some(n) if *n > 0 => {
+                *n -= 1;
+                VoiceStatus { alive: true, remaining_ms: 32 * *n as i32, elapsed_ms: 0 }
+            }
+            _ => VoiceStatus::default(),
+        }
+    }
+}
+
+/// Op 38 (ControlClass) has no oracle (the PoC lacks it): check its lifecycle on Tazer, the one
+/// bank that uses it. c_tazer owns a child post to c_tazer_grn_play; while the child instance lives
+/// the op returns refcount 3 (owner + the child's destructor and ClassData clients), 1 once the
+/// child ended itself; releasing the parent releases the child, and every instance and node goes
+/// away.
+#[test]
+fn tazer_control_class_owns_and_releases_its_child() {
+    let Some(dir) = banks_dir() else {
+        eprintln!("skipped: no extracted banks");
+        return;
+    };
+    let mut eval = Evaluator::new();
+    for name in std::fs::read_to_string(dir.join("csi_order.txt")).unwrap().lines() {
+        eval.install_project(&Project::parse(name, &std::fs::read(dir.join(name)).unwrap()).unwrap());
+    }
+    let tazer = eval.load_bank(Bank::parse("Tazer.abk", std::fs::read(dir.join("Tazer.abk")).unwrap()).unwrap());
+    eval.load_bank(Bank::parse("emitter_utility.abk", std::fs::read(dir.join("emitter_utility.abk")).unwrap()).unwrap());
+    let mut dev = Timed::default();
+    eval.post(eval.class_id("c_emitter_utility").unwrap(), &[]);
+    let base_nodes = eval.node_count();
+    let class = eval.class_id("c_tazer").unwrap();
+    let node = eval.post(class, &[32767, 32767, 4096, 25000, 1, 1, 100, 0, 32767]);
+    eval.trace = Some(Vec::new());
+    let mut child_seen = 0;
+    let mut owner_refcounts = std::collections::BTreeSet::new();
+    for walk in 0..120 {
+        if walk == 25 {
+            eval.redeliver(node, &[1, 16000, 500, 2, 3000, 0, 12000, 4096, 1]);
+        }
+        if walk == 75 {
+            eval.redeliver(node, &[0, 20000, 5, 4096, 25000, 32767, 1, 2, 0]);
+        }
+        for _ in 0..6 {
+            eval.block(&mut dev);
+        }
+        if eval.instances().iter().any(|&(_, b, m)| b == tazer && m == 1) {
+            child_seen += 1;
+        }
+        for t in eval.trace.as_mut().unwrap().drain(..) {
+            if t.opcode == 38 {
+                owner_refcounts.insert(t.result);
+            }
+        }
+    }
+    assert!(child_seen > 0, "the ControlClass child never ran");
+    // 0 = no child post; 3 = child instance alive (owner + its two clients); 1 = the child's program
+    // ended it while the owner still holds the node.
+    assert!(owner_refcounts.contains(&3), "{owner_refcounts:?}");
+    assert!(owner_refcounts.iter().all(|r| [0, 1, 3].contains(r)), "{owner_refcounts:?}");
+    eval.release(node);
+    // The owner ends at once; children released by it end when their own programs say so (here
+    // after their voices finish).
+    let mut walks_to_clear = None;
+    for walk in 0..200 {
+        for _ in 0..6 {
+            eval.block(&mut dev);
+        }
+        if eval.instances().iter().all(|&(_, b, _)| b != tazer) {
+            walks_to_clear = Some(walk);
+            break;
+        }
+    }
+    eprintln!("Tazer cleared {walks_to_clear:?} walks after the release");
+    assert!(eval.instances().iter().all(|&(_, b, _)| b != tazer), "Tazer instances left: {:?}", eval.instances());
+    assert_eq!(eval.node_count(), base_nodes);
+    assert!(dev.left.is_empty(), "voices left open");
+}
diff --git a/crates/skate-audio/tests/disc_grains.rs b/crates/skate-audio/tests/disc_grains.rs
new file mode 100644
index 00000000..182d361a
--- /dev/null
+++ b/crates/skate-audio/tests/disc_grains.rs
@@ -0,0 +1,39 @@
+//! The 14 retail `.grain` members as setup copies them (`assets/private/audio/grains/*.grain`,
+//! tools/asset_pipeline/audio_export.py `grain_whole`): every header, seek table and EAAC header
+//! parses and matches the spec's census (grain-player-spec §1.1). Skips without the private install.
+use skate_audio::grain::GrainFile;
+
+#[test]
+fn every_retail_grain_parses_with_a_single_entry_seek_table() {
+    let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/private/audio/grains");
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        eprintln!("skipped: no {dir}");
+        return;
+    };
+    let mut seen = Vec::new();
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) != Some("grain") {
+            continue;
+        }
+        let bytes = std::fs::read(&path).unwrap();
+        let name = path.file_stem().unwrap().to_string_lossy().into_owned();
+        let g = GrainFile::parse(&bytes).unwrap_or_else(|e| panic!("{name}: {e}"));
+        assert!(g.single_entry(), "{name}: row 0 spans the stream");
+        assert_eq!((g.seek.kind, g.seek.layout, g.seek.low, g.seek.preroll, g.seek.side_offset), (0, 1, 0, 384, 24), "{name}");
+        assert_eq!((g.stream.version, g.stream.codec, g.stream.channels, g.stream.kind, g.stream.looped), (0, 3, 1, 0, false), "{name}");
+        assert!(matches!(g.stream.rate, 44100 | 48000), "{name}");
+        assert!((112..=176).contains(&g.header_len), "{name}");
+        seen.push((name, g.stream.samples, g.duration));
+    }
+    if seen.is_empty() {
+        eprintln!("skipped: no .grain files in {dir} (run stage_grain_mixmap.py or setup)");
+        return;
+    }
+    seen.sort_by(|a, b| a.0.cmp(&b.0));
+    assert_eq!(seen.len(), 14);
+    let crh = seen.iter().find(|s| s.0 == "concrete_rough_hard").unwrap();
+    assert_eq!((crh.1, crh.2.to_bits()), (963228, 0x41AE_BC39));
+    let jet = seen.iter().find(|s| s.0 == "x_jet_rolling").unwrap();
+    assert_eq!(jet.1, 583305);
+}
diff --git a/crates/skate-audio/tests/dsp_oracle.rs b/crates/skate-audio/tests/dsp_oracle.rs
new file mode 100644
index 00000000..17c85a89
--- /dev/null
+++ b/crates/skate-audio/tests/dsp_oracle.rs
@@ -0,0 +1,248 @@
+//! Our voice-graph modules against the PoC's replay-verified kernels (oracle vectors written by the
+//! local PoC probe `.claude/skills/aems-port/tools/poc/dsp_vectors.rs` into
+//! `.local/audio-re/golden/dsp/vectors.txt`; skipped when absent). Prints the agreement numbers.
+use std::path::PathBuf;
+
+use skate_audio::dsp::biquad::{Coefficients, Kind, coefficients, kernel, omega};
+use skate_audio::dsp::gain::ramp;
+use skate_audio::dsp::resample::Resampler;
+
+fn vectors() -> Option<String> {
+    let path = std::env::var_os("SKATE_DSP_VECTORS")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../.local/audio-re/golden/dsp/vectors.txt"));
+    std::fs::read_to_string(path).ok()
+}
+
+/// The probe's test signal (same formula, same f32 libm).
+fn signal(n: usize, seed: u32) -> Vec<f32> {
+    let mut x = seed;
+    (0..n)
+        .map(|i| {
+            x = x.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
+            let noise = (x >> 8) as f32 / (1u32 << 24) as f32 - 0.5;
+            (i as f32 * 0.130_899_7).sin() * 0.6 + noise * 0.3
+        })
+        .collect()
+}
+
+fn floats(words: &[&str]) -> Vec<f32> {
+    words.iter().map(|w| f32::from_bits(u32::from_str_radix(w, 16).unwrap())).collect()
+}
+
+#[test]
+fn resample_is_bit_exact_with_the_retail_kernel() {
+    let Some(text) = vectors() else {
+        eprintln!("skipped: no oracle vectors");
+        return;
+    };
+    let src = signal(16384, 7);
+    let (mut cases, mut samples, mut exact) = (0, 0, 0);
+    for line in text.lines().filter(|l| l.starts_with("resample ")) {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        let step: u32 = parts[1].parse().unwrap();
+        let want = floats(&parts[2..]);
+        let mut r = Resampler::default();
+        r.step = step;
+        let mut got = Vec::new();
+        for _ in 0..8 {
+            let mut out = vec![0.0f32; 256];
+            r.render(&mut out, |i| src.get(i as usize).copied().unwrap_or(0.0));
+            r.advance(256);
+            got.extend(out);
+        }
+        cases += 1;
+        samples += want.len();
+        exact += got.iter().zip(&want).filter(|(a, b)| a.to_bits() == b.to_bits()).count();
+    }
+    eprintln!("resample: {cases} steps, {exact}/{samples} samples bit-exact");
+    assert!(cases > 0);
+    assert_eq!(exact, samples);
+}
+
+#[test]
+fn lowpass_coefficients_and_kernel_agree() {
+    let Some(text) = vectors() else {
+        eprintln!("skipped: no oracle vectors");
+        return;
+    };
+    let mut poc_coeffs = std::collections::HashMap::new();
+    let (mut words, mut exact_words, mut max_ulps) = (0, 0, 0u32);
+    for line in text.lines().filter(|l| l.starts_with("lpfcoef ")) {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        let fc: f32 = parts[1].parse().unwrap();
+        let c = floats(&parts[2..]);
+        let want = Coefficients { a1: c[0], a2: c[1], b0: c[2], b1: c[3], b2: c[4] };
+        let got = coefficients(Kind::LowPass, omega(fc, 48000.0));
+        for (a, b) in [(got.a1, want.a1), (got.a2, want.a2), (got.b0, want.b0), (got.b1, want.b1), (got.b2, want.b2)] {
+            words += 1;
+            let ulps = (a.to_bits() as i64 - b.to_bits() as i64).unsigned_abs() as u32;
+            exact_words += usize::from(ulps == 0);
+            max_ulps = max_ulps.max(ulps);
+        }
+        poc_coeffs.insert(parts[1].to_string(), want);
+    }
+    eprintln!("lpf coefficients: {exact_words}/{words} words bit-exact, max {max_ulps} ulp");
+    assert!(words > 0);
+    assert!(max_ulps <= 1, "coefficients differ by {max_ulps} ulp");
+
+    let input = signal(2048, 11);
+    let (mut samples, mut exact, mut worst) = (0, 0, 0.0f32);
+    for line in text.lines().filter(|l| l.starts_with("biquad ")) {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        let want = floats(&parts[2..]);
+        let k = poc_coeffs[parts[1]];
+        let mut history = [0.0f32; 4];
+        let mut got = input.clone();
+        for block in got.chunks_mut(256) {
+            kernel(&k, &mut history, block);
+        }
+        let peak = want.iter().fold(0.0f32, |m, v| m.max(v.abs())).max(1e-9);
+        let (mut case_exact, mut case_worst, mut first) = (0, 0.0f32, None);
+        for (i, (a, b)) in got.iter().zip(&want).enumerate() {
+            samples += 1;
+            case_exact += usize::from(a.to_bits() == b.to_bits());
+            if a.to_bits() != b.to_bits() && first.is_none() {
+                first = Some(i);
+            }
+            case_worst = case_worst.max((a - b).abs() / peak);
+        }
+        eprintln!("  biquad {} Hz: {case_exact}/{} bit-exact, first diff at {first:?}, max {case_worst:.3e} of peak", parts[1], want.len());
+        exact += case_exact;
+        worst = worst.max(case_worst);
+    }
+    eprintln!("biquad kernel: {exact}/{samples} samples bit-exact, max error {worst:.3e} of peak");
+    assert_eq!(exact, samples, "biquad not bit-exact (max error {worst} of peak)");
+}
+
+/// Fit the feed-forward association per sample position (n mod 8) against the oracle, black box:
+/// each sample is computed from the oracle's own previous outputs (teacher forcing), and every
+/// candidate order of the fused multiply-adds is scored. `cargo test … fit_biquad -- --ignored
+/// --nocapture`. Its result is what `biquad::kernel` implements.
+#[test]
+#[ignore]
+fn fit_biquad_association() {
+    let Some(text) = vectors() else { return };
+    let input = signal(2048, 11);
+    let mut coeffs = std::collections::HashMap::new();
+    for line in text.lines().filter(|l| l.starts_with("lpfcoef ")) {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        let c = floats(&parts[2..]);
+        coeffs.insert(parts[1].to_string(), Coefficients { a1: c[0], a2: c[1], b0: c[2], b1: c[3], b2: c[4] });
+    }
+    // Feed-forward candidates: (order of the three products, bias placement).
+    // bias 0: innermost addend; 1: plain add after the sum; 2: plain mul innermost, bias after.
+    let perms: [[usize; 3]; 6] = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]];
+    let ff = |k: &Coefficients, x: [f32; 3], perm: [usize; 3], bias: u8| -> f32 {
+        let b = [k.b0, k.b1, k.b2];
+        let (o, m, i) = (perm[0], perm[1], perm[2]);
+        match bias {
+            0 => b[o].mul_add(x[o], b[m].mul_add(x[m], b[i].mul_add(x[i], 1e-18))),
+            1 => b[o].mul_add(x[o], b[m].mul_add(x[m], b[i] * x[i])) + 1e-18,
+            _ => b[o].mul_add(x[o], b[m].mul_add(x[m], b[i] * x[i] + 1e-18)),
+        }
+    };
+    let fb = |k: &Coefficients, t: f32, y1: f32, y2: f32, order: u8| -> f32 {
+        match order {
+            0 => (-k.a2).mul_add(y2, (-k.a1).mul_add(y1, t)),
+            1 => (-k.a1).mul_add(y1, (-k.a2).mul_add(y2, t)),
+            _ => t - k.a1.mul_add(y1, k.a2 * y2),
+        }
+    };
+    let mut score = vec![vec![0usize; 6 * 3 * 3]; 8];
+    let mut total = [0usize; 8];
+    for line in text.lines().filter(|l| l.starts_with("biquad ")) {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        let want = floats(&parts[2..]);
+        let k = coeffs[parts[1]];
+        for n in 2..want.len() {
+            let x = [input[n], input[n - 1], input[n - 2]];
+            total[n % 8] += 1;
+            for (pi, perm) in perms.iter().enumerate() {
+                for bias in 0..3u8 {
+                    for order in 0..3u8 {
+                        let y = fb(&k, ff(&k, x, *perm, bias), want[n - 1], want[n - 2], order);
+                        if y.to_bits() == want[n].to_bits() {
+                            score[n % 8][(pi * 3 + bias as usize) * 3 + order as usize] += 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for pos in 0..8 {
+        let best = (0..score[pos].len()).max_by_key(|&c| score[pos][c]).unwrap();
+        let (pi, rest) = (best / 9, best % 9);
+        eprintln!(
+            "position {pos}: products {:?} bias {} feedback {} → {}/{} exact",
+            perms[pi].map(|i| ["b0·x", "b1·x1", "b2·x2"][i]),
+            rest / 3,
+            rest % 3,
+            score[pos][best],
+            total[pos]
+        );
+    }
+}
+
+#[test]
+fn gain_ramp_is_bit_exact_with_the_retail_kernel() {
+    let Some(text) = vectors() else {
+        eprintln!("skipped: no oracle vectors");
+        return;
+    };
+    let input = signal(256, 23);
+    let (mut samples, mut exact, mut max_ulps) = (0, 0, 0u64);
+    for line in text.lines().filter(|l| l.starts_with("gainramp ")) {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        let (g, s) = parts[1].split_once(':').unwrap();
+        let start = f32::from_bits(u32::from_str_radix(g, 16).unwrap());
+        let step = f32::from_bits(u32::from_str_radix(s, 16).unwrap());
+        let want = floats(&parts[2..]);
+        let mut got = input.clone();
+        ramp(&mut got, start, step);
+        samples += want.len();
+        exact += got.iter().zip(&want).filter(|(a, b)| a.to_bits() == b.to_bits()).count();
+        for (a, b) in got.iter().zip(&want) {
+            max_ulps = max_ulps.max((a.to_bits() as i64 - b.to_bits() as i64).unsigned_abs());
+        }
+    }
+    eprintln!("gain ramp: {exact}/{samples} samples bit-exact, max {max_ulps} ulp");
+    assert!(samples > 0);
+    // The lane arithmetic of irregular steps is not fully recovered (fit_gain_ramp): ≤ 1 ulp.
+    assert!(max_ulps <= 1, "gain ramp off by {max_ulps} ulp");
+}
+
+/// Fit the gain-ramp lane arithmetic black-box against the oracle (`--ignored --nocapture`).
+/// Candidates map (src, start, step, k) to the output sample; k ≥ 64 uses k = 64.
+#[test]
+#[ignore]
+fn fit_gain_ramp() {
+    let Some(text) = vectors() else { return };
+    let input = signal(256, 23);
+    type F = fn(f32, f32, f32, usize) -> f32;
+    let candidates: [(&str, F); 8] = [
+        ("src·(start + k·step)", |x, s, d, k| x * (s + k as f32 * d)),
+        ("src·((start + 8g·step) + m·step)", |x, s, d, k| x * ((s + (8 * (k / 8)) as f32 * d) + (k % 8) as f32 * d)),
+        ("fma(src, k·step, src·start)", |x, s, d, k| x.mul_add(k as f32 * d, x * s)),
+        ("fma(src·step, k, src·start)", |x, s, d, k| (x * d).mul_add(k as f32, x * s)),
+        ("src·start + src·(k·step)", |x, s, d, k| x * s + x * (k as f32 * d)),
+        ("src·(f64 start + k·step)", |x, s, d, k| x * (f64::from(s) + k as f64 * f64::from(d)) as f32),
+        ("f64 src·(start + k·step)", |x, s, d, k| (f64::from(x) * (f64::from(s) + k as f64 * f64::from(d))) as f32),
+        ("src·fma(k, step, start) f64", |x, s, d, k| x * ((k as f64).mul_add(f64::from(d), f64::from(s)) as f32)),
+    ];
+    for (name, f) in candidates {
+        let (mut n, mut exact) = (0, 0);
+        for line in text.lines().filter(|l| l.starts_with("gainramp ")) {
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            let (g, s) = parts[1].split_once(':').unwrap();
+            let start = f32::from_bits(u32::from_str_radix(g, 16).unwrap());
+            let step = f32::from_bits(u32::from_str_radix(s, 16).unwrap());
+            let want = floats(&parts[2..]);
+            for k in 0..256 {
+                n += 1;
+                exact += usize::from(f(input[k], start, step, k.min(64)).to_bits() == want[k].to_bits());
+            }
+        }
+        eprintln!("{name}: {exact}/{n}");
+    }
+}
diff --git a/crates/skate-audio/tests/offboard_levels.rs b/crates/skate-audio/tests/offboard_levels.rs
new file mode 100644
index 00000000..40076030
--- /dev/null
+++ b/crates/skate-audio/tests/offboard_levels.rs
@@ -0,0 +1,405 @@
+//! The off-board, clothing and hands-on-deck components through the real MixMap, AEMS banks and
+//! Splice banks, headless: per scenario, the voice gains per (bank, sample) next to retail's
+//! per-sample medians (`.local/recomp/sessions/all_20261002_163809` and `_164620` report.md,
+//! collected in `.local/audio-re/footsteps/retail_levels.txt`). Needs the install's MixMap and WAVs
+//! (`assets/private/audio`), the extracted AEMS banks (`.local/audio-re/aems-banks`) and SPLC banks
+//! (`.local/audio-re/splc-banks`); skipped without them. Run with `--nocapture` for the table.
+use std::collections::{BTreeMap, HashMap};
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use skate_audio::eval::NodeId;
+use skate_audio::formats::{Bank, Project};
+use skate_audio::mixer::Pcm;
+use skate_audio::mixmap::{MixMap, keys};
+use skate_audio::player::clothing::{Clothing, ClothingTuning};
+use skate_audio::player::components::{Command, Slot};
+use skate_audio::player::footsteps::{FootstepMaterial, FootstepTuning, Footsteps};
+use skate_audio::player::objpos::{Listener, ObjPos};
+use skate_audio::player::step_on::{StepOn, StepOnTuning};
+use skate_audio::player::tuning::PlayerTuning;
+use skate_audio::player::{AudioState, Owner, inputs};
+use skate_audio::runtime::Runtime;
+use skate_audio::splice::{MIXER_BANK_BASE, SpliceBank};
+
+fn root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..")
+}
+
+fn wav_pcm(bytes: &[u8]) -> Option<Pcm> {
+    let (mut channels, mut rate, mut bits) = (0usize, 0u32, 0u16);
+    let mut at = 12;
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().ok()?) as usize;
+        let body = at + 8;
+        match &bytes[at..at + 4] {
+            b"fmt " => {
+                channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+                rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().ok()?);
+                bits = u16::from_le_bytes([bytes[body + 14], bytes[body + 15]]);
+            }
+            b"data" if channels > 0 && bits == 16 => {
+                let data = &bytes[body..(body + size).min(bytes.len())];
+                let mut planar = vec![Vec::new(); channels];
+                for (i, s) in data.chunks_exact(2).enumerate() {
+                    planar[i % channels].push(f32::from(i16::from_le_bytes([s[0], s[1]])) / 32768.0);
+                }
+                return Some(Pcm { rate, channels: planar });
+            }
+            _ => {}
+        }
+        at = body + size + (size & 1);
+    }
+    None
+}
+
+fn pcm(stem: &str, count: usize) -> Vec<Option<Arc<Pcm>>> {
+    let dir = root().join("assets/private/audio/banks").join(stem);
+    (0..count).map(|i| std::fs::read(dir.join(format!("{i:04}.wav"))).ok().and_then(|b| wav_pcm(&b)).map(Arc::new)).collect()
+}
+
+const AEMS: [&str; 3] = ["fstep_skateshoe1_sm", "Foley_Cloth", "Bodyslide"];
+const SPLICE: [&str; 3] = ["sk8_foley", "Skate_Collisions", "Skate_Metal"];
+
+struct Harness {
+    rt: Runtime,
+    mxb: Vec<u8>,
+    names: HashMap<usize, String>,
+}
+
+fn harness() -> Option<Harness> {
+    let r = root();
+    let mxb = std::fs::read(r.join("assets/private/audio/aems/MixMapSK8.mxb")).ok()?;
+    let banks = r.join(".local/audio-re/aems-banks");
+    let order = std::fs::read_to_string(banks.join("csi_order.txt")).ok()?;
+    let mut rt = Runtime::new();
+    for name in order.lines() {
+        rt.install_project(&Project::parse(name, &std::fs::read(banks.join(name)).ok()?).ok()?);
+    }
+    let mut names = HashMap::new();
+    for stem in std::iter::once("emitter_utility").chain(AEMS) {
+        let bank = Bank::parse(stem, std::fs::read(banks.join(format!("{stem}.abk"))).ok()?).ok()?;
+        let count = bank.samples.len();
+        let id = rt.load_bank(bank, pcm(stem, count));
+        names.insert(id, stem.to_owned());
+    }
+    let utility = rt.eval.class_id("c_emitter_utility")?;
+    rt.post(utility, &[]);
+    for stem in SPLICE {
+        let bank = SpliceBank::parse(&std::fs::read(r.join(format!(".local/audio-re/splc-banks/{stem}.bnk"))).ok()?).ok()?;
+        let count = bank.samples;
+        let p = pcm(stem, count);
+        if p.iter().all(Option::is_none) {
+            return None;
+        }
+        let index = rt.splice.load_bank(stem, bank, p, &mut rt.mixer);
+        names.insert(MIXER_BANK_BASE + index, stem.to_owned());
+    }
+    Some(Harness { rt, mxb, names })
+}
+
+#[derive(Default)]
+struct Run {
+    /// (bank, sample) → voice gains over the blocks it sounded.
+    gains: BTreeMap<(String, u16), Vec<f32>>,
+    posts: usize,
+}
+
+fn globals(m: &mut MixMap) {
+    for id in 1..=4 {
+        m.set_input(keys::MASTER, id, 32767);
+    }
+    for id in [1, 2, 5] {
+        m.set_input(keys::MUSIC, id, 32767);
+    }
+    m.set_input(keys::REVERB, 5, 32767);
+}
+
+fn apply(rt: &mut Runtime, nodes: &mut HashMap<Slot, NodeId>, cmds: Vec<Command>, posts: &mut usize) {
+    for cmd in cmds {
+        match cmd {
+            Command::Post { slot, class, words } => {
+                let Some(id) = rt.eval.class_id(class) else { panic!("class {class} not bound") };
+                if let Some(old) = nodes.remove(&slot) {
+                    rt.release(old);
+                }
+                nodes.insert(slot, rt.post(id, &words));
+                *posts += 1;
+            }
+            Command::Redeliver { slot, words } => {
+                if let Some(&node) = nodes.get(&slot) {
+                    rt.redeliver(node, &words);
+                }
+            }
+            Command::Release { slot } => {
+                if let Some(node) = nodes.remove(&slot) {
+                    rt.release(node);
+                }
+            }
+        }
+    }
+}
+
+/// Footstep surface 2 (AudioSurfaceMap word 6) for material 3 (the engine's concrete tag 4),
+/// surface 1 and the metal record for material 36; body slide type 2 for material 40.
+fn tunings() -> (PlayerTuning, FootstepTuning, ClothingTuning, StepOnTuning) {
+    let mut t = PlayerTuning::default();
+    t.surface_table = vec![[0; 18]; 95];
+    t.surface_table[3][6] = 2;
+    t.surface_table[36][6] = 1;
+    t.surface_table[40][10] = 2;
+    let mut ft = FootstepTuning::default();
+    ft.materials = vec![FootstepMaterial::default(); 143];
+    // The vault's material 36 (Skate_Metal walk / run / landing 416, +48 6000, landing 20000).
+    ft.materials[36] = FootstepMaterial { kind: 1, enabled: true, gain: 6000, landing_gain: 20000, ids: [416, 416, 416] };
+    (t, ft, ClothingTuning::default(), StepOnTuning::default())
+}
+
+fn run(frames: usize, state: impl Fn(usize) -> AudioState) -> Run {
+    // A fresh runtime per scenario: nothing of the last one keeps sounding.
+    let mut h = harness().expect("data checked by the caller");
+    let h = &mut h;
+    let (t, ft, ct, st) = tunings();
+    let mut m = MixMap::from_bytes(&h.mxb).unwrap();
+    let mut physics = inputs::Physics::default();
+    let mut positions = [ObjPos::default(), ObjPos::default()];
+    let mut foot = Footsteps::default();
+    let mut cloth = Clothing::default();
+    let mut step = StepOn::default();
+    let mut nodes = HashMap::new();
+    let mut out = vec![0.0f32; 1600];
+    let mut r = Run::default();
+    for f in 0..frames {
+        let s = state(f);
+        globals(&mut m);
+        physics.write(&mut m, &s);
+        let l = Listener {
+            camera: [s.com_position[0] - 3.5, 2.4, s.com_position[2]],
+            view: [1.0, -0.3, 0.0],
+            camera_velocity: s.com_velocity,
+            followed: s.com_position,
+            facing: s.com_velocity,
+            followed_velocity: s.com_velocity,
+        };
+        positions[0].write(&mut m, keys::obj_pos(0), &l, Some((s.com_position, s.com_velocity)));
+        positions[1].write(&mut m, keys::obj_pos2(0), &l, Some((s.board_position, s.board_velocity)));
+        inputs::write_off_board(&mut m, &s);
+        let mut cmds = foot.process(&s, &t, &ft, &mut h.rt.splice_host());
+        cmds.extend(cloth.process(&s, &t, &ct, &mut h.rt.splice_host()));
+        step.process(&s, &st, &mut h.rt.splice_host());
+        apply(&mut h.rt, &mut nodes, cmds, &mut r.posts);
+        m.tick(1.0 / 60.0);
+        let off = Owner { mixmap: &m, key: keys::off_board(0) };
+        let clothing = Owner { mixmap: &m, key: keys::clothing(0) };
+        let contacts = Owner { mixmap: &m, key: keys::contacts(0) };
+        let mut cmds = foot.update(&s, &t, &ft, &off, &mut h.rt.splice_host());
+        cmds.extend(cloth.update(&s, &t, &ct, &clothing, &mut h.rt.splice_host()));
+        step.update(&s, &st, &contacts, &mut h.rt.splice_host());
+        apply(&mut h.rt, &mut nodes, cmds, &mut r.posts);
+        h.rt.fill_stereo(&mut out);
+        for v in h.rt.mixer.snapshot() {
+            if let Some(name) = h.names.get(&v.bank) {
+                if v.gain > 0.0 {
+                    r.gains.entry((name.clone(), v.slot)).or_default().push(v.gain);
+                }
+            }
+        }
+    }
+    r
+}
+
+fn q(v: &[f32], p: f32) -> f32 {
+    let mut v = v.to_vec();
+    v.sort_by(f32::total_cmp);
+    if v.is_empty() { 0.0 } else { v[((v.len() - 1) as f32 * p) as usize] }
+}
+
+/// Walking: the feet alternate every `period` frames (A, then B).
+fn walking(f: usize, kmh: f32, period: usize, material: u32) -> AudioState {
+    let v = kmh / 3.6;
+    let phase = (f / period) % 2;
+    AudioState {
+        on_foot: true,
+        com_velocity: [v, 0.0, 0.0],
+        com_position: [v * f as f32 / 60.0, 1.0, 0.0],
+        board_position: [v * f as f32 / 60.0, 0.1, 0.0],
+        foot_down: [phase == 0, phase == 1],
+        foot_material: [material; 2],
+        foot_xz_speed: if phase == 0 { [0.0, 2.0 * v] } else { [2.0 * v, 0.0] },
+        foot_vertical_speed: [0.3, 0.3],
+        // Retail's walking steps play the patch's w13 = 1 sets (samples 30..59, 119..167):
+        // AudibleFootStepStrength below 2.
+        footstep_strength: 1.5,
+        ..Default::default()
+    }
+}
+
+fn print(name: &str, r: &Run, banks: &[&str], retail: &str) {
+    println!("--- {name} (posts {}; retail: {retail})", r.posts);
+    for ((bank, slot), g) in &r.gains {
+        if banks.contains(&bank.as_str()) {
+            println!("  {bank:20} sample {slot:4}  blocks {:5}  gain median {:.3}  p90 {:.3}  max {:.3}", g.len(), q(g, 0.5), q(g, 0.9), q(g, 1.0));
+        }
+    }
+}
+
+fn bank_gains<'a>(r: &'a Run, bank: &str) -> Vec<f32> {
+    r.gains.iter().filter(|((b, _), _)| b == bank).flat_map(|(_, g)| g.iter().copied()).collect()
+}
+
+#[test]
+fn offboard_clothing_and_hands_play_their_retail_banks() {
+    let Some(_) = harness() else { return eprintln!("skipped: no install MixMap / extracted banks / WAVs") };
+    // Walking 5.4 km/h on concrete, board not in hand: step layer sk8_foley 82 (samples 69..75,
+    // retail medians 0.21..0.26), walking foley 62 (samples 94..97, retail 0.387), the packets.
+    let r = run(300, |f| walking(f, 5.4, 20, 3));
+    print("walk 5.4 km/h concrete", &r, &["sk8_foley", "fstep_skateshoe1_sm"], "per-voice GAIN p50: 82 samples 69..75 0.011 0.015 0.024 0.022 0.056 0.076 0.110; 62 94..97 0.387; fstep 35..39 0.16-0.18, 50..54 0.16-0.20, 119..123 0.026-0.040, 141..145 0.062-0.073, 154..157 0.065-0.079, 163..167 0.080-0.10");
+    let foley: Vec<u16> = r.gains.keys().filter(|(b, _)| b == "sk8_foley").map(|(_, s)| *s).collect();
+    assert!(foley.iter().any(|s| (69..=75).contains(s)), "the step layer (82) plays: {foley:?}");
+    assert!(foley.iter().any(|s| (94..=97).contains(s)), "the walking foley (62) plays: {foley:?}");
+    assert!(bank_gains(&r, "sk8_foley").iter().all(|&g| g <= 1.0));
+    // Walking 14.4 km/h with the board in hand: 63 (103..107, retail 0.244) and 1122 (Skate_Collisions).
+    let r = run(300, |f| AudioState { offboard_308: true, ..walking(f, 14.4, 16, 3) });
+    print("walk 14.4 km/h, board in hand", &r, &["sk8_foley", "Skate_Collisions"], "per-voice p50: 63 103..107 0.244; 1121-1123 Skate_Collisions 30..34 0.22-0.34, 94..100 0.169-0.190");
+    assert!(!bank_gains(&r, "Skate_Collisions").is_empty(), "the board-in-hand layer plays");
+    // Running 25 km/h: run mode, step 102 (72..75, retail 0.08..0.24).
+    let r = run(300, |f| walking(f, 25.0, 12, 3));
+    print("run 25 km/h concrete", &r, &["sk8_foley"], "per-voice p50: 72..75 0.022 0.056 0.076 0.110 (all step sets)");
+    // Walking on metal (material 36): the Skate_Metal surface layer 416 at +48 6000 / 32767.
+    let r = run(300, |f| walking(f, 5.4, 20, 36));
+    print("walk 5.4 km/h metal 36", &r, &["Skate_Metal"], "416 at its 59 footstep starts (time-matched, 164620): p50 0.082 p90 0.281");
+    assert!(!bank_gains(&r, "Skate_Metal").is_empty(), "the material's surface layer plays");
+    // Pushing on the board: push stroke → 73, plant → 74 (retail 0.21..0.26), the plant's foot down.
+    let r = run(300, |f| {
+        let phase = f % 40;
+        AudioState {
+            com_velocity: [4.0, 0.0, 0.0],
+            ground_speed: 4.0,
+            wheel_count: 4,
+            wheel_contact: [true; 4],
+            push_stroke: (10..30).contains(&phase),
+            push_trigger: phase == 20,
+            push_planted: (20..28).contains(&phase),
+            foot_down: [false, (20..28).contains(&phase)],
+            foot_material: [3; 2],
+            ..Default::default()
+        }
+    });
+    print("pushing 14.4 km/h", &r, &["sk8_foley"], "per-voice p50: 73 4..7 0.176-0.260; 74 0..3 0.206-0.260");
+    let foley: Vec<u16> = r.gains.keys().filter(|(b, _)| b == "sk8_foley").map(|(_, s)| *s).collect();
+    assert!(foley.iter().any(|s| (0..=7).contains(s)), "the push foley plays: {foley:?}");
+    // Hands on and off the deck (picking the board up on foot with it in hand): 1125 / 1126.
+    let r = run(300, |f| AudioState {
+        on_foot: true,
+        offboard_308: true,
+        hands_on_deck: [(f / 30) % 2 == 1, false],
+        ..Default::default()
+    });
+    print("hand on / off the deck", &r, &["Skate_Collisions"], "per-voice p50: 1125 427..432 0.133-0.160; 1126 422..426 0.071-0.081");
+    assert!(!bank_gains(&r, "Skate_Collisions").is_empty(), "the hand sounds play");
+    // A bail sliding at 3 m/s: c_body_slide (Bodyslide, retail medians 0.001..0.035, max 0.47) and
+    // c_cloth_falls (Foley_Cloth, medians ≤ 0.025, max 0.19).
+    let r = run(240, |f| {
+        let mut body_slide = [0.0; 6];
+        let mut body_tag = [0; 6];
+        if f > 10 {
+            body_slide[0] = 2.0;
+            body_tag[0] = 41;
+        }
+        AudioState {
+            bail: f > 5,
+            com_velocity: [3.0, 0.0, 0.0],
+            body_speed: 3.0,
+            limb_speed: 3.5,
+            body_slide,
+            body_tag,
+            ..Default::default()
+        }
+    });
+    print("bail sliding 3 m/s", &r, &["Bodyslide", "Foley_Cloth"], "per-voice p50: Bodyslide 0..4 0.000-0.035; Foley_Cloth 0..7 0.017-0.052 (pitch p50 1.81: Clothing out1 is a volume read as pitch)");
+    assert!(!bank_gains(&r, "Bodyslide").is_empty(), "the body slide plays");
+    assert!(bank_gains(&r, "Bodyslide").iter().chain(bank_gains(&r, "Foley_Cloth").iter()).all(|&g| g <= 1.0));
+}
+
+/// Which `fstep_skateshoe1_sm` samples the footstep patch opens per packet word (w8 toggling
+/// every 20 frames, the other words as the updater writes them for a 5.4 km/h walk), to map the
+/// patch's sample groups. `--ignored --nocapture`.
+#[test]
+#[ignore]
+fn footstep_patch_sample_groups() {
+    let Some(_) = harness() else { return eprintln!("skipped") };
+    let base: Vec<i32> = vec![32767, 0, 4096, 0, 25000, 25000, 2456, 9200, 0, 2, 513, 0, 1, 2, 300, 1, 2, 1, 32767, 10000, 15000, 25000, 32767, 28000, 12];
+    let variants: Vec<(&str, usize, Vec<i32>)> = vec![
+        ("surface w16", 16, (1..=7).collect()),
+        ("code w17", 17, (1..=5).collect()),
+        ("bucket w12", 12, (1..=4).collect()),
+        ("strength w13", 13, vec![1, 2, 3, 5, 10]),
+        ("walk w14", 14, vec![0, 200, 400, 516]),
+        ("vertical w9", 9, vec![0, 2, 5, 8]),
+        ("xz w10", 10, vec![0, 300, 513]),
+        ("flag w11", 11, vec![0, 1]),
+    ];
+    for (name, word, values) in variants {
+        for v in values {
+            let mut h = harness().unwrap();
+            let class = h.rt.eval.class_id("playercharacter_footstep").unwrap();
+            let mut w = base.clone();
+            w[word] = v;
+            let mut post = w.clone();
+            post[8] = 0;
+            let node = h.rt.post(class, &post);
+            let mut out = vec![0.0f32; 1600];
+            let mut seen: BTreeMap<u16, (usize, f32)> = BTreeMap::new();
+            for f in 0..160 {
+                w[8] = i32::from((f / 20) % 2 == 1);
+                h.rt.redeliver(node, &w);
+                h.rt.fill_stereo(&mut out);
+                for vi in h.rt.mixer.snapshot() {
+                    if h.names.get(&vi.bank).map(String::as_str) == Some("fstep_skateshoe1_sm") && vi.gain > 0.0 {
+                        let e = seen.entry(vi.slot).or_insert((0, 0.0));
+                        e.0 += 1;
+                        e.1 = e.1.max(vi.gain);
+                    }
+                }
+            }
+            let list: Vec<String> = seen.iter().map(|(s, (n, g))| format!("{s}:{n}/{g:.3}")).collect();
+            println!("{name:13} = {v:4}: {}", list.join(" "));
+        }
+    }
+}
+
+/// The OffBoard / Clothing / Contacts outputs the components read, on foot and on the board.
+/// `--ignored --nocapture`.
+#[test]
+#[ignore]
+fn owner_outputs_on_foot_and_on_board() {
+    let Some(h) = harness() else { return eprintln!("skipped") };
+    for (name, on_foot, kmh) in [("on foot 5.4 km/h", true, 5.4f32), ("on foot 14.4", true, 14.4), ("on board 14.4", false, 14.4), ("on board 0", false, 0.0)] {
+        let mut m = MixMap::from_bytes(&h.mxb).unwrap();
+        let mut physics = inputs::Physics::default();
+        let mut positions = [ObjPos::default(), ObjPos::default()];
+        for f in 0..120 {
+            let mut s = walking(f, kmh, 20, 3);
+            s.on_foot = on_foot;
+            if !on_foot {
+                s.ground_speed = kmh / 3.6;
+                s.wheel_count = 4;
+                s.wheel_contact = [true; 4];
+            }
+            globals(&mut m);
+            physics.write(&mut m, &s);
+            let l = Listener { camera: [s.com_position[0] - 3.5, 2.4, 0.0], view: [1.0, -0.3, 0.0], camera_velocity: s.com_velocity, followed: s.com_position, facing: s.com_velocity, followed_velocity: s.com_velocity };
+            positions[0].write(&mut m, keys::obj_pos(0), &l, Some((s.com_position, s.com_velocity)));
+            positions[1].write(&mut m, keys::obj_pos2(0), &l, Some((s.board_position, s.board_velocity)));
+            inputs::write_off_board(&mut m, &s);
+            m.tick(1.0 / 60.0);
+        }
+        let o = keys::off_board(0);
+        let c = keys::clothing(0);
+        let k = keys::contacts(0);
+        let off: Vec<String> = (0..17).map(|i| format!("{i}:{}", m.level(o, i))).collect();
+        let cl: Vec<String> = (0..8).map(|i| format!("{i}:{}", m.level(c, i))).collect();
+        println!("{name:18} OffBoard {} | pitch1 {} raw0 {}", off.join(" "), m.pitch_4096(o, 1), m.raw(o, 0));
+        println!("{:18} Clothing {} | pitch1 {} pitch3 {} pitch6 {} | Contacts 10:{} 11 pitch {}", "", cl.join(" "), m.pitch_4096(c, 1), m.pitch_4096(c, 3), m.pitch_4096(c, 6), m.level(k, 10), m.pitch_4096(k, 11));
+    }
+}
diff --git a/crates/skate-audio/tests/player_tricks.rs b/crates/skate-audio/tests/player_tricks.rs
new file mode 100644
index 00000000..f56604a0
--- /dev/null
+++ b/crates/skate-audio/tests/player_tricks.rs
@@ -0,0 +1,651 @@
+//! The Tricks component (`player::tricks`: Class_Flips, cloth_trick) and `Class_Treatment`
+//! through the real banks, MixMap and runtime, headless, against the retail recomp sessions'
+//! per-voice gains (`.claude/skills/aems-port/tools/retail_voices.py`, sessions
+//! all_20261002_163809 / 164620; spec `.claude/notes/aems-tricks-treatment-spec.md` §6).
+//!
+//! Data-gated: skipped without the install's `assets/private/audio` (banks, WAVs, MixMap). The
+//! `Treatments` bank is not exported by setup yet; it is read from `assets/private/audio` when
+//! present, else from `.local/audio-re/tricks` (`decode_bank.py Treatments`). Run with
+//! `cargo test --release --test player_tricks -- --nocapture` for the tables.
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use skate_audio::eval::NodeId;
+use skate_audio::formats::{Bank, Project};
+use skate_audio::mixer::Pcm;
+use skate_audio::mixmap::{MixMap, keys};
+use skate_audio::player::components::{Command, Slot};
+use skate_audio::player::globals::Globals;
+use skate_audio::player::inputs::Physics;
+use skate_audio::player::objpos::{Listener, ObjPos};
+use skate_audio::player::treatment::{Treatment, TreatmentGlobals, TreatmentTuning};
+use skate_audio::player::tricks::{FOLEY_UTILITY, Tricks, TricksTuning};
+use skate_audio::player::{AudioState, Owner};
+use skate_audio::runtime::Runtime;
+
+/// The disc's project order (audiofiles.big archive order, as setup installs them).
+const PROJECTS: &[&str] = &[
+    "SK8_AEMS_Foley.csi",
+    "Sk8_moments.csi",
+    "Sk8_Emitters_Project.csi",
+    "SK8_AEMS_rolling.csi",
+    "SK8_AEMS_Crowds.csi",
+    "Sk8_AEMS_MoveableObjects.csi",
+    "AEMS_TRAFFIC.csi",
+    "AEMS_Calibrate.csi",
+    "SK8_AEMS_skateboard.csi",
+];
+
+fn root() -> PathBuf {
+    Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../")).to_path_buf()
+}
+
+fn wav_pcm(bytes: &[u8]) -> Option<Pcm> {
+    let (mut channels, mut rate, mut bits) = (0usize, 0u32, 0u16);
+    let mut at = 12;
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().ok()?) as usize;
+        let body = at + 8;
+        match &bytes[at..at + 4] {
+            b"fmt " => {
+                channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+                rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().ok()?);
+                bits = u16::from_le_bytes([bytes[body + 14], bytes[body + 15]]);
+            }
+            b"data" if channels > 0 && bits == 16 => {
+                let data = &bytes[body..(body + size).min(bytes.len())];
+                let mut planar = vec![Vec::new(); channels];
+                for (i, s) in data.chunks_exact(2).enumerate() {
+                    planar[i % channels].push(f32::from(i16::from_le_bytes([s[0], s[1]])) / 32768.0);
+                }
+                return Some(Pcm { rate, channels: planar });
+            }
+            _ => {}
+        }
+        at = body + size + (size & 1);
+    }
+    None
+}
+
+/// Where a bank's `.abk` and decoded WAVs are: the install, or the local research copy.
+fn bank_dirs(stem: &str) -> Option<(PathBuf, PathBuf)> {
+    let install = root().join("assets/private/audio");
+    let local = root().join(".local/audio-re/tricks");
+    [(install.join("aems"), install.clone()), (local.clone(), local)]
+        .into_iter()
+        .find(|(abk, wavs)| abk.join(format!("{stem}.abk")).is_file() && wavs.join(format!("banks/{stem}/0000.wav")).is_file())
+}
+
+struct Rig {
+    rt: Runtime,
+    names: HashMap<usize, &'static str>,
+    mixmap: MixMap,
+    physics: Physics,
+    positions: [ObjPos; 2],
+    nodes: HashMap<Slot, NodeId>,
+    posts: Vec<(usize, &'static str, Vec<i32>)>,
+    frame: usize,
+}
+
+impl Rig {
+    fn new(banks: &[&'static str]) -> Option<Self> {
+        let aems = root().join("assets/private/audio/aems");
+        let mxb = std::fs::read(aems.join("MixMapSK8.mxb")).ok()?;
+        let mut rt = Runtime::new();
+        for name in PROJECTS {
+            rt.install_project(&Project::parse(name, &std::fs::read(aems.join(name)).ok()?).ok()?);
+        }
+        let mut names = HashMap::new();
+        for &stem in std::iter::once(&"emitter_utility").chain(banks) {
+            let (abk, wavs) = bank_dirs(stem).or_else(|| (stem == "emitter_utility").then(|| (aems.clone(), root().join("assets/private/audio"))))?;
+            let bank = Bank::parse(stem, std::fs::read(abk.join(format!("{stem}.abk"))).ok()?).ok()?;
+            let pcm: Vec<Option<Arc<Pcm>>> = (0..bank.samples.len())
+                .map(|i| std::fs::read(wavs.join(format!("banks/{stem}/{i:04}.wav"))).ok().and_then(|b| wav_pcm(&b)).map(Arc::new))
+                .collect();
+            names.insert(rt.load_bank(bank, pcm), stem);
+        }
+        let utility = rt.eval.class_id("c_emitter_utility")?;
+        rt.post(utility, &[]);
+        if let Some(foley) = rt.eval.class_id(FOLEY_UTILITY) {
+            rt.post(foley, &[]); // retail posts it once at boot
+        }
+        let mixmap = MixMap::from_bytes(&mxb).ok()?;
+        Some(Self { rt, names, mixmap, physics: Physics::default(), positions: [ObjPos::default(); 2], nodes: HashMap::new(), posts: Vec::new(), frame: 0 })
+    }
+
+    fn inputs(&mut self, s: &AudioState) {
+        let m = &mut self.mixmap;
+        for id in 1..=4 {
+            m.set_input(keys::MASTER, id, 32767);
+        }
+        for id in [1, 2, 5] {
+            m.set_input(keys::MUSIC, id, 32767);
+        }
+        m.set_input(keys::REVERB, 5, 32767);
+        self.physics.write(m, s);
+        let camera = [s.com_position[0] - 3.5, s.com_position[1] + 1.4, s.com_position[2]];
+        let l = Listener { camera, view: [1.0, -0.3, 0.0], camera_velocity: s.com_velocity, followed: s.com_position, facing: s.com_velocity, followed_velocity: s.com_velocity };
+        self.positions[0].write(m, keys::obj_pos(0), &l, Some((s.com_position, s.com_velocity)));
+        self.positions[1].write(m, keys::obj_pos2(0), &l, Some((s.board_position, s.board_velocity)));
+    }
+
+    fn apply(&mut self, cmds: Vec<Command>) {
+        for cmd in cmds {
+            match cmd {
+                Command::Post { slot, class, words } => {
+                    let id = self.rt.eval.class_id(class).unwrap_or_else(|| panic!("no class {class}"));
+                    if let Some(old) = self.nodes.remove(&slot) {
+                        self.rt.release(old);
+                    }
+                    self.posts.push((self.frame, class, words.clone()));
+                    let node = self.rt.post(id, &words);
+                    self.nodes.insert(slot, node);
+                }
+                Command::Redeliver { slot, words } => {
+                    if let Some(&node) = self.nodes.get(&slot) {
+                        self.rt.redeliver(node, &words);
+                    }
+                }
+                Command::Release { slot } => {
+                    if let Some(node) = self.nodes.remove(&slot) {
+                        self.rt.release(node);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Render one 60 Hz frame (800 stereo frames at 48 kHz); per live voice (bank, slot, id, gain).
+    fn render(&mut self) -> Vec<(&'static str, u16, u32, f32)> {
+        let mut out = vec![0.0f32; 1600];
+        self.rt.fill_stereo(&mut out);
+        self.frame += 1;
+        self.rt.mixer.snapshot().into_iter().filter_map(|v| Some((*self.names.get(&v.bank)?, v.slot, v.id, v.gain))).collect()
+    }
+}
+
+/// A trick: rolling at 20 km/h along +x, `pre` frames with the trick registered on the ground
+/// (retail: cloth A ~13 frames before the air), `air` frames in the air with the deck spinning at
+/// `spin` rad/s about its Ri / Up / At rows (`+480` / `+484` / `+488`), the jump height (`+260`) the
+/// highest point so far of a ballistic hop over the air time, then rolling again.
+fn trick_state(f: usize, id: i32, id2: i32, pre: usize, air: usize, spin: [f32; 3]) -> AudioState {
+    let v = 20.0 / 3.6;
+    let x = v * f as f32 / 60.0;
+    let start = 30;
+    let in_air = f >= start + pre && f < start + pre + air;
+    let registered = f >= start && f < start + pre + air;
+    let t_air = (f as f32 - (start + pre) as f32) / 60.0;
+    let total = air as f32 / 60.0;
+    let v0 = 9.81 * total / 2.0;
+    let rise = t_air.min(total / 2.0);
+    let height = v0 * rise - 0.5 * 9.81 * rise * rise;
+    AudioState {
+        ground_speed: v,
+        com_velocity: [v, 0.0, 0.0],
+        com_position: [x, 1.0, 0.0],
+        board_position: [x, 0.1, 0.0],
+        board_velocity: [v, 0.0, 0.0],
+        wheel_count: if in_air { 0 } else { 4 },
+        wheel_contact: [!in_air; 4],
+        wheel_material: [if in_air { 143 } else { 3 }; 4],
+        airborne: in_air,
+        air_time: if in_air { t_air } else { 0.0 },
+        air_until_landing: if in_air { total - t_air } else { 0.0 },
+        jump_height: if in_air { height } else { 0.0 },
+        trick_active: registered,
+        audio_trick: if registered { id } else { -1 },
+        audio_trick_2: if registered { id2 } else { -1 },
+        scorable: if registered { 1 } else { -1 },
+        deck_spin_xy: if in_air { [spin[0], spin[1]] } else { [0.0; 2] },
+        deck_spin: if in_air { spin[2] } else { 0.0 },
+        ..Default::default()
+    }
+}
+
+struct Stats {
+    /// Per bank: per voice id, (slot, start frame, gains while it sounded).
+    voices: HashMap<&'static str, std::collections::BTreeMap<u32, (u16, usize, Vec<f32>)>>,
+    posts: Vec<(usize, &'static str, Vec<i32>)>,
+}
+
+fn run_tricks(frames: usize, state: impl Fn(usize) -> AudioState) -> Option<Stats> {
+    let mut rig = Rig::new(&["Sk8_Air_Flip_Tricks", "Foley_Cloth"])?;
+    let (t, g) = (TricksTuning::default(), Globals::default());
+    let mut k = Tricks::default();
+    let mut voices: HashMap<&'static str, std::collections::BTreeMap<u32, (u16, usize, Vec<f32>)>> = HashMap::new();
+    for f in 0..frames {
+        let s = state(f);
+        rig.inputs(&s);
+        let cmds = k.process(&s, &t, &g, &Owner { mixmap: &rig.mixmap, key: keys::tricks(0) });
+        rig.apply(cmds);
+        rig.mixmap.tick(s.dt);
+        let cmds = k.update(&s, &t, &Owner { mixmap: &rig.mixmap, key: keys::tricks(0) });
+        rig.apply(cmds);
+        for (bank, slot, id, gain) in rig.render() {
+            voices.entry(bank).or_default().entry(id).or_insert((slot, f, Vec::new())).2.push(gain);
+        }
+    }
+    Some(Stats { voices, posts: rig.posts })
+}
+
+fn peak(g: &[f32]) -> f32 {
+    g.iter().copied().fold(0.0, f32::max)
+}
+
+/// Kickflip, heelflip, pop shove-it, 360 flip and ollie through the real banks: what posts, which
+/// samples open and at which (peak) gain, against retail's Sk8_Air_Flip_Tricks per-stream medians
+/// (164620: streams 0–3 0.35–0.37, 5 0.134, 10–13 ~0.04) and the cloth_trick samples (8–24:
+/// 0.21–0.31). Asserts: Class_Flips posts once on the first air frame and opens a voice; the
+/// voices stay within unity and the flip whooshes land within 3 dB of retail's 0.35.
+#[test]
+fn tricks_play_their_retail_banks() {
+    // Flips spin about the deck's At row, shove-its about Up, the ollie pitches about Ri.
+    let cases = [
+        ("kickflip", 0, 28, [0.0, 0.0, 25.0]),
+        ("heelflip", 1, 28, [0.0, 0.0, -25.0]),
+        ("popshuvit", 2, 28, [0.0, 12.0, 0.0]),
+        ("360flip", 10, 28, [0.0, 12.0, 25.0]),
+        ("ollie", 28, -1, [2.0, 0.0, 0.0]),
+    ];
+    println!("trick       posts (frame class w11)              Flips voices slot:peak            cloth voices slot:peak");
+    let mut whooshes = Vec::new();
+    for (name, id, id2, spin) in cases {
+        let Some(r) = run_tricks(150, |f| trick_state(f, id, id2, 13, 36, spin)) else {
+            return eprintln!("skipped: no install with the trick banks and MixMap");
+        };
+        let posts: Vec<String> = r.posts.iter().map(|(f, c, w)| format!("{f}:{c}:{}", if *c == "Class_Flips" { w[11] } else { w[9] })).collect();
+        let list = |bank: &str| -> String {
+            r.voices.get(bank).map_or(String::new(), |v| v.values().map(|(slot, _, g)| format!("{slot}:{:.3}", peak(g))).collect::<Vec<_>>().join(" "))
+        };
+        println!("{name:10}  {:40} {:30} {}", posts.join(" "), list("Sk8_Air_Flip_Tricks"), list("Foley_Cloth"));
+        let flips: Vec<_> = r.posts.iter().filter(|p| p.1 == "Class_Flips").collect();
+        assert_eq!(flips.len(), 1, "{name}: one Class_Flips post");
+        assert_eq!(flips[0].0, 30 + 13, "{name}: posted on the first air frame");
+        let fv = r.voices.get("Sk8_Air_Flip_Tricks").cloned().unwrap_or_default();
+        assert!(!fv.is_empty(), "{name}: no Sk8_Air_Flip_Tricks voice");
+        for (bank, v) in &r.voices {
+            for (slot, _, g) in v.values() {
+                assert!(peak(g) <= 1.0, "{name}: {bank}:{slot} above unity");
+            }
+        }
+        whooshes.extend(fv.values().filter(|(slot, ..)| *slot <= 3).map(|(.., g)| peak(g)));
+    }
+    if !whooshes.is_empty() {
+        whooshes.sort_by(f32::total_cmp);
+        let med = whooshes[whooshes.len() / 2];
+        let db = 20.0 * (med / 0.35).log10();
+        println!("flip whooshes (slots 0-3): {} voices, median peak gain {med:.3} vs retail 0.35 ({db:+.1} dB)", whooshes.len());
+        assert!(db.abs() < 3.0, "flip whoosh {db:+.1} dB from retail");
+    }
+}
+
+/// First-trigger rule: the same kickflip twice; every voice of the first trick (the bank's first
+/// use) peaks at the gain the same sample reaches in the second.
+#[test]
+fn the_first_flip_sounds_like_the_second() {
+    let Some(r) = run_tricks(300, |f| trick_state(f % 150, 0, 28, 13, 36, [0.0, 0.0, 25.0])) else {
+        return eprintln!("skipped: no install with the trick banks and MixMap");
+    };
+    for bank in ["Sk8_Air_Flip_Tricks", "Foley_Cloth"] {
+        let v = &r.voices[bank];
+        let first: Vec<(u16, f32)> = v.values().filter(|x| x.1 < 150).map(|(slot, _, g)| (*slot, peak(g))).collect();
+        let second: Vec<(u16, f32)> = v.values().filter(|x| x.1 >= 150).map(|(slot, _, g)| (*slot, peak(g))).collect();
+        println!("{bank}: first trick {first:?}, second {second:?}");
+        assert!(!first.is_empty() && !second.is_empty(), "{bank}: both tricks play");
+        for (slot, gain) in &first {
+            if let Some((_, later)) = second.iter().find(|(s, _)| s == slot) {
+                assert!((20.0 * (gain / later).log10()).abs() < 0.1, "{bank} slot {slot}: first {gain} vs later {later}");
+            }
+        }
+    }
+}
+
+/// Two 0.6 s airs (retail's scripted hops are 0.61–0.64 s): returns per Treatments voice (start
+/// frame, slot, peak gain) and the Class_Treatment post count.
+fn run_treatment(b: TreatmentGlobals) -> Option<(Vec<(usize, u16, f32)>, usize)> {
+    run_treatment_with(b, |f| trick_state(f % 200, 0, 28, 13, 36, [0.0, 0.0, 25.0]))
+}
+
+fn run_treatment_with(b: TreatmentGlobals, state: impl Fn(usize) -> AudioState) -> Option<(Vec<(usize, u16, f32)>, usize)> {
+    let mut rig = Rig::new(&["Treatments"])?;
+    let (t, g) = (TreatmentTuning::default(), Globals::default());
+    let mut k = Treatment::default();
+    let mut voices: HashMap<u32, (u16, usize, Vec<f32>)> = HashMap::new();
+    for f in 0..400 {
+        let s = state(f);
+        rig.inputs(&s);
+        let cmds = k.process(&s, &t, &g, &Owner { mixmap: &rig.mixmap, key: keys::treatments(0) });
+        rig.apply(cmds);
+        rig.mixmap.tick(s.dt);
+        let cmds = k.update(&s, &b, &t, &Owner { mixmap: &rig.mixmap, key: keys::treatments(0) });
+        rig.apply(cmds);
+        for (_, slot, id, gain) in rig.render() {
+            voices.entry(id).or_insert((slot, f, Vec::new())).2.push(gain);
+        }
+    }
+    let mut starts: Vec<(usize, u16, f32)> = voices.values().map(|(slot, f, g)| (*f, *slot, peak(g))).collect();
+    starts.sort_by_key(|x| (x.0, x.1));
+    Some((starts, rig.posts.iter().filter(|p| p.1 == "Class_Treatment").count()))
+}
+
+/// Class_Treatment through the real bank: posted once, its streams 13 and 14 start in each air at
+/// retail's gains (164620: 54 × 0.0746 and 50 × 0.0186 — within 0.5 dB) when the predicted time to
+/// the landing (`+240`, w8) falls through ~0.37 s (retail: 14–326 ms before the touchdown contact,
+/// the prediction being approximate). Slots 16 / 17 (the long-air layer that follows w8 from
+/// takeoff) play too, as in the recomp (see `treatment_replay_of_the_recomp_capture`). Also prints,
+/// with the `B+164` flag of PR #4's capture set, slots 0–12 (retail never plays them: the reset
+/// values stay).
+#[test]
+fn treatment_plays_before_the_landing_at_the_retail_level() {
+    let Some((starts, posts)) = run_treatment(TreatmentGlobals::default()) else {
+        return eprintln!("skipped: no Treatments bank (decode_bank.py Treatments) or no install");
+    };
+    let landings = [30 + 13 + 36, 230 + 13 + 36];
+    println!("Treatments voices (start frame, slot, peak gain), landings at frames {landings:?}:\n  {starts:?}");
+    assert_eq!(posts, 1, "posted once");
+    for land in landings {
+        for (slot, retail) in [(13u16, 0.0746f32), (14, 0.0186)] {
+            let v = starts.iter().find(|v| v.1 == slot && v.0 < land && v.0 + 30 > land);
+            let Some(&(f, _, gain)) = v else { panic!("slot {slot} did not start before the landing at {land}") };
+            let db = 20.0 * (gain / retail).log10();
+            println!("  slot {slot}: {} frames before the landing, gain {gain:.4} vs retail {retail} ({db:+.2} dB)", land - f);
+            assert!(db.abs() < 0.5, "slot {slot}: {db:+.2} dB");
+        }
+    }
+    if let Some((with_flag, _)) = run_treatment(TreatmentGlobals { flag_164: true, value_168: 1.0, ..Default::default() }) {
+        let extra: Vec<_> = with_flag.iter().filter(|v| v.1 <= 12).collect();
+        println!("with B+164 set and B+168 = 1.0 (PR #4's capture): slots 0-12 open {} times: {extra:?}", extra.len());
+    }
+}
+
+/// Diagnostic (ignored; `--nocapture`): which packet word starts Treatments slots 16 / 17. The
+/// fixture's air words are varied one at a time over the same two 0.6 s airs. (Written when 16 / 17
+/// seemed absent from the recomp; they are not — their samples equal sense_of_speed 3 / 4.)
+#[test]
+#[ignore = "diagnostic"]
+fn treatment_slots_16_17_by_word() {
+    let base = |f: usize| trick_state(f % 200, 0, 28, 13, 36, [0.0, 0.0, 25.0]);
+    let profiles: Vec<(&str, Box<dyn Fn(usize) -> AudioState>)> = vec![
+        ("fixture", Box::new(base)),
+        ("w9 height 0", Box::new(move |f| AudioState { jump_height: 0.0, ..base(f) })),
+        ("w7 air time 0", Box::new(move |f| AudioState { air_time: 0.0, ..base(f) })),
+        ("w8 to landing 0", Box::new(move |f| AudioState { air_until_landing: 0.0, ..base(f) })),
+        ("w8 10 s on the ground", Box::new(move |f| {
+            let s = base(f);
+            AudioState { air_until_landing: if s.airborne { s.air_until_landing } else { 10.0 }, ..s }
+        })),
+        ("w8 4 s on the first air frame", Box::new(move |f| {
+            let s = base(f);
+            let first = s.airborne && s.air_time < 0.02;
+            AudioState { air_until_landing: if first { 4.0 } else { s.air_until_landing }, ..s }
+        })),
+        ("w8 delayed 1 frame", Box::new(move |f| {
+            let s = base(f);
+            let prev = base(f.saturating_sub(1));
+            AudioState { air_until_landing: if prev.airborne { s.air_until_landing } else { 0.0 }, ..s }
+        })),
+    ];
+    for (name, p) in profiles {
+        let Some((starts, _)) = run_treatment_with(TreatmentGlobals::default(), p) else {
+            return eprintln!("skipped: no Treatments bank or install");
+        };
+        let slots: Vec<_> = starts.iter().filter(|v| v.1 >= 15).collect();
+        println!("{name:32} slots ≥ 15: {slots:?}");
+    }
+}
+
+/// Diagnostic (ignored; `--nocapture`): Treatments slots 16 / 17 against a w8 step from 0 to a
+/// constant (s) at frame 40, held on the ground (no air flags).
+#[test]
+#[ignore = "diagnostic"]
+fn treatment_slots_16_17_by_w8_step() {
+    for v in [0.05f32, 0.1, 0.2, 0.3, 0.37, 0.4, 0.5, 0.7, 1.0, 2.0, 5.0, 10.0] {
+        let p = move |f: usize| AudioState { air_until_landing: if (40..160).contains(&f) { v } else { 0.0 }, ..AudioState::default() };
+        let Some((starts, _)) = run_treatment_with(TreatmentGlobals::default(), p) else {
+            return eprintln!("skipped: no Treatments bank or install");
+        };
+        println!("w8 {v:5.2} s: {:?}", starts);
+    }
+}
+
+/// Diagnostic (ignored; `--nocapture`): the fixture's two airs with one Class_Treatment packet word
+/// forced (post and every redelivery): which slots each word drives, with peak gains
+/// (`SWEEP_WORDS`, `SWEEP_VALUES`). 13 / 14 scale with w0; w7 ≥ 1 s keeps them silent.
+#[test]
+#[ignore = "diagnostic"]
+fn treatment_slots_16_17_by_forced_word() {
+    let mut cases: Vec<(usize, i32)> = vec![(99, 0)];
+    let words: Vec<usize> = std::env::var("SWEEP_WORDS").ok().map_or(vec![0, 1, 2, 3, 5, 6, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21], |s| s.split(',').map(|w| w.parse().unwrap()).collect());
+    let values: Vec<i32> = std::env::var("SWEEP_VALUES").ok().map_or(vec![0, 1, 2, 8, 500, 1000, 32767], |s| s.split(',').map(|w| w.parse().unwrap()).collect());
+    for &w in &words {
+        for &v in &values {
+            cases.push((w, v));
+        }
+    }
+    for (word, value) in cases {
+        let Some(mut rig) = Rig::new(&["Treatments"]) else { return eprintln!("skipped: no Treatments bank or install") };
+        let (t, g) = (TreatmentTuning::default(), Globals::default());
+        let mut k = Treatment::default();
+        let mut starts: Vec<(usize, u16)> = Vec::new();
+        let mut seen = std::collections::HashSet::new();
+        let mut peaks: HashMap<u16, f32> = HashMap::new();
+        let force = |cmds: Vec<Command>| -> Vec<Command> {
+            cmds.into_iter()
+                .map(|c| match c {
+                    Command::Post { slot, class, mut words } if word < words.len() => {
+                        words[word] = value;
+                        Command::Post { slot, class, words }
+                    }
+                    Command::Redeliver { slot, mut words } if word < words.len() => {
+                        words[word] = value;
+                        Command::Redeliver { slot, words }
+                    }
+                    c => c,
+                })
+                .collect()
+        };
+        for f in 0..400 {
+            let s = trick_state(f % 200, 0, 28, 13, 36, [0.0, 0.0, 25.0]);
+            rig.inputs(&s);
+            let cmds = k.process(&s, &t, &g, &Owner { mixmap: &rig.mixmap, key: keys::treatments(0) });
+            rig.apply(force(cmds));
+            rig.mixmap.tick(s.dt);
+            let cmds = k.update(&s, &TreatmentGlobals::default(), &t, &Owner { mixmap: &rig.mixmap, key: keys::treatments(0) });
+            if word == 99 && f % 50 == 0 {
+                if let Some(Command::Redeliver { words, .. }) = cmds.first() {
+                    println!("  frame {f}: fixture words {words:?}");
+                }
+            }
+            rig.apply(force(cmds));
+            for (_, slot, id, gain) in rig.render() {
+                if seen.insert(id) {
+                    starts.push((f, slot));
+                }
+                let p = peaks.entry(slot).or_default();
+                *p = p.max(gain);
+            }
+        }
+        let has = |s: u16| starts.iter().filter(|x| x.1 == s).count();
+        let pk = |s: u16| peaks.get(&s).copied().unwrap_or(0.0);
+        println!("w{word:<2} = {value:5}: 13/14 {}/{} (peak {:.4}/{:.4}), 16/17 {}/{} (peak {:.4}/{:.4}), other {:?}", has(13), has(14), pk(13), pk(14), has(16), has(17), pk(16), pk(17),
+            starts.iter().filter(|x| ![13, 14, 16, 17].contains(&x.1)).collect::<Vec<_>>());
+    }
+}
+
+/// One `TREAT` row of a recomp session (hook on `sub_824DD6F0`, after the call): ms, `+236`,
+/// `+240`, `+260`, `+224`, `+332`, `+200`.
+#[derive(Clone, Copy, Debug)]
+struct TreatRow {
+    ms: f64,
+    air_time: f32,
+    to_land: f32,
+    height: f32,
+    g224: bool,
+    air: bool,
+}
+
+/// The `TREAT` rows of one object of a recomp session (`TREAT_SESSION`, default the TREAT
+/// session all_20261002_223306; `TREAT_OBJECT`, default the local player's object there).
+fn treat_rows() -> Option<Vec<TreatRow>> {
+    let session = std::env::var("TREAT_SESSION").map(PathBuf::from).unwrap_or_else(|_| root().join(".local/recomp/sessions/all_20261002_223306"));
+    let object = std::env::var("TREAT_OBJECT").unwrap_or_else(|_| "40C581A0".into());
+    let text = std::fs::read_to_string(session.join("trace.tsv")).ok()?;
+    let rows: Vec<TreatRow> = text
+        .lines()
+        .filter(|l| l.starts_with("TREAT\t"))
+        .map(|l| l.split('\t').collect::<Vec<_>>())
+        .filter(|f| f.len() >= 10 && f[8] == object)
+        .map(|f| TreatRow {
+            ms: f[1].parse().unwrap(),
+            air_time: f[2].parse().unwrap(),
+            to_land: f[3].parse().unwrap(),
+            height: f[4].parse().unwrap(),
+            g224: f[5] != "0",
+            air: f[6] != "0",
+        })
+        .collect();
+    (!rows.is_empty()).then_some(rows)
+}
+
+/// The recomp's air spans (first and last air row ms) of [`treat_rows`].
+fn treat_airs(rows: &[TreatRow]) -> Vec<(f64, f64)> {
+    let mut airs = Vec::new();
+    let mut start = None;
+    for (i, r) in rows.iter().enumerate() {
+        match (r.air, start) {
+            (true, None) => start = Some(r.ms),
+            (false, Some(s)) => {
+                airs.push((s, rows[i - 1].ms));
+                start = None;
+            }
+            _ => {}
+        }
+    }
+    airs
+}
+
+/// One Treatments voice of a replay: start / last sounding ms on the capture's clock, slot, peak gain.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct ReplayVoice {
+    start: f64,
+    end: f64,
+    slot: u16,
+    peak: f32,
+}
+
+/// Replays a recomp TREAT capture through Class_Treatment on the real bank, one update per 60 Hz
+/// frame from the last row at or before the frame's time (`shape` may rewrite each frame's state).
+fn replay_treat(rows: &[TreatRow], shape: impl Fn(&AudioState, f64) -> AudioState) -> Option<Vec<ReplayVoice>> {
+    let mut rig = Rig::new(&["Treatments"])?;
+    let (t, g) = (TreatmentTuning::default(), Globals::default());
+    let mut k = Treatment::default();
+    let mut voices: HashMap<u32, ReplayVoice> = HashMap::new();
+    let (t0, t1) = (rows[0].ms, rows[rows.len() - 1].ms);
+    let mut at = 0;
+    let mut f = 0usize;
+    loop {
+        let ms = t0 + f as f64 * 1000.0 / 60.0;
+        if ms > t1 {
+            break;
+        }
+        while at + 1 < rows.len() && rows[at + 1].ms <= ms {
+            at += 1;
+        }
+        let r = rows[at];
+        let base = AudioState {
+            airborne: r.air,
+            air_time: r.air_time,
+            air_until_landing: r.to_land,
+            jump_height: r.height,
+            global_224: r.g224,
+            wheel_count: if r.air { 0 } else { 4 },
+            wheel_contact: [!r.air; 4],
+            ..Default::default()
+        };
+        let s = shape(&base, ms);
+        rig.inputs(&s);
+        let cmds = k.process(&s, &t, &g, &Owner { mixmap: &rig.mixmap, key: keys::treatments(0) });
+        rig.apply(cmds);
+        rig.mixmap.tick(s.dt);
+        let cmds = k.update(&s, &TreatmentGlobals::default(), &t, &Owner { mixmap: &rig.mixmap, key: keys::treatments(0) });
+        rig.apply(cmds);
+        for (_, slot, id, gain) in rig.render() {
+            let v = voices.entry(id).or_insert(ReplayVoice { start: ms, end: ms, slot, peak: 0.0 });
+            v.peak = v.peak.max(gain);
+            v.end = ms;
+        }
+        f += 1;
+    }
+    let mut out: Vec<ReplayVoice> = voices.into_values().collect();
+    out.sort_by(|a, b| a.start.total_cmp(&b.start).then(a.slot.cmp(&b.slot)));
+    Some(out)
+}
+
+/// Diagnostic (ignored; `--nocapture`): the recomp's own Class_Treatment inputs (TREAT capture)
+/// replayed through our Class_Treatment, bank and evaluator: which slots open per air, when they
+/// end, and whether `+236` on the landing tick matters.
+#[test]
+#[ignore = "diagnostic"]
+fn treatment_replays_the_recomp_capture() {
+    let Some(rows) = treat_rows() else { return eprintln!("skipped: no TREAT session") };
+    let Some(voices) = replay_treat(&rows, |s, _| s.clone()) else { return eprintln!("skipped: no Treatments bank") };
+    let airs = treat_airs(&rows);
+    for &(a, b) in &airs {
+        let inside: Vec<_> = voices
+            .iter()
+            .filter(|v| v.start >= a - 100.0 && v.start <= b + 300.0)
+            .map(|v| (v.slot, (v.start - a).round(), (v.end - a).round(), (v.peak * 1e4).round() / 1e4))
+            .collect();
+        println!("air {a:9.1} ({:4.0} ms): (slot, start, end, peak) {inside:?}", b - a);
+    }
+    let count = |s: u16| voices.iter().filter(|v| v.slot == s).count();
+    println!("totals: 13 {} 14 {} 15 {} 16 {} 17 {}", count(13), count(14), count(15), count(16), count(17));
+    // The engine before 2026-10-02 dropped `+236` to 0 on the landing tick (the recomp holds it
+    // one tick, like `+240`): does that tick change anything?
+    let Some(zeroed) = replay_treat(&rows, |s, _| AudioState { air_time: if s.airborne { s.air_time } else { 0.0 }, ..s.clone() }) else { return };
+    println!("+236 zeroed on the landing tick: identical voices = {}", zeroed == voices);
+}
+
+/// The recomp's Treatments voices in the TREAT session all_20261002_223306 (University: plain
+/// ollies, one ~2 s air off a ramp), from `retail_voices.py` with the sample-address
+/// disambiguation: Treatments 16 / 17 are byte-identical to sense_of_speed 3 / 4, so they read as
+/// sense_of_speed before it. Slots 13 / 14 / 15 / 16 / 17: 18 / 18 / 1 / 18 / 18 voices. In the 15
+/// airs of 0.6–1.0 s, 16 and 17 each open once per air (median 87 ms after takeoff), peak gains
+/// 0.0042–0.0287, median 0.0149.
+const RECOMP_TREATMENT_VOICES: [(u16, usize); 5] = [(13, 18), (14, 18), (15, 1), (16, 18), (17, 18)];
+const RECOMP_LONG_AIR_GAIN_MEDIAN: f32 = 0.0149;
+
+/// The recomp's own Class_Treatment inputs (`+236` / `+240` / `+260` / `+224` / `+332` per frame,
+/// TREAT capture) through our Class_Treatment, bank and evaluator give the recomp's Treatments
+/// voices: 13 / 14 / 15 exactly, 16 / 17 in every 0.6–1.0 s air at the recomp's level. Data-gated
+/// (the session and the Treatments bank).
+#[test]
+fn treatment_replay_of_the_recomp_capture() {
+    let Some(rows) = treat_rows() else { return eprintln!("skipped: no TREAT session") };
+    let Some(voices) = replay_treat(&rows, |s, _| s.clone()) else { return eprintln!("skipped: no Treatments bank") };
+    let count = |slot: u16| voices.iter().filter(|v| v.slot == slot).count();
+    for (slot, recomp) in RECOMP_TREATMENT_VOICES {
+        println!("slot {slot}: {} voices (recomp {recomp})", count(slot));
+    }
+    for (slot, recomp) in &RECOMP_TREATMENT_VOICES[..3] {
+        assert_eq!(count(*slot), *recomp, "slot {slot}");
+    }
+    for (slot, recomp) in &RECOMP_TREATMENT_VOICES[3..] {
+        assert!(count(*slot).abs_diff(*recomp) <= 3, "slot {slot}: {} vs the recomp's {recomp}", count(*slot));
+    }
+    let mut gains = Vec::new();
+    for (a, b) in treat_airs(&rows).into_iter().filter(|(a, b)| (600.0..=1000.0).contains(&(b - a))) {
+        for slot in [16u16, 17] {
+            let v: Vec<_> = voices.iter().filter(|v| v.slot == slot && v.start >= a - 100.0 && v.start <= b).collect();
+            assert!(!v.is_empty(), "slot {slot} did not open in the {:.0} ms air at {a}", b - a);
+            gains.extend(v.iter().map(|v| v.peak));
+        }
+    }
+    gains.sort_by(f32::total_cmp);
+    let median = gains[gains.len() / 2];
+    let db = 20.0 * (median / RECOMP_LONG_AIR_GAIN_MEDIAN).log10();
+    println!("16 / 17 in the 0.6-1.0 s airs: {} voices, peak gains {:.4}..{:.4}, median {median:.4} vs the recomp's {RECOMP_LONG_AIR_GAIN_MEDIAN} ({db:+.1} dB)",
+        gains.len(), gains[0], gains[gains.len() - 1]);
+    assert!(db.abs() < 3.0, "16 / 17 median {db:+.1} dB from the recomp");
+}
diff --git a/crates/skate-audio/tests/rolling_banks.rs b/crates/skate-audio/tests/rolling_banks.rs
new file mode 100644
index 00000000..1ef37761
--- /dev/null
+++ b/crates/skate-audio/tests/rolling_banks.rs
@@ -0,0 +1,604 @@
+//! The board's rolling layers (`player::rolling`: Class_rolling, Rolling_Rattle_Class,
+//! c_board_slide) through the real banks. Data-gated: needs the disc banks extracted to
+//! `.local/audio-re/aems-banks` (`bank_layout_check.py --extract`) and, for the rendered levels,
+//! their samples decoded to `.local/audio-re/bank-wavs/<stem>/NNNN.wav`
+//! (`.claude/skills/aems-port/tools/decode_bank_samples.py`) plus the install's MixMap; skipped
+//! otherwise (retail data is never committed).
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use skate_audio::eval::{Evaluator, OpenRequest, VoiceHost, VoiceStatus};
+use skate_audio::formats::{Bank, Project};
+use skate_audio::mixer::Pcm;
+use skate_audio::mixmap::{MixMap, keys};
+use skate_audio::player::objpos::{Listener, ObjPos};
+use skate_audio::player::rolling::{self, BoardSlide, Rattle, Rolling, RollingInputs};
+use skate_audio::player::components::Command;
+use skate_audio::player::tuning::PlayerTuning;
+use skate_audio::player::{AudioState, Owner};
+use skate_audio::runtime::Runtime;
+
+fn root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..")
+}
+
+fn banks_dir() -> Option<PathBuf> {
+    let dir = std::env::var_os("SKATE_AEMS_BANKS").map(PathBuf::from).unwrap_or_else(|| root().join(".local/audio-re/aems-banks"));
+    dir.join("csi_order.txt").is_file().then_some(dir)
+}
+
+fn projects(dir: &Path) -> Vec<Project> {
+    let order = std::fs::read_to_string(dir.join("csi_order.txt")).unwrap();
+    order.lines().map(|n| Project::parse(n, &std::fs::read(dir.join(n)).unwrap()).unwrap()).collect()
+}
+
+fn bank(dir: &Path, stem: &str) -> Bank {
+    Bank::parse(stem, std::fs::read(dir.join(format!("{stem}.abk"))).unwrap()).unwrap()
+}
+
+/// Every bank bound to `Class_rolling` (a post reaches each, spec §1.10).
+const ROLLING_BANKS: [&str; 4] = ["PatchBank_Rolling_Surfaces", "PatchBank_SpiderCracks", "PatchBank_Objects", "PatchBank_RocksBounce"];
+
+#[derive(Default)]
+struct Opens {
+    next: u32,
+    left: BTreeMap<u32, u32>,
+    seen: BTreeMap<usize, BTreeSet<u16>>,
+}
+
+impl VoiceHost for Opens {
+    fn open(&mut self, r: &OpenRequest) -> Option<u32> {
+        self.next += 1;
+        self.left.insert(self.next, 30);
+        self.seen.entry(r.bank).or_default().insert(r.slot);
+        Some(self.next)
+    }
+    fn release(&mut self, v: u32) {
+        self.left.remove(&v);
+    }
+    fn pause(&mut self, _: u32) {}
+    fn resume(&mut self, _: u32) {}
+    fn set(&mut self, _: u32, _: u8, _: i32) {}
+    fn set_azimuth(&mut self, _: u32, _: i32) {}
+    fn query(&mut self, v: u32) -> VoiceStatus {
+        match self.left.get_mut(&v) {
+            Some(n) if *n > 0 => {
+                *n -= 1;
+                VoiceStatus { alive: true, remaining_ms: 32 * *n as i32, elapsed_ms: 0 }
+            }
+            _ => VoiceStatus::default(),
+        }
+    }
+}
+
+/// Which Class_rolling module answers which selector (w4) and surface (w6): post one held packet
+/// per (selector, surface) at speed word 5000 with open levels, run 8 s of evaluator blocks and
+/// list the bank slots opened. Diagnostic print (`--nocapture`).
+#[test]
+fn class_rolling_selector_census() {
+    let Some(dir) = banks_dir() else { return eprintln!("skipped: no extracted banks") };
+    println!("selector surface speed: bank slots…");
+    for selector in 0..16 {
+        for surface in [3, 7, 8, 10, 11, 12, 13] {
+            for speed in [1500, 5000, 9000] {
+                let mut eval = Evaluator::new();
+                for p in projects(&dir) {
+                    eval.install_project(&p);
+                }
+                let mut names = BTreeMap::new();
+                for stem in ROLLING_BANKS {
+                    names.insert(eval.load_bank(bank(&dir, stem)), stem);
+                }
+                let class = eval.class_id(rolling::CLASS).unwrap();
+                let mut w = rolling::class_rolling_words(speed, selector, surface);
+                w[0] = 32767;
+                w[11] = 32767;
+                w[8] = 32767;
+                eval.post(class, &w);
+                let mut host = Opens::default();
+                for _ in 0..(8 * 48000 / 256) {
+                    eval.block(&mut host);
+                }
+                if host.seen.is_empty() {
+                    continue;
+                }
+                let list: Vec<String> = host.seen.iter().map(|(b, s)| format!("{} {:?}", names[b], s)).collect();
+                println!("{selector:2} {surface:2} {speed:4}: {}", list.join(" | "));
+            }
+        }
+    }
+}
+
+// --------------------------------------------------------------------------------- rendered
+
+fn wav_pcm(bytes: &[u8]) -> Option<Pcm> {
+    let (mut channels, mut rate, mut bits) = (0usize, 0u32, 0u16);
+    let mut at = 12;
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().ok()?) as usize;
+        let body = at + 8;
+        match &bytes[at..at + 4] {
+            b"fmt " => {
+                channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+                rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().ok()?);
+                bits = u16::from_le_bytes([bytes[body + 14], bytes[body + 15]]);
+            }
+            b"data" if channels > 0 && bits == 16 => {
+                let data = &bytes[body..(body + size).min(bytes.len())];
+                let mut planar = vec![Vec::new(); channels];
+                for (i, s) in data.chunks_exact(2).enumerate() {
+                    planar[i % channels].push(f32::from(i16::from_le_bytes([s[0], s[1]])) / 32768.0);
+                }
+                return Some(Pcm { rate, channels: planar });
+            }
+            _ => {}
+        }
+        at = body + size + (size & 1);
+    }
+    None
+}
+
+/// The samples of a bank: the decoded copies in `.local/audio-re/bank-wavs`, else the install's.
+fn pcm(stem: &str, count: usize) -> Option<Vec<Option<Arc<Pcm>>>> {
+    for base in [root().join(".local/audio-re/bank-wavs"), root().join("assets/private/audio/banks")] {
+        let d = base.join(stem);
+        if d.join("0000.wav").is_file() {
+            return Some((0..count).map(|i| std::fs::read(d.join(format!("{i:04}.wav"))).ok().and_then(|b| wav_pcm(&b)).map(Arc::new)).collect());
+        }
+    }
+    None
+}
+
+fn mixmap() -> Option<Vec<u8>> {
+    std::fs::read(root().join("assets/private/audio/aems/MixMapSK8.mxb")).ok()
+}
+
+/// The install's AudioSurfaceMap (`audio_manifest.json` `grain_player.surface_map`: word 1 per
+/// material) as a surface table with word 1 filled (the other words are not needed here).
+fn surface_table() -> Vec<[i32; 18]> {
+    let Ok(text) = std::fs::read_to_string(root().join("assets/private/audio/audio_manifest.json")) else { return Vec::new() };
+    let Some(at) = text.find("\"surface_map\"") else { return Vec::new() };
+    let rest = &text[at..];
+    let (Some(a), Some(b)) = (rest.find('['), rest.find(']')) else { return Vec::new() };
+    rest[a + 1..b]
+        .split(',')
+        .filter_map(|x| x.trim().parse::<i32>().ok())
+        .map(|s| {
+            let mut row = [0i32; 18];
+            row[1] = s;
+            row
+        })
+        .collect()
+}
+
+fn globals(m: &mut MixMap) {
+    for id in 1..=4 {
+        m.set_input(keys::MASTER, id, 32767);
+    }
+    for id in [1, 2, 5] {
+        m.set_input(keys::MUSIC, id, 32767);
+    }
+    m.set_input(keys::REVERB, 5, 32767);
+}
+
+/// Straight rolling at `kmh` on `material` (tag − 1): the skater along +x, the board 0.9 m below
+/// the COM, the camera 3.5 m behind and 1.4 m above; four wheels down.
+fn rolling_state(kmh: f32, material: u32, f: usize) -> AudioState {
+    let v = kmh / 3.6;
+    let x = v * f as f32 / 60.0;
+    AudioState {
+        ground_speed: v,
+        com_velocity: [v, 0.0, 0.0],
+        com_position: [x, 1.0, 0.0],
+        board_position: [x, 0.1, 0.0],
+        board_velocity: [v, 0.0, 0.0],
+        wheel_count: 4,
+        wheel_contact: [true; 4],
+        wheel_material: [material; 4],
+        ..Default::default()
+    }
+}
+
+/// The two position blocks (skater COM, board) seen from a camera 3.5 m behind and 1.4 m above.
+fn positions(m: &mut MixMap, pos: &mut [ObjPos; 2], s: &AudioState) {
+    let l = Listener {
+        camera: [s.com_position[0] - 3.5, 2.4, s.com_position[2]],
+        view: [1.0, -0.3, 0.0],
+        camera_velocity: s.com_velocity,
+        followed: s.com_position,
+        facing: s.com_velocity,
+        followed_velocity: s.com_velocity,
+    };
+    pos[0].write(m, keys::obj_pos(0), &l, Some((s.com_position, s.com_velocity)));
+    pos[1].write(m, keys::obj_pos2(0), &l, Some((s.board_position, s.board_velocity)));
+}
+
+struct Rig {
+    rt: Runtime,
+    names: BTreeMap<usize, &'static str>,
+    nodes: BTreeMap<String, skate_audio::eval::NodeId>,
+}
+
+impl Rig {
+    fn new(dir: &Path, stems: &[&'static str]) -> Option<Self> {
+        let mut rt = Runtime::new();
+        for p in projects(dir) {
+            rt.install_project(&p);
+        }
+        let mut names = BTreeMap::new();
+        for &stem in std::iter::once(&"emitter_utility").chain(stems) {
+            let b = bank(dir, stem);
+            let n = b.samples.len();
+            let p = if stem == "emitter_utility" { vec![None; n] } else { pcm(stem, n)? };
+            names.insert(rt.load_bank(b, p), stem);
+        }
+        let utility = rt.eval.class_id("c_emitter_utility").unwrap();
+        rt.post(utility, &[]);
+        Some(Self { rt, names, nodes: BTreeMap::new() })
+    }
+
+    fn apply(&mut self, cmds: Vec<Command>, posts: &mut u32) {
+        for c in cmds {
+            match c {
+                Command::Post { slot, class, words } => {
+                    let id = self.rt.eval.class_id(class).expect(class);
+                    if let Some(old) = self.nodes.remove(&format!("{slot:?}")) {
+                        self.rt.release(old);
+                    }
+                    self.nodes.insert(format!("{slot:?}"), self.rt.post(id, &words));
+                    *posts += 1;
+                }
+                Command::Redeliver { slot, words } => {
+                    if let Some(&n) = self.nodes.get(&format!("{slot:?}")) {
+                        self.rt.redeliver(n, &words);
+                    }
+                }
+                Command::Release { slot } => {
+                    if let Some(n) = self.nodes.remove(&format!("{slot:?}")) {
+                        self.rt.release(n);
+                    }
+                }
+            }
+        }
+    }
+}
+
+struct Run {
+    gains: BTreeMap<&'static str, Vec<f32>>,
+    slots: BTreeMap<&'static str, BTreeSet<u16>>,
+    posts: u32,
+    first_gain: BTreeMap<&'static str, f32>,
+    /// Per voice start: the peak gain in its first 0.4 s (retail's per-start level,
+    /// `analyse_session.py` GAIN_WINDOW), by bank.
+    starts: BTreeMap<&'static str, Vec<f32>>,
+}
+
+/// Drive [`Rolling`] (+ the rattle and slide owners) frame by frame through the real MixMap and
+/// banks: PlayerPhysics + the two position blocks + the SkateBoard inputs the routing writes.
+fn run(dir: &Path, mxb: &[u8], frames: usize, tuning: &PlayerTuning, state: impl Fn(usize) -> (AudioState, bool)) -> Option<Run> {
+    let stems: Vec<&'static str> = ROLLING_BANKS.iter().copied().chain(["Rolling_Rattles"]).collect();
+    let mut rig = Rig::new(dir, &stems)?;
+    let mut m = MixMap::from_bytes(mxb).ok()?;
+    let mut physics = skate_audio::player::inputs::Physics::default();
+    let mut pos = [ObjPos::default(); 2];
+    let mut r = Rolling::default();
+    let mut rattle = Rattle::default();
+    let mut out = vec![0.0f32; 1600];
+    let mut run = Run { gains: BTreeMap::new(), slots: BTreeMap::new(), posts: 0, first_gain: BTreeMap::new(), starts: BTreeMap::new() };
+    let mut voice_start: BTreeMap<u32, (&'static str, usize, f32)> = BTreeMap::new();
+    let owner = keys::skateboard(0);
+    for f in 0..frames {
+        let (s, push) = state(f);
+        globals(&mut m);
+        physics.write(&mut m, &s);
+        positions(&mut m, &mut pos, &s);
+        let s = AudioState { push_trigger: push, push_planted: push, ..s };
+        let inp = RollingInputs { speed_scale: None };
+        let (mut cmds, routed) = r.process(&s, tuning, &inp);
+        m.set_input(owner, 0, if routed.surface_pulse { 32767 } else { 0 });
+        m.set_input(owner, 6, if routed.on_metal { 32767 } else { 0 });
+        m.set_input(owner, 4, if s.push_planted { 32767 } else { 0 });
+        cmds.extend(rattle.process(&s, &r, &tuning.rolling));
+        rig.apply(cmds, &mut run.posts);
+        m.tick(1.0 / 60.0);
+        let o = Owner { mixmap: &m, key: owner };
+        let mut cmds = r.update(&s, tuning, &inp, &o);
+        cmds.extend(rattle.update(&o));
+        rig.apply(cmds, &mut run.posts);
+        rig.rt.fill_stereo(&mut out);
+        for v in rig.rt.mixer.snapshot() {
+            if let Some(&stem) = rig.names.get(&v.bank) {
+                if v.gain > 0.0 {
+                    run.first_gain.entry(stem).or_insert(v.gain);
+                }
+                run.gains.entry(stem).or_default().push(v.gain);
+                run.slots.entry(stem).or_default().insert(v.slot);
+                let e = voice_start.entry(v.id).or_insert((stem, f, 0.0));
+                if f < e.1 + 24 {
+                    e.2 = e.2.max(v.gain);
+                }
+            }
+        }
+    }
+    for (stem, _, peak) in voice_start.into_values() {
+        run.starts.entry(stem).or_default().push(peak);
+    }
+    Some(run)
+}
+
+fn quantiles(v: &[f32]) -> (f32, f32, f32) {
+    let mut v: Vec<f32> = v.to_vec();
+    v.sort_by(f32::total_cmp);
+    let q = |p: f32| if v.is_empty() { 0.0 } else { v[((v.len() - 1) as f32 * p) as usize] };
+    (q(0.5), q(0.9), q(1.0))
+}
+
+/// Class_rolling (held layers 0/3, the per-surface patch on the non-grain surfaces, the
+/// spidercrack layer) and the rattle through the real banks and MixMap, per speed and surface:
+/// voices (bank slots) and per-voice gains (master × dry) next to retail's per-voice levels
+/// (163809 report: PatchBank_Rolling_Surfaces median 0.007 / p90 0.044 / max 0.074,
+/// Rolling_Rattles 0.007 / 0.301 / 0.366; 164620: Rolling_Surfaces 0.010 / 0.121 / 0.388).
+/// Asserts that something plays and that no voice exceeds unity.
+#[test]
+fn rolling_layers_play_their_retail_banks() {
+    let (Some(dir), Some(mxb)) = (banks_dir(), mixmap()) else { return eprintln!("skipped: no extracted banks or MixMap") };
+    let mut tuning = PlayerTuning { surface_table: surface_table(), ..Default::default() };
+    if tuning.surface_table.len() < 95 {
+        return eprintln!("skipped: no surface map in the install manifest");
+    }
+    tuning.surface_table.truncate(95);
+    // Materials (tag − 1) per rolling surface: 3 asphalt_smooth (tag 1), 7 (tag 10), 8 (tag 8),
+    // 10 (tag 67), 12 (tag 68), 13 (tag 37).
+    let cases: [(&str, u32); 6] = [("surface 3 (tag 1)", 0), ("surface 7 (tag 10)", 9), ("surface 8 (tag 8)", 7), ("surface 10 (tag 67)", 66), ("surface 12 (tag 68)", 67), ("surface 13 (tag 37)", 36)];
+    println!("case                  km/h push  posts  bank                        frames slots                    gain first / median / p90 / max   starts n: median / p90 / max (peak in 0.4 s)");
+    let mut any = false;
+    for (name, material) in cases {
+        for kmh in [8.0f32, 20.0, 35.0] {
+            for pushes in [false, true] {
+                let Some(r) = run(&dir, &mxb, 360, &tuning, |f| {
+                    let mut s = rolling_state(kmh, material, f);
+                    if f >= 300 {
+                        s.seam_pattern = [1; 4]; // the last second over the spidercrack pattern
+                    }
+                    (s, pushes && f % 90 == 30)
+                }) else {
+                    return eprintln!("skipped: bank samples not decoded (decode_bank_samples.py)");
+                };
+                for (bank, g) in &r.gains {
+                    let audible: Vec<f32> = g.iter().copied().filter(|&x| x > 0.0).collect();
+                    let (med, p90, max) = quantiles(&audible);
+                    let st = r.starts.get(bank).cloned().unwrap_or_default();
+                    let (smed, sp90, smax) = quantiles(&st);
+                    println!(
+                        "{name:21} {kmh:4.0} {pushes:5} {:5}  {bank:27} {:6} {:24} {:.3} / {med:.3} / {p90:.3} / {max:.3}   starts {:3}: {smed:.3} / {sp90:.3} / {smax:.3}",
+                        r.posts,
+                        audible.len(),
+                        format!("{:?}", r.slots[bank]),
+                        r.first_gain.get(bank).copied().unwrap_or(0.0),
+                        st.len()
+                    );
+                    assert!(max <= 1.0, "{name} {kmh}: {bank} above unity");
+                    // First-trigger rule: the first rattle of a run peaks like the later ones (the
+                    // bank's PCM is decoded before use, the same path plays every push).
+                    if *bank == "Rolling_Rattles" && st.len() > 1 {
+                        assert!((st[0] - st[1..].iter().copied().fold(0.0f32, f32::max)).abs() < 2e-3, "{name} {kmh}: first rattle {} vs later {:?}", st[0], &st[1..]);
+                    }
+                    any |= !audible.is_empty();
+                }
+            }
+        }
+    }
+    assert!(any, "no rolling layer sounded");
+}
+
+/// c_board_slide: the loose board (state `+780`) through `board_scrapes`.
+#[test]
+fn board_slide_plays_board_scrapes() {
+    let (Some(dir), Some(mxb)) = (banks_dir(), mixmap()) else { return eprintln!("skipped: no extracted banks or MixMap") };
+    let Some(mut rig) = Rig::new(&dir, &["board_scrapes"]) else { return eprintln!("skipped: board_scrapes not decoded") };
+    let mut m = MixMap::from_bytes(&mxb).unwrap();
+    let mut physics = skate_audio::player::inputs::Physics::default();
+    let mut slide = BoardSlide::default();
+    let mut pos = [ObjPos::default(); 2];
+    let tuning = rolling::RollingTuning::default();
+    let mut out = vec![0.0f32; 1600];
+    let mut posts = 0;
+    println!("loose  km/h  voices  gain median / max");
+    for (loose, kmh) in [(1u32, 6.0f32), (2, 6.0), (2, 15.0)] {
+        let mut gains = Vec::new();
+        for f in 0..240 {
+            let s = AudioState { wheel_count: 0, ..rolling_state(kmh, 3, f) };
+            globals(&mut m);
+            physics.write(&mut m, &s);
+            positions(&mut m, &mut pos, &s);
+            let l = if f < 180 { loose } else { 0 };
+            rig.apply(slide.process(l, &tuning), &mut posts);
+            m.tick(1.0 / 60.0);
+            let o = Owner { mixmap: &m, key: keys::skateboard(0) };
+            rig.apply(slide.update(&s, l, &tuning, &o), &mut posts);
+            rig.rt.fill_stereo(&mut out);
+            gains.extend(rig.rt.mixer.snapshot().iter().filter(|v| rig.names.get(&v.bank) == Some(&"board_scrapes") && v.gain > 0.0).map(|v| v.gain));
+        }
+        let (med, _, max) = quantiles(&gains);
+        println!("{loose:5}  {kmh:4.0}  {:6}  {med:.3} / {max:.3}", gains.len());
+        assert!(max <= 1.0);
+    }
+    assert!(posts > 0);
+}
+
+/// The rattle bank per surface code (w4) and speed word (w3): which sample a push plays and its
+/// peak gain in 0.4 s, with the MixMap outputs of straight rolling at 20 km/h. Diagnostic print
+/// next to retail's per-sample levels (164620: slot 8 median 0.322, 7 0.107, 0 0.050, 2 0.037,
+/// 11 0.035, 1 0.026, 9 0.027, 6 0.022, 10 0.018).
+#[test]
+fn rattle_samples_by_surface_and_speed() {
+    let (Some(dir), Some(mxb)) = (banks_dir(), mixmap()) else { return eprintln!("skipped: no extracted banks or MixMap") };
+    println!("surface speed: slot peak …");
+    for surface in 0..6 {
+        let mut line = String::new();
+        for speed in [0, 1500, 4000, 7000, 10000] {
+            let Some(mut rig) = Rig::new(&dir, &["Rolling_Rattles"]) else { return eprintln!("skipped: not decoded") };
+            let mut m = MixMap::from_bytes(&mxb).unwrap();
+            let mut physics = skate_audio::player::inputs::Physics::default();
+            let mut posts = 0;
+            let mut out = vec![0.0f32; 1600];
+            let mut pos = [ObjPos::default(); 2];
+            let mut peak: BTreeMap<u16, f32> = BTreeMap::new();
+            for f in 0..30 {
+                let s = rolling_state(20.0, 0, f);
+                globals(&mut m);
+                physics.write(&mut m, &s);
+                positions(&mut m, &mut pos, &s);
+                if f == 1 {
+                    rig.apply(vec![Command::Post { slot: skate_audio::player::components::Slot::RollingRattle, class: rolling::RATTLE_CLASS, words: rolling::rattle_words(speed, surface, 8) }], &mut posts);
+                }
+                m.tick(1.0 / 60.0);
+                // Redeliver as `Rattle::update` would (the held packet lives in the rig here).
+                let mut w = rolling::rattle_words(speed, surface, 8);
+                w[0] = 32767;
+                w[10] = m.level(keys::skateboard(0), 6);
+                w[1] = m.raw(keys::skateboard(0), 0).clamp(0, 65535);
+                w[2] = m.pitch_4096(keys::skateboard(0), 3).clamp(0, 8192);
+                w[7] = m.level(keys::skateboard(0), 16);
+                w[8] = m.level(keys::skateboard(0), 14).clamp(0, 25000);
+                w[9] = m.level(keys::skateboard(0), 15).clamp(0, 25000);
+                rig.apply(vec![Command::Redeliver { slot: skate_audio::player::components::Slot::RollingRattle, words: w }], &mut posts);
+                rig.rt.fill_stereo(&mut out);
+                for v in rig.rt.mixer.snapshot() {
+                    if rig.names.get(&v.bank) == Some(&"Rolling_Rattles") {
+                        let e = peak.entry(v.slot).or_insert(0.0);
+                        *e = e.max(v.gain);
+                    }
+                }
+            }
+            line += &format!(" | w3 {speed:5}: {}", peak.iter().map(|(s, g)| format!("{s} {g:.3}")).collect::<Vec<_>>().join(", "));
+        }
+        println!("w4 {surface}{line}");
+    }
+}
+
+/// The SkateBoard outputs these layers read, by speed (straight rolling, 4 wheels; and in the air).
+#[test]
+fn skateboard_outputs_by_speed() {
+    let Some(mxb) = mixmap() else { return eprintln!("skipped: no MixMap") };
+    println!("km/h  air  l1    l6    l7    l9    l10   l13   l16   l19   p3    p8    f11   f12   f14   f15   f17   f18   l24 l27 f25 f26 p23");
+    for air in [false, true] {
+        for kmh in [0.0f32, 3.0, 8.0, 15.0, 25.0, 40.0] {
+            let mut m = MixMap::from_bytes(&mxb).unwrap();
+            let mut physics = skate_audio::player::inputs::Physics::default();
+            let mut pos = [ObjPos::default(); 2];
+            for f in 0..90 {
+                let mut s = rolling_state(kmh, 0, f);
+                if air {
+                    s.wheel_count = 0;
+                    s.wheel_contact = [false; 4];
+                    s.airborne = true;
+                }
+                globals(&mut m);
+                physics.write(&mut m, &s);
+                positions(&mut m, &mut pos, &s);
+                m.tick(1.0 / 60.0);
+            }
+            let k = keys::skateboard(0);
+            let l = |i| m.level(k, i);
+            let fz = |i| m.filter_hz(k, i);
+            println!(
+                "{kmh:4.0} {air:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {:5} {} {} {} {} {}",
+                l(1), l(6), l(7), l(9), l(10), l(13), l(16), l(19), m.pitch_4096(k, 3), m.pitch_4096(k, 8),
+                fz(11), fz(12), fz(14), fz(15), fz(17), fz(18), l(24), l(27), fz(25), fz(26), m.pitch_4096(k, 23)
+            );
+        }
+    }
+}
+
+/// Diagnostic: SenseOfSpeed level(1) (rattle gain) and level(4) (wind) on the ground and in the
+/// air at the same speed (listening report: rolling continues in jumps).
+#[test]
+fn sense_of_speed_levels_ground_vs_air() {
+    let Some(mxb) = mixmap() else { return eprintln!("skipped: no MixMap") };
+    for air in [false, true] {
+        for kmh in [25.0f32, 31.0, 40.0] {
+            let mut m = MixMap::from_bytes(&mxb).unwrap();
+            let mut physics = skate_audio::player::inputs::Physics::default();
+            let mut pos = [ObjPos::default(); 2];
+            for f in 0..90 {
+                let mut s = rolling_state(kmh, 0, f);
+                if air {
+                    s.wheel_count = 0;
+                    s.wheel_contact = [false; 4];
+                    s.airborne = true;
+                }
+                globals(&mut m);
+                physics.write(&mut m, &s);
+                positions(&mut m, &mut pos, &s);
+                m.tick(1.0 / 60.0);
+            }
+            let k = keys::sense_of_speed(0);
+            println!("air {air:5} {kmh:4.0} km/h: SoS level(1) {} level(4) {} level(5) {}; board level(1) {}", m.level(k, 1), m.level(k, 4), m.level(k, 5), m.level(keys::skateboard(0), 1));
+        }
+    }
+}
+
+/// Listening report "rolling continues in jumps": push at 30 km/h, take off 10 frames later; the
+/// native layers (rattle, held layers, patch) must go quiet in the air through the MixMap words
+/// (level(6)/(7)/(9)/(1) are 0 without wheels). Prints the per-bank gain before / after takeoff.
+#[test]
+fn layers_go_quiet_after_takeoff() {
+    let (Some(dir), Some(mxb)) = (banks_dir(), mixmap()) else { return eprintln!("skipped: no extracted banks or MixMap") };
+    let mut tuning = PlayerTuning { surface_table: surface_table(), ..Default::default() };
+    if tuning.surface_table.len() < 95 {
+        return eprintln!("skipped: no surface map");
+    }
+    tuning.surface_table.truncate(95);
+    for material in [0u32, 7] {
+        let mut ground = BTreeMap::<&str, f32>::new();
+        let mut air = BTreeMap::<&str, f32>::new();
+        let stems: Vec<&'static str> = ROLLING_BANKS.iter().copied().chain(["Rolling_Rattles"]).collect();
+        let Some(mut rig) = Rig::new(&dir, &stems) else { return eprintln!("skipped: not decoded") };
+        let mut m = MixMap::from_bytes(&mxb).unwrap();
+        let mut physics = skate_audio::player::inputs::Physics::default();
+        let mut pos = [ObjPos::default(); 2];
+        let (mut r, mut k) = (Rolling::default(), Rattle::default());
+        let mut out = vec![0.0f32; 1600];
+        let mut posts = 0;
+        for f in 0..200 {
+            let mut s = rolling_state(30.0, material, f);
+            s.push_trigger = f == 100;
+            s.push_planted = f == 100;
+            let airborne = f >= 110;
+            if airborne {
+                s.wheel_count = 0;
+                s.wheel_contact = [false; 4];
+                s.wheel_material = [skate_audio::player::state::NO_MATERIAL; 4];
+                s.airborne = true;
+            }
+            globals(&mut m);
+            physics.write(&mut m, &s);
+            positions(&mut m, &mut pos, &s);
+            let inp = RollingInputs::default();
+            let (mut cmds, routed) = r.process(&s, &tuning, &inp);
+            m.set_input(keys::skateboard(0), 0, if routed.surface_pulse { 32767 } else { 0 });
+            cmds.extend(k.process(&s, &r, &tuning.rolling));
+            rig.apply(cmds, &mut posts);
+            m.tick(1.0 / 60.0);
+            let o = Owner { mixmap: &m, key: keys::skateboard(0) };
+            let mut cmds = r.update(&s, &tuning, &inp, &o);
+            cmds.extend(k.update(&o));
+            rig.apply(cmds, &mut posts);
+            rig.rt.fill_stereo(&mut out);
+            let target = if (100..110).contains(&f) { Some(&mut ground) } else if f >= 120 { Some(&mut air) } else { None };
+            if let Some(t) = target {
+                for v in rig.rt.mixer.snapshot() {
+                    if let Some(&stem) = rig.names.get(&v.bank) {
+                        let e = t.entry(stem).or_insert(0.0);
+                        *e = e.max(v.gain);
+                    }
+                }
+            }
+        }
+        println!("material {material}: peak gain on the ground (push..takeoff) {ground:?}");
+        println!("material {material}: peak gain from 10 frames after takeoff   {air:?}");
+        assert!(air.values().all(|&g| g < 0.01), "a layer keeps sounding in the air: {air:?}");
+    }
+}
diff --git a/crates/skate-core/src/physics/board_ground.rs b/crates/skate-core/src/physics/board_ground.rs
index 3223aafe..e230958f 100644
--- a/crates/skate-core/src/physics/board_ground.rs
+++ b/crates/skate-core/src/physics/board_ground.rs
@@ -49,6 +49,10 @@ pub struct WheelLineState {
     /// Audio material (surface tag bits 0..6, `& 0x7F`) per wheel, 0 on a miss. Not
     /// part of 82C079E0; kept for the engine's rolling sound.
     pub audio_surfaces: [u32; 4],
+    /// Seam pattern (surface tag bits 12..15, `>> 12 & 0xF`) per wheel, 0 on a miss: the
+    /// audio state's `+636..+648` (82C079E0 stores it next to the material). Engine-side input
+    /// for the rolling bed's seam-pattern gain envelope and `Class_Seams`.
+    pub seam_patterns: [u32; 4],
     pub minimum_distance: f32,
 }
 impl Default for WheelLineState {
@@ -59,6 +63,7 @@ impl Default for WheelLineState {
             distances: [0.0; 4],
             physics_surfaces: [0; 4],
             audio_surfaces: [0; 4],
+            seam_patterns: [0; 4],
             minimum_distance: 0.0,
         }
     }
@@ -71,6 +76,7 @@ impl WheelLineState {
         for (i, hit) in hits.into_iter().enumerate() {
             self.physics_surfaces[i] = 0;
             self.audio_surfaces[i] = 0;
+            self.seam_patterns[i] = 0;
             if let Some(hit) = hit {
                 let distance = hit.fraction * WHEEL_LINE_LENGTH;
                 self.minimum_distance = if distance - self.minimum_distance >= -0.0 {
@@ -82,6 +88,7 @@ impl WheelLineState {
                 self.distances[i] = distance;
                 self.physics_surfaces[i] = (hit.surface_tag >> 7) & 31;
                 self.audio_surfaces[i] = hit.surface_tag & 0x7F;
+                self.seam_patterns[i] = (hit.surface_tag >> 12) & 0xF;
             }
         }
     }
@@ -128,6 +135,9 @@ pub struct BoardGroundState {
     /// Angular drag: S3 postphysics82C08634 writes wheel inertia+36;
     /// paired S2 postphysics82B372E0 names this mAngularDrag.
     pub wheel_angular_drag: [f32; 4],
+    /// CollisionInfo+4/+8/+12: the trucks' and deck's last contact audio surface (tag & 0x7F,
+    /// 0 without contact this frame), read by the audio state as materials +652..+660.
+    pub part_audio_surfaces: [u32; 3],
 }
 impl Default for BoardGroundState {
     fn default() -> Self {
@@ -144,6 +154,7 @@ impl Default for BoardGroundState {
             collision_flags: 0,
             valid_wheel_normals: [false; 4], part_contact_count: 0,
             wheel_contact_count: 0, time_without_wheel_contact: 0.0, wheel_angular_drag: [0.0; 4],
+            part_audio_surfaces: [0; 3],
         }
     }
 }
@@ -185,6 +196,7 @@ impl BoardGroundState {
         self.collision_flags &= 0x01ff_ffff;
         self.overall_normal = UP;
         self.valid_wheel_normals.fill(true);
+        self.part_audio_surfaces = [0; 3];
         let mut highest_y = -2.0;
         let mut highest_part = None;
         //82C07E24..30 seeds min/max; only deck reports enter82C07EAC..CC.
@@ -217,6 +229,7 @@ impl BoardGroundState {
             }
             if i >= 4 {
                 surfaces[i] = surface; //82C081B4..81E0, last report wins.
+                self.part_audio_surfaces[i - 4] = u32::from(report.other_surface) & 0x7F;
             }
             let contact = &mut self.parts[i];
             if !contact.in_contact || report.normal.y > contact.normal.y {
diff --git a/crates/skate-core/src/physics/tests/board_ground.rs b/crates/skate-core/src/physics/tests/board_ground.rs
index eef12ed0..fe1bd6cf 100644
--- a/crates/skate-core/src/physics/tests/board_ground.rs
+++ b/crates/skate-core/src/physics/tests/board_ground.rs
@@ -127,17 +127,21 @@ fn surface_flags_use_actual_contacts_and_reset_each_frame() {
     first.position.y = 2.0;
     let mut last = first;
     last.position.y = 5.0;
+    // The deck's audio surface (CollisionInfo+12): the last report's tag & 0x7F.
+    last.other_surface = 12 << 7 | 41;
     let mut lines = WheelLineState::default();
     lines.physics_surfaces[0] = 8;
     ground.update(&[first, last], &lines, UP, 80.0, false);
     assert_eq!(ground.collision_flags, 1 << 25);
     assert_eq!(ground.surface_twelve_height, 5.0);
+    assert_eq!(ground.part_audio_surfaces, [0, 0, 41]);
     //A wheel ray reporting surface8 alone does not set the physical flag.
     ground.update(&[report(BodyId::RightFrontWheel, UP)], &lines, UP, 80.0, false);
     assert_eq!(ground.collision_flags, 1 << 31);
     ground.update(&[], &lines, UP, 80.0, false);
     assert_eq!(ground.collision_flags, 0);
     assert_eq!(ground.surface_twelve_height, 0.0);
+    assert_eq!(ground.part_audio_surfaces, [0; 3]);
 }
 
 #[test]
@@ -165,6 +169,11 @@ fn wheel_lines_keep_audio_and_physics_bits_of_the_same_tag() {
     lines.publish([hit(1591), hit(3 << 7 | 9), None, hit(0)]);
     assert_eq!(lines.physics_surfaces, [12, 3, 0, 0]);
     assert_eq!(lines.audio_surfaces, [55, 9, 0, 0]);
+    assert_eq!(lines.seam_patterns, [0; 4]);
+    // Seam pattern bits 12..15 (audio state +636): sidewalk 11 on asphalt 1.
+    lines.publish([hit(11 << 12 | 3 << 7 | 1), None, None, None]);
+    assert_eq!((lines.audio_surfaces[0], lines.physics_surfaces[0], lines.seam_patterns[0]), (1, 3, 11));
     lines.publish([None; 4]);
     assert_eq!(lines.audio_surfaces, [0; 4]);
+    assert_eq!(lines.seam_patterns, [0; 4]);
 }
diff --git a/crates/skate-game/Cargo.toml b/crates/skate-game/Cargo.toml
index 601559e6..5074dedf 100644
--- a/crates/skate-game/Cargo.toml
+++ b/crates/skate-game/Cargo.toml
@@ -34,6 +34,7 @@ blake3 = "=1.8.7"
 image = { version = "=0.25.10", default-features = false, features = ["png", "jpeg"] }
 skate-mods = { path = "../skate-mods" }
 skate-dynamics = { path = "../skate-dynamics" }
+skate-audio = { path = "../skate-audio" }
 gltf = { version = "=1.4.1", default-features = true }
 # SDL3 gamepad input for every platform, built from source and statically linked.
 sdl3 = { version = "=0.20.0", features = ["build-from-source-static"] }
diff --git a/crates/skate-game/src/game_audio/ambience.rs b/crates/skate-game/src/game_audio/ambience.rs
index 16e9dc7b..6b4b9a40 100644
--- a/crates/skate-game/src/game_audio/ambience.rs
+++ b/crates/skate-game/src/game_audio/ambience.rs
@@ -1,15 +1,29 @@
-//! One ambience bed per map, cross-faded on map change. Retail switches beds by
-//! zone (per-map `.ems` emitter files); here each map gets the bed that fits
-//! it best. The choices are by name and ear, not from retail data
-//! (docs/hails-additions/11-audio.md).
+//! Zone ambience beds, as retail plays them (TU3 SFXObj_Ambience; notes ems-emitters-re.md, docs 11):
+//! - the zone is the district's world-painter region layer `audio_ambience` at the skater's x, z,
+//!   an `aud_wp_ambiences` record naming its bed (ambience.big stream), volume and fade times;
+//! - one bed at a time: on a zone change the old bed fades out over the OLD zone's fade-out time and
+//!   stops, then the new bed starts and fades in over the NEW zone's fade-in time (linear); a return
+//!   to the old zone during the fade-out fades it back in; a change during a fade-in waits for it;
+//! - for the whole transition the district's crossfade bank (`Main_Ambience_Crossfade_DT/Ind/Uni`)
+//!   plays the group of the zone pair (either order; group 1, level 1.0 if no pair), four looping
+//!   voices from fixed directions (`crossfade_groups.rs`); stopped when the fade-in ends.
+//! Beds are not positional (retail plays the channels as authored; ours are stereo downmixes).
+//! Installs without the zone data (manifest v3) keep the old per-map bed choice (`BEDS`).
 use super::{Category, Library, Play, Voices, library::Clip, voices::VoiceId};
 use bevy::prelude::*;
 
-/// Bed level before the ambience and master volumes.
+/// Fallback bed level and fade for installs without zone data.
 const LEVEL: f32 = 0.6;
 const CROSSFADE: f32 = 2.0;
+/// The Ambience MixMap's bed level carries a −11 dB base before any ducking (mixmap-spec.md; out0).
+/// Verified against retail captures at four zones (dt_open, dt_main, dt_rez, indu_quarry): predicted
+/// with the base within 0.6 dB, without it 11 dB too loud (tools/check_bed_level.py). Our levels run at
+/// `cues::RETAIL_SCALE` × retail, so the bed gets the same scale to keep retail's balance.
+const BED_BASE: f32 = 0.281_838_3; // 10^(-11/20)
+/// Directional crossfade voices sit this far from the listener (Bevy attenuation stays 1).
+const PAN_DISTANCE: f32 = 8.0;
 
-/// Map name (maps.json / CurrentMap) -> ambience bed. Unlisted maps are silent.
+/// Map name -> bed, used only without zone data (choices by name and ear, not retail data).
 const BEDS: &[(&str, &str)] = &[
     ("University", "09_univ_campus"),
     ("StartPark", "10_univ_housing"),
@@ -27,13 +41,50 @@ pub(super) fn bed_for(map: &str) -> Option<&'static str> {
     BEDS.iter().find(|(name, _)| name.eq_ignore_ascii_case(map)).map(|(_, bed)| *bed)
 }
 
+/// The district's crossfade bank (retail: dist_downtown / dist_industrial / dist_university only).
+fn crossfade_bank(district: &str) -> Option<&'static str> {
+    match district {
+        "DownTown" => Some("Main_Ambience_Crossfade_DT"),
+        "Industrial" => Some("Main_Ambience_Crossfade_Ind"),
+        "University" => Some("Main_Ambience_Crossfade_Uni"),
+        _ => None,
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Phase {
+    Silent,
+    FadeIn,
+    Steady,
+    FadeOut,
+}
+
+/// Attenuation 0 (full) .. 1 (silent) of the bed for a phase and its timer (retail's MixMap input 0).
+fn attenuation(phase: Phase, t: f32, fade_in: f32, fade_out: f32) -> f32 {
+    match phase {
+        Phase::Silent => 1.0,
+        Phase::Steady => 0.0,
+        Phase::FadeIn => 1.0 - (t / fade_in.max(1e-3)).clamp(0.0, 1.0),
+        Phase::FadeOut => (t / fade_out.max(1e-3)).clamp(0.0, 1.0),
+    }
+}
+
 #[derive(Default)]
 pub(super) struct State {
     map: Option<(String, u64)>,
-    current: Option<(VoiceId, Clip)>,
+    /// Zone of the bed that plays (retail obj+48), its phase and timer.
+    current: u64,
+    phase: Option<Phase>,
+    t: f32,
+    bed: Option<(VoiceId, Clip)>,
+    crossfade: Vec<(VoiceId, Clip, f32, f32)>,
+    crossfade_level: f32,
     fading: Vec<Clip>,
+    /// Fallback (no zone data): the per-map bed.
+    fallback: Option<(VoiceId, Clip)>,
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(super) fn update(
     mut state: Local<State>,
     mut commands: Commands,
@@ -41,35 +92,170 @@ pub(super) fn update(
     library: Option<ResMut<Library>>,
     mut voices: ResMut<Voices>,
     mut assets: ResMut<Assets<AudioSource>>,
+    listener: Query<&GlobalTransform, With<super::GameAudioListener>>,
+    cues: Res<super::skate_events::Cues>,
     time: Res<Time<Real>>,
 ) {
     let Some(mut library) = library else { return };
-    // Free beds whose fade-out has finished.
+    let state = &mut *state;
+    let now = time.elapsed_secs_f64();
+    let dt = time.delta_secs().clamp(0.0, 0.25);
+    // Free clips whose voices have finished fading.
     let fading = std::mem::take(&mut state.fading);
     for clip in fading {
         if voices.uses(&clip) { state.fading.push(clip); } else { library.release(&mut assets, &clip); }
     }
     let identity = (map.name.clone(), map.generation);
-    if state.map.as_ref() == Some(&identity) {
+    let new_map = state.map.as_ref() != Some(&identity);
+    if new_map {
+        state.map = Some(identity);
+        // A new map starts from silence: stop everything at once.
+        stop_all(state, &mut voices, CROSSFADE);
+    }
+    if !library.has_zones() {
+        if new_map {
+            fallback(state, &mut commands, &map.name, &mut library, &mut voices, &mut assets, now);
+        }
         return;
     }
-    state.map = Some(identity);
-    let bed = bed_for(&map.name);
-    if let Some((voice, clip)) = state.current.take() {
-        // Released only once no voice uses it (a reload may restart the same bed).
-        voices.stop(voice, CROSSFADE);
-        state.fading.push(clip);
+    let district = map.path.as_deref().and_then(|p| p.file_stem()).and_then(|s| s.to_str()).unwrap_or("").to_owned();
+    let at = cues.riding.board;
+    let desired = library.region_key(&district, "audio_ambience", at.x, at.z)
+        .filter(|key| library.zone(*key).and_then(|z| z.bed.as_ref()).is_some()).unwrap_or(0);
+
+    let phase = state.phase.unwrap_or(Phase::Silent);
+    let zone = library.zone(state.current).cloned();
+    let (fade_in, fade_out) = zone.as_ref().map_or((1.0, 1.0), |z| (z.time_b, z.time_a));
+    match phase {
+        Phase::Silent => {
+            if desired != 0 {
+                let zone = library.zone(desired).cloned();
+                if let Some(bed) = zone.as_ref().and_then(|z| z.bed.clone()) {
+                    if let Some(clip) = library.ambience(&mut assets, &bed) {
+                        let play = Play { category: Category::Ambience, volume: 0.0, pitch: 1.0, position: None,
+                            looping: true, fade_in: 0.0, envelope: None };
+                        if let Some(id) = voices.play(&mut commands, &clip, play, now) {
+                            info!("AUDIO_AMBIENCE zone {} bed {bed}", zone.as_ref().and_then(|z| z.name.as_deref()).unwrap_or("?"));
+                            state.bed = Some((id, clip));
+                        } else {
+                            state.fading.push(clip);
+                        }
+                    }
+                }
+                state.current = desired;
+                state.phase = Some(Phase::FadeIn);
+                state.t = 0.0;
+            }
+        }
+        Phase::FadeIn => {
+            state.t += dt;
+            if state.t >= fade_in {
+                state.phase = Some(Phase::Steady);
+                stop_crossfade(state, &mut voices);
+            }
+        }
+        Phase::Steady => {
+            if desired != state.current {
+                state.phase = Some(Phase::FadeOut);
+                state.t = 0.0;
+                stop_crossfade(state, &mut voices);
+                if desired != 0 {
+                    start_crossfade(state, &district, desired, &mut commands, &mut library, &mut voices, &mut assets, now);
+                }
+            }
+        }
+        Phase::FadeOut => {
+            state.t += dt;
+            if desired == state.current {
+                // Back into the zone that is fading out: fade the same bed back in.
+                state.t = (1.0 - state.t / fade_out.max(1e-3)).clamp(0.0, 1.0) * fade_in;
+                state.phase = Some(Phase::FadeIn);
+            } else if state.t >= fade_out {
+                if let Some((id, clip)) = state.bed.take() {
+                    voices.stop(id, 0.05);
+                    state.fading.push(clip);
+                }
+                state.current = 0;
+                state.phase = Some(Phase::Silent);
+            }
+        }
     }
-    let Some(bed) = bed else {
-        info!("Ambience: none for map {:?}", map.name);
+
+    // Bed level and the crossfade voices' directions.
+    let phase = state.phase.unwrap_or(Phase::Silent);
+    let zone = library.zone(state.current).cloned();
+    if let (Some((id, _)), Some(zone)) = (&state.bed, &zone) {
+        let gain = zone.volume * BED_BASE * super::cues::RETAIL_SCALE * (1.0 - attenuation(phase, state.t, zone.time_b, zone.time_a));
+        voices.set(*id, gain, 1.0, None);
+    }
+    if let Ok(ear) = listener.single() {
+        let (forward, right, origin) = (ear.forward().as_vec3(), ear.right().as_vec3(), ear.translation());
+        let level = state.crossfade_level;
+        for (id, _, pan, voice_level) in &state.crossfade {
+            let angle = pan.to_radians();
+            let at = origin + (forward * angle.cos() + right * angle.sin()) * PAN_DISTANCE;
+            voices.set(*id, voice_level * level, 1.0, Some(at));
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn start_crossfade(
+    state: &mut State, district: &str, to: u64, commands: &mut Commands, library: &mut Library,
+    voices: &mut Voices, assets: &mut Assets<AudioSource>, now: f64,
+) {
+    let Some(bank) = crossfade_bank(district) else { return };
+    let (group, level) = library.crossfade(state.current, to).map_or((1, 1.0), |c| (c.group, c.level));
+    let Some((_, _, layout)) = super::crossfade_groups::GROUPS.iter().find(|(b, g, _)| *b == bank && *g == group) else {
         return;
     };
-    let Some(clip) = library.ambience(&mut assets, bed) else { return };
+    // w0 = clamp(MixMap out1 x level); out1 not decoded yet, taken as full scale.
+    state.crossfade_level = level.min(1.0);
+    for (sample, pan, voice_level) in layout {
+        if let Some(clip) = library.sample(assets, bank, *sample) {
+            let play = Play { category: Category::Ambience, volume: 0.0, pitch: 1.0, position: Some(Vec3::ZERO),
+                looping: true, fade_in: 0.0, envelope: None };
+            if let Some(id) = voices.play(commands, &clip, play, now) {
+                state.crossfade.push((id, clip, *pan, *voice_level));
+            }
+        }
+    }
+    info!("AUDIO_AMBIENCE crossfade {bank} group {group} level {level:.2}");
+}
+
+fn stop_crossfade(state: &mut State, voices: &mut Voices) {
+    for (id, clip, ..) in state.crossfade.drain(..) {
+        voices.stop(id, 0.05);
+        state.fading.push(clip);
+    }
+}
+
+fn stop_all(state: &mut State, voices: &mut Voices, fade: f32) {
+    stop_crossfade(state, voices);
+    for (id, clip) in state.bed.take().into_iter().chain(state.fallback.take()) {
+        voices.stop(id, fade);
+        state.fading.push(clip);
+    }
+    state.current = 0;
+    state.phase = None;
+    state.t = 0.0;
+}
+
+#[allow(clippy::too_many_arguments)]
+fn fallback(
+    state: &mut State, commands: &mut Commands, map: &str, library: &mut Library, voices: &mut Voices,
+    assets: &mut Assets<AudioSource>, now: f64,
+) {
+    let Some(bed) = bed_for(map) else {
+        info!("Ambience: none for map {map:?}");
+        return;
+    };
+    let Some(clip) = library.ambience(assets, bed) else { return };
     let play = Play { category: Category::Ambience, volume: LEVEL, pitch: 1.0, position: None, looping: true, fade_in: CROSSFADE, envelope: None };
-    match voices.play(&mut commands, &clip, play, time.elapsed_secs_f64()) {
+    match voices.play(commands, &clip, play, now) {
         Some(voice) => {
-            info!("Ambience: {bed} for map {:?}", map.name);
-            state.current = Some((voice, clip));
+            info!("Ambience: {bed} for map {map:?} (no zone data; run setup)");
+            state.fallback = Some((voice, clip));
         }
         None => state.fading.push(clip),
     }
@@ -80,12 +266,29 @@ mod tests {
     use super::*;
 
     #[test]
-    fn every_installed_map_has_a_bed_from_the_export_list() {
+    fn every_installed_map_has_a_fallback_bed() {
         for map in ["University", "BlackBoxPark", "DownTown", "DownTownSkatePark", "Industrial",
                     "IndustrialSkatePark", "MaloofMoneyCup", "MegaPark", "SkateSchool", "StartPark"] {
             assert!(bed_for(map).is_some(), "{map}");
         }
-        assert_eq!(bed_for("university"), Some("09_univ_campus"));
         assert_eq!(bed_for("Test world"), None);
     }
+
+    #[test]
+    fn fades_are_linear_and_one_bed_at_a_time() {
+        assert_eq!(attenuation(Phase::Silent, 0.0, 2.0, 3.0), 1.0);
+        assert_eq!(attenuation(Phase::Steady, 9.0, 2.0, 3.0), 0.0);
+        assert!((attenuation(Phase::FadeIn, 1.0, 2.0, 3.0) - 0.5).abs() < 1e-6);
+        assert!((attenuation(Phase::FadeOut, 1.5, 2.0, 3.0) - 0.5).abs() < 1e-6);
+        assert_eq!(attenuation(Phase::FadeOut, 5.0, 2.0, 3.0), 1.0);
+    }
+
+    #[test]
+    fn crossfade_banks_exist_only_for_the_three_districts() {
+        assert_eq!(crossfade_bank("DownTown"), Some("Main_Ambience_Crossfade_DT"));
+        assert_eq!(crossfade_bank("MegaPark"), None);
+        for bank in ["Main_Ambience_Crossfade_DT", "Main_Ambience_Crossfade_Ind", "Main_Ambience_Crossfade_Uni"] {
+            assert!(super::super::crossfade_groups::GROUPS.iter().any(|(b, g, _)| *b == bank && *g == 1), "{bank}");
+        }
+    }
 }
diff --git a/crates/skate-game/src/game_audio/crossfade_groups.rs b/crates/skate-game/src/game_audio/crossfade_groups.rs
new file mode 100644
index 00000000..b214b529
--- /dev/null
+++ b/crates/skate-game/src/game_audio/crossfade_groups.rs
@@ -0,0 +1,29 @@
+//! What each `c_main_ambience_crossfade` group plays, measured by posting the program (w0 = w8 = 32767,
+//! w9 = group) through the PoC evaluator (2026-10-02; data .local/audio-re/crossfade). Four looping voices:
+//! (bank sample, pan degrees, level incl. the rear 23000/32767 factor). Interim until the AEMS evaluator
+//! is ported; regenerate, do not hand-edit.
+
+/// (district bank, group, voices)
+pub(super) const GROUPS: &[(&str, u32, [(usize, f32, f32); 4])] = &[
+    ("Main_Ambience_Crossfade_DT", 1, [(1, 45.0, 1.0000), (1, 225.0, 0.7019), (0, 135.0, 0.7019), (0, 315.0, 1.0000)]),
+    ("Main_Ambience_Crossfade_DT", 2, [(1, 45.0, 1.0000), (1, 225.0, 0.7019), (0, 135.0, 0.7019), (0, 295.2, 1.0000)]),
+    ("Main_Ambience_Crossfade_DT", 3, [(2, 295.2, 1.0000), (3, 45.0, 1.0000), (3, 225.0, 0.7019), (2, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_DT", 4, [(5, 45.0, 1.0000), (5, 225.0, 0.7019), (4, 135.0, 0.7019), (4, 295.2, 1.0000)]),
+    ("Main_Ambience_Crossfade_DT", 5, [(7, 45.0, 1.0000), (7, 225.0, 0.7019), (6, 135.0, 0.7019), (6, 295.2, 1.0000)]),
+    ("Main_Ambience_Crossfade_DT", 6, [(9, 45.0, 1.0000), (9, 225.0, 0.7019), (8, 135.0, 0.7019), (8, 295.2, 1.0000)]),
+    ("Main_Ambience_Crossfade_DT", 7, [(6, 295.2, 1.0000), (7, 45.0, 1.0000), (7, 225.0, 0.7019), (6, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Ind", 1, [(0, 135.0, 0.7019), (1, 225.0, 0.7019), (0, 315.0, 1.0000), (1, 45.0, 1.0000)]),
+    ("Main_Ambience_Crossfade_Ind", 2, [(2, 295.2, 1.0000), (3, 45.0, 1.0000), (3, 225.0, 0.7019), (2, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Ind", 3, [(4, 295.2, 1.0000), (5, 45.0, 1.0000), (4, 135.0, 0.7019), (5, 225.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Ind", 4, [(0, 135.0, 0.7019), (1, 225.0, 0.7019), (1, 45.0, 0.6104), (0, 295.2, 0.6104)]),
+    ("Main_Ambience_Crossfade_Ind", 5, [(3, 225.0, 0.7019), (2, 135.0, 0.7019), (2, 295.2, 0.6104), (3, 45.0, 0.6104)]),
+    ("Main_Ambience_Crossfade_Ind", 6, [(7, 225.0, 0.7019), (6, 135.0, 0.7019), (6, 295.2, 0.6104), (7, 45.0, 0.6104)]),
+    ("Main_Ambience_Crossfade_Ind", 7, [(8, 295.2, 1.0000), (9, 45.0, 1.0000), (9, 225.0, 0.7019), (8, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Ind", 8, [(2, 295.2, 1.0000), (3, 45.0, 1.0000), (3, 225.0, 0.7019), (2, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Ind", 9, [(1, 225.0, 0.7019), (0, 135.0, 0.7019), (0, 295.2, 0.6104), (1, 45.0, 0.6104)]),
+    ("Main_Ambience_Crossfade_Uni", 1, [(2, 315.0, 1.0000), (3, 45.0, 1.0000), (3, 225.0, 0.7019), (2, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Uni", 2, [(0, 295.2, 1.0000), (1, 45.0, 1.0000), (1, 225.0, 0.7019), (0, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Uni", 3, [(2, 295.2, 1.0000), (3, 45.0, 1.0000), (3, 225.0, 0.7019), (2, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Uni", 4, [(2, 295.2, 0.6104), (3, 45.0, 0.6104), (3, 225.0, 0.7019), (2, 135.0, 0.7019)]),
+    ("Main_Ambience_Crossfade_Uni", 5, [(2, 295.2, 0.6104), (3, 45.0, 0.6104), (3, 225.0, 0.7019), (2, 135.0, 0.7019)]),
+];
diff --git a/crates/skate-game/src/game_audio/cues.rs b/crates/skate-game/src/game_audio/cues.rs
index a1a8121b..4b7c9c81 100644
--- a/crates/skate-game/src/game_audio/cues.rs
+++ b/crates/skate-game/src/game_audio/cues.rs
@@ -6,6 +6,17 @@
 //! retail mapping"). The rest are our own picks, made by ear. Bank names and
 //! indices refer to assets/private/audio/audio_manifest.json.
 //!
+//! **Native runtime (`SKATE_AEMS=1`):** these tables are the interim path only. With the native
+//! player components running, the retired ones never play (`skate_events::play` gates them):
+//! - retired, user-confirmed (19:19 build): `POP`, `POP_TAIL`, `LAND`, `LAND_NORMAL`,
+//!   `LAND_HOLLOW`, `LAND_KIND_CHANCE`, `land_tier`, `land_scale`, `LAND_CLOTH`, `POWERSLIDE*`;
+//! - retired, native replacement ready but not user-confirmed yet: `GRIND_START`, `GRIND_PIECES`,
+//!   `GRIND_METAL*`, `AIR_WHEELS`, `BOARD_DOWN_KNOCK`, `BOARD_DOWN_TOUCH`, `CATCH`, `FLIP`,
+//!   `FOOT_DRAG*`, and the `BED_CUES` / `BED_RECORDS` entries the native components play
+//!   (sense_of_speed, Seams_Bank, Rolling_Rattles, PatchBank_Rolling_Surfaces, the knocks
+//!   1112 / 1115 / 1119 and the scuffs `sk8_foley` 94 / 95).
+//! They stay for the default path (native runtime off) until that path is retired as a whole.
+//!
 //! Levels are linear and deliberately low: many raw samples peak at 0 dBFS
 //! (retail mixes them down at runtime). Final gain = level x effects x master.
 //! Retail-measured cues use level = measured retail level x RETAIL_SCALE,
@@ -238,6 +249,11 @@ pub(super) const BED_RECORDS: &[(Record, f32)] = &[
     (retail(SC, 1112, 0.19).shaped(KNOCK_ENV), 0.11), (retail(SC, 1115, 0.26).shaped(KNOCK_ENV), 0.08),
     (retail(SC, 1119, 0.32).shaped(KNOCK_ENV), 0.02),
 ];
+/// Bed records the native contacts play from the retail mechanism (`player::contacts` foot taps
+/// 1112..1120 and shoe scuffs `sk8_foley` 94 / 95): silent in the interim bed when those run.
+pub(super) fn bed_record_native(record: &Record) -> bool {
+    matches!((record.bank, record.id), (SC, 1112 | 1115 | 1119) | ("sk8_foley", 94 | 95))
+}
 /// Object-bank layers of the bed (retail's most used samples): truck rattles,
 /// seams/cracks, speed wind and rolling-surface patches.
 pub(super) const BED_CUES: &[(Cue, f32)] = &[
@@ -287,24 +303,58 @@ pub(super) const AIR_WHEELS: (&str, f32) = ("Whls_spins_Jump_1", 0.15);
 /// Rolling grain for an audio material ID (low 7 bits of the collision
 /// surface tag; names from the map tooling's audio surface table). Retail was
 /// measured playing these "hard" grains too.
+/// Rolling grain for a wheel's 7-bit audio surface tag, as retail maps it: tag → material (tag − 1) →
+/// the vault's `Sk8::AudioSurfaceMap` → rolling surface 1–14 → grain member
+/// (.claude/notes/grain-player-spec.md §1.4; corrected 2026-10-02, it used to be an own guess).
+/// Only the hard-wheel members play: what selects the soft ones is not decoded yet.
 pub(super) fn grain_for(audio_surface: u32) -> &'static str {
-    match audio_surface {
-        1 => "asphalt_smooth_hard",
-        2 => "asphalt_rough_hard",
-        4 | 66 => "concrete_rough_hard",                       // Concrete_Rough, Brick_Coarse
-        5 | 8 | 10 | 55 | 56 => "concrete_aggregate_hard",    // Aggregate, Dirt, Grass, Leaves, Bush
-        6 | 7 | 41..=46 | 90 => "wood_ramp_hard",             // Wood_Ramp, Plywood, Wood_*
-        9 | 11..=40 | 67..=69 | 85 | 89 | 91 => "metal_smooth_hard", // Metal_*, grates, rails, Metal_Ramp
-        // Concrete_Polished (the common default), curbs, benches, tile, marble,
-        // smooth brick and anything unlisted.
-        _ => "concrete_smooth_hard",
+    match audio_surface & 0x7F {
+        2 => "asphalt_rough_hard",                                                    // surface 1
+        4 | 66 => "concrete_rough_hard",                                              // surface 2
+        3 | 51..=54 | 57 | 60 | 63..=65 | 92 | 93 => "concrete_smooth_hard",          // surface 4
+        6 | 7 | 41..=50 | 58 | 59 | 94 => "wood_ramp_hard",                           // surface 5
+        5 => "concrete_aggregate_hard",                                               // surface 6
+        9 | 11..=36 | 38..=40 | 84 | 85 | 89 | 91 => "metal_smooth_hard",             // surface 9
+        // INTERIM stand-ins. Retail plays no grain on these: rolling surfaces 7 (tags 10, 70),
+        // 8 (tag 8), 10 (67), 12 (68, 69) and 13 (37) post a per-surface `Class_rolling` patch
+        // (selectors 1, 2, 10, 11, 9) that this engine cannot play until the AEMS evaluator exists.
+        8 | 10 | 70 => "concrete_aggregate_hard",
+        37 | 67..=69 => "metal_smooth_hard",
+        // UNCERTAIN: tag 90 maps to rolling surface 0, which has no grain member; kept as before.
+        90 => "wood_ramp_hard",
+        // Surface 3 asphalt_smooth: tags 1, 55, 56, 61, 62, 71–83, 86–88, ≥ 95 and 0 (no material).
+        _ => "asphalt_smooth_hard",
     }
 }
 
+/// Whether retail plays a grain on this tag (false: a `Class_rolling` patch, or uncertain).
+#[cfg(test)]
+fn retail_plays_grain(audio_surface: u32) -> bool {
+    !matches!(audio_surface & 0x7F, 8 | 10 | 70 | 37 | 67..=69 | 90)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn rolling_grains_follow_the_retail_surface_map() {
+        // Spot checks against the vault's AudioSurfaceMap (grain-player-spec.md §1.4).
+        for (tag, grain) in [
+            (2, "asphalt_rough_hard"), (66, "concrete_rough_hard"), (1, "asphalt_smooth_hard"),
+            (55, "asphalt_smooth_hard"), (0, "asphalt_smooth_hard"), (100, "asphalt_smooth_hard"),
+            (3, "concrete_smooth_hard"), (93, "concrete_smooth_hard"), (47, "wood_ramp_hard"),
+            (94, "wood_ramp_hard"), (5, "concrete_aggregate_hard"), (84, "metal_smooth_hard"),
+            (36, "metal_smooth_hard"), (130, "asphalt_rough_hard"),
+        ] {
+            assert_eq!(grain_for(tag), grain, "tag {tag}");
+        }
+        for tag in [8, 10, 70, 37, 67, 68, 69, 90] {
+            assert!(!retail_plays_grain(tag), "tag {tag} is a Class_rolling / uncertain surface");
+        }
+        assert!(retail_plays_grain(1) && retail_plays_grain(9));
+    }
+
     #[test]
     fn cue_ranges_and_levels_are_sane() {
         assert_eq!(FLIP.samples, &[1, 2, 3]);
@@ -334,6 +384,7 @@ mod tests {
         assert_eq!(grain_for(3), "concrete_smooth_hard");
         assert_eq!(grain_for(6), "wood_ramp_hard");
         assert_eq!(grain_for(31), "metal_smooth_hard");
-        assert_eq!(grain_for(127), "concrete_smooth_hard");
+        // Retail: tags ≥ 95 map to asphalt_smooth (was concrete_smooth before the 2026-10-02 correction).
+        assert_eq!(grain_for(127), "asphalt_smooth_hard");
     }
 }
diff --git a/crates/skate-game/src/game_audio/e2e.rs b/crates/skate-game/src/game_audio/e2e.rs
new file mode 100644
index 00000000..49a6cffc
--- /dev/null
+++ b/crates/skate-game/src/game_audio/e2e.rs
@@ -0,0 +1,499 @@
+//! End-to-end render of the native player audio (MixMap inputs → components → AEMS voices →
+//! granular bed → 6-channel bus) for the scripted per-frame situations of
+//! `.claude/skills/aems-port/tools/e2e/scenarios.py`, headless. The same scripts drive the PoC's
+//! oracle probe; `.claude/skills/aems-port/tools/e2e/compare.py` compares the two renders.
+//!
+//!   set E2E_DIR=...\.local\audio-re\e2e   (optional E2E_ONLY=roll20,grind_metal)
+//!   cargo test -p skate-game --release --bin skate3rust -- --ignored e2e_render --nocapture
+//!
+//! Writes `<name>.ours.f32` (raw f32, 6 channels in the PoC's order L, R, C, LFE, Ls, Rs) and
+//! `<name>.ours.voices.tsv` (per frame: bank, slot, gain, pitch of every sounding voice; grain
+//! voices as `grain`).
+use std::collections::HashMap;
+use std::io::Write;
+use std::sync::{Arc, Mutex};
+
+use skate_audio::formats::{Bank, Project};
+use skate_audio::mixmap::{MixMap, keys};
+use skate_audio::player::AudioState;
+use skate_audio::player::state::material_of_tag;
+use skate_audio::runtime::Runtime;
+
+use super::player_audio::{BANKS, PlayerAudio};
+use super::skate_events::Riding;
+
+struct Row(HashMap<String, f64>);
+impl Row {
+    fn f(&self, k: &str) -> f32 {
+        self.0.get(k).copied().unwrap_or(0.0) as f32
+    }
+    fn i(&self, k: &str) -> i64 {
+        self.0.get(k).copied().unwrap_or(0.0) as i64
+    }
+}
+
+fn read(path: &std::path::Path) -> Vec<Row> {
+    let text = std::fs::read_to_string(path).unwrap();
+    let mut lines = text.lines();
+    let cols: Vec<String> = lines.next().unwrap().split('\t').map(str::to_owned).collect();
+    lines.map(|l| Row(cols.iter().cloned().zip(l.split('\t').map(|v| v.parse::<f64>().unwrap())).collect())).collect()
+}
+
+/// What `skate_events::observe` / `audio_state` would publish for this row.
+struct Script {
+    x: f32,
+    air_time: f32,
+    pushes: u32,
+    family: Option<i32>,
+    material: Option<u32>,
+    jump_velocity: f32,
+}
+
+impl Script {
+    fn riding(&mut self, r: &Row) -> Riding {
+        let speed = r.f("speed");
+        self.x += speed / 60.0;
+        let state = r.i("state") as u32;
+        // As `skate_events::observe`: an unridden board reports no contacts (logs recorded before
+        // that gate still carry them).
+        let unridden = super::skate_events::board_unridden(state);
+        let mask = if unridden { 0 } else { r.i("wheels") as u32 };
+        let contact: [bool; 4] = std::array::from_fn(|i| mask & (1 << i) != 0);
+        let wheels = contact.iter().filter(|c| **c).count() as u32;
+        // E2E_CONTACT_MATERIALS=1: the materials gated by contact, as the game did before 20:15.
+        let lines = if std::env::var("E2E_CONTACT_MATERIALS").is_ok_and(|v| v == "1") {
+            mask
+        } else if unridden {
+            0
+        } else if r.0.contains_key("lines") {
+            r.i("lines") as u32
+        } else if mask != 0 {
+            15
+        } else {
+            0
+        };
+        let tag = if unridden { 0 } else { r.i("tag") as u32 };
+        let airborne = (200..300).contains(&state) && wheels == 0;
+        // `+236` as `skate_events::audio_state`; E2E_AIR_TIME_STATE=0: the old count (air flag only).
+        let follow = !std::env::var("E2E_AIR_TIME_STATE").is_ok_and(|v| v == "0");
+        let air_words = !std::env::var("E2E_AIR_WORDS").is_ok_and(|v| v == "0");
+        self.air_time = super::skate_events::air_time_236(self.air_time, state, airborne, 1.0 / 60.0, follow);
+        let grinding = r.i("grinding") != 0;
+        if grinding {
+            self.family = Some(r.i("family") as i32);
+            self.material = Some((r.i("grind_tag") as u32).min(143));
+        }
+        let push = r.i("push") != 0;
+        self.pushes += u32::from(push);
+        let scorable = r.i("scorable");
+        let jv = r.f("jv");
+        if jv != 0.0 {
+            self.jump_velocity = skate_audio::player::state::jump_velocity(jv);
+        }
+        let feet = r.i("feet") as u32;
+        let audio = AudioState {
+            dt: 1.0 / 60.0,
+            ground_speed: speed,
+            com_velocity: [speed, 0.0, 0.0],
+            com_position: [self.x, 1.0, 0.0],
+            board_position: [self.x, 0.1, 0.0],
+            board_velocity: [speed, 0.0, 0.0],
+            wheel_count: wheels,
+            wheel_contact: contact,
+            // The materials come from the wheel lines (`skate_events::audio_state`): logs since 20:15
+            // carry their hit mask (`lines`); older logs and the scripts take every line as hitting
+            // while any wheel is down (retail keeps wheel 0's material on 100 % of 3-wheel frames).
+            wheel_material: std::array::from_fn(|i| if lines & (1 << i) != 0 { material_of_tag(tag) } else { 143 }),
+            // Wheel 0's pattern for the front pair, wheel 3's for the rear (logs since the seams
+            // port); scripted scenarios have none.
+            seam_pattern: if unridden { [0; 4] } else {
+                let (f, b) = (r.i("seam0") as u32, r.i("seam3") as u32);
+                std::array::from_fn(|i| if lines & (1 << i) == 0 { 0 } else if i < 2 { f } else { b })
+            },
+            // The wheels around wheel 0's logged position along the deck heading (track 0.2 m,
+            // wheelbase 0.6 m — the engine's board; only the grid crossings read them).
+            wheel_position: {
+                let (x0, z0, h) = (r.f("wheel_x"), r.f("wheel_z"), r.f("heading"));
+                let (ax, az, rx, rz) = (h.sin(), h.cos(), h.cos(), -h.sin());
+                let offs = [(0.0, 0.0), (-0.2, 0.0), (0.0, -0.6), (-0.2, -0.6)];
+                std::array::from_fn(|i| [x0 + rx * offs[i].0 + ax * offs[i].1, 0.0, z0 + rz * offs[i].0 + az * offs[i].1])
+            },
+            turn: r.f("turn"),
+            slope: r.f("slope"),
+            airborne,
+            air_time: self.air_time,
+            brake: r.i("brake") != 0,
+            manual_brake: r.i("manual") != 0,
+            balance: r.i("balance") != 0,
+            grinding,
+            trick_active: scorable != -1,
+            hippy_jump: airborne && scorable == 234,
+            bail: false,
+            bail_end: false,
+            on_foot: false,
+            soft_wheels: false,
+            push_planted: push,
+            push_trigger: push,
+            feet_in_deck_box: [feet & 1 != 0, feet & 2 != 0],
+            grind_family: self.family.unwrap_or(-1),
+            // `+692` = Grinds+216 as the game publishes it (`audio_state`: no tag − 1 here).
+            grind_material: self.material.unwrap_or(143),
+            local: true,
+            jump_velocity: self.jump_velocity,
+            audio_trick: -1,
+            scorable: scorable as i32,
+            // The scenario's slip is the sine of the deck's turn off the roll (lateral / speed).
+            slip: if wheels > 0 { skate_audio::player::state::slip(r.f("slip") * speed) } else { 0.0 },
+            revert: state == 102,
+            offboard_308: false,
+            deck_tilt: r.f("tilt"),
+            deck_spin: 0.0,
+            // `+240` / `+260` (Class_Treatment w8 / w9) from the rows' to_land / jump_height (both
+            // scenario kinds carry them); E2E_AIR_WORDS=0: 0 as before 2026-10-02 (no Treatments).
+            air_until_landing: if air_words { r.f("to_land") } else { 0.0 },
+            jump_height: if air_words { r.f("jump_height") } else { 0.0 },
+            // Real-play logs carry these (state_log.rs, appended columns); scripted scenarios
+            // leave them 0.
+            grind_impact: r.f("grind_impact"),
+            deck_impact: if unridden { 0.0 } else { r.f("deck_impact") },
+            deck_material: if unridden { 143 } else { material_of_tag(r.i("deck_tag") as u32) },
+            foot_speed_y: [r.f("foot_y0"), r.f("foot_y1")],
+            foot_speed_xz: [r.f("foot_xz0"), r.f("foot_xz1")],
+            // Off-board inputs (logs since 21:00; older logs: none).
+            foot_down: [r.i("foot_down") & 1 != 0, r.i("foot_down") & 2 != 0],
+            foot_material: if r.0.contains_key("foot_tag_a") { [r.i("foot_tag_a") as u32, r.i("foot_tag_b") as u32] } else { [143; 2] },
+            hands_on_deck: [r.i("hands") & 1 != 0, r.i("hands") & 2 != 0],
+            footstep_strength: r.f("strength"),
+            foot_vertical_speed: [r.f("foot_vy_a"), r.f("foot_vy_b")],
+            // The skeleton inputs (logs since the skeleton-inputs stage; older logs: the defaults).
+            step_code: if r.0.contains_key("step") { r.i("step") as i32 } else { 1 },
+            body_speed: r.f("body"),
+            limb_speed: r.f("limb"),
+            ..AudioState::default()
+        };
+        Riding {
+            board: bevy::math::Vec3::new(self.x, 0.1, 0.0),
+            speed,
+            rolling: wheels > 0,
+            surface: tag,
+            airborne,
+            grinding,
+            grind_surface: r.i("grind_tag") as u32,
+            sliding: state == 101,
+            braking: r.i("brake") != 0 && speed > 0.5,
+            wheels,
+            pushes: self.pushes,
+            audio,
+            // The loose-board inputs (logs since the skeleton-inputs stage; older: upright, no contact).
+            deck_up: if r.0.contains_key("deck_up") { r.f("deck_up") } else { 1.0 },
+            deck_contact: r.i("deck_contact") != 0,
+            deck_material: material_of_tag(r.i("deck_tag") as u32),
+        }
+    }
+}
+
+fn globals(m: &mut MixMap) {
+    for id in 1..=4 {
+        m.set_input(keys::MASTER, id, 32767);
+    }
+    for id in [1, 2, 5] {
+        m.set_input(keys::MUSIC, id, 32767);
+    }
+    m.set_input(keys::REVERB, 5, 32767);
+}
+
+#[test]
+#[ignore = "headless render for the PoC comparison; needs E2E_DIR and the install"]
+fn e2e_render() {
+    let Some(dir) = std::env::var_os("E2E_DIR").map(std::path::PathBuf::from) else { return eprintln!("E2E_DIR not set") };
+    let root = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets"));
+    let library = super::Library::load(root).expect("install");
+    let mxb = library.read(library.aems().mixmap.as_ref().expect("MixMap")).unwrap();
+    let only = std::env::var("E2E_ONLY").ok();
+    let mut paths: Vec<_> = std::fs::read_dir(&dir).unwrap().filter_map(|e| e.ok().map(|e| e.path())).filter(|p| p.extension().is_some_and(|x| x == "tsv") && !p.file_stem().unwrap().to_string_lossy().contains('.')).collect();
+    paths.sort();
+    for path in paths {
+        let name = path.file_stem().unwrap().to_string_lossy().to_string();
+        if only.as_ref().is_some_and(|o| !o.split(',').any(|x| x == name)) {
+            continue;
+        }
+        let rows = read(&path);
+        let mut rt = Runtime::new();
+        for file in &library.aems().projects {
+            rt.install_project(&Project::parse(file, &library.read(file).unwrap()).unwrap());
+        }
+        let mut names = HashMap::new();
+        for stem in std::iter::once("emitter_utility").chain(BANKS.iter().copied()) {
+            let file = &library.aems().banks[stem];
+            let bank = Bank::parse(stem, library.read(file).unwrap()).unwrap();
+            let id = rt.load_bank(bank, library.bank_pcm(stem));
+            names.insert(id, stem);
+        }
+        let utility = rt.eval.class_id("c_emitter_utility").unwrap();
+        rt.post(utility, &[]);
+        let off = |var: &str| std::env::var(var).is_ok_and(|v| v == "0");
+        // Retail's second boot utility (the Seams program's sample shuffles); E2E_SEAM_UTILITY=0:
+        // without it, as before Listening test 8.
+        if !off("E2E_SEAM_UTILITY") {
+            use skate_audio::player::seams::{UTILITY, UTILITY_BANK};
+            if let Some(file) = library.aems().banks.get(UTILITY_BANK) {
+                let id = rt.load_bank(Bank::parse(UTILITY_BANK, library.read(file).unwrap()).unwrap(), Vec::new());
+                names.insert(id, UTILITY_BANK);
+                rt.post(rt.eval.class_id(UTILITY).unwrap(), &[]);
+            }
+        }
+        // The optional components (rolling layers, rattle, board slide, tricks, treatment) run when
+        // their first bank is in the install, as in the game; E2E_<NAME>=0 turns one off.
+        let off = |var: &str| std::env::var(var).is_ok_and(|v| v == "0");
+        let mut optional = [false; 5];
+        for (k, (banks, var)) in super::player_audio::OPTIONAL_BANKS.iter().zip(["E2E_ROLLING", "E2E_RATTLE", "E2E_SLIDE", "E2E_TRICKS", "E2E_TREATMENT"]).enumerate() {
+            if off(var) {
+                continue;
+            }
+            for (i, stem) in banks.iter().enumerate() {
+                let Some(file) = library.aems().banks.get(*stem) else { continue };
+                let bank = Bank::parse(stem, library.read(file).unwrap()).unwrap();
+                let id = rt.load_bank(bank, library.bank_pcm(stem));
+                names.insert(id, stem);
+                optional[k] |= i == 0;
+            }
+        }
+        if optional[3] {
+            if let Some(id) = rt.eval.class_id(skate_audio::player::tricks::FOLEY_UTILITY) {
+                rt.post(id, &[]);
+            }
+        }
+        // E2E_CHAIN=0: the bed's chain as before the full graph-1/2/3 port.
+        rt.grains.chain_extras = !off("E2E_CHAIN");
+        let mut contacts = true;
+        for (i, stem) in super::player_audio::SPLICE_BANKS.iter().enumerate() {
+            match library.splice_bank(stem) {
+                Some((bank, pcm)) => {
+                    let r = &mut rt;
+                    r.splice.load_bank(stem, bank, pcm, &mut r.mixer);
+                }
+                None => contacts &= i > 0,
+            }
+        }
+        let streams: Vec<_> = super::player_audio::WHEEL_STREAMS.iter().map(|n| library.wheels_pcm(n)).collect();
+        let wheels = streams.iter().all(Option::is_some);
+        rt.load_streams(streams);
+        // The buses (E2E_BUSES=0: dry, as before the bus port): the reverb network at the default
+        // preset (no map → reverb01) and the eEQChain buses.
+        if std::env::var("E2E_BUSES").map_or(true, |v| v != "0") {
+            let (presets, eq) = library.bus_tuning();
+            rt.mixer.buses.env.presets = presets;
+            rt.mixer.buses.eq.set_records(&eq);
+            // E2E_PRESET=<16 hex digits>: a region's preset key instead (e.g. University's
+            // 407AFA1D6C7CEAD8, DownTown's 68A9E6020DF2076D).
+            let preset = std::env::var("E2E_PRESET").ok().and_then(|k| u64::from_str_radix(&k, 16).ok());
+            rt.mixer.buses.env.request(preset.unwrap_or(skate_audio::bus::env::DEFAULT_PRESET));
+            // The FlangeSub returns (E2E_FLANGE=0: off).
+            if let Some([a, b]) = library.flange_presets().filter(|_| !off("E2E_FLANGE")) {
+                rt.mixer.buses.flange.set_presets(a, b);
+            }
+        }
+        // The FootStep SubMix graphs (E2E_FOOTSTEP_SUBMIX=0: the foot voices straight into SFX Master).
+        rt.mixer.buses.submix.enabled = !off("E2E_FOOTSTEP_SUBMIX");
+        // Reverb.in0..6 from the preset and the env scale (E2E_REVERB_INPUTS=0: in5 = 32767, no scale).
+        let reverb_inputs = !off("E2E_REVERB_INPUTS");
+        let shared = Arc::new(Mutex::new(rt));
+        let mut m = MixMap::from_bytes(&mxb).unwrap();
+        let mut p = PlayerAudio::new(library.player_tuning(), true);
+        p.contacts_on = contacts && std::env::var("E2E_CONTACTS").map_or(true, |v| v != "0");
+        p.contact_tuning = library.contacts_tuning();
+        p.footsteps_on = p.contacts_on && !off("E2E_FOOTSTEPS");
+        p.set_footstep_materials(library.footstep_materials());
+        p.wheels_on = wheels && std::env::var("E2E_WHEELS").map_or(true, |v| v != "0");
+        (p.rolling_on, p.rattle_on, p.slide_on, p.tricks_on, p.treatment_on) = (optional[0], optional[1], optional[2], optional[3], optional[4]);
+        let mut bed = super::grain_bed::Bed::new(&library).expect("grain bed data");
+        let seams = skate_audio::player::tuning::PlayerTuning { seam_wobbles: p.tuning.seam_wobbles.clone(), ..Default::default() };
+        let mut script = Script { x: 0.0, air_time: 0.0, pushes: 0, family: None, material: None, jump_velocity: 0.0 };
+        let mut out = std::io::BufWriter::new(std::fs::File::create(dir.join(format!("{name}.ours.f32"))).unwrap());
+        let mut voices = std::io::BufWriter::new(std::fs::File::create(dir.join(format!("{name}.ours.voices.tsv"))).unwrap());
+        writeln!(voices, "frame\tbank\tslot\tgain\tpitch").unwrap();
+        let (mut owed, blocks_per_frame) = (0.0f64, 48_000.0 / 256.0 / 60.0);
+        let order: Vec<usize> = std::iter::repeat(0).take(60).chain(0..rows.len()).collect();
+        // E2E_TIMING=1: per-frame cost of the game-thread side and per-block cost of the render.
+        let timing = std::env::var("E2E_TIMING").is_ok_and(|v| v == "1");
+        let (mut game_us, mut block_us): (Vec<(f64, usize, [f64; 5])>, Vec<f64>) = (Vec::new(), Vec::new());
+        // E2E_SUBSTEPS=N: N audio-manager calls per 60 Hz physics row (the recomp calls it per
+        // rendered frame, ~5 per physics step: the state, wheel positions included, changes only on
+        // the first). Diagnostic for cadence-dependent components (Class_Seams' one-call w7 pulse);
+        // 1 (default) = the game's 60 Hz host.
+        let substeps: usize = std::env::var("E2E_SUBSTEPS").ok().and_then(|v| v.parse().ok()).unwrap_or(1).max(1);
+        let sub_dt = 1.0 / 60.0 / substeps as f32;
+        // E2E_CALLS=N: the game's host at N rendered frames per 60 Hz tick (353 fps ≈ 6): the full
+        // tick on the first call; Class_Seams on its console cadence (`PlayerAudio::seam_frame`) on
+        // every call, at the wheel positions interpolated from the previous row like the rendered
+        // board; the blocks spread evenly. 1 (default) = one call per row, the seams per tick at the
+        // physics positions, as before.
+        let calls: usize = std::env::var("E2E_CALLS").ok().and_then(|v| v.parse().ok()).unwrap_or(1).max(1);
+        let per_row = substeps * calls;
+        // E2E_FPS=f (overrides E2E_CALLS): the game's host at a rendered frame rate f, as
+        // `native::mixmap_frame` runs it: f/60 calls per physics row on average (the first call of a
+        // row ticks; every call runs `seam_frame`); below 60 fps a call ticks the MixMap once per
+        // elapsed 60 Hz step and rows without a call only render.
+        let fps: Option<f64> = std::env::var("E2E_FPS").ok().and_then(|v| v.parse().ok());
+        let console = fps.is_some() || calls > 1;
+        let (mut fps_acc, mut rows_since_call) = (0.0f64, 0usize);
+        for (frame, &i) in order.iter().enumerate() {
+          let row_riding = script.riding(&rows[i]);
+          rows_since_call += 1;
+          let (n_row, calls) = match fps {
+              Some(f) => {
+                  fps_acc += f / 60.0;
+                  let n = fps_acc.floor() as usize;
+                  fps_acc -= n as f64;
+                  (n, n.max(1))
+              }
+              None => (per_row, calls),
+          };
+          let per_row = n_row.max(1);
+          if n_row == 0 {
+              owed += blocks_per_frame;
+              let mut rt = shared.lock().unwrap();
+              while owed >= 1.0 {
+                  owed -= 1.0;
+                  let bus = rt.render_block();
+                  for k in 0..skate_audio::BLOCK {
+                      for ch in [0, 2, 1, 5, 3, 4] {
+                          out.write_all(&bus[ch][k].to_le_bytes()).unwrap();
+                      }
+                  }
+              }
+          }
+          for call in 0..n_row {
+            // The console seams cadence (Listening test 9) whenever the host runs other than one
+            // call per row: every call is a rendered frame of 1/f s.
+            if console {
+                p.seam_console = true;
+                p.seam_alpha = Some((call % calls) as f32 / calls as f32);
+                let dt = fps.map_or(1.0 / (60.0 * calls as f64), |f| 1.0 / f) as f32;
+                p.seam_frame(&m, &row_riding.audio, dt, &mut shared.lock().unwrap());
+            }
+            if call % calls != 0 {
+                owed += blocks_per_frame / per_row as f64;
+                let mut rt = shared.lock().unwrap();
+                while owed >= 1.0 {
+                    owed -= 1.0;
+                    let bus = rt.render_block();
+                    for k in 0..skate_audio::BLOCK {
+                        for ch in [0, 2, 1, 5, 3, 4] {
+                            out.write_all(&bus[ch][k].to_le_bytes()).unwrap();
+                        }
+                    }
+                }
+                continue;
+            }
+            let t0 = std::time::Instant::now();
+            let riding = row_riding;
+            let mut s = riding.audio;
+            if substeps > 1 {
+                s.dt = sub_dt;
+            }
+            globals(&mut m);
+            if reverb_inputs {
+                let v = shared.lock().unwrap().mixer.buses.env.reverb_inputs();
+                for (id, x) in v.into_iter().enumerate() {
+                    m.set_input(keys::REVERB, id, x);
+                }
+            }
+            let l = p.listener([script.x - 3.0, 2.5, 0.0], [1.0, 0.0, 0.0], sub_dt, &s);
+            p.write_inputs(&mut m, &s, Some(&l));
+            bed.write_inputs(&mut m, &s, !p.rolling_on);
+            let speed_scale = bed.push_scale();
+            let loose = PlayerAudio::loose_board(&s, &riding);
+            let t1 = std::time::Instant::now();
+            p.process(&mut m, &s, &mut shared.lock().unwrap(), speed_scale, loose);
+            let t2 = std::time::Instant::now();
+            // Below 60 fps one call ticks once per elapsed 60 Hz step (`mixmap_frame`'s ticks loop).
+            let ticks = if fps.is_some_and(|f| f < 60.0) { rows_since_call } else { 1 };
+            for _ in 0..ticks {
+                m.tick(sub_dt);
+            }
+            rows_since_call = 0;
+            if frame % 2 == 1 {
+                shared.lock().unwrap().mixer.buses.eq.clear(p.eq_jitter());
+            }
+            let t3 = std::time::Instant::now();
+            p.update(&m, &s, &mut shared.lock().unwrap(), speed_scale, loose);
+            shared.lock().unwrap().mixer.buses.flange.frame(std::array::from_fn(|i| m.level(keys::REVERB, i)));
+            if reverb_inputs {
+                shared.lock().unwrap().mixer.buses.env.scale_frame(m.level(keys::REVERB, 4));
+            }
+            let t4 = std::time::Instant::now();
+            let routed = p.rolling_on.then(|| (std::mem::take(&mut p.routed.grains), p.routed.primary));
+            super::grain_bed::step(&mut bed, &library, &m, &shared, &riding, sub_dt, &seams, routed);
+            let t5 = std::time::Instant::now();
+            if timing && frame >= 60 {
+                let us = |a: std::time::Instant, b: std::time::Instant| (b - a).as_secs_f64() * 1e6;
+                game_us.push((us(t0, t5), frame - 60, [us(t0, t1), us(t1, t2), us(t2, t3), us(t3, t4), us(t4, t5)]));
+            }
+            owed += blocks_per_frame / per_row as f64;
+            let mut rt = shared.lock().unwrap();
+            while owed >= 1.0 {
+                owed -= 1.0;
+                let tb = std::time::Instant::now();
+                let bus = rt.render_block();
+                if timing && frame >= 60 {
+                    block_us.push(tb.elapsed().as_secs_f64() * 1e6);
+                }
+                // Ours: L, C, R, Ls, Rs, LFE → the PoC's L, R, C, LFE, Ls, Rs.
+                for k in 0..skate_audio::BLOCK {
+                    for ch in [0, 2, 1, 5, 3, 4] {
+                        out.write_all(&bus[ch][k].to_le_bytes()).unwrap();
+                    }
+                }
+            }
+            drop(rt);
+          }
+            let rt = shared.lock().unwrap();
+            if frame >= 60 {
+                for v in rt.mixer.snapshot() {
+                    let bank = names.get(&v.bank).copied().unwrap_or("?");
+                    let out = match v.output {
+                        skate_audio::bus::Output::Master => 8,
+                        skate_audio::bus::Output::Eq(i) => i,
+                        // A FootStep SubMix graph (sends on into the env bus and SFX Master).
+                        skate_audio::bus::Output::Submix(i) => 20 + i,
+                    };
+                    writeln!(voices, "{}\t{bank}\t{}\t{:.5}\t{:.4}\t{:.5}\t{out}", frame - 60, v.slot, v.gain, v.pitch, v.send).unwrap();
+                }
+                for (t, truck) in rt.grains.trucks.iter().enumerate() {
+                    for (k, player) in truck.players.iter().enumerate() {
+                        if player.voices() > 0 {
+                            let r = player.record;
+                            writeln!(voices, "{}\tgrain{t}{}\t{}\t{:.5}\t{:.4}\t{:.4}", frame - 60, ["A", "B"][k], player.starts, r.gain, r.pitch, r.position).unwrap();
+                        }
+                    }
+                }
+                for (bank, record, sample, gain, pitch) in rt.splice.voices() {
+                    writeln!(voices, "{}	splice:{bank}:{record}	{sample}	{gain:.5}	{pitch:.4}", frame - 60).unwrap();
+                }
+                if rt.grains.rocket.voices() > 0 {
+                    let r = rt.grains.rocket.record;
+                    writeln!(voices, "{}\trocket\t{}\t{:.5}\t{:.4}\t{:.4}", frame - 60, rt.grains.rocket.starts, r.gain, r.pitch, r.position).unwrap();
+                }
+            }
+        }
+        let (hits, transitions) = p.seam_hits();
+        eprintln!("{name}: {} frames (+60 settle); Class_Seams hits {hits} ({transitions} material changes)", rows.len());
+        if timing && !game_us.is_empty() {
+            let pct = |v: &mut Vec<f64>, q: f64| {
+                v.sort_by(f64::total_cmp);
+                v[((v.len() - 1) as f64 * q) as usize]
+            };
+            let mut g: Vec<f64> = game_us.iter().map(|x| x.0).collect();
+            eprintln!("  game thread per frame (us): p50 {:.0} p99 {:.0} max {:.0}", pct(&mut g, 0.5), pct(&mut g, 0.99), pct(&mut g, 1.0));
+            let mut slow: Vec<(usize, f64)> = block_us.iter().copied().enumerate().collect();
+            slow.sort_by(|a, b| b.1.total_cmp(&a.1));
+            eprintln!("  slowest blocks (index, us): {:?}", &slow[..slow.len().min(4)]);
+            eprintln!("  render per 256-frame block (us, budget 5333): p50 {:.0} p99 {:.0} max {:.0}", pct(&mut block_us, 0.5), pct(&mut block_us, 0.99), pct(&mut block_us, 1.0));
+            game_us.sort_by(|a, b| b.0.total_cmp(&a.0));
+            for (total, f, parts) in game_us.iter().take(8) {
+                eprintln!("  frame {f}: {total:.0} us = inputs {:.0} process {:.0} tick {:.0} update {:.0} bed {:.0}", parts[0], parts[1], parts[2], parts[3], parts[4]);
+            }
+        }
+    }
+}
diff --git a/crates/skate-game/src/game_audio/emitters.rs b/crates/skate-game/src/game_audio/emitters.rs
index f127ae88..9b83732a 100644
--- a/crates/skate-game/src/game_audio/emitters.rs
+++ b/crates/skate-game/src/game_audio/emitters.rs
@@ -13,12 +13,19 @@
 //!   listener leaves stops at once (retail releases it without a fade).
 //!
 //! What each bank then plays (relay of short pieces or one loop, and its slow
-//! level/pitch movement) is retail's patch program for the bank. Until the
-//! AEMS evaluator is ported, `PROFILES` holds those programs' measured
-//! behaviour (PoC evaluator runs, notes ems-emitters-re.md); banks without a
-//! profile are not played yet.
-use super::{Category, Library, Play, Voices, library::Clip, voices::VoiceId};
+//! level/pitch movement) is retail's patch program for the bank:
+//! - with the native AEMS runtime on (`native.rs`, `SKATE_AEMS=1`), every record whose bank is in
+//!   the install takes one of the 5 emitter states (= MixMap Emitter instances), posts `c_emitter`
+//!   and the bank's own program plays it. The payload comes from the MixMap (`Native::
+//!   emitter_payload`: w1 dry = out4 × level, w2 send = out8 × level, w3 pan = out0, w4 pitch =
+//!   out5, w5 low-pass = out6, w8 = the attribute patch = selector); the state's 3-D input gets the
+//!   listener's distance and azimuth each frame. Redelivered every frame, released (state freed)
+//!   when the listener leaves;
+//! - otherwise `PROFILES` holds those programs' measured behaviour (PoC evaluator runs, notes
+//!   ems-emitters-re.md) and banks without a profile are not played.
+use super::{Category, Library, Play, Voices, library::Clip, native::Native, voices::VoiceId};
 use bevy::prelude::*;
+use skate_audio::eval::NodeId;
 
 /// CSTATEMGR_Emitter's pool size.
 const MAX_ACTIVE: usize = 5;
@@ -80,6 +87,123 @@ fn ems_file(map_stem: &str) -> Option<&'static str> {
     })
 }
 
+/// The `.ems` files a map's database entry lists (`F4917ACACAFAF913` field `65FA976EF23A314E`, in
+/// that order): the districts load five, the parks one. The emitter system (`sub_824A24F8`) loads
+/// them all; the sound emitters above still come from the `sfx_` file only.
+fn ems_files(map_stem: &str) -> &'static [&'static str] {
+    match map_stem {
+        "University" => &["music_university", "sfx_university", "reverb_university", "speakers_university", "crowds_university"],
+        "DownTown" => &["music_downtown", "sfx_downtown", "reverb_downtown", "speakers_downtown", "crowds_downtown"],
+        "Industrial" => &["music_industrial", "sfx_industrial", "reverb_industrial", "speakers_industrial", "crowds_industrial"],
+        _ => match ems_file(map_stem) {
+            Some("sfx_dt_skatepark") => &["sfx_dt_skatepark"],
+            Some("sfx_ind_skatepark") => &["sfx_ind_skatepark"],
+            Some("sfx_mega_skatepark") => &["sfx_mega_skatepark"],
+            Some("sfx_maloof_money_cup") => &["sfx_maloof_money_cup"],
+            Some("sfx_startpark") => &["sfx_startpark"],
+            Some("sfx_blackbox_park") => &["sfx_blackbox_park"],
+            Some("skateschool") => &["skateschool"],
+            _ => &[],
+        },
+    }
+}
+
+/// The reverb-zone emitters (`eVolumeType` 5) the listener is inside this frame, in the order
+/// they were reached (retail's active node list, which `sub_82488278` walks for `SFXObj_Reverb`).
+#[derive(Resource, Default)]
+pub(super) struct ReverbZones {
+    pub zones: Vec<skate_audio::bus::zones::Zone>,
+}
+
+struct ZoneRecord {
+    shape: Shape,
+    id: u64,
+    attribute: u64,
+    preset: u64,
+}
+
+#[derive(Default)]
+pub(super) struct ZoneState {
+    map: Option<(String, u64)>,
+    records: Vec<ZoneRecord>,
+    /// Reached records in discovery order.
+    active: Vec<usize>,
+}
+
+/// Per frame, before `native::reverb_frame`: which reverb zones hold the listener (the camera, as
+/// the emitter query's `0x820CFDD4`), with their normalised distance after the inner core
+/// (`sub_828EA918`'s sphere / ellipsoid test, as for the sound emitters) and their attribute's
+/// preset (`99FD793BC30CF0FA`). Native runtime only.
+pub(super) fn reverb_zones(
+    mut state: Local<ZoneState>,
+    map: Res<crate::map_transition::CurrentMap>,
+    library: Option<Res<Library>>,
+    native: Option<Res<Native>>,
+    listener: Query<&GlobalTransform, With<super::GameAudioListener>>,
+    mut out: ResMut<ReverbZones>,
+) {
+    let (Some(library), Some(_)) = (library, native) else { return };
+    let state = &mut *state;
+    let identity = (map.name.clone(), map.generation);
+    if state.map.as_ref() != Some(&identity) {
+        let stem = map.path.as_deref().and_then(|p| p.file_stem()).and_then(|s| s.to_str()).unwrap_or("");
+        state.records = zone_records(&library, stem);
+        state.active.clear();
+        if !state.records.is_empty() {
+            info!("Reverb zones: {} records on {stem}", state.records.len());
+        }
+        state.map = Some(identity);
+    }
+    out.zones.clear();
+    let Ok(listener) = listener.single() else { return };
+    zones_at(&state.records, &mut state.active, listener.translation(), &mut out.zones);
+}
+
+/// The map's reverb-zone records (eVolumeType 5 with a preset, flags 0) from its `.ems` files.
+fn zone_records(library: &Library, map_stem: &str) -> Vec<ZoneRecord> {
+    let mut records = Vec::new();
+    for (f, file) in ems_files(map_stem).iter().enumerate() {
+        for r in library.emitters(file) {
+            let Some(preset) = r.reverb.as_deref().and_then(|k| u64::from_str_radix(k, 16).ok()) else { continue };
+            if r.kind != 5 || r.flags != 0 {
+                continue;
+            }
+            let s = r.scalars;
+            records.push(ZoneRecord {
+                shape: Shape { position: Vec3::from(r.position), extent: Vec3::from(r.extent), forward: Vec3::new(s[1], s[2], s[3]), core: s[0] },
+                id: ((f as u64) << 32) | u64::from(r.index),
+                attribute: u64::from_str_radix(&r.sound_id, 16).unwrap_or(0),
+                preset,
+            });
+        }
+    }
+    records
+}
+
+/// One frame of the zone node list: drop the records the listener left, append new hits in
+/// record order, and list the active ones (in node order) with their distance.
+fn zones_at(records: &[ZoneRecord], active: &mut Vec<usize>, ear: Vec3, out: &mut Vec<skate_audio::bus::zones::Zone>) {
+    let reached: Vec<Option<f32>> = records.iter().map(|z| reach(&z.shape, ear)).collect();
+    active.retain(|&i| reached[i].is_some());
+    for (i, hit) in reached.iter().enumerate() {
+        if hit.is_some() && !active.contains(&i) {
+            active.push(i);
+        }
+    }
+    out.clear();
+    for &i in active.iter() {
+        let (z, d) = (&records[i], reached[i].unwrap_or(1.0));
+        out.push(skate_audio::bus::zones::Zone {
+            id: z.id,
+            attribute: z.attribute,
+            preset: z.preset,
+            d,
+            position: [z.shape.position.x, z.shape.position.z],
+            enabled: true,
+        });
+    }
+}
+
 /// A record's shape, in world space.
 #[derive(Clone, Copy, Debug)]
 struct Shape {
@@ -122,7 +246,10 @@ struct Emitter {
     shape: Shape,
     volume: f32,
     falloff: i32,
-    profile: &'static Profile,
+    /// The measured table's profile (None when the native runtime plays the bank).
+    profile: Option<&'static Profile>,
+    bank: String,
+    patch: i32,
 }
 
 /// A started emitter: its voices and program state.
@@ -135,6 +262,9 @@ struct Node {
     turn: usize,
     bags: [Vec<usize>; 2],
     phase: (f32, f32),
+    /// The native runtime's post and emitter state (native mode only).
+    post: Option<NodeId>,
+    state: Option<usize>,
 }
 
 #[derive(Default)]
@@ -182,7 +312,10 @@ pub(super) fn update(
     time: Res<Time<Real>>,
     menu: Option<Res<crate::graphics_menu::Menu>>,
     replay: Res<crate::replay::Replay>,
+    mut native: Option<ResMut<Native>>,
+    cues: Res<super::skate_events::Cues>,
 ) {
+    let _timing = super::timing::scope(&super::timing::EMITTERS);
     let Some(mut library) = library else { return };
     let state = &mut *state;
     let identity = (map.name.clone(), map.generation);
@@ -191,21 +324,40 @@ pub(super) fn update(
             for (id, ..) in node.voices {
                 voices.stop(id, STOP_FADE);
             }
+            if let Some(native) = native.as_deref_mut() {
+                if let Some(post) = node.post {
+                    native.release(post);
+                }
+                if let Some(g) = node.state {
+                    native.release_emitter_state(g);
+                }
+            }
+        }
+        if let Some(native) = native.as_deref_mut() {
+            native.unload_map_banks();
         }
         let stem = map.path.as_deref().and_then(|p| p.file_stem()).and_then(|s| s.to_str()).unwrap_or("");
         let records = ems_file(stem).map_or(&[][..], |file| library.emitters(file));
+        let native_banks = native.as_deref();
         state.emitters = records.iter().filter(|r| r.kind == 1 && r.flags == 0).filter_map(|r| {
-            let profile = profile(r.bank.as_deref()?)?;
+            let bank = r.bank.clone()?;
+            let profile = match native_banks {
+                Some(n) if n.has_bank(&library, &bank) => None,
+                Some(_) => return None,
+                None => Some(profile(&bank)?),
+            };
             let s = r.scalars;
             Some(Emitter {
                 shape: Shape { position: Vec3::from(r.position), extent: Vec3::from(r.extent), forward: Vec3::new(s[1], s[2], s[3]), core: s[0] },
-                volume: r.volume, falloff: r.falloff, profile,
+                volume: r.volume, falloff: r.falloff, profile, bank, patch: r.patch,
             })
         }).collect();
         info!("World emitters: {} of {} records on {stem} have a played sound", state.emitters.len(), records.len());
         state.map = Some(identity);
     }
-    let Ok(ear) = listener.single().map(GlobalTransform::translation) else { return };
+    let Ok(listener) = listener.single() else { return };
+    let ear = listener.translation();
+    let skater = cues.riding.board;
     let silent = super::silenced(menu.as_deref(), &replay);
     let now = time.elapsed_secs_f64();
     let mut rng = state.rng;
@@ -216,11 +368,19 @@ pub(super) fn update(
         let keep = reached[node.record].is_some();
         if !keep {
             if node.started {
-                info!("AUDIO_EMITTER stop {} #{}", state.emitters[node.record].profile.bank, node.record);
+                info!("AUDIO_EMITTER stop {} #{}", state.emitters[node.record].bank, node.record);
             }
             for (id, ..) in &node.voices {
                 voices.stop(*id, STOP_FADE);
             }
+            if let Some(native) = native.as_deref_mut() {
+                if let Some(post) = node.post {
+                    native.release(post);
+                }
+                if let Some(g) = node.state {
+                    native.release_emitter_state(g);
+                }
+            }
         }
         keep
     });
@@ -230,6 +390,8 @@ pub(super) fn update(
             state.nodes.push(Node {
                 record: index, started: false, voices: Vec::new(), turn: 0, bags: [Vec::new(), Vec::new()],
                 phase: (random(&mut rng) * std::f32::consts::TAU, random(&mut rng) * std::f32::consts::TAU),
+                post: None,
+                state: None,
             });
         }
     }
@@ -242,13 +404,41 @@ pub(super) fn update(
         node.started = true;
         active += 1;
         let e = &state.emitters[node.record];
-        info!("AUDIO_EMITTER start {} #{} at {:.1?} volume {:.2}", e.profile.bank, node.record, e.shape.position.to_array(), e.volume);
+        info!("AUDIO_EMITTER start {} #{} at {:.1?} volume {:.2}{}", e.bank, node.record, e.shape.position.to_array(), e.volume,
+            if e.profile.is_none() { " (native)" } else { "" });
+        if e.profile.is_none() {
+            if let Some(native) = native.as_deref_mut() {
+                match native.ensure_bank(&library, &e.bank) {
+                    Ok(_) => {
+                        let level = e.volume * falloff(e.falloff, reached[node.record].unwrap_or(1.0));
+                        node.state = native.claim_emitter_state();
+                        if let Some(g) = node.state {
+                            native.set_emitter_position(g, listener, skater, e.shape.position);
+                        }
+                        let payload = native.emitter_payload(node.state, level, super::native::azimuth(listener, e.shape.position), e.patch);
+                        node.post = native.post_emitter(&payload);
+                    }
+                    Err(error) => warn!("AUDIO_EMITTER {}: {error}", e.bank),
+                }
+            }
+        }
     }
 
     for node in state.nodes.iter_mut().filter(|n| n.started) {
         let emitter = &state.emitters[node.record];
         let Some(d) = reached[node.record] else { continue };
-        let profile = emitter.profile;
+        let Some(profile) = emitter.profile else {
+            // Native: the bank's program does the rest; only the game-side words change.
+            if let (Some(post), Some(native)) = (node.post, native.as_deref_mut()) {
+                let level = emitter.volume * falloff(emitter.falloff, d);
+                if let Some(g) = node.state {
+                    native.set_emitter_position(g, listener, skater, emitter.shape.position);
+                }
+                let payload = native.emitter_payload(node.state, level, super::native::azimuth(listener, emitter.shape.position), emitter.patch);
+                native.redeliver(post, &payload);
+            }
+            continue;
+        };
         let level = emitter.volume * falloff(emitter.falloff, d) * modulate(profile.level, node.phase.0, now);
         let pitch = modulate(profile.pitch, node.phase.1, now);
         let towards = emitter.shape.position - ear;
@@ -341,6 +531,60 @@ mod tests {
         assert_eq!(seen, (0..10).collect::<Vec<_>>());
     }
 
+    /// A DownTown reverb zone (attribute `1F94F2F815C00368` → reverb11) through the retail selector:
+    /// standing in its core the zone's preset fades in and commits, Reverb.in5 rises, and the
+    /// MixMap's Reverb out4 (the global env scale) drops by F213's −400 mB.
+    #[test]
+    fn a_downtown_reverb_zone_selects_its_preset_and_raises_reverb_in5() {
+        let root = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets"));
+        let Ok(library) = Library::load(root) else { return eprintln!("skipped: no audio install") };
+        let records = zone_records(&library, "DownTown");
+        if records.is_empty() {
+            return eprintln!("skipped: the install has no reverb-zone presets (stage_reverb_zones.py)");
+        }
+        let (presets, _) = library.bus_tuning();
+        let Some(zone) = records.iter().find(|z| z.attribute == 0x1F94_F2F8_15C0_0368) else { panic!("no 1F94F2F815C00368 zone") };
+        assert_eq!(zone.preset, 0xBEEF_C8E3_DE04_FBAE);
+        let (mut active, mut zones) = (Vec::new(), Vec::new());
+        zones_at(&records, &mut active, zone.shape.position, &mut zones);
+        let first = zones.iter().find(|z| z.id == zone.id).expect("the listener at its centre is inside");
+        assert_eq!(first.d, 0.0, "inside the inner core");
+        zones_at(&records, &mut active, Vec3::new(1.0e5, 0.0, 1.0e5), &mut zones);
+        assert!(zones.is_empty() && active.is_empty(), "far away: no zone");
+        let mut env = skate_audio::bus::env::EnvNetwork::default();
+        env.presets = presets;
+        let at = zone.shape.position + Vec3::new(0.0, 0.0, 0.0);
+        let camera = skate_audio::bus::zones::Camera { position: at.to_array(), forward: [0.0, 0.0, -1.0] };
+        let mut zones = Vec::new();
+        // Only this zone, so the test does not depend on overlapping records.
+        let only = [ZoneRecord { shape: zone.shape, id: zone.id, attribute: zone.attribute, preset: zone.preset }];
+        for _ in 0..90 {
+            zones_at(&only, &mut active, at, &mut zones);
+            env.update(1.0 / 60.0, 0, &zones, Some(&camera));
+        }
+        assert_eq!(env.target_key(), Some(0xBEEF_C8E3_DE04_FBAE));
+        assert_eq!(env.reverb_inputs(), [0, 0, 0, 0, 0, 32767, 0], "reverb11 → Reverb.in5");
+        let Some(mxb) = library.aems().mixmap.clone() else { return eprintln!("skipped: no MixMap") };
+        let mut m = skate_audio::mixmap::MixMap::from_bytes(&library.read(&mxb).unwrap()).unwrap();
+        let out4 = |m: &mut skate_audio::mixmap::MixMap, inputs: [i32; 7]| {
+            for id in 1..=4 {
+                m.set_input(skate_audio::mixmap::keys::MASTER, id, 32767);
+            }
+            for (id, x) in inputs.into_iter().enumerate() {
+                m.set_input(skate_audio::mixmap::keys::REVERB, id, x);
+            }
+            for _ in 0..120 {
+                m.tick(1.0 / 60.0);
+            }
+            m.level(skate_audio::mixmap::keys::REVERB, 4)
+        };
+        let outside = out4(&mut m, [0, 0, 0, 0, 32767, 0, 0]);
+        let inside = out4(&mut m, env.reverb_inputs());
+        println!("Reverb out4: reverb01 {outside}, reverb11 zone {inside}");
+        assert_eq!(outside, 32730, "0 mB with in4 (reverb01)");
+        assert!((20000..21200).contains(&inside), "−400 mB with in5: {inside}");
+    }
+
     #[test]
     fn every_map_has_its_emitter_file() {
         for map in ["University", "DownTown", "Industrial", "SkateSchool", "MegaPark"] {
@@ -348,4 +592,5 @@ mod tests {
         }
         assert!(profile("water_fountain").is_some() && profile("trees_rustle").is_none());
     }
+
 }
diff --git a/crates/skate-game/src/game_audio/grain_bed.rs b/crates/skate-game/src/game_audio/grain_bed.rs
new file mode 100644
index 00000000..2274cb72
--- /dev/null
+++ b/crates/skate-game/src/game_audio/grain_bed.rs
@@ -0,0 +1,447 @@
+//! The game side of the native granular rolling bed (`skate_audio::grain`, spec
+//! `.claude/notes/grain-player-spec.md`), on when the native runtime runs with a MixMap and the
+//! install has the whole grain recordings and their vault tuning (`audio_export.grain_whole` /
+//! `grain_tuning`). Otherwise the interim speed-band loop in `skate_events.rs` plays.
+//!
+//! Per frame, after the MixMap tick (`native::mixmap_frame`):
+//! - **Surface routing** (§1.4, one sounding truck): the wheels' majority surface → grain member
+//!   (`cues::grain_for`, the retail AudioSurfaceMap); a change stops both players and binds the new
+//!   member (pulsing SkateBoard input 0); grinding (surface 14) stops them. In the air the last
+//!   member keeps playing and the MixMap's no-contact duck silences it (what retail does with the
+//!   wheel material in the air is UNCERTAIN, spec §2.10).
+//! - **Records** (§2.2): position A from the member's Bézier of speed (push-scaled), B 0.1 behind;
+//!   gains from SkateBoard level(1)/(2), pitch from pitch(3); the push speed-scale envelope, the
+//!   brake slew, the turn intensity (`sub_824C8588`: |COM v|·0.24 capped × the turn input, slewed),
+//!   the manual / trick latches ("special": A × special gain, no turn layer), the downhill level D
+//!   (`sub_824CA738`, owner inputs 2/3) and wheel 0's seam-pattern gain envelope (`sub_824CA448`).
+//!   Player B is the turning / downhill layer.
+//! - **Soft wheels** (`sub_824C8370`): the soft member of surfaces 1..6 while the board's wheel
+//!   hardness is below 0.5 (audio state `+684` = Motion+200 < 0.5); metal has only a hard member.
+//! - **Chains** (§3.2, `skate_audio::grain::chain`): high-/low-pass from level(12)/(11), pan from
+//!   raw(0), the FrequencyShiftSsb values (the +150 Hz special shift, the push shift envelope, the
+//!   slope terms), the graph-1 level ramp and gain wobbles, the graph-3 send by speed, the env send
+//!   level(13) and the FlangeSub send level(21)/(22) (carried, not rendered).
+//! - **Rocket** (§2.8): `x_jet_rolling` above the owner's start speed (35 km/h), into the default bus.
+//! - **Routing:** with the native rolling layers (`PlayerAudio::rolling_on`) the owner's two-truck
+//!   surface routing (`player::rolling`, `sub_824C5CA8`) decides the binds and stops ([`GrainEvent`]s)
+//!   and writes SkateBoard inputs 0 / 6; otherwise the bed routes one truck itself (as before).
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use bevy::prelude::*;
+use skate_audio::eval::rng::Rng;
+use skate_audio::grain::board::{self, BoardInputs, Latches, PushEnvelope, RocketTuning, SeamEnvelope, SurfaceTuning, TurnIntensity};
+use skate_audio::grain::chain::{self, ChainFrame, ChainState, ChainTuning, PushShift};
+use skate_audio::grain::{GrainFile, GrainSource};
+use skate_audio::player::rolling::{self, GrainEvent};
+use skate_audio::mixmap::{MixMap, keys};
+
+use super::Library;
+
+/// Every member `cues::grain_for` can name, plus the rocket layer.
+const MEMBERS: &[&str] = &[
+    "asphalt_rough_hard",
+    "concrete_rough_hard",
+    "concrete_smooth_hard",
+    "wood_ramp_hard",
+    "concrete_aggregate_hard",
+    "metal_smooth_hard",
+    "asphalt_smooth_hard",
+];
+/// Soft-wheel members (surfaces 1..6), used when the install has them.
+const SOFT_MEMBERS: &[&str] = &[
+    "asphalt_rough_soft",
+    "concrete_rough_soft",
+    "concrete_smooth_soft",
+    "wood_ramp_soft",
+    "concrete_aggregate_soft",
+    "asphalt_smooth_soft",
+];
+const ROCKET: &str = "x_jet_rolling";
+/// The brake slew step per 60 Hz frame (§2.7).
+const BRAKE_STEP: f32 = 0.05;
+
+/// The `default` collection's tuning key in [`Bed`]'s map (rolling surface 0 binds
+/// asphalt_rough_hard with it, `rolling::member`).
+const DEFAULT_TUNING: &str = "default";
+
+/// A bound truck: the recording and the collection whose tuning it plays with.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct Bound {
+    stem: &'static str,
+    tuning: &'static str,
+}
+
+pub(crate) struct Bed {
+    tunings: HashMap<&'static str, SurfaceTuning>,
+    rocket: Option<RocketTuning>,
+    chain_tuning: ChainTuning,
+    tuned: bool,
+    sources: HashMap<String, Arc<GrainSource>>,
+    failed: HashSet<String>,
+    /// Per truck (the bed's own routing uses truck 0 only).
+    bound: [Option<Bound>; 2],
+    /// The routing's primary truck (`+1500`).
+    primary: usize,
+    rocket_on: bool,
+    /// SkateBoard owner inputs for the next tick: 0 surface-change pulse, 4 push plant.
+    pulse_surface: bool,
+    pulse_push: bool,
+    pushes_seen: Option<u32>,
+    push_scale: PushEnvelope,
+    /// The push frequency-shift envelope (`+1036`).
+    shift: PushShift,
+    brake: f32,
+    /// Send, level ramp, wobbles and the gains each chain holds.
+    chain: ChainState,
+    turn: TurnIntensity,
+    latches: Latches,
+    seam: SeamEnvelope,
+    /// Our own instance of the title generator for the seam draws (retail's is shared and
+    /// unreproducible anyway).
+    rng: Rng,
+    /// Downhill level D (owner `+1508`), computed with the owner inputs.
+    downhill: f32,
+}
+
+impl Bed {
+    pub(crate) fn new(library: &Library) -> Option<Self> {
+        let mut tunings = HashMap::new();
+        for &name in MEMBERS {
+            library.grain_whole(name)?;
+            tunings.insert(name, library.grain_tuning(name)?);
+        }
+        for &name in SOFT_MEMBERS {
+            if let (Some(_), Some(t)) = (library.grain_whole(name), library.grain_tuning(name)) {
+                tunings.insert(name, t);
+            }
+        }
+        if let Some(t) = library.grain_default_tuning() {
+            tunings.insert(DEFAULT_TUNING, t);
+        }
+        let rocket = library.rocket_tuning().filter(|_| library.grain_whole(ROCKET).is_some());
+        let chain_tuning = library.chain_tuning();
+        let mut bed = Self {
+            tunings,
+            rocket,
+            chain_tuning,
+            tuned: false,
+            sources: HashMap::new(),
+            failed: HashSet::new(),
+            bound: [None; 2],
+            primary: 0,
+            rocket_on: false,
+            pulse_surface: false,
+            pulse_push: false,
+            pushes_seen: None,
+            push_scale: PushEnvelope::default(),
+            shift: PushShift::default(),
+            brake: 0.0,
+            chain: ChainState::default(),
+            turn: TurnIntensity::default(),
+            latches: Latches::default(),
+            seam: SeamEnvelope::default(),
+            rng: Rng::new(skate_audio::grain::GrainBed::SEED),
+            downhill: 0.0,
+        };
+        // Decode every recording now: a grain's first trigger must sound like the later ones
+        // (no decode on the game thread at first use).
+        let names: Vec<&'static str> = bed.tunings.keys().copied().filter(|n| *n != DEFAULT_TUNING).chain(bed.rocket.map(|_| ROCKET)).collect();
+        for name in names {
+            bed.source(library, name);
+        }
+        Some(bed)
+    }
+
+    /// The member for a wheel surface tag: the soft member while the wheels are soft and the
+    /// install has it (`sub_824C8370`).
+    fn member(&self, tag: u32, soft: bool) -> &'static str {
+        let hard = super::cues::grain_for(tag);
+        if soft {
+            if let Some(&name) = SOFT_MEMBERS.iter().find(|n| n.strip_suffix("_soft") == hard.strip_suffix("_hard")) {
+                if self.tunings.contains_key(name) {
+                    return name;
+                }
+            }
+        }
+        hard
+    }
+
+    /// The primary truck's binding (or the other's when only that one runs).
+    fn primary_bound(&self) -> Option<Bound> {
+        self.bound[self.primary].or(self.bound[1 - self.primary])
+    }
+
+    /// The push speed-scale envelope while it runs (`player::rolling` scales its patch speeds).
+    pub(crate) fn push_scale(&self) -> Option<f32> {
+        self.push_scale.value()
+    }
+
+    /// The board owner's MixMap inputs (written before the tick): 0 = 32767 for the frame after a
+    /// surface change, 4 = 32767 on a push plant, 6 = 32767 on metal, 2 / 3 = the downhill /
+    /// uphill levels (`sub_824CA738`: the primary truck on a grain surface, slope `+712` over the
+    /// member's divisors). Heading rate (5) and skid (1) reach no MixMap output and are not written.
+    /// `own_routing`: the bed routes itself and writes 0 / 6 (else `player::rolling` does).
+    pub(crate) fn write_inputs(&mut self, m: &mut MixMap, s: &skate_audio::player::AudioState, own_routing: bool) {
+        let owner = keys::skateboard(0);
+        let pulse = std::mem::take(&mut self.pulse_surface);
+        if own_routing {
+            m.set_input(owner, 0, if pulse { 32767 } else { 0 });
+            m.set_input(owner, 6, if self.bound[0].is_some_and(|b| b.stem == "metal_smooth_hard") { 32767 } else { 0 });
+        }
+        m.set_input(owner, 4, if std::mem::take(&mut self.pulse_push) { 32767 } else { 0 });
+        let tuning = self.primary_bound().and_then(|b| self.tunings.get(b.tuning));
+        let (down, up) = match tuning {
+            Some(t) => board::slope_levels(s.slope, true, t.slope_divisors.0, t.slope_divisors.1),
+            None => (0.0, 0.0),
+        };
+        self.downhill = down;
+        let word = |x: f32| ((x * 32767.0) as i32).clamp(0, 32767);
+        m.set_input(owner, 2, word(down));
+        m.set_input(owner, 3, word(up));
+    }
+
+    /// The decoded recording of a member (all are decoded in [`Bed::new`]).
+    fn source(&mut self, library: &Library, name: &str) -> Option<Arc<GrainSource>> {
+        if let Some(s) = self.sources.get(name) {
+            return Some(s.clone());
+        }
+        if self.failed.contains(name) {
+            return None;
+        }
+        let loaded = (|| -> Result<Arc<GrainSource>, String> {
+            let (wav, raw) = library.grain_whole(name).ok_or("not in the install")?;
+            let header = GrainFile::parse(&library.read(raw).map_err(|e| e.to_string())?).map_err(|e| e.to_string())?;
+            let pcm = super::library::wav_pcm(&library.read(wav).map_err(|e| e.to_string())?).ok_or("not a PCM16 WAV")?;
+            if pcm.rate != header.stream.rate {
+                return Err(format!("WAV rate {} ≠ stream rate {}", pcm.rate, header.stream.rate));
+            }
+            Ok(Arc::new(GrainSource { name: name.to_owned(), duration: header.duration, pcm: Arc::new(pcm) }))
+        })();
+        match loaded {
+            Ok(s) => {
+                self.sources.insert(name.to_owned(), s.clone());
+                Some(s)
+            }
+            Err(e) => {
+                warn!("Game audio: grain {name}: {e}");
+                self.failed.insert(name.to_owned());
+                None
+            }
+        }
+    }
+}
+
+pub(super) fn update(
+    native: Option<ResMut<super::native::Native>>,
+    library: Option<Res<Library>>,
+    cues: Res<super::skate_events::Cues>,
+    time: Res<Time<Real>>,
+) {
+    let _timing = super::timing::scope(&super::timing::GRAIN_BED);
+    let (Some(mut native), Some(library)) = (native, library) else { return };
+    let native = &mut *native;
+    // The seam wobbles live with the player tuning.
+    let seams = skate_audio::player::tuning::PlayerTuning {
+        seam_wobbles: native.player.as_ref().map(|p| p.tuning.seam_wobbles.clone()).unwrap_or_default(),
+        ..Default::default()
+    };
+    // The owner's routing (native rolling layers): its binds / stops since the last frame.
+    let routed = native.player.as_mut().filter(|p| p.components && p.rolling_on).map(|p| (std::mem::take(&mut p.routed.grains), p.routed.primary));
+    let (Some(bed), Some(m)) = (&mut native.bed, &native.mixmap) else { return };
+    step(bed, &library, m, &native.shared, &cues.riding, time.delta_secs(), &seams, routed);
+}
+
+/// One game frame of the bed (after the MixMap tick): [`update`]'s body, callable headless.
+/// `routed`: the owner routing's grain events since the last frame and its primary truck (native
+/// rolling layers), or `None` for the bed's own one-truck routing.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn step(
+    bed: &mut Bed,
+    library: &Library,
+    m: &MixMap,
+    shared: &std::sync::Mutex<skate_audio::runtime::Runtime>,
+    r: &super::skate_events::Riding,
+    dt: f32,
+    seams: &skate_audio::player::tuning::PlayerTuning,
+    routed: Option<(Vec<GrainEvent>, usize)>,
+) {
+    let r = *r;
+    let s = r.audio;
+    let frames = (dt * 60.0).clamp(0.0, 6.0);
+    let speed = r.speed.abs();
+
+    // Surface routing: the wanted binding per truck (None = stopped).
+    let mut wanted = bed.bound;
+    match &routed {
+        Some((events, primary)) => {
+            bed.primary = *primary;
+            for e in events {
+                match *e {
+                    GrainEvent::Bind { truck, surface, soft } => {
+                        let m = rolling::member(surface, soft);
+                        let tuning = if m.default_tuning { DEFAULT_TUNING } else { m.stem };
+                        // Soft members the install lacks play their hard member (as before).
+                        let stem = if bed.tunings.contains_key(m.stem) { m.stem } else { rolling::member(surface, false).stem };
+                        let tuning = if bed.tunings.contains_key(tuning) { tuning } else { stem };
+                        wanted[truck] = Some(Bound { stem, tuning });
+                    }
+                    GrainEvent::Stop { truck } => wanted[truck] = None,
+                }
+            }
+        }
+        None => {
+            bed.primary = 0;
+            wanted[0] = if r.grinding {
+                None
+            } else if r.wheels == 0 {
+                bed.bound[0]
+            } else {
+                let stem = bed.member(r.surface, s.soft_wheels);
+                Some(Bound { stem, tuning: stem })
+            };
+        }
+    }
+    let primary = wanted[bed.primary].or(wanted[1 - bed.primary]);
+    let tuning = primary.and_then(|b| bed.tunings.get(b.tuning)).cloned();
+
+    // Modulators.
+    if bed.pushes_seen.is_some_and(|seen| seen != r.pushes) {
+        bed.pulse_push = true;
+        if let Some(t) = &tuning {
+            let (scale, shift) = board::push_peaks(&t.push, speed);
+            bed.push_scale.trigger(scale, 1.0, t.push.scale_ms);
+            bed.shift.trigger(shift, t.push.shift_ms);
+        }
+    }
+    bed.pushes_seen = Some(r.pushes);
+    bed.push_scale.advance(dt);
+    bed.shift.advance(dt);
+    bed.brake = board::slew(bed.brake, if r.braking { 1.0 } else { 0.0 }, BRAKE_STEP * frames);
+    let special = bed.latches.update(s.balance, s.wheel_count, s.hippy_jump, s.feet_in_deck_box);
+    let turn = tuning.as_ref().map_or(0.0, |t| bed.turn.step(t, s.com_speed(), s.turn, special, frames));
+    let rng = &mut bed.rng;
+    bed.seam.update(s.seam_pattern[0], dt, |p| seams.seam_wobble(p), || rng.draw());
+    // The chain modulators share the title generator, after the seam draws (retail's frame order).
+    let rng = &mut bed.rng;
+    bed.chain.frame(&bed.chain_tuning, speed, dt, [wanted[0].is_some(), wanted[1].is_some()], || rng.draw());
+
+    let owner = keys::skateboard(0);
+    let inputs = BoardInputs {
+        speed,
+        speed_scale: bed.push_scale.value(),
+        level_a: m.level(owner, 1),
+        level_b: m.level(owner, 2),
+        pitch: m.pitch_4096(owner, 3),
+        turn,
+        brake: bed.brake,
+        special,
+        downhill: bed.downhill,
+        seam: bed.seam.value(),
+    };
+    let truck_tuning = |b: Option<Bound>| b.and_then(|b| bed.tunings.get(b.tuning)).cloned();
+    let tunings = [truck_tuning(wanted[0]), truck_tuning(wanted[1])];
+    let records = tunings.clone().map(|t| t.map(|t| board::records(&t, &inputs)));
+    let (push_shift, downhill) = (bed.shift.value(), bed.downhill);
+    let frame = |t: &SurfaceTuning| ChainFrame {
+        highpass_hz: m.filter_hz(owner, 12) as f32,
+        lowpass_hz: m.filter_hz(owner, 11) as f32,
+        pan_degrees: m.raw(owner, 0) as f32 * chain::DEGREES_PER_RAW,
+        env_send: m.level(owner, 13) as f32 * chain::PER_LEVEL,
+        flange_send: [m.level(owner, 21) as f32 * chain::PER_LEVEL, m.level(owner, 22) as f32 * chain::PER_LEVEL],
+        fss_hz: chain::fss_shifts(t, tuning.as_ref().unwrap_or(t), special, push_shift, downhill),
+    };
+    let sos = keys::sense_of_speed(0);
+    let rocket_record = bed.rocket.map(|t| board::rocket_record(&t, speed, m.level(sos, 5), m.pitch_4096(sos, 3)));
+    let sources: [Option<Arc<GrainSource>>; 2] = std::array::from_fn(|t| {
+        if wanted[t] != bed.bound[t] { wanted[t].and_then(|b| bed.source(library, b.stem)) } else { None }
+    });
+    let rocket_source = match (bed.rocket, bed.rocket_on) {
+        (Some(t), false) if speed * 3.6 > t.start_kmh => bed.source(library, ROCKET),
+        _ => None,
+    };
+
+    let Ok(mut runtime) = super::timing::lock(shared, &super::timing::GAME_LOCK) else { return };
+    let grains = &mut runtime.grains;
+    if !bed.tuned {
+        grains.chain_tuning = bed.chain_tuning;
+        bed.tuned = true;
+    }
+    for t in 0..2 {
+        if wanted[t] != bed.bound[t] {
+            grains.stop_truck(t);
+            if routed.is_none() {
+                bed.pulse_surface = bed.bound[t].is_some();
+            }
+            bed.bound[t] = None;
+            if let (Some(b), Some(source), Some(tu), Some(rec)) = (wanted[t], sources[t].clone(), &tunings[t], records[t]) {
+                info!("AUDIO_EVENT grain bind truck {t} {} ({} tuning, surface tag {})", b.stem, b.tuning, r.surface);
+                bed.chain.rebuilt(t);
+                grains.bind_truck(t, source, tu.params, rec);
+                bed.bound[t] = Some(b);
+            }
+        } else if let Some(rec) = records[t] {
+            grains.set_records(t, rec);
+        }
+        if let Some(tu) = &tunings[t] {
+            grains.set_chains(t, bed.chain.values(t, &frame(tu)));
+        }
+    }
+    if let (Some(t), Some(rec)) = (bed.rocket, rocket_record) {
+        if bed.rocket_on && speed * 3.6 <= t.start_kmh {
+            grains.stop_rocket();
+            bed.rocket_on = false;
+        } else if let Some(source) = rocket_source {
+            grains.start_rocket(source, t.params, rec);
+            bed.rocket_on = true;
+        } else if bed.rocket_on {
+            grains.rocket.record = rec;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `cues::grain_for` against the install's own `Sk8::AudioSurfaceMap` (when present): tag →
+    /// material (tag − 1; 0 = none → 143 → surface 3) → rolling surface → grain member, for every
+    /// surface that plays a grain (1–6, 9). And every member has its tuning and recording.
+    #[test]
+    fn grain_for_matches_the_vault_surface_map_and_the_bed_loads() {
+        let root = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets"));
+        let Ok(library) = Library::load(root) else {
+            eprintln!("skipped: no audio install under {}", root.display());
+            return;
+        };
+        let map = library.surface_map();
+        if map.is_empty() {
+            eprintln!("skipped: the install has no grain tuning (stage_grain_mixmap.py)");
+            return;
+        }
+        assert_eq!(map.len(), 95);
+        for tag in 0..128u32 {
+            let material = if tag == 0 { 143 } else { tag - 1 };
+            let surface = if material == 143 { 3 } else { map[material.min(94) as usize] };
+            let want = match surface {
+                1 => "asphalt_rough_hard",
+                2 => "concrete_rough_hard",
+                3 => "asphalt_smooth_hard",
+                4 => "concrete_smooth_hard",
+                5 => "wood_ramp_hard",
+                6 => "concrete_aggregate_hard",
+                9 => "metal_smooth_hard",
+                _ => continue, // Class_rolling surfaces and surface 0: stand-ins
+            };
+            assert_eq!(super::super::cues::grain_for(tag), want, "tag {tag} (surface {surface})");
+        }
+        let bed = Bed::new(&library).expect("every member has its recording and tuning");
+        assert_eq!(bed.tunings.len(), MEMBERS.len() + SOFT_MEMBERS.len() + 1, "hard and soft members and the `default` collection");
+        assert!(bed.rocket.is_some_and(|r| r.start_kmh == 35.0 && r.gain_word == 22000));
+        assert_eq!(bed.tunings["concrete_rough_hard"].max_kmh, 60.0);
+        // Soft wheels pick the soft member where one exists; metal has only the hard one.
+        assert_eq!(bed.member(4, true), "concrete_rough_soft");
+        assert_eq!(bed.member(4, false), "concrete_rough_hard");
+        assert_eq!(bed.member(9, true), "metal_smooth_hard");
+    }
+}
diff --git a/crates/skate-game/src/game_audio/library.rs b/crates/skate-game/src/game_audio/library.rs
index 0c63a8ef..054966ee 100644
--- a/crates/skate-game/src/game_audio/library.rs
+++ b/crates/skate-game/src/game_audio/library.rs
@@ -9,9 +9,10 @@ use std::{
     sync::Arc,
 };
 
-/// Manifests this build reads. Version 4 added the world emitters (`emitters`);
-/// a version 3 install still plays everything else until setup refreshes it.
-const MANIFEST_VERSIONS: std::ops::RangeInclusive<u32> = 3..=4;
+/// Manifests this build reads. Version 4 added the world emitters (`emitters`), version 5 the
+/// native AEMS runtime's banks and projects (`aems`); an older install still plays everything else
+/// until setup refreshes it.
+const MANIFEST_VERSIONS: std::ops::RangeInclusive<u32> = 3..=5;
 
 #[derive(Debug, Deserialize)]
 pub(crate) struct Entry {
@@ -36,12 +37,165 @@ pub(crate) struct EmitterRecord {
     pub falloff: i32,
     #[serde(default)]
     pub bank: Option<String>,
+    /// The attribute patch index: `c_emitter`'s selector (payload word 8).
+    #[serde(default)]
+    pub patch: i32,
+    /// The record's index in its file, its sound id (16 hex digits) and, for reverb zones
+    /// (`kind` 5), the attribute's reverb preset key (`99FD793BC30CF0FA`, 16 hex digits; setups
+    /// before the reverb-zone stage have none).
+    #[serde(default)]
+    pub index: u32,
+    #[serde(default)]
+    pub sound_id: String,
+    #[serde(default)]
+    pub reverb: Option<String>,
 }
 
-/// A rolling grain: its slow-to-fast recording cut into loopable speed bands.
+/// The native AEMS runtime's inputs (audio_export.aems_files): Csis projects in install order and
+/// module banks by stem, as files under the audio folder.
+#[derive(Debug, Default, Deserialize)]
+pub(crate) struct AemsFiles {
+    #[serde(default)]
+    pub projects: Vec<String>,
+    #[serde(default)]
+    pub banks: BTreeMap<String, String>,
+    /// `MixMapSK8.mxb` (setup copies it next to the banks; absent before 2026-10-02 installs).
+    #[serde(default)]
+    pub mixmap: Option<String>,
+    /// SPLC patch trees by bank stem (`audio_export.splice_trees`; absent before 2026-10-02).
+    #[serde(default)]
+    pub splice: BTreeMap<String, String>,
+}
+
+/// A rolling grain: its slow-to-fast recording cut into loopable speed bands (the interim loop),
+/// plus the whole recording and its raw `.grain` member for the native grain player.
 #[derive(Debug, Deserialize)]
 struct Grain {
     bands: Vec<Entry>,
+    #[serde(default)]
+    file: Option<String>,
+    #[serde(default)]
+    grain: Option<String>,
+}
+
+/// The vault's grain tuning (audio_export.grain_tuning): every float exactly as stored.
+#[derive(Debug, Default, Deserialize)]
+pub(crate) struct GrainTuningJson {
+    #[serde(default)]
+    surfaces: BTreeMap<String, SurfaceJson>,
+    #[serde(default)]
+    default: SurfaceJson,
+    #[serde(default)]
+    owner: OwnerJson,
+    /// Collision material (tag − 1) → rolling surface 1–14 (`Sk8::AudioSurfaceMap`).
+    #[serde(default)]
+    pub surface_map: Vec<u32>,
+}
+
+#[derive(Debug, Default, Clone, Deserialize)]
+struct SurfaceJson {
+    max_kmh: Option<f32>,
+    bezier: Option<[f32; 4]>,
+    params: Option<Vec<Vec<f32>>>,
+    turn_cap: Option<f32>,
+    turn_rise_step: Option<f32>,
+    turn_fall_step: Option<f32>,
+    special_gain: Option<f32>,
+    special_shift_hz: Option<f32>,
+    b_slope_gain: Option<f32>,
+    b_slope_ramp_kmh: Option<f32>,
+    a_shift_per_slope_hz: Option<f32>,
+    b_base_shift_hz: Option<f32>,
+    b_shift_per_slope_hz: Option<f32>,
+    push_ramp_kmh: Option<f32>,
+    push_scale_low: Option<f32>,
+    push_scale_high: Option<f32>,
+    push_shift_low_hz: Option<f32>,
+    push_shift_high_hz: Option<f32>,
+    push_scale_attack_ms: Option<f32>,
+    push_scale_hold_ms: Option<f32>,
+    push_scale_return_ms: Option<f32>,
+    push_shift_attack_ms: Option<f32>,
+    push_shift_hold_ms: Option<f32>,
+    push_shift_return_ms: Option<f32>,
+    slope_down_divisor: Option<f32>,
+    slope_up_divisor: Option<f32>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct OwnerJson {
+    rocket_start_kmh: Option<f32>,
+    rocket_top_kmh: Option<f32>,
+    rocket_gain_word: Option<i32>,
+    rocket_params: Option<Vec<f32>>,
+    g1_level_start_kmh: Option<f32>,
+    g1_level_end_kmh: Option<f32>,
+    g1_level_floor: Option<f32>,
+    // The board chains' tuning (`grain::chain::ChainTuning`; absent before the chain export).
+    g3_send_start_kmh: Option<f32>,
+    g3_send_end_kmh: Option<f32>,
+    g3_send_max: Option<f32>,
+    g3_clip: Option<f32>,
+    g3_shelf_hz: Option<f32>,
+    g3_shelf_gain: Option<f32>,
+    wobble_start_kmh: Option<f32>,
+    wobble_end_kmh: Option<f32>,
+    wobble_a_ms_low: Option<i32>,
+    wobble_a_ms_high: Option<i32>,
+    wobble_a_low: Option<f32>,
+    wobble_a_high: Option<f32>,
+    wobble_b_ms_low: Option<i32>,
+    wobble_b_ms_high: Option<i32>,
+    wobble_b_low: Option<f32>,
+    wobble_b_high: Option<f32>,
+}
+
+impl SurfaceJson {
+    /// The member's tuning with every missing field from `default`; None if a field is missing
+    /// from both (an install without the vault tuning).
+    fn tuning(&self, d: &SurfaceJson) -> Option<skate_audio::grain::board::SurfaceTuning> {
+        use skate_audio::grain::{GrainParams, board::{PushTuning, SurfaceTuning}};
+        let f = |a: Option<f32>, b: Option<f32>| a.or(b);
+        let params = self.params.as_ref().or(d.params.as_ref())?;
+        let params = [GrainParams::from_slice(params.first()?)?, GrainParams::from_slice(params.get(1)?)?];
+        Some(SurfaceTuning {
+            max_kmh: f(self.max_kmh, d.max_kmh)?,
+            bezier: self.bezier.or(d.bezier)?,
+            params,
+            turn_cap: f(self.turn_cap, d.turn_cap)?,
+            turn_rise_step: f(self.turn_rise_step, d.turn_rise_step)?,
+            turn_fall_step: f(self.turn_fall_step, d.turn_fall_step)?,
+            special_gain: f(self.special_gain, d.special_gain)?,
+            special_shift_hz: f(self.special_shift_hz, d.special_shift_hz)?,
+            b_slope_gain: f(self.b_slope_gain, d.b_slope_gain)?,
+            b_slope_ramp_kmh: f(self.b_slope_ramp_kmh, d.b_slope_ramp_kmh)?,
+            a_shift_per_slope_hz: f(self.a_shift_per_slope_hz, d.a_shift_per_slope_hz)?,
+            b_base_shift_hz: f(self.b_base_shift_hz, d.b_base_shift_hz)?,
+            b_shift_per_slope_hz: f(self.b_shift_per_slope_hz, d.b_shift_per_slope_hz)?,
+            // Installs staged before these fields were read fall back to the vault's values.
+            slope_divisors: (
+                f(self.slope_down_divisor, d.slope_down_divisor).unwrap_or(-10.0),
+                f(self.slope_up_divisor, d.slope_up_divisor).unwrap_or(10.0),
+            ),
+            push: PushTuning {
+                ramp_kmh: f(self.push_ramp_kmh, d.push_ramp_kmh)?,
+                scale_low: f(self.push_scale_low, d.push_scale_low)?,
+                scale_high: f(self.push_scale_high, d.push_scale_high)?,
+                shift_low_hz: f(self.push_shift_low_hz, d.push_shift_low_hz)?,
+                shift_high_hz: f(self.push_shift_high_hz, d.push_shift_high_hz)?,
+                scale_ms: [
+                    f(self.push_scale_attack_ms, d.push_scale_attack_ms)?,
+                    f(self.push_scale_hold_ms, d.push_scale_hold_ms)?,
+                    f(self.push_scale_return_ms, d.push_scale_return_ms)?,
+                ],
+                shift_ms: [
+                    f(self.push_shift_attack_ms, d.push_shift_attack_ms)?,
+                    f(self.push_shift_hold_ms, d.push_shift_hold_ms)?,
+                    f(self.push_shift_return_ms, d.push_shift_return_ms)?,
+                ],
+            },
+        })
+    }
 }
 
 /// One layer of a retail patch record: members as
@@ -60,6 +214,104 @@ pub(crate) struct Patches {
     pub containers: Vec<Vec<usize>>,
 }
 
+/// One sound of a location set (audio_export.random_sets).
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct RandomSound {
+    pub bank: String,
+    pub volume: f32,
+    /// Retail's timeout for the post (seconds).
+    pub seconds: f32,
+    pub weight: i32,
+}
+
+/// A location set of random distant one-shots (class `aud_wp_emitters`).
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct RandomSet {
+    #[serde(default)]
+    pub name: Option<String>,
+    pub sounds: Vec<RandomSound>,
+    #[serde(default = "default_min_level")]
+    pub min_level: f32,
+    #[serde(default = "one")]
+    pub max_level: f32,
+    #[serde(default = "default_min_interval")]
+    pub min_interval: f32,
+    #[serde(default = "default_max_interval")]
+    pub max_interval: f32,
+}
+fn default_min_level() -> f32 { 0.2 }
+fn one() -> f32 { 1.0 }
+fn default_min_interval() -> f32 { 10.0 }
+fn default_max_interval() -> f32 { 20.0 }
+
+/// One tile of a world-painter region layer: a quadtree of (x, z) boxes whose leaves index `keys`
+/// (audio_formats.region_layers).
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct RegionTile {
+    /// Centre x, z and half sizes x, z.
+    pub r#box: [f32; 4],
+    /// Four child indices, then the value; child 0 = `NO_KEY` marks a leaf.
+    pub nodes: Vec<[u16; 5]>,
+    pub keys: Vec<String>,
+}
+pub(crate) const NO_KEY: u16 = 0xFFFF;
+
+impl RegionTile {
+    /// The key at (x, z): None outside the tile or on a leaf without a key (retail's walk:
+    /// inclusive edges, children tested -x-z, -x+z, +x-z, +x+z).
+    pub(crate) fn key(&self, x: f32, z: f32) -> Option<u64> {
+        let [mut cx, mut cz, mut hx, mut hz] = self.r#box;
+        if self.nodes.is_empty() || (x - cx).abs() > hx || (z - cz).abs() > hz {
+            return None;
+        }
+        let mut index = 0usize;
+        for _ in 0..64 {
+            let node = self.nodes.get(index)?;
+            if node[0] == NO_KEY {
+                return if node[4] == NO_KEY { None } else { u64::from_str_radix(self.keys.get(usize::from(node[4]))?, 16).ok() };
+            }
+            hx *= 0.5;
+            hz *= 0.5;
+            let child = [(-1.0, -1.0), (-1.0, 1.0), (1.0, -1.0), (1.0, 1.0)].iter().position(|(sx, sz)| {
+                (x - (cx + sx * hx)).abs() <= hx && (z - (cz + sz * hz)).abs() <= hz
+            })?;
+            let (sx, sz) = [(-1.0, -1.0), (-1.0, 1.0), (1.0, -1.0), (1.0, 1.0)][child];
+            cx += sx * hx;
+            cz += sz * hz;
+            index = usize::from(node[child]);
+        }
+        None
+    }
+}
+
+/// A zone ambience (class `aud_wp_ambiences`): its bed and fades (audio_export.ambience_zones).
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct Zone {
+    #[serde(default)]
+    pub name: Option<String>,
+    /// The ambience bed stream (e.g. `06_dt_open`), None for zones without one.
+    #[serde(default)]
+    pub bed: Option<String>,
+    #[serde(default = "one")]
+    pub volume: f32,
+    /// Fade-out time (s) when leaving this zone (record +8).
+    #[serde(default = "one")]
+    pub time_a: f32,
+    /// Fade-in time (s) when entering it (record +12).
+    #[serde(default = "one")]
+    pub time_b: f32,
+}
+
+/// A zone-pair crossfade (class `aud_wp_ambience_crossfades`).
+#[derive(Debug, Clone, Deserialize)]
+pub(crate) struct Crossfade {
+    pub from: String,
+    pub to: String,
+    pub group: u32,
+    #[serde(default = "one")]
+    pub level: f32,
+}
+
 #[derive(Debug, Deserialize)]
 struct Manifest {
     version: u32,
@@ -72,6 +324,281 @@ struct Manifest {
     /// Emitter file stem (`sfx_university`, ...) -> its records.
     #[serde(default)]
     emitters: BTreeMap<String, Vec<EmitterRecord>>,
+    /// Location set key (16 hex digits) -> set.
+    #[serde(default)]
+    random_sets: BTreeMap<String, RandomSet>,
+    /// Zone key (16 hex digits) -> zone ambience.
+    #[serde(default)]
+    zones: BTreeMap<String, Zone>,
+    #[serde(default)]
+    crossfades: Vec<Crossfade>,
+    /// District (map stem) -> region layer name -> tiles.
+    #[serde(default)]
+    regions: BTreeMap<String, BTreeMap<String, Vec<RegionTile>>>,
+    #[serde(default)]
+    aems: AemsFiles,
+    /// The native grain player's vault tuning (absent before 2026-10-02 installs).
+    #[serde(default)]
+    grain_player: GrainTuningJson,
+    /// The native player components' vault tuning (audio_export.player_tuning; optional).
+    #[serde(default)]
+    player_tuning: PlayerTuningJson,
+    /// The native environment network's presets and the eEQChain buses (optional).
+    #[serde(default)]
+    bus_tuning: BusTuningJson,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct JitterJson {
+    /// The collection key (16 hex digits; absent before the eEQChain bus export).
+    #[serde(default)]
+    key: String,
+    #[serde(default)]
+    enabled: bool,
+    #[serde(default)]
+    id: i64,
+    params: Vec<f32>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct SeamJson {
+    gain_low: Option<f32>,
+    gain_high: Option<f32>,
+    ms_low: Option<i32>,
+    ms_high: Option<i32>,
+    // Class_Seams' pattern fields (absent before the seams export).
+    gain: Option<f32>,
+    angle: Option<i32>,
+    grid_z: Option<f32>,
+    grid_x: Option<f32>,
+    class: Option<i32>,
+    mode: Option<i32>,
+    min_frames: Option<i32>,
+    speed_threshold: Option<f32>,
+    spacing: Option<f32>,
+    level: Option<f32>,
+    surface3_scale: Option<f32>,
+}
+
+/// The native buses' vault tuning (`audio_export.bus_tuning`; optional).
+#[derive(Debug, Default, Deserialize)]
+struct BusTuningJson {
+    /// Reverb preset key (16 hex digits) → its 44 record values by offset.
+    #[serde(default)]
+    reverb: BTreeMap<String, Vec<f32>>,
+    #[serde(default)]
+    eq_buses: Vec<EqBusJson>,
+    /// The two FlangeSub effect returns' records (A, B), nine values each by record offset.
+    #[serde(default)]
+    flange: Vec<Vec<f32>>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct EqBusJson {
+    #[serde(default)]
+    enabled: bool,
+    #[serde(default)]
+    clip: f32,
+    #[serde(default)]
+    ranges: Vec<[f32; 2]>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct GrindJson {
+    v: Vec<f32>,
+    f: Vec<f32>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct PlayerTuningJson {
+    #[serde(default)]
+    surface_table: Vec<Vec<i32>>,
+    #[serde(default)]
+    jitter: Vec<JitterJson>,
+    #[serde(default)]
+    seam_wobbles: Vec<SeamJson>,
+    #[serde(default)]
+    grind: Vec<GrindJson>,
+    #[serde(default)]
+    landing_materials: Vec<u32>,
+    wheel_bucket_high: Option<f32>,
+    wheel_bucket_low: Option<f32>,
+    /// Name hash (16 hex digits) → audio trick id.
+    #[serde(default)]
+    audio_tricks: BTreeMap<String, i32>,
+    /// The scorables' second audio trick field (`A2C5C22C5BE725F8`, state `+352`), keyed the same way.
+    #[serde(default)]
+    audio_tricks_2: BTreeMap<String, i32>,
+    /// The collision manager's material table and the posters' vault values
+    /// (`audio_export.collision_tuning`; optional).
+    #[serde(default)]
+    collision: CollisionJson,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct CollisionJson {
+    #[serde(default)]
+    materials: Vec<MaterialJson>,
+    #[serde(default)]
+    posters: BTreeMap<String, serde_json::Value>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct MaterialJson {
+    #[serde(default = "no_kind")]
+    kind: i32,
+    #[serde(default)]
+    ids: Vec<i32>,
+    #[serde(default)]
+    gain: i32,
+    pitch: Option<i32>,
+    #[serde(default)]
+    pitch_flag: bool,
+    #[serde(default)]
+    pitch_alt: i32,
+    #[serde(default)]
+    category: i32,
+    #[serde(default)]
+    landing: bool,
+    #[serde(default)]
+    windows: Vec<i32>,
+    #[serde(default)]
+    scale: f32,
+    #[serde(default)]
+    bands: Vec<f32>,
+    /// The footstep layer (`player::footsteps::FootstepMaterial`; absent before that export).
+    #[serde(default)]
+    footsteps: bool,
+    step_gain: Option<i32>,
+    step_landing_gain: Option<i32>,
+}
+
+fn no_kind() -> i32 {
+    -1
+}
+
+impl CollisionJson {
+    fn tuning(&self, surface_table: &[Vec<i32>]) -> skate_audio::player::collision::CollisionTuning {
+        use skate_audio::player::collision::{CollisionTuning, Material};
+        CollisionTuning {
+            materials: self
+                .materials
+                .iter()
+                .map(|m| Material {
+                    kind: m.kind,
+                    ids: std::array::from_fn(|i| m.ids.get(i).copied().unwrap_or(0)),
+                    gain: m.gain,
+                    pitch: m.pitch.unwrap_or(4096),
+                    pitch_flag: m.pitch_flag,
+                    pitch_alt: m.pitch_alt,
+                    category: m.category,
+                    landing: m.landing,
+                    windows: std::array::from_fn(|i| m.windows.get(i).copied().unwrap_or(0)),
+                    scale: m.scale,
+                    bands: std::array::from_fn(|i| m.bands.get(i).copied().unwrap_or(0.0)),
+                })
+                .collect(),
+            // AudioSurfaceMap word 7 (+28): the collision class.
+            surface_class: surface_table.iter().map(|r| r.get(7).copied().unwrap_or(0)).collect(),
+            // Words 12..16 (+48..+64): the collision voices' eEQChain bus by tier / class.
+            surface_eq: surface_table.iter().map(|r| std::array::from_fn(|i| r.get(12 + i).copied().unwrap_or(8))).collect(),
+        }
+    }
+
+    /// The posters' vault values over the retail defaults.
+    pub(crate) fn contacts(&self) -> skate_audio::player::contacts::ContactsTuning {
+        let mut c = skate_audio::player::contacts::ContactsTuning::default();
+        let f = |k: &str| self.posters.get(k).and_then(serde_json::Value::as_f64).map(|v| v as f32);
+        let ids = |k: &str| -> Option<Vec<u32>> {
+            self.posters.get(k)?.as_array().map(|a| a.iter().filter_map(|v| v.as_u64().map(|v| v as u32)).collect())
+        };
+        let three = |v: Option<Vec<u32>>, d: [u32; 3]| v.filter(|v| v.len() == 3).map_or(d, |v| [v[0], v[1], v[2]]);
+        let two = |v: Option<Vec<u32>>, d: [u32; 2]| v.filter(|v| v.len() == 2).map_or(d, |v| [v[0], v[1]]);
+        c.grind_split = f("grind_split").unwrap_or(c.grind_split);
+        c.grind_high = f("grind_high").unwrap_or(c.grind_high);
+        c.landing_air = f("landing_air").unwrap_or(c.landing_air);
+        c.landing_board = f("landing_board").map_or(c.landing_board, |v| v as i32);
+        c.landing_split = f("landing_split").unwrap_or(c.landing_split);
+        c.landing_high = f("landing_high").unwrap_or(c.landing_high);
+        c.landing_scale = [f("landing_scale_a").unwrap_or(c.landing_scale[0]), f("landing_scale_b").unwrap_or(c.landing_scale[1])];
+        c.deck_cooldown = f("deck_cooldown").unwrap_or(c.deck_cooldown);
+        c.scuff_speed = f("scuff_speed").unwrap_or(c.scuff_speed);
+        c.scuff_ids = two(ids("scuff_ids"), c.scuff_ids);
+        c.scuff_ids_soft = two(ids("scuff_ids_soft"), c.scuff_ids_soft);
+        c.tap_off_ms = f("tap_off_ms").unwrap_or(c.tap_off_ms);
+        c.tap_speed = f("tap_speed").unwrap_or(c.tap_speed);
+        c.tap_mid = f("tap_mid").unwrap_or(c.tap_mid);
+        c.tap_high = f("tap_high").unwrap_or(c.tap_high);
+        c.tap_ids = [
+            three(ids("tap_first"), c.tap_ids[0]),
+            three(ids("tap_second"), c.tap_ids[1]),
+            three(ids("tap_both"), c.tap_ids[2]),
+            three(ids("tap_special"), c.tap_ids[3]),
+        ];
+        c.tap_ids_soft = [
+            three(ids("tap_first_soft"), c.tap_ids_soft[0]),
+            three(ids("tap_second_soft"), c.tap_ids_soft[1]),
+            three(ids("tap_other_soft"), c.tap_ids_soft[2]),
+        ];
+        c
+    }
+}
+
+impl PlayerTuningJson {
+    fn tuning(&self) -> skate_audio::player::tuning::PlayerTuning {
+        use skate_audio::player::tuning::{GrindSurface, JitterParams, PlayerTuning, SeamWobble};
+        let d = PlayerTuning::default();
+        let four = |v: &[f32]| -> [f32; 4] { std::array::from_fn(|i| v.get(i).copied().unwrap_or(1.0)) };
+        PlayerTuning {
+            surface_table: self.surface_table.iter().map(|r| std::array::from_fn(|i| r.get(i).copied().unwrap_or(0))).collect(),
+            jitter: self.jitter.iter().filter(|j| j.params.len() == 4).map(|j| JitterParams {
+                enabled: j.enabled,
+                id: j.id.clamp(0, 15) as usize,
+                centre: j.params[0],
+                range: j.params[1],
+                max_step: j.params[2],
+                min_step: j.params[3],
+            }).collect(),
+            // A pattern without a collection reads the image's zero block (all fields 0).
+            seam_wobbles: self.seam_wobbles.iter().map(|w| SeamWobble {
+                gain_low: w.gain_low.unwrap_or(0.0),
+                gain_high: w.gain_high.unwrap_or(0.0),
+                ms_low: w.ms_low.unwrap_or(0),
+                ms_high: w.ms_high.unwrap_or(0),
+            }).collect(),
+            grind: self.grind.iter().map(|g| GrindSurface { v: four(&g.v), f: four(&g.f) }).collect(),
+            landing_materials: self.landing_materials.clone(),
+            wheel_bucket_high: self.wheel_bucket_high.unwrap_or(d.wheel_bucket_high),
+            wheel_bucket_low: self.wheel_bucket_low.unwrap_or(d.wheel_bucket_low),
+            audio_tricks: self.audio_tricks.iter().filter_map(|(k, v)| Some((u64::from_str_radix(k, 16).ok()?, *v))).collect(),
+            audio_tricks_2: self.audio_tricks_2.iter().filter_map(|(k, v)| Some((u64::from_str_radix(k, 16).ok()?, *v))).collect(),
+            // The rolling layers', the Tricks component's and Class_Treatment's vault words: the
+            // defaults are the user's vault values (not exported by setup yet).
+            rolling: Default::default(),
+            tricks: Default::default(),
+            treatment: Default::default(),
+            collision: self.collision.tuning(&self.surface_table),
+            seam_patterns: self.seam_wobbles.iter().map(|w| skate_audio::player::tuning::SeamPattern {
+                gain: w.gain.unwrap_or(0.0),
+                angle: w.angle.unwrap_or(0),
+                grid_z: w.grid_z.unwrap_or(0.0),
+                grid_x: w.grid_x.unwrap_or(0.0),
+                class: w.class.unwrap_or(0),
+                mode: w.mode.unwrap_or(0),
+                min_frames: w.min_frames.unwrap_or(0),
+                speed_threshold: w.speed_threshold.unwrap_or(0.0),
+                spacing: w.spacing.unwrap_or(0.0),
+                level: w.level.unwrap_or(0.0),
+            }).collect(),
+            seam_surface3_scale: self.seam_wobbles.first().and_then(|w| w.surface3_scale).unwrap_or(1.0),
+            eq_jitter: {
+                let channels: Vec<&JitterJson> = self.jitter.iter().filter(|j| j.params.len() == 4).collect();
+                skate_audio::player::tuning::EQ_JITTER_KEYS.map(|k| {
+                    channels.iter().position(|j| u64::from_str_radix(&j.key, 16).ok() == Some(k))
+                })
+            },
+        }
+    }
 }
 
 /// A loaded sound. `key` identifies the file for per-sound voice limits;
@@ -81,6 +608,23 @@ pub(crate) struct Clip {
     pub handle: Handle<AudioSource>,
     pub key: Arc<str>,
     pub peak: f32,
+    /// Channel count from the WAV header (1 if unreadable): the native fold of an interim voice
+    /// depends on it (`voices::native_fold_gain`).
+    pub channels: u16,
+}
+
+/// Channel count of a WAV's `fmt ` chunk (1 if unreadable).
+pub(crate) fn wav_channels(bytes: &[u8]) -> u16 {
+    let mut at = 12;
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().unwrap()) as usize;
+        let body = at + 8;
+        if &bytes[at..at + 4] == b"fmt " && body + 4 <= bytes.len() {
+            return u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]).max(1);
+        }
+        at = body + size + (size & 1);
+    }
+    1
 }
 
 /// Loudest sample of a PCM16 WAV as a fraction of full scale (1.0 if unreadable).
@@ -99,6 +643,34 @@ pub(crate) fn wav_peak(bytes: &[u8]) -> f32 {
     1.0
 }
 
+/// A PCM16 WAV as planar f32 (−1..1), or None if it is not one.
+pub(crate) fn wav_pcm(bytes: &[u8]) -> Option<skate_audio::mixer::Pcm> {
+    let (mut channels, mut rate, mut bits) = (0usize, 0u32, 0u16);
+    let mut at = 12;
+    while at + 8 <= bytes.len() {
+        let size = u32::from_le_bytes(bytes[at + 4..at + 8].try_into().ok()?) as usize;
+        let body = at + 8;
+        match &bytes[at..at + 4] {
+            b"fmt " if body + 16 <= bytes.len() => {
+                channels = usize::from(u16::from_le_bytes([bytes[body + 2], bytes[body + 3]]));
+                rate = u32::from_le_bytes(bytes[body + 4..body + 8].try_into().ok()?);
+                bits = u16::from_le_bytes([bytes[body + 14], bytes[body + 15]]);
+            }
+            b"data" if channels > 0 && bits == 16 => {
+                let data = &bytes[body..(body + size).min(bytes.len())];
+                let mut planar = vec![Vec::with_capacity(data.len() / (2 * channels)); channels];
+                for (i, s) in data.chunks_exact(2).enumerate() {
+                    planar[i % channels].push(f32::from(i16::from_le_bytes([s[0], s[1]])) / 32768.0);
+                }
+                return Some(skate_audio::mixer::Pcm { rate, channels: planar });
+            }
+            _ => {}
+        }
+        at = body + size + (size & 1);
+    }
+    None
+}
+
 #[derive(Resource)]
 pub(crate) struct Library {
     root: PathBuf,
@@ -114,6 +686,60 @@ fn safe_relative(file: &str) -> bool {
 }
 
 impl Library {
+    /// The player components' vault tuning (empty tables on installs set up before it existed).
+    pub(crate) fn player_tuning(&self) -> skate_audio::player::tuning::PlayerTuning {
+        self.manifest.player_tuning.tuning()
+    }
+
+    /// The environment network's reverb presets by key and the eight eEQChain bus records (empty
+    /// on installs set up before the bus export: no wet path, buses pass dry).
+    pub(crate) fn bus_tuning(&self) -> (std::collections::HashMap<u64, skate_audio::bus::env::Preset>, Vec<skate_audio::bus::eqchain::EqRecord>) {
+        let b = &self.manifest.bus_tuning;
+        let presets = b.reverb.iter().filter_map(|(k, v)| {
+            let key = u64::from_str_radix(k, 16).ok()?;
+            (v.len() == 44).then(|| (key, skate_audio::bus::env::Preset(std::array::from_fn(|i| v[i]))))
+        }).collect();
+        let eq = b.eq_buses.iter().filter(|e| e.ranges.len() == 6).map(|e| skate_audio::bus::eqchain::EqRecord {
+            enabled: e.enabled,
+            clip: e.clip,
+            ranges: std::array::from_fn(|i| e.ranges[i]),
+        }).collect();
+        (presets, eq)
+    }
+
+    /// The FlangeSub effect returns' presets (A, B), when the install has them.
+    pub(crate) fn flange_presets(&self) -> Option<[skate_audio::bus::flange::FlangePreset; 2]> {
+        let f = &self.manifest.bus_tuning.flange;
+        let preset = |v: &Vec<f32>| (v.len() == 9).then(|| skate_audio::bus::flange::FlangePreset(std::array::from_fn(|i| v[i])));
+        Some([preset(f.first()?)?, preset(f.get(1)?)?])
+    }
+
+    /// The footstep layer of materials 0..142 (empty on installs set up before that export: no
+    /// material footstep layer, the step / walking layers still play).
+    pub(crate) fn footstep_materials(&self) -> Vec<skate_audio::player::footsteps::FootstepMaterial> {
+        let rows = &self.manifest.player_tuning.collision.materials;
+        if rows.iter().all(|m| m.step_gain.is_none()) {
+            return Vec::new();
+        }
+        rows.iter()
+            .map(|m| {
+                let ids: [i32; 7] = std::array::from_fn(|i| m.ids.get(i).copied().unwrap_or(0));
+                skate_audio::player::footsteps::FootstepMaterial::from_collision(m.kind, &ids, m.footsteps, m.step_gain.unwrap_or(32767), m.step_landing_gain.unwrap_or(32767))
+            })
+            .collect()
+    }
+
+    /// The Contacts posters' vault values (collision posters, foot taps, scuffs).
+    pub(crate) fn contacts_tuning(&self) -> skate_audio::player::contacts::ContactsTuning {
+        self.manifest.player_tuning.collision.contacts()
+    }
+
+    /// A wheel-spin recording (`SFXObj_Wheels`) as planar PCM, decoded now.
+    pub(crate) fn wheels_pcm(&self, name: &str) -> Option<Arc<skate_audio::mixer::Pcm>> {
+        let entry = self.manifest.wheels.get(name)?;
+        self.read(&entry.file).ok().and_then(|bytes| wav_pcm(&bytes)).map(Arc::new)
+    }
+
     pub(crate) fn load(asset_root: &Path) -> Result<Self, String> {
         let root = asset_root.join("private/audio");
         let path = root.join("audio_manifest.json");
@@ -124,7 +750,10 @@ impl Library {
         }
         let files = manifest.ambience.values().chain(manifest.grains.values().flat_map(|g| &g.bands)).chain(manifest.wheels.values())
             .chain(manifest.banks.values().flatten());
-        if let Some(bad) = files.map(|e| &e.file).find(|f| !safe_relative(f)) {
+        let aems = manifest.aems.projects.iter().chain(manifest.aems.banks.values()).chain(manifest.aems.mixmap.iter())
+            .chain(manifest.aems.splice.values())
+            .chain(manifest.grains.values().flat_map(|g| g.file.iter().chain(g.grain.iter())));
+        if let Some(bad) = files.map(|e| &e.file).chain(aems).find(|f| !safe_relative(f)) {
             return Err(format!("{}: invalid file path {bad:?}", path.display()));
         }
         info!(
@@ -144,7 +773,8 @@ impl Library {
         match std::fs::read(self.root.join(file)) {
             Ok(bytes) => {
                 let peak = wav_peak(&bytes);
-                let clip = Clip { handle: assets.add(AudioSource { bytes: bytes.into() }), key: file.into(), peak };
+                let channels = wav_channels(&bytes);
+                let clip = Clip { handle: assets.add(AudioSource { bytes: bytes.into() }), key: file.into(), peak, channels };
                 self.loaded.insert(file.to_owned(), clip.clone());
                 Some(clip)
             }
@@ -214,6 +844,33 @@ impl Library {
         self.manifest.emitters.get(file).map_or(&[], Vec::as_slice)
     }
 
+    /// The key a district's region layer holds at (x, z), if any tile covers it.
+    pub(crate) fn region_key(&self, district: &str, layer: &str, x: f32, z: f32) -> Option<u64> {
+        self.manifest.regions.get(district)?.get(layer)?.iter().find_map(|tile| tile.key(x, z))
+    }
+
+    /// Whether this install has the retail zone ambience data (manifest v4 with zones).
+    pub(crate) fn has_zones(&self) -> bool {
+        !self.manifest.zones.is_empty()
+    }
+    pub(crate) fn zone(&self, key: u64) -> Option<&Zone> {
+        self.manifest.zones.get(&format!("{key:016X}"))
+    }
+    /// The crossfade joining two zones, in either order.
+    pub(crate) fn crossfade(&self, a: u64, b: u64) -> Option<&Crossfade> {
+        let (a, b) = (format!("{a:016X}"), format!("{b:016X}"));
+        self.manifest.crossfades.iter().find(|c| (c.from == a && c.to == b) || (c.from == b && c.to == a))
+    }
+
+    /// A location set by its u64 key, or by name.
+    pub(crate) fn random_set(&self, key: u64) -> Option<&RandomSet> {
+        self.manifest.random_sets.get(&format!("{key:016X}"))
+    }
+    pub(crate) fn random_set_named(&self, name: &str) -> Option<(u64, &RandomSet)> {
+        self.manifest.random_sets.iter().find(|(_, s)| s.name.as_deref() == Some(name))
+            .and_then(|(k, s)| Some((u64::from_str_radix(k, 16).ok()?, s)))
+    }
+
     /// A bank's retail patch tree (SPLC banks only).
     pub(crate) fn patches(&self, bank: &str) -> Option<&Patches> {
         self.manifest.patches.get(bank)
@@ -232,6 +889,98 @@ impl Library {
         samples
     }
 
+    /// The native AEMS runtime's files (empty before manifest v5).
+    pub(crate) fn aems(&self) -> &AemsFiles {
+        &self.manifest.aems
+    }
+
+    /// A grain member's whole recording and raw `.grain` file (native grain player), if staged.
+    pub(crate) fn grain_whole(&self, name: &str) -> Option<(&str, &str)> {
+        let g = self.manifest.grains.get(name)?;
+        Some((g.file.as_deref()?, g.grain.as_deref()?))
+    }
+
+    /// The vault tuning of a grain member (its collection over `default`).
+    pub(crate) fn grain_tuning(&self, name: &str) -> Option<skate_audio::grain::board::SurfaceTuning> {
+        let t = &self.manifest.grain_player;
+        t.surfaces.get(name)?.tuning(&t.default)
+    }
+
+    /// The grain class's `default` collection as a tuning (what a bind with the `default` key uses:
+    /// rolling surface 0, `player::rolling::member`).
+    pub(crate) fn grain_default_tuning(&self) -> Option<skate_audio::grain::board::SurfaceTuning> {
+        let t = &self.manifest.grain_player;
+        t.default.tuning(&t.default)
+    }
+
+    /// The rocket layer's tuning (owner class `default`).
+    pub(crate) fn rocket_tuning(&self) -> Option<skate_audio::grain::board::RocketTuning> {
+        let o = &self.manifest.grain_player.owner;
+        Some(skate_audio::grain::board::RocketTuning {
+            start_kmh: o.rocket_start_kmh?,
+            top_kmh: o.rocket_top_kmh?,
+            gain_word: o.rocket_gain_word?,
+            params: skate_audio::grain::GrainParams::from_slice(o.rocket_params.as_deref()?)?,
+        })
+    }
+
+    /// Collision material → rolling surface (`Sk8::AudioSurfaceMap`, 95 entries; empty before
+    /// 2026-10-02 installs).
+    pub(crate) fn surface_map(&self) -> &[u32] {
+        &self.manifest.grain_player.surface_map
+    }
+
+    /// The board chains' tuning (owner class `default`): the install's values over the vault
+    /// defaults `ChainTuning::default()` holds (installs set up before the chain export).
+    pub(crate) fn chain_tuning(&self) -> skate_audio::grain::chain::ChainTuning {
+        let o = &self.manifest.grain_player.owner;
+        let mut t = skate_audio::grain::chain::ChainTuning::default();
+        let set = |v: &mut f32, x: Option<f32>| if let Some(x) = x { *v = x };
+        let seti = |v: &mut i32, x: Option<i32>| if let Some(x) = x { *v = x };
+        set(&mut t.send_start_kmh, o.g3_send_start_kmh);
+        set(&mut t.send_end_kmh, o.g3_send_end_kmh);
+        set(&mut t.send_max, o.g3_send_max);
+        set(&mut t.level_start_kmh, o.g1_level_start_kmh);
+        set(&mut t.level_end_kmh, o.g1_level_end_kmh);
+        set(&mut t.level_floor, o.g1_level_floor);
+        set(&mut t.wobble_start_kmh, o.wobble_start_kmh);
+        set(&mut t.wobble_end_kmh, o.wobble_end_kmh);
+        seti(&mut t.wobble[0].ms_low, o.wobble_a_ms_low);
+        seti(&mut t.wobble[0].ms_high, o.wobble_a_ms_high);
+        set(&mut t.wobble[0].low, o.wobble_a_low);
+        set(&mut t.wobble[0].high, o.wobble_a_high);
+        seti(&mut t.wobble[1].ms_low, o.wobble_b_ms_low);
+        seti(&mut t.wobble[1].ms_high, o.wobble_b_ms_high);
+        set(&mut t.wobble[1].low, o.wobble_b_low);
+        set(&mut t.wobble[1].high, o.wobble_b_high);
+        set(&mut t.clip, o.g3_clip);
+        set(&mut t.shelf_hz, o.g3_shelf_hz);
+        set(&mut t.shelf_gain, o.g3_shelf_gain);
+        t
+    }
+
+
+    /// Read a manifest-listed file (paths were validated at load).
+    pub(crate) fn read(&self, file: &str) -> std::io::Result<Vec<u8>> {
+        std::fs::read(self.root.join(file))
+    }
+
+    /// A Splice bank for the native player: its patch tree and its samples (stream n = WAV n), or
+    /// None when the install lacks the tree or the WAVs don't match its sample count.
+    pub(crate) fn splice_bank(&self, stem: &str) -> Option<(skate_audio::splice::SpliceBank, Vec<Option<Arc<skate_audio::mixer::Pcm>>>)> {
+        let file = self.manifest.aems.splice.get(stem)?;
+        let bank = skate_audio::splice::SpliceBank::parse(&self.read(file).ok()?).ok()?;
+        let pcm = self.bank_pcm(stem);
+        (pcm.len() == bank.samples).then_some((bank, pcm))
+    }
+
+    /// A bank's decoded samples as planar f32 PCM by S10A slot (the WAV order); None where a file
+    /// is missing or unreadable (the native runtime then plays silence of the right length).
+    pub(crate) fn bank_pcm(&self, bank: &str) -> Vec<Option<Arc<skate_audio::mixer::Pcm>>> {
+        let Some(entries) = self.manifest.banks.get(bank) else { return Vec::new() };
+        entries.iter().map(|e| self.read(&e.file).ok().and_then(|bytes| wav_pcm(&bytes)).map(Arc::new)).collect()
+    }
+
     /// Drop a clip's PCM once nothing plays it (rodio keeps its own copy while playing).
     pub(crate) fn release(&mut self, assets: &mut Assets<AudioSource>, clip: &Clip) {
         if self.loaded.remove(&*clip.key).is_some() {
@@ -255,6 +1004,24 @@ mod tests {
         }
         assert_eq!(wav_peak(&wav), 0.25);
         assert_eq!(wav_peak(b"RIFF"), 1.0);
+        assert_eq!(wav_channels(&wav), 1);
+        wav[22] = 2;
+        assert_eq!(wav_channels(&wav), 2);
+        assert_eq!(wav_channels(b"RIFF"), 1);
+    }
+
+    #[test]
+    fn wav_pcm_decodes_planar_channels() {
+        let mut wav = b"RIFF\x00\x00\x00\x00WAVEfmt \x10\x00\x00\x00".to_vec();
+        wav.extend([1, 0, 2, 0, 0x80, 0xbb, 0, 0, 0, 0xee, 2, 0, 4, 0, 16, 0]);
+        wav.extend(b"data\x08\x00\x00\x00");
+        for s in [16384i16, -32768, 0, 8192] {
+            wav.extend(s.to_le_bytes());
+        }
+        let pcm = wav_pcm(&wav).unwrap();
+        assert_eq!(pcm.rate, 48000);
+        assert_eq!(pcm.channels, vec![vec![0.5, 0.0], vec![-1.0, 0.25]]);
+        assert!(wav_pcm(b"RIFF").is_none());
     }
 
     #[test]
diff --git a/crates/skate-game/src/game_audio/mod.rs b/crates/skate-game/src/game_audio/mod.rs
index dbc10841..e02e791e 100644
--- a/crates/skate-game/src/game_audio/mod.rs
+++ b/crates/skate-game/src/game_audio/mod.rs
@@ -14,10 +14,20 @@
 //! scale it down (voices.rs), sounds fade in, voice counts are capped, and nothing plays while
 //! the menu is open or a replay runs. `--mute` silences game and mod audio.
 mod ambience;
+mod crossfade_groups;
 mod cues;
+#[cfg(test)]
+mod e2e;
 mod emitters;
+mod grain_bed;
 mod library;
+mod native;
+mod player_audio;
+mod random_programs;
+mod random_sets;
 mod skate_events;
+mod state_log;
+mod timing;
 mod voices;
 
 use bevy::{audio::Volume, prelude::*};
@@ -36,10 +46,13 @@ struct SavedSettings {
     master: u32,
     ambience: u32,
     effects: u32,
+    /// Play the world emitters through the native AEMS runtime (crates/skate-audio) instead of
+    /// the measured tables. Off by default; `SKATE_AEMS=1` overrides it (native.rs).
+    native: bool,
 }
 impl Default for SavedSettings {
     fn default() -> Self {
-        Self { master: 75, ambience: 100, effects: 100 }
+        Self { master: 75, ambience: 100, effects: 100, native: false }
     }
 }
 impl SavedSettings {
@@ -75,6 +88,10 @@ impl AudioSettings {
     pub(crate) fn master(&self) -> f32 {
         if self.muted { 0.0 } else { self.saved.master as f32 / 100.0 }
     }
+    /// Whether `settings/audio.json` asks for the native AEMS runtime.
+    pub(crate) fn native(&self) -> bool {
+        self.saved.native
+    }
     pub(crate) fn category(&self, category: Category) -> f32 {
         let percent = match category {
             Category::Ambience => self.saved.ambience,
@@ -138,10 +155,14 @@ impl Plugin for GameAudioPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<Voices>()
             .init_resource::<skate_events::Cues>()
+            .init_resource::<emitters::ReverbZones>()
             .add_systems(Startup, setup)
             .add_systems(FixedUpdate, skate_events::observe.after(crate::app::SimulationSet::Physics))
-            .add_systems(Update, (ambience::update, skate_events::play, emitters::update).in_set(CueSet).after(crate::app::FrameSet::Animation))
+            .add_systems(Update, (native::mixmap_frame, grain_bed::update, emitters::reverb_zones, native::reverb_frame).chain().before(CueSet).after(crate::app::FrameSet::Animation))
+            .add_systems(Update, (ambience::update, skate_events::play, emitters::update, random_sets::update).in_set(CueSet).after(crate::app::FrameSet::Animation))
             .add_systems(Update, voices::sync.after(CueSet))
+            .add_systems(Update, timing::report)
+            .add_plugins(native::register)
             .add_systems(
                 PostUpdate,
                 (apply_global_volume, follow_camera).before(bevy::transform::TransformSystems::Propagate),
@@ -208,7 +229,7 @@ mod tests {
     fn defaults_are_quiet_and_saved_values_are_bounded() {
         assert_eq!(SavedSettings::default().master, 75);
         let loaded: SavedSettings = serde_json::from_str(r#"{"master":400,"ambience":33,"effects":7}"#).unwrap();
-        assert_eq!(loaded.validated(), SavedSettings { master: 100, ambience: 30, effects: 5 });
+        assert_eq!(loaded.validated(), SavedSettings { master: 100, ambience: 30, effects: 5, native: false });
     }
 
     #[test]
diff --git a/crates/skate-game/src/game_audio/native.rs b/crates/skate-game/src/game_audio/native.rs
new file mode 100644
index 00000000..03e78c72
--- /dev/null
+++ b/crates/skate-game/src/game_audio/native.rs
@@ -0,0 +1,774 @@
+//! Host for the native AEMS runtime (`crates/skate-audio`): retail's own patch programs and voice
+//! graph instead of our measured tables. Off by default; `SKATE_AEMS=1` or `"native": true` in
+//! `settings/audio.json` turns it on (docs/hails-additions/11-audio.md, "Native AEMS runtime").
+//!
+//! - At startup every Csis project is installed and `emitter_utility.abk` is loaded and posted
+//!   (retail posts `c_emitter_utility` once at boot; it feeds the `*_snd` / `random_*_gbl` globals).
+//! - Banks are loaded on first use, with their decoded WAVs as PCM, and unloaded on map change.
+//! - One device-paced stream: rodio pulls 48 kHz stereo; each 256-frame block renders the voices
+//!   and ticks the evaluator, so programs run on the audio clock exactly like retail. Game code
+//!   posts, redelivers and releases between blocks under the runtime's lock.
+//! - The stream follows the master volume (the AEMS voices × ambience, the rolling bed × effects)
+//!   and pauses while the menu or a replay runs.
+//! - The MixMap mixer (`MixMapSK8.mxb`, `skate_audio::mixmap`) runs on the game thread once per
+//!   60 Hz frame (fixed steps): [`mixmap_frame`] writes the inputs we can supply (category gains,
+//!   pause, the local player's physics and 3-D position, the emitter states' positions), ticks,
+//!   and the systems read its outputs (the `c_emitter` words; the rolling bed's levels, pitch,
+//!   filters and pan).
+//!
+//! Which systems use it so far: the `.ems` world emitters (`emitters.rs`) and, when the install
+//! has the whole grain recordings, the granular rolling bed (`grain_bed.rs`). Location sets, zone
+//! beds, crossfades and the other skate cues still use their measured tables.
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use bevy::audio::{AddAudioSource, AudioPlayer, Decodable, PlaybackSettings, Source, Volume};
+use bevy::prelude::*;
+use skate_audio::eval::NodeId;
+use skate_audio::formats::{Bank, Project};
+use skate_audio::mixmap::{MixMap, keys};
+use skate_audio::runtime::Runtime;
+
+use super::Library;
+
+/// One MixMap evaluation per 60 Hz frame (mixmap-spec §1: retail's rule for any dt > 0.02).
+const MIX_STEP: f32 = 1.0 / 60.0;
+/// CSTATEMGR_Emitter's pool = the MixMap's Emitter instances.
+pub(crate) const EMITTER_STATES: usize = 5;
+
+/// The runtime, shared with the audio thread.
+pub(crate) type Shared = Arc<Mutex<Runtime>>;
+
+/// The asset rodio plays: an endless 48 kHz stereo stream pulled from the runtime.
+#[derive(Asset, TypePath, Clone)]
+pub(crate) struct NativeStream {
+    shared: Shared,
+}
+
+pub(crate) struct NativeDecoder {
+    shared: Shared,
+    buffer: Vec<f32>,
+    at: usize,
+}
+
+impl Iterator for NativeDecoder {
+    type Item = f32;
+    fn next(&mut self) -> Option<f32> {
+        if self.at >= self.buffer.len() {
+            match super::timing::lock(&self.shared, &super::timing::AUDIO_LOCK) {
+                Ok(mut runtime) => {
+                    let _render = super::timing::scope(&super::timing::RENDER);
+                    runtime.fill_stereo(&mut self.buffer);
+                }
+                Err(_) => self.buffer.fill(0.0),
+            }
+            self.at = 0;
+        }
+        let v = self.buffer[self.at];
+        self.at += 1;
+        Some(v)
+    }
+}
+
+impl Source for NativeDecoder {
+    fn current_frame_len(&self) -> Option<usize> {
+        None
+    }
+    fn channels(&self) -> u16 {
+        2
+    }
+    fn sample_rate(&self) -> u32 {
+        skate_audio::MIX_RATE
+    }
+    fn total_duration(&self) -> Option<Duration> {
+        None
+    }
+}
+
+impl Decodable for NativeStream {
+    type DecoderItem = f32;
+    type Decoder = NativeDecoder;
+    fn decoder(&self) -> NativeDecoder {
+        // One block of stereo per lock.
+        NativeDecoder { shared: self.shared.clone(), buffer: vec![0.0; 2 * skate_audio::BLOCK], at: usize::MAX }
+    }
+}
+
+/// Marks the stream's player entity.
+#[derive(Component)]
+struct NativeOutput;
+
+/// The running native runtime and what the game has loaded into it.
+#[derive(Resource)]
+pub(crate) struct Native {
+    pub(crate) shared: Shared,
+    /// Bank stem → runtime bank id.
+    banks: HashMap<String, usize>,
+    emitter_class: Option<usize>,
+    /// The MixMap, when the install has `MixMapSK8.mxb`.
+    pub(crate) mixmap: Option<MixMap>,
+    mix_clock: f32,
+    /// MixMap frames run (the eEQChain clear runs on every second one).
+    mix_frames: u64,
+    /// The local player's MixMap inputs and components (None without a MixMap).
+    pub(crate) player: Option<super::player_audio::PlayerAudio>,
+    /// Which emitter states (MixMap Emitter instances 0..4) are taken.
+    emitter_states: [bool; EMITTER_STATES],
+    /// The granular rolling bed's game-side state (None: the interim rolling loop plays).
+    pub(crate) bed: Option<super::grain_bed::Bed>,
+}
+
+impl Native {
+    fn start(library: &Library) -> Result<Self, String> {
+        let files = library.aems();
+        if files.projects.is_empty() {
+            return Err("this install has no AEMS banks (run setup to refresh the audio)".into());
+        }
+        let mut runtime = Runtime::new();
+        for file in &files.projects {
+            let bytes = library.read(file).map_err(|e| format!("{file}: {e}"))?;
+            let project = Project::parse(file, &bytes).map_err(|e| e.to_string())?;
+            runtime.install_project(&project);
+        }
+        let mixmap = match &files.mixmap {
+            Some(file) => {
+                let bytes = library.read(file).map_err(|e| format!("{file}: {e}"))?;
+                let m = MixMap::from_bytes(&bytes).map_err(|e| e.to_string())?;
+                info!("Game audio: MixMap {} controllers ({} output blocks)", m.controller_count(), m.output_blocks());
+                Some(m)
+            }
+            None => {
+                warn!("Game audio: this install has no MixMapSK8.mxb (run setup to refresh the audio); emitter words use defaults");
+                None
+            }
+        };
+        let bed = if mixmap.is_some() { super::grain_bed::Bed::new(library) } else { None };
+        let player = mixmap.as_ref().map(|_| {
+            super::player_audio::PlayerAudio::new(library.player_tuning(), super::player_audio::components_requested())
+        });
+        if bed.is_none() {
+            info!("Game audio: no MixMap, whole grain recordings or grain tuning in this install; the interim rolling loop plays");
+        }
+        let mut native = Self {
+            shared: Arc::new(Mutex::new(runtime)),
+            banks: HashMap::new(),
+            emitter_class: None,
+            mixmap,
+            mix_clock: 0.0,
+            mix_frames: 0,
+            player,
+            emitter_states: [false; EMITTER_STATES],
+            bed,
+        };
+        // The environment (reverb) network and the eEQChain buses (optional install data).
+        let (presets, eq) = library.bus_tuning();
+        if !presets.is_empty() || !eq.is_empty() {
+            let mut runtime = native.shared.lock().map_err(|_| "audio lock poisoned")?;
+            info!("Game audio: native buses on ({} reverb presets, {} eEQChain buses)", presets.len(), eq.len());
+            runtime.mixer.buses.env.presets = presets;
+            runtime.mixer.buses.eq.set_records(&eq);
+        }
+        // The FlangeSub effect returns (GRINDS and the skid send into return A).
+        if let Some([a, b]) = library.flange_presets() {
+            let mut runtime = native.shared.lock().map_err(|_| "audio lock poisoned")?;
+            info!("Game audio: native FlangeSub returns on");
+            runtime.mixer.buses.flange.set_presets(a, b);
+        }
+        // The FootStep SubMix graphs (`sub_82494188`: each foot sound through its EQ record, env
+        // send and panner); `SKATE_AEMS_FOOTSTEP_SUBMIX=0` = the voices straight into SFX Master.
+        if let Ok(mut runtime) = native.shared.lock() {
+            runtime.mixer.buses.submix.enabled = !std::env::var("SKATE_AEMS_FOOTSTEP_SUBMIX").is_ok_and(|v| v == "0");
+        }
+        native.ensure_bank(library, "emitter_utility")?;
+        native.load_player_banks(library);
+        let mut runtime = native.shared.lock().map_err(|_| "audio lock poisoned")?;
+        let utility = runtime.eval.class_id("c_emitter_utility").ok_or("no c_emitter_utility class")?;
+        runtime.post(utility, &[]);
+        drop(runtime);
+        // Retail's second boot utility (Start_up_Play_ctl, Common.abk): the Seams program's sample
+        // shuffles. Older installs without Common.abk keep the fixed seam samples.
+        match native.ensure_bank(library, skate_audio::player::seams::UTILITY_BANK) {
+            Ok(_) => {
+                let mut runtime = native.shared.lock().map_err(|_| "audio lock poisoned")?;
+                if let Some(class) = runtime.eval.class_id(skate_audio::player::seams::UTILITY) {
+                    runtime.post(class, &[]);
+                }
+            }
+            Err(e) => warn!("Game audio: {e}; seam hits play fixed samples (rerun setup)"),
+        }
+        // Then the foley utility (the cloth_trick programs call it): retail's boot order
+        // c_emitter_utility → Start_up_Play_ctl → c_foley_utility, which matters because every
+        // program shares one random generator.
+        if native.player.as_ref().is_some_and(|p| p.components && p.tricks_on) {
+            let mut runtime = native.shared.lock().map_err(|_| "audio lock poisoned")?;
+            if let Some(id) = runtime.eval.class_id(skate_audio::player::tricks::FOLEY_UTILITY) {
+                runtime.post(id, &[]);
+            }
+        }
+        let runtime = native.shared.lock().map_err(|_| "audio lock poisoned")?;
+        native.emitter_class = runtime.eval.class_id("c_emitter");
+        drop(runtime);
+        Ok(native)
+    }
+
+    /// Load a bank (and its samples) unless it is loaded already.
+    pub(crate) fn ensure_bank(&mut self, library: &Library, stem: &str) -> Result<usize, String> {
+        if let Some(&id) = self.banks.get(stem) {
+            return Ok(id);
+        }
+        let file = library.aems().banks.get(stem).ok_or_else(|| format!("bank {stem} is not in the install"))?;
+        let bytes = library.read(file).map_err(|e| format!("{file}: {e}"))?;
+        let bank = Bank::parse(stem, bytes).map_err(|e| e.to_string())?;
+        let pcm = library.bank_pcm(stem);
+        let id = self.shared.lock().map_err(|_| "audio lock poisoned")?.load_bank(bank, pcm);
+        self.banks.insert(stem.to_owned(), id);
+        Ok(id)
+    }
+
+    /// The player components' banks, in the player volume group; without them the components
+    /// stay off and their interim cues play.
+    fn load_player_banks(&mut self, library: &Library) {
+        if !self.player.as_ref().is_some_and(|p| p.components) {
+            return;
+        }
+        for stem in super::player_audio::BANKS {
+            match self.ensure_bank(library, stem) {
+                Ok(id) => {
+                    if let Ok(mut runtime) = self.shared.lock() {
+                        runtime.mixer.set_bank_group(id, skate_audio::mixer::GROUP_PLAYER);
+                    }
+                }
+                Err(e) => {
+                    warn!("Game audio: native player sounds off ({e}); the measured cues play");
+                    if let Some(p) = &mut self.player {
+                        p.components = false;
+                    }
+                    return;
+                }
+            }
+        }
+        info!("Game audio: native player components on (Class_grind, SenseOfSpeed, Class_foot_drag)");
+        self.load_optional_player_banks(library);
+        // The Splice banks (pops, landings, touchdowns), decoded up front so a sample's first
+        // trigger sounds like every later one.
+        let mut first = false;
+        for (i, stem) in super::player_audio::SPLICE_BANKS.iter().enumerate() {
+            match library.splice_bank(stem) {
+                Some((bank, pcm)) => {
+                    if let Ok(mut runtime) = self.shared.lock() {
+                        let rt = &mut *runtime;
+                        rt.splice.load_bank(stem, bank, pcm, &mut rt.mixer);
+                        first |= i == 0;
+                    }
+                }
+                None => warn!("Game audio: {stem} has no patch tree in this install (run setup to refresh the audio); its native sounds stay off"),
+            }
+        }
+        // SFXObj_Wheels' spin-down recordings, decoded now (first trigger = later triggers).
+        let streams: Vec<_> = super::player_audio::WHEEL_STREAMS.iter().map(|n| library.wheels_pcm(n)).collect();
+        let wheels = streams.iter().all(Option::is_some);
+        if let Ok(mut runtime) = self.shared.lock() {
+            runtime.load_streams(streams);
+        }
+        if let Some(p) = &mut self.player {
+            p.contacts_on = first;
+            p.set_footstep_materials(library.footstep_materials());
+            p.footsteps_on = first && !std::env::var("SKATE_AEMS_FOOTSTEPS").is_ok_and(|v| v == "0");
+            p.contact_tuning = library.contacts_tuning();
+            p.wheels_on = wheels;
+            if p.contacts_on {
+                info!("Game audio: native board contacts on (Splice: pops, landings, touchdowns, foot taps, scuffs; collision pairs: {} materials)", p.tuning.collision.materials.len());
+            }
+            if wheels {
+                info!("Game audio: native wheel spin on (SFXObj_Wheels)");
+            }
+        }
+    }
+
+    /// The optional components' banks (rolling layers, rattle, board slide, tricks, treatment):
+    /// each component runs when its first bank is in the install; missing later banks only drop
+    /// their layers (a Class_rolling post reaches every bank bound to the class).
+    fn load_optional_player_banks(&mut self, library: &Library) {
+        use super::player_audio::{RATTLE_BANKS, ROLLING_BANKS, SLIDE_BANKS, TREATMENT_BANKS, TRICKS_BANKS};
+        let load = |me: &mut Self, banks: &[&str]| -> bool {
+            let mut first = false;
+            for (i, stem) in banks.iter().enumerate() {
+                match me.ensure_bank(library, stem) {
+                    Ok(id) => {
+                        if let Ok(mut runtime) = me.shared.lock() {
+                            runtime.mixer.set_bank_group(id, skate_audio::mixer::GROUP_PLAYER);
+                        }
+                        first |= i == 0;
+                    }
+                    Err(e) => warn!("Game audio: {e}; its native layers stay off (run setup to refresh the audio)"),
+                }
+            }
+            first
+        };
+        let rolling = load(self, ROLLING_BANKS);
+        let rattle = load(self, RATTLE_BANKS);
+        let slide = load(self, SLIDE_BANKS);
+        let tricks = load(self, TRICKS_BANKS);
+        let treatment = load(self, TREATMENT_BANKS);
+        // With the tricks the foley utility is posted at boot, after Start_up_Play_ctl (`start`).
+        if let Some(p) = &mut self.player {
+            (p.rolling_on, p.rattle_on, p.slide_on, p.tricks_on, p.treatment_on) = (rolling, rattle, slide, tricks, treatment);
+            info!("Game audio: native rolling layers {rolling}, rattle {rattle}, board slide {slide}, tricks {tricks}, treatment {treatment}");
+        }
+    }
+
+    /// Unload every bank but the utility and the player's (map change).
+    pub(crate) fn unload_map_banks(&mut self) {
+        let Ok(mut runtime) = self.shared.lock() else { return };
+        self.banks.retain(|stem, id| {
+            let keep = stem == "emitter_utility" || stem == skate_audio::player::seams::UTILITY_BANK || super::player_audio::BANKS.contains(&stem.as_str()) || super::player_audio::OPTIONAL_BANKS.iter().any(|b| b.contains(&stem.as_str()));
+            if !keep {
+                runtime.unload_bank(*id);
+            }
+            keep
+        });
+    }
+
+    pub(crate) fn has_bank(&self, library: &Library, stem: &str) -> bool {
+        library.aems().banks.contains_key(stem)
+    }
+
+    /// Post to `c_emitter` (payload words: level, dry, send, azimuth, pitch, low-pass, high-pass,
+    /// unused, selector).
+    pub(crate) fn post_emitter(&self, payload: &[i32; 9]) -> Option<NodeId> {
+        let class = self.emitter_class?;
+        Some(self.shared.lock().ok()?.post(class, payload))
+    }
+
+    /// Take a free emitter state (0..4), if any.
+    pub(crate) fn claim_emitter_state(&mut self) -> Option<usize> {
+        let g = self.emitter_states.iter().position(|used| !used)?;
+        self.emitter_states[g] = true;
+        Some(g)
+    }
+
+    /// Free an emitter state; its 3-D input goes inactive.
+    pub(crate) fn release_emitter_state(&mut self, g: usize) {
+        if let Some(used) = self.emitter_states.get_mut(g) {
+            *used = false;
+        }
+        if let Some(m) = &mut self.mixmap {
+            m.set_input(keys::emitter_pos(g as u32), keys::pos::FLAGS, 0);
+        }
+    }
+
+    /// The emitter state's SFXCTL 3-D input (what B0 reads: camera distance and azimuth). Who
+    /// writes it in retail is not traced (mixmap-spec §10); we follow the 3DObjPos layout (§7.3).
+    pub(crate) fn set_emitter_position(&mut self, g: usize, listener: &GlobalTransform, skater: Vec3, source: Vec3) {
+        let Some(m) = &mut self.mixmap else { return };
+        write_position(m, keys::emitter_pos(g as u32), listener, skater, source);
+    }
+
+    /// The positional `c_emitter` payload from the MixMap (mixmap-spec §6.3, `sub_824DCF08`):
+    /// w1 dry = out4 × level, w2 send = out8 × level, w3 pan = out0 (raw azimuth of B0), w4 pitch
+    /// = out5 through the pitch reader, w5 low-pass = out6; w8 = the attribute patch. Without a
+    /// MixMap (or a state) the old defaults apply: dry = level, send 0, pitch 4096, 25 kHz.
+    pub(crate) fn emitter_payload(&self, g: Option<usize>, level: f32, azimuth: i32, patch: i32) -> [i32; 9] {
+        let level = level.clamp(0.0, 1.0);
+        let patch = patch.clamp(0, 500);
+        match (&self.mixmap, g) {
+            (Some(m), Some(g)) => {
+                let key = keys::emitter(g as u32);
+                let scaled = |id: usize| (m.level(key, id) as f32 * level) as i32;
+                [32767, scaled(4), scaled(8), m.raw(key, 0), m.pitch_4096(key, 5), m.filter_hz(key, 6), 0, 0, patch]
+            }
+            _ => [32767, (level * 32767.0).round() as i32, 0, azimuth, 4096, 25000, 0, 0, patch],
+        }
+    }
+
+    pub(crate) fn redeliver(&self, node: NodeId, payload: &[i32]) {
+        if let Ok(mut runtime) = self.shared.lock() {
+            runtime.redeliver(node, payload);
+        }
+    }
+
+    pub(crate) fn release(&self, node: NodeId) {
+        if let Ok(mut runtime) = self.shared.lock() {
+            runtime.release(node);
+        }
+    }
+}
+
+/// Whether the player asked for the native runtime.
+pub(crate) fn requested(settings: &super::AudioSettings) -> bool {
+    match std::env::var("SKATE_AEMS") {
+        Ok(v) => v == "1" || v.eq_ignore_ascii_case("true"),
+        Err(_) => settings.native(),
+    }
+}
+
+pub(crate) fn register(app: &mut App) {
+    app.add_audio_source::<NativeStream>()
+        .add_systems(PostStartup, start)
+        .add_systems(PostUpdate, follow_volume);
+}
+
+/// Write an emitter state's 3DObjPos-style input block (mixmap-spec §7.3): in0 = f32 distance
+/// from the skater, in1 = f32 distance from the camera itself, in2 / in3 = azimuths (u16 scale,
+/// both in the camera frame here: who writes the emitter blocks in retail is not traced, §10),
+/// in15 bit 0 = active. The emitters are static: relative speeds (in13/14) stay 0.
+fn write_position(m: &mut MixMap, key: u32, listener: &GlobalTransform, skater: Vec3, source: Vec3) {
+    let az = azimuth(listener, source);
+    m.set_input_f32(key, keys::pos::DIST_SKATER, skater.distance(source));
+    m.set_input_f32(key, keys::pos::DIST_CAMERA, listener.translation().distance(source));
+    m.set_input(key, keys::pos::AZ_SKATER, az);
+    m.set_input(key, keys::pos::AZ_CAMERA, az);
+    m.set_input(key, keys::pos::FLAGS, 1);
+}
+
+/// The inputs we can supply for this frame, then the fixed-step MixMap ticks (spec §1: inputs →
+/// components' process → tick → components' update). Written here: Master.in1–4, Music.in1/2/5,
+/// Reverb.in5 (free-skate values, §7.4) and Pause.in0 while the menu is open; through
+/// `player_audio`: PlayerPhysics 0–14, the two 3DObjPos blocks (skater COM and board, with
+/// relative speeds and the sign-flip bits), Jitter, Contacts 1/2/6, Rail 0/1, OffBoard 0; the
+/// board owner inputs (`grain_bed.rs`). Left at their free-skate 0: VU (no output meter; only the
+/// ambience reads it, not native yet), Menu / NIS / HOM / Challenge / Speech flags (no such modes
+/// in free skate), HandGrabs, Music.in3/6 (combo emphasis, not wired).
+/// `SKATE_AEMS_REVERB_ZONES=0`: the reverb preset from the region layer only.
+fn reverb_zones_requested() -> bool {
+    !std::env::var("SKATE_AEMS_REVERB_ZONES").is_ok_and(|v| v == "0")
+}
+
+/// `SKATE_AEMS_REVERB_INPUTS=0` keeps the fixed Reverb.in5 = 32767 (no env scale).
+fn reverb_inputs_requested() -> bool {
+    !std::env::var("SKATE_AEMS_REVERB_INPUTS").is_ok_and(|v| v == "0")
+}
+
+/// `SKATE_AEMS_SEAM_PULSE=0` turns off Class_Seams' console cadence (Listening test 9).
+fn seam_pulse_requested() -> bool {
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ON.get_or_init(|| !std::env::var("SKATE_AEMS_SEAM_PULSE").is_ok_and(|v| v == "0"))
+}
+
+pub(super) fn mixmap_frame(
+    native: Option<ResMut<Native>>,
+    cues: Res<super::skate_events::Cues>,
+    listener: Query<&GlobalTransform, With<super::GameAudioListener>>,
+    time: Res<Time<Real>>,
+    fixed: Res<Time<Fixed>>,
+    menu: Option<Res<crate::graphics_menu::Menu>>,
+    replay: Res<crate::replay::Replay>,
+) {
+    let _timing = super::timing::scope(&super::timing::MIXMAP_FRAME);
+    let Some(mut native) = native else { return };
+    let native = &mut *native;
+    let Some(m) = &mut native.mixmap else { return };
+    for id in 1..=4 {
+        m.set_input(keys::MASTER, id, 32767);
+    }
+    for id in [1, 2, 5] {
+        m.set_input(keys::MUSIC, id, 32767);
+    }
+    // SFXObj_Reverb's first step (`sub_824DF468`): Reverb.in0..6 from the number of the preset
+    // being faded to (in5 = reverb11/12/15/16/22, which ducks the global env scale out4 by 4 dB).
+    // `SKATE_AEMS_REVERB_INPUTS=0`: the old fixed in5 = 32767 and no scale.
+    let reverb = reverb_inputs_requested().then(|| super::timing::lock(&native.shared, &super::timing::GAME_LOCK).ok().map(|r| r.mixer.buses.env.reverb_inputs())).flatten();
+    match reverb {
+        Some(v) => {
+            for (id, x) in v.into_iter().enumerate() {
+                m.set_input(keys::REVERB, id, x);
+            }
+        }
+        None => m.set_input(keys::REVERB, 5, 32767),
+    }
+    let silenced = super::silenced(menu.as_deref(), &replay);
+    m.set_input(keys::PAUSE, 0, if silenced { 32767 } else { 0 });
+
+    // Inputs, components and the tick run only on frames that tick (retail: once per 60 Hz frame),
+    // so one-frame pulses (landing, surface change, push) always reach an evaluation.
+    native.mix_clock = (native.mix_clock + time.delta_secs()).min(4.0 * MIX_STEP);
+    let ticks = (native.mix_clock / MIX_STEP) as usize;
+    // Class_Seams on the console's 30 fps process cadence at the rendered board's wheels, on every
+    // rendered frame (Listening test 9). `SKATE_AEMS_SEAM_PULSE=0`: its whole process per 60 Hz tick
+    // at the physics positions, as before.
+    if let Some(player) = &mut native.player {
+        let console = seam_pulse_requested();
+        player.seam_console = console;
+        player.seam_alpha = console.then(|| fixed.overstep_fraction());
+        if console {
+            if let Ok(mut runtime) = super::timing::lock(&native.shared, &super::timing::GAME_LOCK) {
+                player.seam_frame(m, &cues.riding.audio, time.delta_secs(), &mut runtime);
+            }
+        }
+    }
+    if ticks == 0 {
+        return;
+    }
+    native.mix_clock -= ticks as f32 * MIX_STEP;
+    // sub_82491180 on every second game frame (both halves when the frame is longer than 20 ms):
+    // the jittered eEQChain buses take the walk's values and every bus may re-roll again.
+    native.mix_frames += 1;
+    if native.mix_frames % 2 == 0 || ticks > 1 {
+        let jitter = native.player.as_ref().and_then(|p| p.eq_jitter());
+        if let Ok(mut runtime) = native.shared.lock() {
+            runtime.mixer.buses.eq.clear(jitter);
+        }
+    }
+    let s = cues.riding.audio;
+    if let Some(player) = &mut native.player {
+        let dt = ticks as f32 * MIX_STEP;
+        let l = listener.single().ok().map(|t| player.listener(t.translation().to_array(), t.forward().as_vec3().to_array(), dt, &s));
+        player.write_inputs(m, &s, l.as_ref());
+    }
+    // With the native rolling layers the owner's surface routing (player::rolling) writes
+    // SkateBoard inputs 0 / 6 and drives the bed's binds; otherwise the bed routes itself.
+    let routing = native.player.as_ref().is_some_and(|p| p.components && p.rolling_on);
+    if let Some(bed) = &mut native.bed {
+        bed.write_inputs(m, &s, !routing);
+    }
+    let speed_scale = native.bed.as_ref().and_then(|b| b.push_scale());
+    let loose = super::player_audio::PlayerAudio::loose_board(&s, &cues.riding);
+    if let (Some(player), Ok(mut runtime)) = (&mut native.player, super::timing::lock(&native.shared, &super::timing::GAME_LOCK)) {
+        player.process(m, &s, &mut runtime, speed_scale, loose);
+    }
+    for _ in 0..ticks {
+        m.tick(MIX_STEP);
+    }
+    if let (Some(player), Ok(mut runtime)) = (&mut native.player, super::timing::lock(&native.shared, &super::timing::GAME_LOCK)) {
+        player.update(m, &s, &mut runtime, speed_scale, loose);
+    }
+    // SFXObj_Reverb's update (`sub_824DF220`): the FlangeSub returns' levels and the global env
+    // scale (manager +104 = out4) from the Reverb owner.
+    if let Ok(mut runtime) = super::timing::lock(&native.shared, &super::timing::GAME_LOCK) {
+        runtime.mixer.buses.flange.frame(std::array::from_fn(|i| m.level(keys::REVERB, i)));
+        if reverb.is_some() {
+            runtime.mixer.buses.env.scale_frame(m.level(keys::REVERB, 4));
+        }
+    }
+}
+
+fn start(
+    mut commands: Commands,
+    settings: Option<Res<super::AudioSettings>>,
+    library: Option<Res<Library>>,
+    mut streams: ResMut<Assets<NativeStream>>,
+) {
+    let (Some(settings), Some(library)) = (settings, library) else { return };
+    if !requested(&settings) {
+        return;
+    }
+    match Native::start(&library) {
+        Ok(native) => {
+            info!("Game audio: native AEMS runtime on ({} projects)", library.aems().projects.len());
+            let handle = streams.add(NativeStream { shared: native.shared.clone() });
+            // ONCE, not LOOP: the stream never ends, and Bevy's LOOP wraps it in rodio's
+            // `repeat_infinite`, i.e. `Buffered`, which renders 32768 samples (64 blocks, 341 ms)
+            // at a time inside the device callback and keeps every chunk forever: a lock burst of
+            // 64 renders every 341 ms (game-thread stalls = the 19:01 stutter), up to 341 ms of
+            // event-to-sound latency and ~23 MB/min of memory growth.
+            commands.spawn((NativeOutput, AudioPlayer(handle), PlaybackSettings::ONCE.with_volume(Volume::Linear(0.0))));
+            commands.insert_resource(native);
+        }
+        Err(error) => warn!("Game audio: native AEMS runtime unavailable, using the measured tables: {error}"),
+    }
+}
+
+/// Master volume on the stream; inside it the AEMS voices (world emitters: ambience) and the
+/// rolling bed (effects) take their category volumes. Pause while silenced.
+fn follow_volume(
+    settings: Option<Res<super::AudioSettings>>,
+    native: Option<Res<Native>>,
+    menu: Option<Res<crate::graphics_menu::Menu>>,
+    replay: Res<crate::replay::Replay>,
+    mut sinks: Query<&mut AudioSink, With<NativeOutput>>,
+    voices: Option<ResMut<super::Voices>>,
+    mut listeners: Query<&mut SpatialListener, With<super::GameAudioListener>>,
+) {
+    let Some(settings) = settings else { return };
+    // rodio 0.20's spatial source gives the ear FARTHER from the source the larger factor
+    // (((d_left - d_right) / gap + 1) / 4 + 0.5 on the left channel), so with the ears where Bevy
+    // puts them every interim positional sound is mirrored. With the native host on, swap the
+    // ears so interim sounds come from the side native voices (Pan2D1) put them on.
+    for mut listener in &mut listeners {
+        let gap = listener.left_ear_offset.distance(listener.right_ear_offset);
+        let want = if native.is_some() { Vec3::X * gap / 2.0 } else { Vec3::X * gap / -2.0 };
+        if listener.left_ear_offset != want {
+            listener.left_ear_offset = want;
+            listener.right_ear_offset = -want;
+        }
+    }
+    let silenced = super::silenced(menu.as_deref(), &replay);
+    let volume = settings.master().clamp(0.0, 1.0);
+    // The interim cues are measured retail level × RETAIL_SCALE (anchored to the interim rolling
+    // loop); with the native player sounds (retail level) they drop back to the measured level.
+    let native_player = native.as_deref().is_some_and(|n| n.player.as_ref().is_some_and(|p| p.components));
+    if let Some(mut voices) = voices {
+        let scale = if native_player { 1.0 / super::cues::RETAIL_SCALE } else { 1.0 };
+        if voices.scale != scale {
+            voices.scale = scale;
+        }
+        // Interim and native voices share the ears: fold the interim ones like native voices.
+        let fold = native.is_some();
+        if voices.native_fold != fold {
+            voices.native_fold = fold;
+        }
+    }
+    if let Some(native) = native {
+        if let Ok(mut runtime) = native.shared.lock() {
+            runtime.aems_gain = settings.category(super::Category::Ambience).clamp(0.0, 1.0);
+            runtime.player_gain = settings.category(super::Category::Effects).clamp(0.0, 1.0);
+            runtime.grains.gain = settings.category(super::Category::Effects).clamp(0.0, 1.0);
+        }
+    }
+    for mut sink in &mut sinks {
+        sink.set_volume(Volume::Linear(volume));
+        if silenced && !sink.is_paused() {
+            sink.pause();
+        } else if !silenced && sink.is_paused() {
+            sink.play();
+        }
+    }
+}
+
+/// The reverb preset (`SFXObj_Reverb`, `sub_824DE548`): the district's `audio_reverb` region at the
+/// skater's x, z (reverb01 when none), crossfaded over 1 s of game time; per frame.
+pub(super) fn reverb_frame(
+    native: Option<Res<Native>>,
+    library: Option<Res<Library>>,
+    map: Res<crate::map_transition::CurrentMap>,
+    cues: Res<super::skate_events::Cues>,
+    time: Res<Time<Real>>,
+    listener: Query<&GlobalTransform, With<super::GameAudioListener>>,
+    zones: Res<super::emitters::ReverbZones>,
+) {
+    let (Some(native), Some(library)) = (native, library) else { return };
+    let district = map.path.as_deref().and_then(|p| p.file_stem()).and_then(|s| s.to_str()).unwrap_or("");
+    let at = cues.riding.board;
+    let key = library.region_key(district, "audio_reverb", at.x, at.z).unwrap_or(skate_audio::bus::env::DEFAULT_PRESET);
+    let camera = listener.single().ok().map(|t| skate_audio::bus::zones::Camera {
+        position: t.translation().to_array(),
+        forward: t.forward().as_vec3().to_array(),
+    });
+    if let Ok(mut runtime) = native.shared.lock() {
+        let env = &mut runtime.mixer.buses.env;
+        if env.enabled() {
+            // SFXObj_Reverb's update (`sub_824DE548`) in retail's order, with the reverb-zone
+            // emitters the listener is in (`emitters::reverb_zones`; `SKATE_AEMS_REVERB_ZONES=0`: none).
+            let zones = if reverb_zones_requested() { &zones.zones[..] } else { &[] };
+            env.update(time.delta_secs().clamp(0.0, 0.25), key, zones, camera.as_ref());
+        }
+    }
+}
+
+/// The `c_emitter` azimuth word for a source seen from the listener: 0 = straight ahead,
+/// increasing clockwise (to the right), 65536 = 360°.
+pub(crate) fn azimuth(listener: &GlobalTransform, source: Vec3) -> i32 {
+    let local = listener.affine().inverse().transform_point3(source);
+    // Bevy cameras look down −Z with +X to the right.
+    let degrees = local.x.atan2(-local.z).to_degrees();
+    ((degrees / 360.0 * 65536.0).round() as i32).rem_euclid(65536)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn azimuth_is_clockwise_from_the_view_direction() {
+        let listener = GlobalTransform::from(Transform::from_xyz(0.0, 0.0, 0.0));
+        assert_eq!(azimuth(&listener, Vec3::new(0.0, 0.0, -5.0)), 0);
+        assert_eq!(azimuth(&listener, Vec3::new(5.0, 0.0, 0.0)), 16384);
+        assert_eq!(azimuth(&listener, Vec3::new(-5.0, 0.0, 0.0)), 49152);
+        assert_eq!(azimuth(&listener, Vec3::new(0.0, 0.0, 5.0)), 32768);
+        // Turned to face +X, a source at +X is ahead.
+        let turned = GlobalTransform::from(Transform::from_xyz(1.0, 0.0, 0.0).looking_at(Vec3::new(10.0, 0.0, 0.0), Vec3::Y));
+        assert_eq!(azimuth(&turned, Vec3::new(10.0, 0.0, 0.0)), 0);
+    }
+
+    fn native(mixmap: Option<MixMap>) -> Native {
+        Native {
+            shared: Arc::new(Mutex::new(Runtime::new())),
+            banks: HashMap::new(),
+            emitter_class: None,
+            mixmap,
+            mix_clock: 0.0,
+            mix_frames: 0,
+            player: None,
+            emitter_states: [false; EMITTER_STATES],
+            bed: None,
+        }
+    }
+
+    #[test]
+    fn emitter_words_without_a_mixmap_keep_the_old_defaults() {
+        let n = native(None);
+        assert_eq!(n.emitter_payload(Some(0), 0.5, 16384, 81), [32767, 16384, 0, 16384, 4096, 25000, 0, 0, 81]);
+        assert_eq!(n.emitter_payload(None, 3.0, 0, 900)[1], 32767);
+        assert_eq!(n.emitter_payload(None, -1.0, 0, -4)[..2], [32767, 0]);
+        assert_eq!(n.emitter_payload(None, 0.0, 0, -4)[8], 0);
+    }
+
+    #[test]
+    fn emitter_states_are_the_five_mixmap_instances() {
+        let mut n = native(None);
+        let got: Vec<_> = (0..6).map(|_| n.claim_emitter_state()).collect();
+        assert_eq!(got, vec![Some(0), Some(1), Some(2), Some(3), Some(4), None]);
+        n.release_emitter_state(2);
+        assert_eq!(n.claim_emitter_state(), Some(2));
+    }
+
+    /// With the retail MixMap (when the private install has it): a positional emitter's dry word is
+    /// out4 (−600 mB + the Global ducks' rest) × level, the pan is the B0 azimuth we wrote, the
+    /// send rolls off with camera distance (4 → 70 m) and the filter stays open.
+    #[test]
+    fn emitter_words_from_the_retail_mixmap() {
+        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/private/audio/aems/MixMapSK8.mxb");
+        let Ok(bytes) = std::fs::read(path) else {
+            eprintln!("skipped: no {path}");
+            return;
+        };
+        let mut n = native(Some(MixMap::from_bytes(&bytes).unwrap()));
+        let g = n.claim_emitter_state().unwrap();
+        let listener = GlobalTransform::from(Transform::from_xyz(0.0, 0.0, 0.0));
+        let source = Vec3::new(10.0, 0.0, 0.0);
+        n.set_emitter_position(g, &listener, Vec3::ZERO, source);
+        let m = n.mixmap.as_mut().unwrap();
+        for id in 1..=4 {
+            m.set_input(keys::MASTER, id, 32767);
+        }
+        for _ in 0..3 {
+            m.tick(MIX_STEP);
+        }
+        let near = n.emitter_payload(Some(g), 1.0, 0, 81);
+        assert_eq!(near[1], 16365);
+        assert_eq!(near[3], 16384, "pan = the azimuth written");
+        assert_eq!((near[4], near[5], near[8]), (4096, 24971, 81));
+        assert!(near[2] > 0);
+        assert_eq!(n.emitter_payload(Some(g), 0.5, 0, 81)[1], 16365 / 2);
+        n.set_emitter_position(g, &listener, Vec3::ZERO, Vec3::new(100.0, 0.0, 0.0));
+        n.mixmap.as_mut().unwrap().tick(MIX_STEP);
+        let far = n.emitter_payload(Some(g), 1.0, 0, 81);
+        assert_eq!(far[2], 0, "beyond 70 m the send is silent");
+        assert_eq!(far[1], near[1], "the dry level has no distance roll-off");
+    }
+
+    /// The stutter of the 19:01 build: a looped (`repeat_infinite`) stream renders 64 blocks on
+    /// its first pull; played once it renders one block per 256 frames.
+    #[test]
+    fn the_stream_renders_one_block_per_pull_unless_looped() {
+        let looped = NativeStream { shared: Arc::new(Mutex::new(Runtime::new())) };
+        let mut source = looped.decoder().repeat_infinite();
+        source.next();
+        assert_eq!(looped.shared.lock().unwrap().blocks, 64, "Buffered pulls 32768 samples");
+        let once = NativeStream { shared: Arc::new(Mutex::new(Runtime::new())) };
+        let mut source = once.decoder();
+        source.next();
+        assert_eq!(once.shared.lock().unwrap().blocks, 1);
+    }
+
+    #[test]
+    fn the_stream_pulls_blocks_from_the_runtime() {
+        let stream = NativeStream { shared: Arc::new(Mutex::new(Runtime::new())) };
+        let mut decoder = stream.decoder();
+        let samples: Vec<f32> = (&mut decoder).take(4 * skate_audio::BLOCK).collect();
+        assert!(samples.iter().all(|&s| s == 0.0));
+        assert_eq!(stream.shared.lock().unwrap().blocks, 2);
+        assert_eq!((decoder.channels(), decoder.sample_rate()), (2, 48000));
+    }
+}
diff --git a/crates/skate-game/src/game_audio/player_audio.rs b/crates/skate-game/src/game_audio/player_audio.rs
new file mode 100644
index 00000000..3234859b
--- /dev/null
+++ b/crates/skate-game/src/game_audio/player_audio.rs
@@ -0,0 +1,961 @@
+//! The local player's sounds on the native runtime (`skate_audio::player`), hosted per 60 Hz
+//! frame by `native::mixmap_frame`:
+//! 1. inputs: PlayerPhysics, the two 3DObjPos blocks, Jitter, Contacts, Rail, OffBoard;
+//! 2. components' process (posts / releases) — before the MixMap tick;
+//! 3. components' update (packets rewritten from the MixMap outputs, redelivered) — after it.
+//!
+//! The player components (Class_grind, SenseOfSpeed rattle / wind, Class_foot_drag) run when the
+//! native runtime is on unless `SKATE_AEMS_PLAYER=0`; their interim cues in `skate_events.rs`
+//! (the metal GRINDS loop, the sense_of_speed bed cue, the foot-drag pieces) are then silent. The
+//! default path (native off) is unchanged.
+use std::collections::HashMap;
+
+use skate_audio::eval::NodeId;
+use skate_audio::mixmap::{MixMap, keys};
+use skate_audio::player::collision::{self as collisions, CollisionManager};
+use skate_audio::player::components::{self, Command, FootDrag, Grind, SenseOfSpeed, Skid, Slot, Squeaks};
+use skate_audio::player::contacts::{self as board_contacts, ContactsTuning};
+use skate_audio::player::inputs::{self, Contacts, Physics};
+use skate_audio::player::jitter::Jitter;
+use skate_audio::player::objpos::{Listener, ObjPos};
+use skate_audio::player::tuning::PlayerTuning;
+use skate_audio::player::clothing::{Clothing, ClothingTuning};
+use skate_audio::player::footsteps::{FootstepTuning, Footsteps, LandingBucket};
+use skate_audio::player::globals::Globals;
+use skate_audio::player::rolling::{self, BoardSlide, Rattle, Rolling, RollingInputs, Routed};
+use skate_audio::player::treatment::{self, Treatment, TreatmentGlobals};
+use skate_audio::player::tricks::{self, Tricks};
+use skate_audio::player::wheels::{Wheels, WheelsTuning};
+use skate_audio::player::{AudioState, Owner};
+use skate_audio::runtime::Runtime;
+
+/// Whether the native player components run (with the native runtime on).
+pub(crate) fn components_requested() -> bool {
+    !std::env::var("SKATE_AEMS_PLAYER").is_ok_and(|v| v == "0" || v.eq_ignore_ascii_case("false"))
+}
+
+pub(crate) struct PlayerAudio {
+    pub(crate) tuning: PlayerTuning,
+    physics: Physics,
+    contacts: Contacts,
+    jitter: Jitter,
+    positions: [ObjPos; 2],
+    was_grinding: bool,
+    last_camera: Option<[f32; 3]>,
+    /// The components run (banks loaded, classes bound).
+    pub(crate) components: bool,
+    grind: Grind,
+    speed: SenseOfSpeed,
+    foot_drag: FootDrag,
+    skid: Skid,
+    squeaks: Squeaks,
+    /// `Class_Seams` (the wheels' seam / crack hits, `Seams_Bank`).
+    seams: skate_audio::player::seams::Seams,
+    /// The rendered board's interpolation factor for this call (the fixed step's overstep fraction):
+    /// Class_Seams reads the wheel positions interpolated between the last two physics samples, as
+    /// retail's per-rendered-frame process does (Listening test 9). `None`: the physics positions.
+    pub(crate) seam_alpha: Option<f32>,
+    /// The last two physics samples of the wheel positions (previous, current).
+    seam_wheels: Option<([[f32; 3]; 4], [[f32; 3]; 4])>,
+    /// Class_Seams on the console's 30 fps process cadence ([`Self::seam_frame`]); off: its whole
+    /// process once per 60 Hz tick (before Listening test 9).
+    pub(crate) seam_console: bool,
+    /// `SFXObj_Contacts`' Splice one-shots (pops, landings, touchdowns); on when the install has
+    /// the `Skate_Collisions` patch tree ([`PlayerAudio::contacts_on`]).
+    board: board_contacts::Contacts,
+    pub(crate) contact_tuning: ContactsTuning,
+    pub(crate) contacts_on: bool,
+    /// The collision manager (`CSTATEMGR_Collision`): the contact pairs the board contacts post
+    /// (grind start, landing pair, deck impacts); on with the contacts.
+    collision: CollisionManager,
+    /// `SFXObj_Wheels` (the spin-down streams); on when the install has both recordings
+    /// ([`WHEEL_STREAMS`], decoded at start).
+    wheels: Wheels,
+    wheels_tuning: WheelsTuning,
+    pub(crate) wheels_on: bool,
+    /// `SFXObj_SkateBoard`'s rolling layers (`player::rolling`): the two-truck surface routing with
+    /// its Class_rolling patches and held layers (on with `PatchBank_Rolling_Surfaces`), the rattle
+    /// (`Rolling_Rattles`) and the loose-board slide (`board_scrapes`).
+    rolling: Rolling,
+    rattle: Rattle,
+    slide: BoardSlide,
+    pub(crate) rolling_on: bool,
+    pub(crate) rattle_on: bool,
+    pub(crate) slide_on: bool,
+    /// The routing's grain binds / stops since the bed last took them (the bed follows the
+    /// routing while [`PlayerAudio::rolling_on`]).
+    pub(crate) routed: Routed,
+    /// The Tricks component (Class_Flips, cloth_trick; `Sk8_Air_Flip_Tricks`, `Foley_Cloth`) and
+    /// Class_Treatment (`Treatments`), each on when its banks are in the install.
+    tricks: Tricks,
+    treatment: Treatment,
+    pub(crate) tricks_on: bool,
+    pub(crate) treatment_on: bool,
+    /// The game-mode globals those read (free skate).
+    globals: Globals,
+    /// SFXObj_OffBoard's footsteps (packets + the foot-down / walking / jump Splice sounds) and the
+    /// Clothing component (cloth falls, push foley, body slide): on with the board contacts (their
+    /// Splice banks) — `SKATE_AEMS_FOOTSTEPS=0` keeps the interim steps.
+    footsteps: Footsteps,
+    footstep_tuning: FootstepTuning,
+    clothing: Clothing,
+    clothing_tuning: ClothingTuning,
+    pub(crate) footsteps_on: bool,
+    /// `+300` the landing bucket (it reads the resolved audio trick), this frame's value.
+    landing: LandingBucket,
+    landing_bucket: i32,
+    /// The last listener the position writers used (the collision slots' 3-D blocks).
+    last_listener: Option<Listener>,
+    nodes: HashMap<Slot, NodeId>,
+    classes: HashMap<&'static str, usize>,
+    /// Commands of the last frame (for the log on change and the tests).
+    pub(crate) posts: u64,
+}
+
+impl PlayerAudio {
+    pub(crate) fn new(tuning: PlayerTuning, components: bool) -> Self {
+        let jitter = Jitter::new(&tuning.jitter, skate_audio::grain::GrainBed::SEED);
+        // The collision voices play through their Collision SubMix (`sub_824D25E0`: mono, env send
+        // at the category's Collision output, eEQChain bus); `SKATE_AEMS_SUBMIX=0` = straight into
+        // SFX Master as before.
+        let mut collision = CollisionManager::default();
+        collision.submix = !std::env::var("SKATE_AEMS_SUBMIX").is_ok_and(|v| v == "0");
+        Self {
+            tuning,
+            physics: Physics::default(),
+            contacts: Contacts::default(),
+            jitter,
+            positions: [ObjPos::default(); 2],
+            was_grinding: false,
+            last_camera: None,
+            components,
+            grind: Grind::default(),
+            speed: SenseOfSpeed::default(),
+            foot_drag: FootDrag::default(),
+            skid: Skid::default(),
+            squeaks: Squeaks::default(),
+            seams: Default::default(),
+            seam_alpha: None,
+            seam_wheels: None,
+            seam_console: false,
+            board: board_contacts::Contacts::default(),
+            contact_tuning: ContactsTuning::default(),
+            contacts_on: false,
+            collision,
+            wheels: Wheels::default(),
+            wheels_tuning: WheelsTuning::default(),
+            wheels_on: false,
+            rolling: Rolling::default(),
+            rattle: Rattle::default(),
+            slide: BoardSlide::default(),
+            rolling_on: false,
+            rattle_on: false,
+            slide_on: false,
+            routed: Routed::default(),
+            tricks: Tricks::default(),
+            treatment: Treatment::default(),
+            tricks_on: false,
+            treatment_on: false,
+            globals: Globals::default(),
+            footsteps: Footsteps::default(),
+            footstep_tuning: FootstepTuning::default(),
+            clothing: Clothing::default(),
+            clothing_tuning: ClothingTuning::default(),
+            footsteps_on: false,
+            landing: LandingBucket::default(),
+            landing_bucket: 1,
+            last_listener: None,
+            nodes: HashMap::new(),
+            classes: HashMap::new(),
+            posts: 0,
+        }
+    }
+
+    /// The materials' footstep layers (`Library::footstep_materials`).
+    pub(crate) fn set_footstep_materials(&mut self, materials: Vec<skate_audio::player::footsteps::FootstepMaterial>) {
+        self.footstep_tuning.materials = materials;
+    }
+
+    /// The listener as the position controllers see it: the camera (position, view, velocity from
+    /// the last frame) and the followed point (the skater's COM).
+    /// `dt`: the time since the last call.
+    pub(crate) fn listener(&mut self, camera: [f32; 3], view: [f32; 3], dt: f32, s: &AudioState) -> Listener {
+        let velocity = match self.last_camera {
+            Some(last) if dt > 0.0 => std::array::from_fn(|i| (camera[i] - last[i]) / dt),
+            _ => [0.0; 3],
+        };
+        self.last_camera = Some(camera);
+        Listener {
+            camera,
+            view,
+            camera_velocity: velocity,
+            followed: s.com_position,
+            // Frame B's direction is only read by the skater-frame azimuth (input 2), which no B
+            // lookup of the MixMap uses; the COM velocity stands in for the facing.
+            facing: s.com_velocity,
+            followed_velocity: s.com_velocity,
+        }
+    }
+
+    /// Step 1: every input the player's writers supply (mixmap-spec §7).
+    pub(crate) fn write_inputs(&mut self, m: &mut MixMap, s: &AudioState, listener: Option<&Listener>) -> bool {
+        self.last_listener = listener.copied();
+        self.physics.write(m, s);
+        if let Some(l) = listener {
+            // 60010010 follows the skater (COM, COM velocity); 60010020 the board (deck, its
+            // velocity), as `sub_824B0C48` binds them.
+            self.positions[0].write(m, keys::obj_pos(0), l, Some((s.com_position, s.com_velocity)));
+            self.positions[1].write(m, keys::obj_pos2(0), l, Some((s.board_position, s.board_velocity)));
+        }
+        for (id, word) in self.jitter.process() {
+            m.set_input(keys::JITTER, id, word);
+        }
+        let landed = self.contacts.write(m, s, &self.tuning);
+        inputs::write_rail(m, s.grinding, self.was_grinding);
+        self.was_grinding = s.grinding;
+        inputs::write_off_board(m, s);
+        landed
+    }
+
+    fn apply(&mut self, rt: &mut Runtime, cmds: Vec<Command>) {
+        for cmd in cmds {
+            match cmd {
+                Command::Post { slot, class, words } => {
+                    let id = *self.classes.entry(class).or_insert_with(|| rt.eval.class_id(class).unwrap_or(usize::MAX));
+                    if id == usize::MAX {
+                        continue;
+                    }
+                    if let Some(old) = self.nodes.remove(&slot) {
+                        rt.release(old);
+                    }
+                    self.nodes.insert(slot, rt.post(id, &words));
+                    self.posts += 1;
+                    bevy::log::info!("AUDIO_NATIVE post {class} {slot:?} words={words:?}");
+                }
+                Command::Redeliver { slot, words } => {
+                    if let Some(&node) = self.nodes.get(&slot) {
+                        rt.redeliver(node, &words);
+                    }
+                }
+                Command::Release { slot } => {
+                    if let Some(node) = self.nodes.remove(&slot) {
+                        rt.release(node);
+                        bevy::log::info!("AUDIO_NATIVE release {slot:?}");
+                    }
+                }
+            }
+        }
+    }
+
+    /// The state with the host-resolved fields (`+348` / `+352` the audio tricks of the scorable).
+    fn resolved(&self, s: &AudioState) -> AudioState {
+        let mut s = *s;
+        let name = usize::try_from(s.scorable).ok().and_then(|id| skate_core::scoring::catalog::IDENTIFIERS.get(id)).map(|(name, ..)| name);
+        s.audio_trick = name.map_or(-1, |n| self.tuning.audio_trick(n));
+        s.audio_trick_2 = name.map_or(-1, |n| self.tuning.audio_trick_2(n));
+        s
+    }
+
+    /// The loose-board state (`+780`, `rolling::loose_board`): the deck in contact while the rider
+    /// bails or walks, by how the deck lies (`skate_events::Riding`: `up_dot` = SkateboardReckoning
+    /// +80 · Ground+80, the deck contact Collision+3475 and its material Collision+12 − 1).
+    pub(crate) fn loose_board(s: &AudioState, riding: &super::skate_events::Riding) -> u32 {
+        rolling::loose_board(s.bail || s.on_foot, riding.deck_contact, riding.deck_material, riding.deck_up)
+    }
+
+    /// The six jitter values the jittered eEQChain buses 5–7 read (`sub_82491180`), when the
+    /// install's tuning names all six channels.
+    pub(crate) fn eq_jitter(&self) -> Option<[f32; 6]> {
+        let idx = self.tuning.eq_jitter;
+        if idx.iter().any(Option::is_none) {
+            return None;
+        }
+        let mut out = [0.0f32; 6];
+        for (o, i) in out.iter_mut().zip(idx) {
+            *o = self.jitter.channels.get(i?)?.value;
+        }
+        Some(out)
+    }
+
+    /// Class_Seams' hits so far and how many were material changes (diagnostics, e2e).
+    #[cfg(test)]
+    pub(crate) fn seam_hits(&self) -> (u64, u64) {
+        (self.seams.hits, self.seams.transitions)
+    }
+
+    fn seam_commands(cmds: Vec<skate_audio::player::seams::SeamCommand>) -> Vec<Command> {
+        use skate_audio::player::seams::{CLASS, SeamCommand};
+        cmds.into_iter()
+            .map(|c| match c {
+                SeamCommand::Post { wheel, words } => Command::Post { slot: Slot::Seam(wheel as u8), class: CLASS, words },
+                SeamCommand::Redeliver { wheel, words } => Command::Redeliver { slot: Slot::Seam(wheel as u8), words },
+                // Scheduled on the audio clock by `seam_frame`; never reaches here.
+                SeamCommand::RedeliverAt { wheel, words, .. } => Command::Redeliver { slot: Slot::Seam(wheel as u8), words },
+            })
+            .collect()
+    }
+
+    /// Step 2 (before the tick): the components' process. `speed_scale`: the bed's push
+    /// speed-scale envelope while it runs; `loose`: the loose-board state ([`Self::loose_board`]).
+    pub(crate) fn process(&mut self, m: &mut MixMap, s: &AudioState, rt: &mut Runtime, speed_scale: Option<f32>, loose: u32) {
+        if !self.components {
+            return;
+        }
+        let m_mut = m;
+        let mut resolved = self.resolved(s);
+        self.landing_bucket = self.landing.update(resolved.com_velocity[1], resolved.offboard_air, resolved.trick_active, resolved.audio_trick);
+        resolved.landing_bucket = self.landing_bucket;
+        let s = &resolved;
+        let mut rolling_cmds = Vec::new();
+        if self.rolling_on {
+            // SFXObj_SkateBoard's process: the routing, then the rattle (it reads the routing),
+            // then the board slide; SkateBoard inputs 0 / 6 from the routing.
+            let (cmds, routed) = self.rolling.process(s, &self.tuning, &RollingInputs { speed_scale });
+            rolling_cmds = cmds;
+            let board = keys::skateboard(0);
+            m_mut.set_input(board, 0, if routed.surface_pulse { 32767 } else { 0 });
+            m_mut.set_input(board, 6, if routed.on_metal { 32767 } else { 0 });
+            self.routed.grains.extend(routed.grains);
+            self.routed.primary = routed.primary;
+            self.routed.surface_pulse = routed.surface_pulse;
+            self.routed.on_metal = routed.on_metal;
+        }
+        if self.rattle_on {
+            rolling_cmds.extend(self.rattle.process(s, &self.rolling, &self.tuning.rolling));
+        }
+        if self.slide_on {
+            rolling_cmds.extend(self.slide.process(loose, &self.tuning.rolling));
+        }
+        let seam_state = self.seam_state(s);
+        let seams = if self.seam_console {
+            Self::seam_commands(self.seams.process_tick(&seam_state, &self.tuning, m_mut))
+        } else {
+            Self::seam_commands(self.seams.process(&seam_state, &self.tuning, m_mut))
+        };
+        let m: &MixMap = m_mut;
+        let rail = Owner { mixmap: m, key: keys::rail(0) };
+        let mut cmds = self.grind.process(s, &self.tuning, &rail);
+        cmds.extend(self.speed.process(s));
+        cmds.extend(self.foot_drag.process(s, &self.tuning));
+        let board = Owner { mixmap: m, key: keys::skateboard(0) };
+        cmds.extend(self.skid.process(s, &self.tuning, &board));
+        cmds.extend(self.squeaks.process(s));
+        cmds.extend(seams);
+        cmds.extend(rolling_cmds);
+        if self.tricks_on {
+            cmds.extend(self.tricks.process(s, &self.tuning.tricks, &self.globals, &Owner { mixmap: m, key: keys::tricks(0) }));
+        }
+        if self.treatment_on {
+            cmds.extend(self.treatment.process(s, &self.tuning.treatment, &self.globals, &Owner { mixmap: m, key: keys::treatments(0) }));
+        }
+        self.apply(rt, cmds);
+        if self.contacts_on {
+            let before = self.board.starts;
+            self.board.process(s, self.contacts.buckets(), &self.tuning, &self.contact_tuning, &mut rt.splice_host());
+            self.posts += self.board.starts - before;
+            // The collision manager runs after the player's components (its own state manager).
+            let mut host = rt.splice_host();
+            for msg in std::mem::take(&mut self.board.outbox) {
+                self.collision.post(msg, &mut host);
+            }
+            self.collision.process(m_mut, self.last_listener.as_ref());
+        }
+        if self.footsteps_on {
+            let mut cmds = self.footsteps.process(s, &self.tuning, &self.footstep_tuning, &mut rt.splice_host());
+            cmds.extend(self.clothing.process(s, &self.tuning, &self.clothing_tuning, &mut rt.splice_host()));
+            self.apply(rt, cmds);
+        }
+    }
+
+    /// The state Class_Seams reads: with [`Self::seam_alpha`], the wheel positions of the rendered
+    /// board (the last two physics samples interpolated), else the physics sample.
+    fn seam_state(&mut self, s: &AudioState) -> AudioState {
+        let Some(alpha) = self.seam_alpha else { return *s };
+        let now = s.wheel_position;
+        let (prev, cur) = match self.seam_wheels {
+            Some((_, cur)) if cur != now => (cur, now),
+            Some(track) => track,
+            None => (now, now),
+        };
+        self.seam_wheels = Some((prev, cur));
+        let mut out = *s;
+        let u = alpha.clamp(0.0, 1.0);
+        out.wheel_position = std::array::from_fn(|w| std::array::from_fn(|c| prev[w][c] + (cur[w][c] - prev[w][c]) * u));
+        out
+    }
+
+    /// Class_Seams on the console cadence (Listening test 9): called on every rendered frame of
+    /// `dt` seconds, before [`Self::process`] on frames that tick. Runs the seams' process on a 30 Hz
+    /// virtual grid at the rendered wheel positions (`seams::Seams::frame`) and their update once
+    /// per console frame; the tick only creates the packets and writes Cracks.in0. Needs
+    /// [`Self::seam_console`].
+    pub(crate) fn seam_frame(&mut self, m: &MixMap, s: &AudioState, dt: f32, rt: &mut Runtime) {
+        if !self.components || !self.seam_console {
+            return;
+        }
+        let seam_state = self.seam_state(s);
+        let calls = self.seams.calls;
+        let (now, later): (Vec<_>, Vec<_>) = self
+            .seams
+            .frame(&seam_state, &self.tuning, dt, rt.blocks)
+            .into_iter()
+            .partition(|c| !matches!(c, skate_audio::player::seams::SeamCommand::RedeliverAt { .. }));
+        if !now.is_empty() {
+            self.apply(rt, Self::seam_commands(now));
+        }
+        for c in later {
+            if let skate_audio::player::seams::SeamCommand::RedeliverAt { wheel, words, block } = c {
+                if let Some(&node) = self.nodes.get(&Slot::Seam(wheel as u8)) {
+                    rt.redeliver_at(node, &words, block);
+                }
+            }
+        }
+        // The update half once per console frame too (its turn word slews per packet write), with
+        // the last tick's Cracks outputs.
+        if self.seams.calls != calls {
+            let cracks = Owner { mixmap: m, key: keys::cracks(0) };
+            let cmds = Self::seam_commands(self.seams.update(&seam_state, &cracks));
+            self.apply(rt, cmds);
+        }
+    }
+
+    /// Step 3 (after the tick): the components' update.
+    pub(crate) fn update(&mut self, m: &MixMap, s: &AudioState, rt: &mut Runtime, speed_scale: Option<f32>, loose: u32) {
+        if !self.components {
+            return;
+        }
+        let mut resolved = self.resolved(s);
+        resolved.landing_bucket = self.landing_bucket;
+        let s = &resolved;
+        let rail = Owner { mixmap: m, key: keys::rail(0) };
+        let sos = Owner { mixmap: m, key: keys::sense_of_speed(0) };
+        let contacts = Owner { mixmap: m, key: keys::contacts(0) };
+        let mut cmds = self.grind.update(s, &self.tuning, &rail);
+        cmds.extend(self.speed.update(s, &sos));
+        cmds.extend(self.foot_drag.update(s, &self.tuning, &contacts));
+        let board = Owner { mixmap: m, key: keys::skateboard(0) };
+        cmds.extend(self.skid.update(s, &self.tuning, &board));
+        cmds.extend(self.squeaks.update(s, &board));
+        let cracks = Owner { mixmap: m, key: keys::cracks(0) };
+        // Under the console cadence the seams' update runs in `seam_frame`.
+        if !self.seam_console {
+            cmds.extend(Self::seam_commands(self.seams.update(s, &cracks)));
+        }
+        if self.rolling_on {
+            cmds.extend(self.rolling.update(s, &self.tuning, &RollingInputs { speed_scale }, &board));
+        }
+        if self.rattle_on {
+            cmds.extend(self.rattle.update(&board));
+        }
+        if self.slide_on {
+            cmds.extend(self.slide.update(s, loose, &self.tuning.rolling, &board));
+        }
+        if self.tricks_on {
+            cmds.extend(self.tricks.update(s, &self.tuning.tricks, &Owner { mixmap: m, key: keys::tricks(0) }));
+        }
+        if self.treatment_on {
+            cmds.extend(self.treatment.update(s, &TreatmentGlobals::default(), &self.tuning.treatment, &Owner { mixmap: m, key: keys::treatments(0) }));
+        }
+        self.apply(rt, cmds);
+        if self.contacts_on {
+            self.board.update(s, &contacts, &self.contact_tuning, &mut rt.splice_host());
+            let before = self.collision.starts;
+            self.collision.update(m, &self.tuning.collision, s.dt, &mut rt.splice_host());
+            self.posts += self.collision.starts - before;
+        }
+        if self.footsteps_on {
+            let off = Owner { mixmap: m, key: keys::off_board(0) };
+            let mut cmds = self.footsteps.update(s, &self.tuning, &self.footstep_tuning, &off, &mut rt.splice_host());
+            let cloth = Owner { mixmap: m, key: keys::clothing(0) };
+            cmds.extend(self.clothing.update(s, &self.tuning, &self.clothing_tuning, &cloth, &mut rt.splice_host()));
+            self.apply(rt, cmds);
+        }
+        if self.wheels_on {
+            let owner = Owner { mixmap: m, key: keys::wheels(0) };
+            let before = self.wheels.starts;
+            self.wheels.update(s, &owner, &self.wheels_tuning, &mut rt.stream_host());
+            self.posts += self.wheels.starts - before;
+        }
+    }
+}
+
+/// The banks the components post into.
+pub(crate) const BANKS: &[&str] = components::BANKS;
+/// Optional component banks: a component runs when its first bank loads (the rest add layers).
+pub(crate) const ROLLING_BANKS: &[&str] = &["PatchBank_Rolling_Surfaces", "PatchBank_SpiderCracks", "PatchBank_Objects", "PatchBank_RocksBounce"];
+pub(crate) const RATTLE_BANKS: &[&str] = &["Rolling_Rattles"];
+pub(crate) const SLIDE_BANKS: &[&str] = &["board_scrapes"];
+pub(crate) const TRICKS_BANKS: &[&str] = tricks::BANKS;
+pub(crate) const TREATMENT_BANKS: &[&str] = treatment::BANKS;
+pub(crate) const OPTIONAL_BANKS: [&[&str]; 5] = [ROLLING_BANKS, RATTLE_BANKS, SLIDE_BANKS, TRICKS_BANKS, TREATMENT_BANKS];
+/// The Splice banks the components play (patch trees from `audio_export.splice_trees`): the board
+/// contacts need the first; the collision manager's metal family and the shoe scuffs use the others
+/// when present.
+pub(crate) const SPLICE_BANKS: &[&str] = &[board_contacts::BANK, collisions::BANKS[1], board_contacts::FOLEY];
+/// `SFXObj_Wheels`' recordings (stream 0 jump, 1 manual) in the manifest's `wheels`.
+pub(crate) const WHEEL_STREAMS: [&str; 2] = ["Whls_spins_Jump_1", "Whls_spins_Man_1"];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use skate_audio::grain::board::{self, BoardInputs, TurnIntensity};
+
+    fn install() -> Option<(super::super::Library, Vec<u8>)> {
+        let root = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets"));
+        let library = super::super::Library::load(root).ok()?;
+        let mxb = library.aems().mixmap.clone()?;
+        let bytes = library.read(&mxb).ok()?;
+        Some((library, bytes))
+    }
+
+    /// Straight rolling at a speed: the skater along +x, the board 0.9 m below the COM, the camera
+    /// 3.5 m behind and 1.4 m above looking ahead; four wheels down; free-skate globals.
+    fn rolling(kmh: f32, turn: f32) -> AudioState {
+        let v = kmh / 3.6;
+        AudioState {
+            ground_speed: v,
+            com_velocity: [v, 0.0, 0.0],
+            com_position: [0.0, 1.0, 0.0],
+            board_position: [0.0, 0.1, 0.0],
+            board_velocity: [v, 0.0, 0.0],
+            wheel_count: 4,
+            wheel_contact: [true; 4],
+            wheel_material: [3; 4],
+            turn,
+            ..Default::default()
+        }
+    }
+
+    fn globals(m: &mut MixMap) {
+        for id in 1..=4 {
+            m.set_input(keys::MASTER, id, 32767);
+        }
+        for id in [1, 2, 5] {
+            m.set_input(keys::MUSIC, id, 32767);
+        }
+        m.set_input(keys::REVERB, 5, 32767);
+    }
+
+    fn median(mut v: Vec<f32>) -> f32 {
+        v.sort_by(f32::total_cmp);
+        v[v.len() / 2]
+    }
+
+    /// The rolling bed's gain A with every input the game now writes (Jitter included), against
+    /// retail's capture (upstream PR #4's transfer table: median gain A 0.06 at 5 km/h, 0.07–0.17 from
+    /// 10 km/h; level(1) p90 0.24). Prints the table (`--nocapture`); asserts only the shape: Jitter
+    /// lowers level(1) a little at most and never raises it.
+    #[test]
+    fn bed_gain_a_with_the_full_inputs() {
+        let Some((library, base)) = install() else { return eprintln!("skipped: no install with a MixMap") };
+        let tuning = library.player_tuning();
+        if tuning.jitter.is_empty() {
+            return eprintln!("skipped: no player_tuning (stage_player_tuning.py)");
+        }
+        let surface = library.grain_tuning("asphalt_smooth_hard").expect("grain tuning");
+        println!("km/h  level(1) no-jitter  level(1) jitter p10/p50/p90   gainA(turn 0)  gainA / gainB (turn 0.5)  level(2)");
+        for kmh in [5.0f32, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0] {
+            let mut out = [Vec::new(), Vec::new()];
+            let mut b_level = Vec::new();
+            let mut turned = Vec::new();
+            let mut turned_b = Vec::new();
+            for (pass, jitter) in [false, true].into_iter().enumerate() {
+                let mut m = MixMap::from_bytes(&base).unwrap();
+                let mut p = PlayerAudio::new(PlayerTuning { jitter: if jitter { tuning.jitter.clone() } else { Vec::new() }, ..tuning.clone() }, false);
+                let mut ti = TurnIntensity::default();
+                for frame in 0..900 {
+                    let s = rolling(kmh, 0.0);
+                    globals(&mut m);
+                    let l = p.listener([-3.5, 2.4, 0.0], [1.0, -0.3, 0.0], 1.0 / 60.0, &s);
+                    p.write_inputs(&mut m, &s, Some(&l));
+                    m.tick(1.0 / 60.0);
+                    if frame >= 300 {
+                        let a = m.level(keys::skateboard(0), 1);
+                        out[pass].push(a as f32 / 32767.0);
+                        if jitter {
+                            b_level.push(m.level(keys::skateboard(0), 2) as f32 / 32767.0);
+                            let i = ti.step(&surface, s.com_speed(), 0.5, false, 1.0);
+                            let rec = board::records(&surface, &BoardInputs {
+                                speed: s.ground_speed, speed_scale: None, level_a: a, level_b: m.level(keys::skateboard(0), 2),
+                                pitch: 4096, turn: i, brake: 0.0, special: false, downhill: 0.0, seam: None,
+                            });
+                            turned.push(rec[0].gain);
+                            turned_b.push(rec[1].gain);
+                        }
+                    }
+                }
+            }
+            let mut j = out[1].clone();
+            j.sort_by(f32::total_cmp);
+            let pct = |q: f32| j[((j.len() - 1) as f32 * q) as usize];
+            println!(
+                "{kmh:4.0}  {:.3}               {:.3} / {:.3} / {:.3}        {:.3}          {:.3} / {:.3}            {:.3}",
+                median(out[0].clone()), pct(0.1), pct(0.5), pct(0.9), median(out[1].clone()), median(turned), median(turned_b), median(b_level)
+            );
+            assert!(pct(0.9) <= median(out[0].clone()) + 1e-3, "Jitter never raises gain A");
+        }
+    }
+
+    /// Diagnostics: the property records each player bank's voices get at open and on change
+    /// (ids 0 pitch, 2 volume, 5 FXWET0 = the env send, 6/7 filters, 8 dry, ≥ 9 routing).
+    #[test]
+    #[ignore = "diagnostic print; needs the install"]
+    fn player_voice_properties() {
+        struct Log<'a> {
+            inner: &'a mut skate_audio::mixer::Mixer,
+            seen: std::collections::BTreeMap<(usize, u8), (i32, i32, u32)>,
+            bank_of: HashMap<u32, usize>,
+        }
+        impl skate_audio::eval::VoiceHost for Log<'_> {
+            fn open(&mut self, r: &skate_audio::eval::OpenRequest) -> Option<u32> {
+                let v = self.inner.open(r)?;
+                self.bank_of.insert(v, r.bank);
+                for &(id, value) in r.inputs {
+                    let e = self.seen.entry((r.bank, id)).or_insert((i32::MAX, i32::MIN, 0));
+                    *e = (e.0.min(value), e.1.max(value), e.2 + 1);
+                }
+                Some(v)
+            }
+            fn release(&mut self, v: u32) { self.inner.release(v) }
+            fn pause(&mut self, v: u32) { self.inner.pause(v) }
+            fn resume(&mut self, v: u32) { self.inner.resume(v) }
+            fn set(&mut self, v: u32, id: u8, value: i32) {
+                if let Some(&b) = self.bank_of.get(&v) {
+                    let e = self.seen.entry((b, id)).or_insert((i32::MAX, i32::MIN, 0));
+                    *e = (e.0.min(value), e.1.max(value), e.2 + 1);
+                }
+                self.inner.set(v, id, value)
+            }
+            fn set_azimuth(&mut self, v: u32, value: i32) { self.inner.set_azimuth(v, value) }
+            fn query(&mut self, v: u32) -> skate_audio::eval::VoiceStatus { self.inner.query(v) }
+        }
+        let Some((library, base)) = install() else { return eprintln!("skipped") };
+        let (mut rt, names) = runtime(&library);
+        let mut m = MixMap::from_bytes(&base).unwrap();
+        let mut p = PlayerAudio::new(library.player_tuning(), true);
+        let mut log = std::collections::BTreeMap::new();
+        let mut bank_of = HashMap::new();
+        for f in 0..600 {
+            let mut s = rolling(if f < 300 { 40.0 } else { 15.0 }, 0.0);
+            s.grinding = (200..400).contains(&f);
+            s.grind_family = 1;
+            s.grind_material = 40;
+            s.brake = (450..520).contains(&f);
+            globals(&mut m);
+            let l = p.listener([s.com_position[0] - 3.5, 2.4, s.com_position[2]], [1.0, -0.3, 0.0], 1.0 / 60.0, &s);
+            p.write_inputs(&mut m, &s, Some(&l));
+            p.process(&mut m, &s, &mut rt, None, 0);
+            m.tick(1.0 / 60.0);
+            p.update(&m, &s, &mut rt, None, 0);
+            for _ in 0..3 {
+                rt.mixer.render(&mut [[0.0; skate_audio::BLOCK]; 6]);
+                let Runtime { eval, mixer, .. } = &mut rt;
+                let mut host = Log { inner: mixer, seen: std::mem::take(&mut log), bank_of: std::mem::take(&mut bank_of) };
+                eval.block(&mut host);
+                log = host.seen;
+                bank_of = host.bank_of;
+            }
+        }
+        for ((bank, id), (lo, hi, n)) in &log {
+            println!("{:<18} id {id:>3}: {lo}..{hi} ({n}×)", names.get(bank).copied().unwrap_or("?"));
+        }
+    }
+
+    /// A runtime with every project, the utility posted (as at boot) and the player banks.
+    fn runtime(library: &super::super::Library) -> (Runtime, HashMap<usize, &'static str>) {
+        use skate_audio::formats::{Bank, Project};
+        let mut rt = Runtime::new();
+        for file in &library.aems().projects {
+            rt.install_project(&Project::parse(file, &library.read(file).unwrap()).unwrap());
+        }
+        let mut names = HashMap::new();
+        for stem in std::iter::once("emitter_utility").chain(BANKS.iter().copied()) {
+            let file = &library.aems().banks[stem];
+            let bank = Bank::parse(stem, library.read(file).unwrap()).unwrap();
+            let id = rt.load_bank(bank, library.bank_pcm(stem));
+            names.insert(id, stem);
+        }
+        let utility = rt.eval.class_id("c_emitter_utility").unwrap();
+        rt.post(utility, &[]);
+        // Retail's second boot utility: the Seams program's sample shuffles (Listening test 8).
+        use skate_audio::player::seams::{UTILITY, UTILITY_BANK};
+        if let Some(file) = library.aems().banks.get(UTILITY_BANK) {
+            let id = rt.load_bank(Bank::parse(UTILITY_BANK, library.read(file).unwrap()).unwrap(), Vec::new());
+            names.insert(id, UTILITY_BANK);
+            rt.post(rt.eval.class_id(UTILITY).unwrap(), &[]);
+        }
+        (rt, names)
+    }
+
+    struct Run {
+        /// Per bank: voice gains (master × dry) over the frames a voice sounded, and opens.
+        gains: HashMap<&'static str, Vec<f32>>,
+        opens: HashMap<&'static str, std::collections::BTreeSet<u32>>,
+        rms_db: f32,
+        posts: u64,
+    }
+
+    /// Drive the player for `frames` 60 Hz frames through the real banks, MixMap and runtime.
+    fn run(library: &super::super::Library, mxb: &[u8], frames: usize, state: impl Fn(usize) -> AudioState) -> Run {
+        let (mut rt, names) = runtime(library);
+        let mut m = MixMap::from_bytes(mxb).unwrap();
+        let mut p = PlayerAudio::new(library.player_tuning(), true);
+        let mut out = vec![0.0f32; 1600];
+        let mut run = Run { gains: HashMap::new(), opens: HashMap::new(), rms_db: 0.0, posts: 0 };
+        let (mut sum, mut n) = (0.0f64, 0usize);
+        for f in 0..frames {
+            let s = state(f);
+            globals(&mut m);
+            let l = p.listener([s.com_position[0] - 3.5, 2.4, s.com_position[2]], [1.0, -0.3, 0.0], 1.0 / 60.0, &s);
+            p.write_inputs(&mut m, &s, Some(&l));
+            p.process(&mut m, &s, &mut rt, None, 0);
+            m.tick(1.0 / 60.0);
+            p.update(&m, &s, &mut rt, None, 0);
+            rt.fill_stereo(&mut out);
+            for v in rt.mixer.snapshot() {
+                if let Some(&stem) = names.get(&v.bank) {
+                    run.gains.entry(stem).or_default().push(v.gain);
+                    run.opens.entry(stem).or_default().insert(v.id);
+                }
+            }
+            sum += out.iter().map(|&x| f64::from(x) * f64::from(x)).sum::<f64>();
+            n += out.len();
+        }
+        run.rms_db = (10.0 * (sum / n.max(1) as f64).max(1e-12).log10()) as f32;
+        run.posts = p.posts;
+        run
+    }
+
+    fn stats(v: &[f32]) -> (f32, f32) {
+        let mut v = v.to_vec();
+        v.sort_by(f32::total_cmp);
+        (v.get(v.len() / 2).copied().unwrap_or(0.0), v.last().copied().unwrap_or(0.0))
+    }
+
+    /// The ported components through the real banks, MixMap and voice graph, headless: what they
+    /// post, how many voices open and at which gain (master × dry), against the retail trace
+    /// (session 20261001_211347 report: per-sample audible level = gain × send, median / max:
+    /// Class_grind GRINDS ≤ 0.28 (medians 0.004–0.11), SenseOfSpeed_wind ≤ 0.54, rattle ≤ 0.28,
+    /// Class_foot_drag FOOT_DRAG ≤ 0.28 (medians 0.002–0.07)). Prints the table (`--nocapture`).
+    #[test]
+    fn components_play_their_retail_banks() {
+        let Some((library, mxb)) = install() else { return eprintln!("skipped: no install with a MixMap") };
+        if !BANKS.iter().all(|b| library.aems().banks.contains_key(*b)) {
+            return eprintln!("skipped: the install lacks the player banks");
+        }
+        let metal = skate_audio::player::state::material_of_tag(9);
+        let concrete = skate_audio::player::state::material_of_tag(3);
+        let cases: Vec<(&str, &str, Box<dyn Fn(usize) -> AudioState>)> = vec![
+            ("grind metal 6 m/s (family 1)", "GRINDS", Box::new(move |_| AudioState { grinding: true, grind_family: 1, grind_material: metal, ..rolling(21.6, 0.0) })),
+            ("grind ledge 6 m/s (family 0)", "GRINDS", Box::new(move |_| AudioState { grinding: true, grind_family: 0, grind_material: concrete, ..rolling(21.6, 0.0) })),
+            ("wind 20 km/h", "sense_of_speed", Box::new(|_| rolling(20.0, 0.0))),
+            ("wind + rattle 40 km/h", "sense_of_speed", Box::new(|_| rolling(40.0, 0.0))),
+            ("wind + rattle 55 km/h", "sense_of_speed", Box::new(|_| rolling(55.0, 0.0))),
+            ("foot drag 4 m/s", "FOOT_DRAG", Box::new(|_| AudioState { brake: true, ..rolling(14.4, 0.0) })),
+        ];
+        println!("case                           bank            posts voices  gain median / max   RMS dBFS");
+        for (name, bank, state) in cases {
+            let r = run(&library, &mxb, 180, state);
+            let (med, max) = stats(r.gains.get(bank).map_or(&[][..], |v| &v[..]));
+            let voices = r.opens.get(bank).map_or(0, |s| s.len());
+            println!("{name:30} {bank:15} {:5} {voices:6}  {med:.3} / {max:.3}       {:.1}", r.posts, r.rms_db);
+            assert!(r.posts > 0, "{name}: nothing posted");
+            assert!(voices > 0, "{name}: no voice opened in {bank}");
+            assert!(max <= 1.0, "{name}: gain above unity");
+        }
+    }
+
+    /// Class_Seams through the real bank and MixMap: rolling over the sidewalk pattern (11) at three
+    /// speeds, the wheels moving along +x. Prints hits, voices and the Seams_Bank voice gains next to
+    /// retail's Seams_Bank level (164620 report: median 0.005, p90 0.095); asserts that hits play,
+    /// stay at or below unity and that the first hit's voice gain equals the later hits' (first-trigger
+    /// rule: the bank is decoded at start, the same path plays every hit).
+    #[test]
+    fn seams_play_their_retail_bank() {
+        let Some((library, mxb)) = install() else { return eprintln!("skipped: no install with a MixMap") };
+        let tuning = library.player_tuning();
+        if tuning.seam_patterns.len() < 16 || !library.aems().banks.contains_key("Seams_Bank") {
+            return eprintln!("skipped: no seam patterns (stage_bus_tuning.py) or Seams_Bank");
+        }
+        println!("pattern km/h  hits  voices  gain first / median / p90 / max");
+        for (pattern, kmh) in [(11u32, 10.0f32), (11, 20.0), (11, 30.0), (4, 20.0)] {
+            let v = kmh / 3.6;
+            let r = run(&library, &mxb, 300, |f| {
+                let x = v * f as f32 / 60.0;
+                let mut s = rolling(kmh, 0.0);
+                s.seam_pattern = [pattern; 4];
+                s.wheel_position = [[x + 0.3, 0.0, 0.1], [x + 0.3, 0.0, -0.1], [x - 0.3, 0.0, 0.1], [x - 0.3, 0.0, -0.1]];
+                s
+            });
+            let mut g: Vec<f32> = r.gains.get("Seams_Bank").cloned().unwrap_or_default().into_iter().filter(|&x| x > 0.0).collect();
+            let first = g.first().copied().unwrap_or(0.0);
+            g.sort_by(f32::total_cmp);
+            let q = |p: f32| if g.is_empty() { 0.0 } else { g[((g.len() - 1) as f32 * p) as usize] };
+            let voices = r.opens.get("Seams_Bank").map_or(0, |s| s.len());
+            println!("{pattern:7} {kmh:4.0}  {:4}  {voices:6}  {first:.3} / {:.3} / {:.3} / {:.3}", r.posts, q(0.5), q(0.9), q(1.0));
+            assert!(voices > 0, "pattern {pattern} at {kmh} km/h: no seam voice");
+            assert!(q(1.0) <= 1.0);
+        }
+    }
+
+    /// Retail's boot utility `Start_up_Play_ctl` (Common.abk) answers the Seams program's `rnd_call`
+    /// with shuffled `send_random_0_to_9*` globals: on brick (material 65, pattern 13) at 30 km/h the
+    /// hits spread over both eight-sample blocks (32–39 and 80–87, retail 180430), not one sample
+    /// per block (Listening test 8).
+    #[test]
+    fn seam_hits_shuffle_their_samples() {
+        let Some((library, mxb)) = install() else { return eprintln!("skipped: no install with a MixMap") };
+        let tuning = library.player_tuning();
+        let banks = &library.aems().banks;
+        if tuning.seam_patterns.len() < 16 || !banks.contains_key("Seams_Bank") || !banks.contains_key(skate_audio::player::seams::UTILITY_BANK) {
+            return eprintln!("skipped: no seam patterns, Seams_Bank or Common.abk (stage_extra_banks.py Common)");
+        }
+        let v = 30.0f32 / 3.6;
+        let (mut rt, names) = runtime(&library);
+        let mut m = MixMap::from_bytes(&mxb).unwrap();
+        let mut p = PlayerAudio::new(library.player_tuning(), true);
+        let mut out = vec![0.0f32; 1600];
+        let mut seen = std::collections::BTreeSet::new();
+        let mut slots = std::collections::BTreeSet::new();
+        for f in 0..300 {
+            let x = v * f as f32 / 60.0;
+            let mut s = rolling(30.0, 0.0);
+            s.wheel_material = [65; 4];
+            s.seam_pattern = [13; 4];
+            s.wheel_position = [[x + 0.3, 0.0, 0.1], [x + 0.3, 0.0, -0.1], [x - 0.3, 0.0, 0.1], [x - 0.3, 0.0, -0.1]];
+            globals(&mut m);
+            let l = p.listener([s.com_position[0] - 3.5, 2.4, s.com_position[2]], [1.0, -0.3, 0.0], 1.0 / 60.0, &s);
+            p.write_inputs(&mut m, &s, Some(&l));
+            p.process(&mut m, &s, &mut rt, None, 0);
+            m.tick(1.0 / 60.0);
+            p.update(&m, &s, &mut rt, None, 0);
+            rt.fill_stereo(&mut out);
+            for vi in rt.mixer.snapshot() {
+                if names.get(&vi.bank) == Some(&"Seams_Bank") && seen.insert(vi.id) {
+                    slots.insert(vi.slot);
+                }
+            }
+        }
+        println!("brick 30 km/h: {} voices over samples {slots:?}", seen.len());
+        for block in [32u16, 80] {
+            let n = slots.iter().filter(|&&s| (block..block + 8).contains(&s)).count();
+            assert!(n >= 6, "block {block}: only {n} of 8 samples in 5 s ({slots:?})");
+        }
+    }
+
+    /// Diagnostic (`--ignored --nocapture`): Class_Seams voice starts per second and the samples they
+    /// play, per seam pattern, on one material at 30 km/h, against retail's mixes on that material
+    /// (`SEAM_MATERIAL`, default 65 = tag 66: 180430 plays 36 voices/s over streams 45, 83, 170, 80,
+    /// 176, 34 …).
+    #[test]
+    #[ignore = "diagnostic print"]
+    fn seam_samples_by_pattern() {
+        let Some((library, mxb)) = install() else { return eprintln!("skipped: no install with a MixMap") };
+        let material: u32 = std::env::var("SEAM_MATERIAL").ok().and_then(|v| v.parse().ok()).unwrap_or(65);
+        let kmh = 30.0f32;
+        let v = kmh / 3.6;
+        for pattern in 0u32..16 {
+            let (mut rt, names) = runtime(&library);
+            let mut m = MixMap::from_bytes(&mxb).unwrap();
+            let mut p = PlayerAudio::new(library.player_tuning(), true);
+            let mut out = vec![0.0f32; 1600];
+            let mut seen = std::collections::BTreeSet::new();
+            let mut slots: std::collections::BTreeMap<u16, u32> = Default::default();
+            let frames = 300;
+            for f in 0..frames {
+                let x = v * f as f32 / 60.0;
+                let mut s = rolling(kmh, 0.0);
+                s.wheel_material = [material; 4];
+                s.seam_pattern = [pattern; 4];
+                s.wheel_position = [[x + 0.3, 0.0, 0.1], [x + 0.3, 0.0, -0.1], [x - 0.3, 0.0, 0.1], [x - 0.3, 0.0, -0.1]];
+                globals(&mut m);
+                let l = p.listener([s.com_position[0] - 3.5, 2.4, s.com_position[2]], [1.0, -0.3, 0.0], 1.0 / 60.0, &s);
+                p.write_inputs(&mut m, &s, Some(&l));
+                p.process(&mut m, &s, &mut rt, None, 0);
+                m.tick(1.0 / 60.0);
+                p.update(&m, &s, &mut rt, None, 0);
+                rt.fill_stereo(&mut out);
+                for vi in rt.mixer.snapshot() {
+                    if names.get(&vi.bank) == Some(&"Seams_Bank") && seen.insert(vi.id) {
+                        *slots.entry(vi.slot).or_default() += 1;
+                    }
+                }
+            }
+            let (hits, _) = p.seam_hits();
+            let mut top: Vec<_> = slots.into_iter().collect();
+            top.sort_by(|a, b| b.1.cmp(&a.1));
+            println!("pattern {pattern:2}: hits {:5.1}/s voices {:5.1}/s samples {:?}", hits as f32 / 5.0, seen.len() as f32 / 5.0, &top[..top.len().min(8)]);
+        }
+    }
+
+    /// Diagnostic (`--ignored --nocapture`): which Seams_Bank samples the Class_Seams program plays
+    /// for each surface word w10 and class word w13, posting one packet and toggling w7 like the
+    /// hits do (every 4th frame).
+    #[test]
+    #[ignore = "diagnostic print"]
+    fn seam_samples_by_words() {
+        let Some((library, _)) = install() else { return eprintln!("skipped: no install with a MixMap") };
+        // SEAM_SWEEP=word:value,… overrides words of the base packet (w10 1, w13 12) instead.
+        let sweep: Vec<(usize, i32)> = std::env::var("SEAM_SWEEP")
+            .map(|v| v.split(',').filter_map(|p| p.split_once(':')).filter_map(|(a, b)| Some((a.parse().ok()?, b.parse().ok()?))).collect())
+            .unwrap_or_default();
+        let grid: Vec<(i32, i32)> = if sweep.is_empty() { [0, 2, 8, 12].iter().flat_map(|&c| (0..9).map(move |s| (c, s))).collect() } else { vec![(12, 1)] };
+        for (w13, w10) in grid {
+            {
+                let (mut rt, names) = runtime(&library);
+                let class = rt.eval.class_id("Class_Seams").unwrap();
+                let mut w = vec![0i32; 20];
+                (w[0], w[1], w[4], w[5], w[6], w[8], w[10], w[13], w[16], w[18], w[19]) = (32767, 20000, 4096, 25000, 25000, 6000, w10, w13, 32767, 32767, 8);
+                for &(i, v) in &sweep {
+                    w[i] = v;
+                }
+                let node = rt.post(class, &w);
+                let mut out = vec![0.0f32; 1600];
+                let mut seen = std::collections::BTreeSet::new();
+                let mut slots: std::collections::BTreeMap<u16, u32> = Default::default();
+                let mut toggle = false;
+                for f in 0..600 {
+                    w[7] = if f % 4 == 0 {
+                        toggle = !toggle;
+                        if toggle { 1 } else { 2 }
+                    } else {
+                        0
+                    };
+                    rt.redeliver(node, &w);
+                    rt.fill_stereo(&mut out);
+                    for vi in rt.mixer.snapshot() {
+                        if names.get(&vi.bank) == Some(&"Seams_Bank") && seen.insert(vi.id) {
+                            *slots.entry(vi.slot).or_default() += 1;
+                        }
+                    }
+                }
+                let mut top: Vec<_> = slots.into_iter().collect();
+                top.sort_by(|a, b| b.1.cmp(&a.1));
+                println!("w13 {w13:2} w10 {w10}: voices {:3} samples {:?}", seen.len(), &top[..top.len().min(10)]);
+            }
+        }
+    }
+
+    /// SenseOfSpeed_wind's level word w7 = SenseOfSpeed level(4) at matched COM speeds against
+    /// retail's capture medians (upstream PR #4's driver notes §11, ±0.5 km/h bins: 25 km/h 343,
+    /// 30 km/h 730, 35 km/h 1194, 40 km/h 2017): within 1 dB.
+    #[test]
+    fn wind_level_matches_the_retail_medians() {
+        let Some((library, mxb)) = install() else { return eprintln!("skipped: no install with a MixMap") };
+        for (kmh, retail) in [(25.0f32, 343.0f32), (30.0, 730.0), (35.0, 1194.0), (40.0, 2017.0)] {
+            let mut m = MixMap::from_bytes(&mxb).unwrap();
+            let mut p = PlayerAudio::new(library.player_tuning(), false);
+            for _ in 0..120 {
+                let s = rolling(kmh, 0.0);
+                globals(&mut m);
+                let l = p.listener([-3.5, 2.4, 0.0], [1.0, -0.3, 0.0], 1.0 / 60.0, &s);
+                p.write_inputs(&mut m, &s, Some(&l));
+                m.tick(1.0 / 60.0);
+            }
+            let w7 = m.level(keys::sense_of_speed(0), 4) as f32;
+            let db = 20.0 * (w7 / retail).log10();
+            println!("wind {kmh} km/h: w7 {w7} (retail median {retail}, {db:+.2} dB)");
+            assert!(db.abs() < 1.0, "{kmh} km/h: {db:+.2} dB");
+        }
+    }
+}
diff --git a/crates/skate-game/src/game_audio/random_programs.rs b/crates/skate-game/src/game_audio/random_programs.rs
new file mode 100644
index 00000000..92d600f0
--- /dev/null
+++ b/crates/skate-game/src/game_audio/random_programs.rs
@@ -0,0 +1,121 @@
+//! Measured behaviour of the location-set banks' AEMS programs (one post each through the PoC
+//! evaluator, 2026-10-02): the layers a post opens. Interim until the evaluator is ported;
+//! generated from PoC probe runs (local tools: .claude/skills/audio-tuning/tools) — regenerate, do not hand-edit.
+//! (bank, [(delay s, sample index or SHUFFLE, relative level, pan sweep deg/s, loops)])
+use super::random_sets::{Layer, SHUFFLE};
+
+pub(super) const PROGRAMS: &[(&str, &[Layer])] = &[
+    ("Bird_calls_crows", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }]),
+    ("Bird_calls_non_song", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }]),
+    ("Bird_calls_seagulls", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.74, looping: false }]),
+    ("Bird_calls_song", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.77, looping: false }]),
+    ("Bird_calls_wilderness", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }]),
+    ("Bird_calls_woodpecker", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }]),
+    ("Boat_Horns", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 0.00, looping: false }]),
+    ("Buoy_Bell", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("Car_UpHill_suburb_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }]),
+    ("Car_UpHill_urban_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.519, pan_sweep: 0.00, looping: false }]),
+    ("Car_UpHill_urban_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.519, pan_sweep: 0.00, looping: false }]),
+    ("Delivery_truck_leave_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.519, pan_sweep: 6.35, looping: false }]),
+    ("Delivery_truck_leave_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.519, pan_sweep: 6.11, looping: false }]),
+    ("Delivery_truck_leave_3", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.519, pan_sweep: 7.21, looping: false }]),
+    ("Delivery_truck_unload", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("Dock_Yard_PA", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("DogBarks_large", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("DogBarks_medium", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("DogBarks_small", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("DogBarks_suburb", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("DogBarks_urban", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("Garbage_Dumps", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("Garbage_Truck_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.458, pan_sweep: 7.92, looping: false }]),
+    ("Garbage_Truck_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.458, pan_sweep: 6.67, looping: false }]),
+    ("Janitor", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: true }]),
+    ("Jet_Passby_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -8.04, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.549, pan_sweep: -7.95, looping: false }]),
+    ("Metal_Bang_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("PropPlane_Passby_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.549, pan_sweep: -14.75, looping: false }]),
+    ("Racey_cars_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.549, pan_sweep: -14.75, looping: false }]),
+    ("Racey_cars_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.549, pan_sweep: -14.76, looping: false }]),
+    ("Racey_cars_3", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.549, pan_sweep: -14.75, looping: false }]),
+    ("Racey_cars_4", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.549, pan_sweep: -14.75, looping: false }]),
+    ("Siren_city_10", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -11.86, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 5.86, looping: false }]),
+    ("Siren_city_11", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 31.73, looping: false }]),
+    ("Siren_city_12", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -7.25, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 7.34, looping: false }]),
+    ("Siren_city_13", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 7.78, looping: false }]),
+    ("Siren_city_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.58, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 4.95, looping: false }]),
+    ("Siren_city_3", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 20.84, looping: false }]),
+    ("Siren_city_4", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 5.62, looping: false }]),
+    ("Siren_city_5", &[]),
+    ("Siren_city_6", &[]),
+    ("Siren_city_7", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 18.23, looping: false }]),
+    ("Siren_city_8", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 7.25, looping: false }]),
+    ("Siren_city_9", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.427, pan_sweep: -14.76, looping: false }]),
+    ("Siren_distant_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }]),
+    ("Siren_distant_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -7.36, looping: false }]),
+    ("Siren_distant_3", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }]),
+    ("Siren_euro_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -13.48, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 5.31, looping: false }]),
+    ("Siren_euro_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 5.22, looping: false }]),
+    ("Siren_euro_4", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -9.98, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.519, pan_sweep: 6.49, looping: false }]),
+    ("Siren_suburb_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }]),
+    ("Siren_suburb_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }]),
+    ("Siren_yelps_city", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.79, looping: false }, Layer { delay: 0.096, sample: SHUFFLE, level: 0.458, pan_sweep: -14.79, looping: false }]),
+    ("Subway_Trains", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("Tire_Squeals", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.549, pan_sweep: -14.75, looping: false }]),
+    ("bird_calls_european", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.74, looping: false }]),
+    ("bus_by_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 12.75, looping: false }]),
+    ("bus_by_3", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 11.40, looping: false }]),
+    ("buzzer_alarm", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_alarm_city_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_alarm_city_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_alarm_dstant_city_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_alarm_dstant_city_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_alarm_dstant_city_4", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_alarm_dstant_suburb", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_alarm_suburb_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_backfire", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.74, looping: false }]),
+    ("car_crash", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }, Layer { delay: 1.888, sample: 1, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("car_horn_city_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.77, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.519, pan_sweep: -14.77, looping: false }]),
+    ("car_horn_city_2", &[]),
+    ("car_horn_city_3", &[]),
+    ("car_horn_city_4", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.488, pan_sweep: -14.75, looping: false }]),
+    ("car_horn_suburb_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.74, looping: false }]),
+    ("car_horn_suburb_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.73, looping: false }]),
+    ("cicadas", &[Layer { delay: 0.000, sample: SHUFFLE, level: 0.610, pan_sweep: 0.00, looping: false }]),
+    ("coyote_howl", &[Layer { delay: 0.000, sample: SHUFFLE, level: 0.610, pan_sweep: 0.00, looping: false }]),
+    ("crane_moves_A", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }, Layer { delay: 24.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("delivery_truck_in_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.549, pan_sweep: 6.11, looping: false }]),
+    ("delivery_truck_in_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.519, pan_sweep: 8.15, looping: false }]),
+    ("doorman_whistle", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }, Layer { delay: 0.064, sample: SHUFFLE, level: 0.382, pan_sweep: 0.00, looping: false }]),
+    ("elevator_loop", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: true }]),
+    ("euro_economy_car_by", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.549, pan_sweep: 21.19, looping: false }]),
+    ("euro_scooter_by", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.549, pan_sweep: -14.76, looping: false }]),
+    ("forest_misc", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("hawks", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("helicopter_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -7.25, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.549, pan_sweep: -7.20, looping: false }]),
+    ("industrial_sweetners", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("insects", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: true }]),
+    ("manhole_cover_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }, Layer { delay: 0.288, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("manhole_cover_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("mcycle_revs_urban_distnt", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.549, pan_sweep: -14.75, looping: false }]),
+    ("misc_bangs_distant", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("misc_indust_sounds", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("motocycle_revs_surburb", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.458, pan_sweep: -14.76, looping: false }]),
+    ("motocycle_revs_urban", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.549, pan_sweep: -14.76, looping: false }]),
+    ("pipe_bang", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("rattle_snake", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("rockfalls", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("semi_truck_by_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 21.19, looping: false }]),
+    ("semi_truck_by_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 21.29, looping: false }]),
+    ("semi_truck_horns", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("steam_release", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("truck_back_up_beeps", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+    ("truck_by_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 19.64, looping: false }]),
+    ("truck_by_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.76, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: 19.75, looping: false }]),
+    ("truck_horn_city_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.458, pan_sweep: -14.79, looping: false }]),
+    ("truck_horn_city_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.77, looping: false }, Layer { delay: 0.160, sample: SHUFFLE, level: 0.519, pan_sweep: -14.77, looping: false }]),
+    ("vehicle_away", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: -14.75, looping: false }, Layer { delay: 0.192, sample: SHUFFLE, level: 0.458, pan_sweep: -14.75, looping: false }]),
+    ("warehouse_door_1", &[Layer { delay: 0.000, sample: SHUFFLE, level: 0.824, pan_sweep: 0.00, looping: false }]),
+    ("warehouse_door_2", &[Layer { delay: 0.000, sample: SHUFFLE, level: 0.824, pan_sweep: 0.00, looping: false }]),
+    ("window_break", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }, Layer { delay: 0.096, sample: SHUFFLE, level: 0.519, pan_sweep: 0.00, looping: false }]),
+    ("wolf_howl", &[Layer { delay: 0.000, sample: SHUFFLE, level: 0.610, pan_sweep: 0.00, looping: false }]),
+    ("work_whistles", &[Layer { delay: 0.000, sample: SHUFFLE, level: 1.000, pan_sweep: 0.00, looping: false }]),
+];
diff --git a/crates/skate-game/src/game_audio/random_sets.rs b/crates/skate-game/src/game_audio/random_sets.rs
new file mode 100644
index 00000000..1f304b4a
--- /dev/null
+++ b/crates/skate-game/src/game_audio/random_sets.rs
@@ -0,0 +1,329 @@
+//! Random distant one-shots — police sirens, horns, dogs, bangs, jets — from the
+//! location sets (`aud_wp_emitters`) setup exports into the audio manifest.
+//!
+//! Retail's scheduler (TU3 EmitterSystem; notes ems-emitters-re.md, docs 11), confirmed by a
+//! recomp trace at the Aletown spawn (set `e_dwtn_spillway_brewery`, a sound every 4–8 s):
+//! - the current location selects one set; a change rebuilds its entries and draws an interval;
+//! - at most `LOADED` banks are loaded at once, each picked by weight among unloaded entries;
+//! - a timer runs; past the interval the loaded idle entry loaded longest ago plays, the timer
+//!   resets and a new interval is drawn (uniform min..max, 1 ms steps) even if nothing played;
+//! - a post plays at volume x L, L = (min x 10 + rand % ((max-min) x 10)) / 10, from a random
+//!   fixed direction (not positional), and ends with its program or after its timeout; its bank
+//!   then unloads and another weighted pick loads.
+//! What a post plays (layers, delays, pan sweep) is the bank's program, measured per bank in
+//! `random_programs.rs` until the AEMS evaluator is ported.
+//!
+//! Location -> set: the district's world-painter region layer `audio_emitters` (128 m tiles of
+//! quadtrees in the `cSim_*.xsf` streams; TU3 sub_827A2E88 -> sub_82C0EAC0 at the focused
+//! skater's x, z). Verified against the recomp at the Aletown spawn and University start.
+//! `SKATE_AUDIO_SET=<set name>` forces a set for testing.
+use super::{Category, Library, Play, Voices, library::Clip, voices::VoiceId};
+use bevy::prelude::*;
+
+/// Banks loaded at once (EmitterSystem +56).
+const LOADED: usize = 2;
+/// Directional voices sit this far from the listener (Bevy attenuation stays 1).
+const PAN_DISTANCE: f32 = 8.0;
+
+/// One voice a post opens, measured from the bank's program.
+#[derive(Clone, Copy, Debug)]
+pub(super) struct Layer {
+    pub delay: f32,
+    /// Sample index, or `SHUFFLE` for the bank's shuffle draw shared by the post.
+    pub sample: usize,
+    pub level: f32,
+    /// Degrees per second the voice's direction turns.
+    pub pan_sweep: f32,
+    pub looping: bool,
+}
+pub(super) const SHUFFLE: usize = usize::MAX;
+
+fn program(bank: &str) -> &'static [Layer] {
+    super::random_programs::PROGRAMS.iter().find(|(b, _)| *b == bank).map_or(&[], |(_, l)| *l)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Slot {
+    Unloaded,
+    /// Loaded at this time (the oldest loaded plays first).
+    Loaded(f64),
+    Playing,
+}
+
+struct Post {
+    entry: usize,
+    started: f64,
+    until: f64,
+    /// Direction in degrees, and per layer: (start time, voice once started, layer).
+    angle: f32,
+    layers: Vec<(f64, Option<(VoiceId, Clip)>, Layer, usize)>,
+}
+
+#[derive(Default)]
+pub(super) struct State {
+    key: Option<u64>,
+    slots: Vec<Slot>,
+    timer: f32,
+    interval: f32,
+    posts: Vec<Post>,
+    bags: std::collections::HashMap<String, Vec<usize>>,
+    rng: u32,
+}
+
+/// Retail's `rand()` stand-in: uniform u32.
+fn next(rng: &mut u32) -> u32 {
+    if *rng == 0 {
+        *rng = 0x2545_f491;
+    }
+    *rng ^= *rng << 13;
+    *rng ^= *rng >> 17;
+    *rng ^= *rng << 5;
+    *rng
+}
+
+/// Uniform interval min..max in 1 ms steps (sub_824A1980).
+fn interval(min: f32, max: f32, rng: &mut u32) -> f32 {
+    min + (max - min) * (next(rng) % 1000) as f32 * 0.001
+}
+
+/// Level factor in 0.1 steps from min, max excluded (sub_824A1A20).
+fn level(min: f32, max: f32, rng: &mut u32) -> f32 {
+    let steps = ((max - min) * 10.0).round().max(0.0) as u32;
+    let offset = if steps == 0 { 0 } else { next(rng) % steps };
+    ((min * 10.0).round() + offset as f32) / 10.0
+}
+
+/// Weighted pick among unloaded entries (`rand() % Σweights`).
+fn weighted(weights: &[i32], slots: &[Slot], rng: &mut u32) -> Option<usize> {
+    let total: i64 = weights.iter().zip(slots).filter(|(_, s)| **s == Slot::Unloaded).map(|(w, _)| i64::from((*w).max(0))).sum();
+    if total <= 0 {
+        return None;
+    }
+    let mut pick = i64::from(next(rng)) % total;
+    for (index, (weight, slot)) in weights.iter().zip(slots).enumerate() {
+        if *slot != Slot::Unloaded {
+            continue;
+        }
+        pick -= i64::from((*weight).max(0));
+        if pick < 0 {
+            return Some(index);
+        }
+    }
+    None
+}
+
+fn draw(bag: &mut Vec<usize>, count: usize, rng: &mut u32) -> usize {
+    if bag.is_empty() {
+        *bag = (0..count).collect();
+    }
+    let at = next(rng) as usize % bag.len();
+    bag.swap_remove(at)
+}
+
+/// The set for the skater's location (see module docs).
+fn selected(library: &Library, district: &str, at: Vec3) -> Option<u64> {
+    static FORCED: std::sync::OnceLock<Option<String>> = std::sync::OnceLock::new();
+    if let Some(name) = FORCED.get_or_init(|| std::env::var("SKATE_AUDIO_SET").ok()).as_deref() {
+        return library.random_set_named(name).map(|(key, _)| key);
+    }
+    library.region_key(district, "audio_emitters", at.x, at.z).filter(|key| library.random_set(*key).is_some())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn update(
+    mut state: Local<State>,
+    mut commands: Commands,
+    library: Option<ResMut<Library>>,
+    mut voices: ResMut<Voices>,
+    mut assets: ResMut<Assets<AudioSource>>,
+    listener: Query<&GlobalTransform, With<super::GameAudioListener>>,
+    cues: Res<super::skate_events::Cues>,
+    map: Res<crate::map_transition::CurrentMap>,
+    time: Res<Time<Real>>,
+    menu: Option<Res<crate::graphics_menu::Menu>>,
+    replay: Res<crate::replay::Replay>,
+) {
+    let Some(mut library) = library else { return };
+    let state = &mut *state;
+    let Ok(ear) = listener.single() else { return };
+    let now = time.elapsed_secs_f64();
+    let dt = time.delta_secs().clamp(0.0, 0.25);
+    let mut rng = state.rng;
+
+    // Location change (or silenced: no set): rebuild the entries.
+    let district = map.path.as_deref().and_then(|p| p.file_stem()).and_then(|s| s.to_str()).unwrap_or("");
+    let key = if super::silenced(menu.as_deref(), &replay) { None } else { selected(&library, district, cues.riding.board) };
+    if key != state.key {
+        for post in state.posts.drain(..) {
+            for (_, voice, ..) in post.layers {
+                if let Some((id, _)) = voice {
+                    voices.stop(id, 0.3);
+                }
+            }
+        }
+        state.key = key;
+        state.slots = key.and_then(|k| library.random_set(k)).map_or(Vec::new(), |s| vec![Slot::Unloaded; s.sounds.len()]);
+        state.timer = 0.0;
+        if let Some(set) = key.and_then(|k| library.random_set(k)) {
+            state.interval = interval(set.min_interval, set.max_interval, &mut rng);
+            info!("AUDIO_RANDOM set {} ({} sounds, {:.0}–{:.0} s)", set.name.as_deref().unwrap_or("?"), set.sounds.len(),
+                set.min_interval, set.max_interval);
+        }
+    }
+    let Some(set) = state.key.and_then(|k| library.random_set(k)).cloned() else {
+        state.rng = rng;
+        return;
+    };
+
+    // Keep LOADED banks loaded.
+    let weights: Vec<i32> = set.sounds.iter().map(|s| s.weight).collect();
+    while state.slots.iter().filter(|s| **s != Slot::Unloaded).count() < LOADED {
+        let Some(pick) = weighted(&weights, &state.slots, &mut rng) else { break };
+        state.slots[pick] = Slot::Loaded(now);
+    }
+
+    // Timer: past the interval the oldest loaded idle entry plays.
+    state.timer += dt;
+    if state.timer >= state.interval {
+        let oldest = state.slots.iter().enumerate()
+            .filter_map(|(i, s)| if let Slot::Loaded(t) = s { Some((i, *t)) } else { None })
+            .min_by(|a, b| a.1.total_cmp(&b.1)).map(|(i, _)| i);
+        if let Some(entry) = oldest {
+            let sound = &set.sounds[entry];
+            let layers = program(&sound.bank);
+            if layers.is_empty() {
+                // The bank's program does not answer this sound's selector: retail is silent too.
+                state.slots[entry] = Slot::Unloaded;
+            } else {
+                let gain = sound.volume * level(set.min_level, set.max_level, &mut rng);
+                let samples = library.bank_len(&sound.bank);
+                let shuffle = if samples > 0 {
+                    draw(state.bags.entry(sound.bank.clone()).or_default(), samples, &mut rng)
+                } else {
+                    0
+                };
+                let angle = (next(&mut rng) & 0xFFFF) as f32 * 360.0 / 65536.0;
+                info!("AUDIO_RANDOM fire {} level {:.2} angle {:.0}", sound.bank, gain, angle);
+                state.posts.push(Post {
+                    entry, started: now, until: now + f64::from(sound.seconds), angle,
+                    layers: layers.iter().map(|l| {
+                        let sample = if l.sample == SHUFFLE { shuffle } else { l.sample };
+                        (now + f64::from(l.delay), None, Layer { level: l.level * gain, ..*l }, sample)
+                    }).collect(),
+                });
+                state.slots[entry] = Slot::Playing;
+            }
+        }
+        state.timer = 0.0;
+        state.interval = interval(set.min_interval, set.max_interval, &mut rng);
+    }
+
+    // Run the posts: start due layers, turn their direction, end on timeout or when all finished.
+    let (forward, right) = (ear.forward().as_vec3(), ear.right().as_vec3());
+    let origin = ear.translation();
+    let bank_of = |entry: usize| set.sounds[entry].bank.clone();
+    let mut finished = Vec::new();
+    for (index, post) in state.posts.iter_mut().enumerate() {
+        let elapsed = (now - post.started) as f32;
+        let bank = bank_of(post.entry);
+        let mut alive = false;
+        for (start, voice, layer, sample) in post.layers.iter_mut() {
+            let angle = (post.angle + layer.pan_sweep * elapsed).to_radians();
+            let at = origin + (forward * angle.cos() + right * angle.sin()) * PAN_DISTANCE;
+            match voice {
+                None if now >= *start => {
+                    if let Some(clip) = library.sample(&mut assets, &bank, *sample) {
+                        let play = Play { category: Category::Ambience, volume: layer.level, pitch: 1.0, position: Some(at),
+                            looping: layer.looping, fade_in: 0.0, envelope: None };
+                        if let Some(id) = voices.play(&mut commands, &clip, play, now) {
+                            *voice = Some((id, clip));
+                        }
+                    }
+                    alive = true;
+                }
+                None => alive = true,
+                Some((id, _)) => {
+                    if voices.playing(*id) {
+                        voices.set(*id, layer.level, 1.0, Some(at));
+                        alive = true;
+                    }
+                }
+            }
+        }
+        if !alive || now >= post.until {
+            finished.push(index);
+        }
+    }
+    for index in finished.into_iter().rev() {
+        let post = state.posts.remove(index);
+        for (_, voice, ..) in post.layers {
+            if let Some((id, _)) = voice {
+                voices.stop(id, 0.3);
+            }
+        }
+        if let Some(slot) = state.slots.get_mut(post.entry) {
+            *slot = Slot::Unloaded;
+        }
+    }
+    state.rng = rng;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn intervals_stay_in_range_with_millisecond_steps() {
+        let mut rng = 7;
+        for _ in 0..1000 {
+            let v = interval(4.0, 8.0, &mut rng);
+            assert!((4.0..8.0).contains(&v));
+            assert!(((v - 4.0) / 0.004).fract().abs() < 1e-3 || ((v - 4.0) / 0.004).fract() > 0.999);
+        }
+    }
+
+    #[test]
+    fn levels_are_tenths_below_the_maximum() {
+        let mut rng = 3;
+        let mut seen = std::collections::BTreeSet::new();
+        for _ in 0..1000 {
+            seen.insert((level(0.2, 1.0, &mut rng) * 10.0).round() as i32);
+        }
+        assert_eq!(seen.into_iter().collect::<Vec<_>>(), (2..10).collect::<Vec<_>>());
+        assert_eq!(level(0.5, 0.5, &mut rng), 0.5);
+    }
+
+    #[test]
+    fn weighted_pick_skips_loaded_entries_and_follows_weights() {
+        let mut rng = 11;
+        let slots = [Slot::Loaded(0.0), Slot::Unloaded, Slot::Unloaded];
+        let mut counts = [0; 3];
+        for _ in 0..3000 {
+            counts[weighted(&[100, 1, 3], &slots, &mut rng).unwrap()] += 1;
+        }
+        assert_eq!(counts[0], 0);
+        assert!(counts[2] > counts[1] * 2, "{counts:?}");
+        assert_eq!(weighted(&[1], &[Slot::Playing], &mut rng), None);
+    }
+
+    #[test]
+    fn region_tiles_walk_their_quadtree() {
+        use super::super::library::{NO_KEY, RegionTile};
+        // A 128 m tile split once: only the +x+z quarter has a key.
+        let tile = RegionTile {
+            r#box: [576.0, 192.0, 64.0, 64.0],
+            nodes: vec![[1, 2, 3, 4, 0], [NO_KEY, 0, 0, 0, NO_KEY], [NO_KEY, 0, 0, 0, NO_KEY], [NO_KEY, 0, 0, 0, NO_KEY], [NO_KEY, 0, 0, 0, 0]],
+            keys: vec!["7EE1991E4909C50E".into()],
+        };
+        assert_eq!(tile.key(600.0, 220.0), Some(0x7EE1_991E_4909_C50E));
+        assert_eq!(tile.key(550.0, 220.0), None);
+        assert_eq!(tile.key(700.0, 220.0), None);
+    }
+
+    #[test]
+    fn programs_cover_sirens_and_mark_unanswered_selectors_silent() {
+        assert!(!program("Siren_city_8").is_empty());
+        assert!(program("Siren_city_6").is_empty());
+        assert!(program("Siren_euro_1").len() == 2);
+    }
+}
diff --git a/crates/skate-game/src/game_audio/skate_events.rs b/crates/skate-game/src/game_audio/skate_events.rs
index e8e8e98a..96cd7e81 100644
--- a/crates/skate-game/src/game_audio/skate_events.rs
+++ b/crates/skate-game/src/game_audio/skate_events.rs
@@ -77,6 +77,19 @@ pub(super) struct Riding {
     pub grind_surface: u32,
     pub sliding: bool,
     pub braking: bool,
+    /// Wheels in contact (0..4) and pushes since start (the native rolling bed reads these).
+    pub wheels: u32,
+    pub pushes: u32,
+    /// The retail audio-state view of this tick for the native runtime (`skate_audio::player`).
+    pub audio: skate_audio::player::AudioState,
+    /// The loose-board state's inputs (`PlayerAudio::loose_board`, conditioner `sub_827A1B78`):
+    /// `up_dot` = SkateboardReckoning+80 (the deck's physical up) · Ground+80 (the retained
+    /// wheel-contact normal, Board Fill82C03318); the deck contact Collision+3475 and its material
+    /// Collision+12 − 1 (read raw: the riderless-board gate of the record's wheel fields does not
+    /// apply to these).
+    pub deck_up: f32,
+    pub deck_contact: bool,
+    pub deck_material: u32,
 }
 
 #[derive(Resource, Default)]
@@ -110,6 +123,22 @@ pub(super) struct Seen {
     /// Last trick announced in the current air phase.
     air_trick: Option<String>,
     trace: Option<bool>,
+    /// Seconds in the current air phase (audio state `+236`).
+    air_time: f32,
+    /// Latched grind family / material (`+192` / `+692`).
+    grind_family: Option<i32>,
+    grind_material: Option<u32>,
+    /// `+468` (written while Air440 holds).
+    jump_velocity: f32,
+    /// `+228` the last positive grind impact, and the conditioner's 4-frame deck-impact ring
+    /// (`+668`).
+    grind_impact: f32,
+    deck_ring: [f32; 4],
+    deck_at: usize,
+    /// The conditioner's step code (`+740`, `sub_827729B8`).
+    step_code: skate_audio::player::footsteps::StepCode,
+    /// Rows written to the audio state log.
+    log_frame: u64,
 }
 
 /// Foot-strike detector on one foot's height above the ground under it. The
@@ -156,12 +185,23 @@ fn grinding(state: u32) -> bool {
 }
 
 /// Majority audio surface under the wheels that touch the ground.
-fn wheel_surface(physics: &GamePhysics) -> (bool, u32) {
+/// The skater is off the board or wiping out (Wipeout 300, Offboard 500 / 501 / 502): the riding
+/// board's contacts are not the player's. Retail's audio record reports no wheels (material 143)
+/// through such stretches — clean GREC sessions show it moving at speed with wheels 0, air 0 and
+/// material 143 for whole stretches, never flickering — while our riding ground state keeps
+/// reporting the riderless board's touches (the 19:29 listening test: a bed and skid burst when
+/// the dropped board touched down after a trick). UNCERTAIN: the record writer itself (+152 bits
+/// 20–22) is not located; this is the measured behaviour.
+pub(super) fn board_unridden(state: u32) -> bool {
+    matches!(state, 300 | 500..=502)
+}
+
+fn wheel_surface(physics: &GamePhysics) -> (u32, u32) {
     let ground = &physics.riding.ground;
     let lines = &physics.riding.wheel_lines;
     let touching: Vec<u32> = (0..4).filter(|&i| ground.parts[i].in_contact).map(|i| lines.audio_surfaces[i]).collect();
     let surface = touching.iter().copied().max_by_key(|s| touching.iter().filter(|t| *t == s).count());
-    (!touching.is_empty(), surface.unwrap_or(0))
+    (touching.len() as u32, surface.unwrap_or(0))
 }
 
 pub(super) fn observe(
@@ -171,6 +211,7 @@ pub(super) fn observe(
     mut seen: Local<Seen>,
     time: Res<Time>,
 ) {
+    let _timing = super::timing::scope(&super::timing::OBSERVE);
     // Animation events latched during the tick (physics never reads these).
     let audio = std::mem::take(&mut skater.animation_input.audio);
     let p = &skater.player_input.physical;
@@ -282,7 +323,103 @@ pub(super) fn observe(
         info!("AUDIO_EVENT grind {} surface={} ledge={} flag={} leaving={} state={state}", if on_rail { "start" } else { "stop" },
             grinds.audio_surface_216, grinds.is_ledge_320, grinds.grinding_316, grinds.leaving_317);
     }
-    let (rolling, surface) = wheel_surface(&physics);
+    let unridden = board_unridden(state);
+    let (wheels, surface) = if unridden { (0, 0) } else { wheel_surface(&physics) };
+    let rolling = wheels > 0;
+    let memory: &mut Seen = &mut seen;
+    let audio_state = audio_state(&physics, &skater, AudioFrame {
+        dt: time.delta_secs(),
+        state,
+        unridden,
+        wheels,
+        board: (board, vec(deck.linear_velocity)),
+        on_rail,
+        push: audio.push,
+        push_trigger: memory.started && audio.push && !memory.push,
+        air_time: &mut memory.air_time,
+        grind_family: &mut memory.grind_family,
+        grind_material: &mut memory.grind_material,
+        jump_velocity: &mut memory.jump_velocity,
+        grind_impact: &mut memory.grind_impact,
+        deck_ring: &mut memory.deck_ring,
+        deck_at: &mut memory.deck_at,
+        step_code: &mut memory.step_code,
+        slip: if wheels > 0 {
+            let ri = physics.board.part_transforms()[BodyId::Deck.index()].basis.columns[0];
+            skate_audio::player::state::slip(vec(deck.linear_velocity).dot(Vec3::from_array(ri)))
+        } else {
+            0.0
+        },
+        deck_spin: {
+            let at = physics.board.part_transforms()[BodyId::Deck.index()].basis.columns[2];
+            vec(deck.angular_velocity).dot(Vec3::from_array(at))
+        },
+        deck_spin_xy: {
+            let basis = physics.board.part_transforms()[BodyId::Deck.index()].basis.columns;
+            let w = vec(deck.angular_velocity);
+            [w.dot(Vec3::from_array(basis[0])), w.dot(Vec3::from_array(basis[1]))]
+        },
+    });
+    if super::state_log::enabled() {
+        let p = &skater.player_input.physical;
+        let s = &audio_state;
+        let v = vec(deck.linear_velocity);
+        let lateral = Vec3::from_array(physics.board.part_transforms()[BodyId::Deck.index()].basis.columns[0]);
+        let air440 = skater.player_input.processed.flags_2468 & 0x0040_0000 != 0;
+        let [jx, jy, jz] = raw3(p.air.jump_velocity_delta_112);
+        super::state_log::write(&super::state_log::Row {
+            ms: time.elapsed_secs_f64() * 1000.0,
+            frame: seen.log_frame,
+            speed: s.ground_speed,
+            turn: s.turn,
+            wheels: (0..4).filter(|&i| s.wheel_contact[i]).map(|i| 1u32 << i).sum(),
+            tag: surface,
+            air: s.airborne,
+            air_time: s.air_time,
+            to_land: p.air.scalar_184,
+            jump_height: p.air.jump_height_200,
+            jv: if air440 { (jx * jx + jy * jy + jz * jz).sqrt() } else { 0.0 },
+            grinding: s.grinding,
+            family: if s.grinding { s.grind_family } else { 0 },
+            grind_tag: if s.grinding { s.grind_material } else { 0 },
+            brake: s.brake,
+            manual: s.manual_brake,
+            balance: s.balance,
+            scorable: s.scorable,
+            push: s.push_trigger,
+            slope: s.slope,
+            tilt: skater.ground.steering.deck_tilt,
+            slip: if v.length() > 1e-3 { v.dot(lateral) / v.length() } else { 0.0 },
+            feet: u32::from(s.feet_in_deck_box[0]) | (u32::from(s.feet_in_deck_box[1]) << 1),
+            state,
+            board: board.to_array(),
+            com: s.com_position,
+            grind_impact: s.grind_impact,
+            deck_impact: s.deck_impact,
+            deck_tag: physics.riding.ground.part_audio_surfaces[2],
+            foot_y: s.foot_speed_y,
+            foot_xz: s.foot_speed_xz,
+            seam: [s.seam_pattern[0], s.seam_pattern[3]],
+            wheel: [s.wheel_position[0][0], s.wheel_position[0][2]],
+            heading: {
+                let at = physics.board.part_transforms()[BodyId::Deck.index()].basis.columns[2];
+                at[0].atan2(at[2])
+            },
+            foot_down: u32::from(s.foot_down[0]) | (u32::from(s.foot_down[1]) << 1),
+            foot_material: s.foot_material,
+            hands: u32::from(s.hands_on_deck[0]) | (u32::from(s.hands_on_deck[1]) << 1),
+            strength: s.footstep_strength,
+            foot_vy: s.foot_vertical_speed,
+            step: s.step_code,
+            body: s.body_speed,
+            limb: s.limb_speed,
+            slide: s.body_slide.iter().copied().fold(0.0, f32::max),
+            deck_up: deck_up(&physics, &skater),
+            deck_contact: p.collision.flag_3475 != 0,
+            lines: if unridden { 0 } else { (0..4).filter(|&i| physics.riding.wheel_lines.audio_surfaces[i] != 0).map(|i| 1u32 << i).sum() },
+        });
+    }
+    let pushes = cues.riding.pushes.wrapping_add(u32::from(seen.started && audio.push && !seen.push));
     cues.riding = Riding {
         board,
         speed: physics.riding.motion.ground_speed,
@@ -293,14 +430,288 @@ pub(super) fn observe(
         grind_surface: grinds.audio_surface_216,
         sliding: state == PhysicalStateId::SlideGround as u32,
         braking: braking && speed > DRAG_MIN_SPEED,
+        wheels,
+        pushes,
+        audio: audio_state,
+        deck_up: deck_up(&physics, &skater),
+        deck_contact: skater.player_input.physical.collision.flag_3475 != 0,
+        deck_material: skate_audio::player::state::material_of_tag(physics.riding.ground.part_audio_surfaces[2]),
     };
     *seen = Seen {
         started: true, launched, filtered, state, trick_seq, in_water, splash_cooldown: cooldown,
         push: audio.push, feet: seen.feet, air_from_foot, since_foot, braking, brake_time, brake_event, on_rail, since_splash, trace: Some(trace),
         air_trick: if filtered == air { seen.air_trick.take() } else { None },
+        air_time: seen.air_time,
+        grind_family: seen.grind_family,
+        grind_material: seen.grind_material,
+        jump_velocity: seen.jump_velocity,
+        grind_impact: seen.grind_impact,
+        deck_ring: seen.deck_ring,
+        step_code: seen.step_code,
+        deck_at: seen.deck_at,
+        log_frame: seen.log_frame + u64::from(super::state_log::enabled()),
     };
 }
 
+/// The audio state's `+236` (Air+176, the time in the air *state*) after this tick. It counts
+/// while the air state (200..300) holds, so it keeps counting on the landing tick (wheels down,
+/// `+332` already clear, the state still air) and drops to 0 with the state — the recomp's TREAT
+/// capture (session all_20261002_223306: last air tick 0.750 s, landing tick 0.767 s, then 0; the
+/// same one-tick hold as `+240`). `follow_state` off: the count before 2026-10-02 (air flag only,
+/// 0 on the landing tick).
+pub(super) fn air_time_236(previous: f32, state: u32, airborne: bool, dt: f32, follow_state: bool) -> f32 {
+    let counting = if follow_state { (200..300).contains(&state) } else { airborne };
+    if counting { previous + dt } else { 0.0 }
+}
+
+/// `SKATE_AEMS_AIR_TIME_STATE=0` restores the audio state's `+236` count from before 2026-10-02
+/// (reset on the landing tick instead of with the air state).
+fn air_time_follows_state() -> bool {
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ON.get_or_init(|| !std::env::var("SKATE_AEMS_AIR_TIME_STATE").is_ok_and(|v| v == "0"))
+}
+
+/// What [`audio_state`] needs beyond the physics resources.
+struct AudioFrame<'a> {
+    dt: f32,
+    state: u32,
+    /// [`board_unridden`]: no board contacts reach the record.
+    unridden: bool,
+    wheels: u32,
+    board: (Vec3, Vec3),
+    on_rail: bool,
+    push: bool,
+    push_trigger: bool,
+    air_time: &'a mut f32,
+    grind_family: &'a mut Option<i32>,
+    grind_material: &'a mut Option<u32>,
+    jump_velocity: &'a mut f32,
+    grind_impact: &'a mut f32,
+    deck_ring: &'a mut [f32; 4],
+    deck_at: &'a mut usize,
+    step_code: &'a mut skate_audio::player::footsteps::StepCode,
+    /// `+232` from the deck's lateral speed (0 with no wheel down).
+    slip: f32,
+    /// `+488` the deck's angular velocity about its At axis.
+    deck_spin: f32,
+    /// `+480` / `+484` the same about its Ri and Up axes.
+    deck_spin_xy: [f32; 2],
+}
+
+fn raw3(v: [u32; 4]) -> [f32; 3] {
+    [f32::from_bits(v[0]), f32::from_bits(v[1]), f32::from_bits(v[2])]
+}
+
+/// The loose-board `up_dot` (`sub_827A1B78` at 0x827A2A60): SkateboardReckoning+80 (Y of
+/// GetEffectiveTransform82C01BF8 = the physical deck's up; the stance flip only negates X / Z) ·
+/// Ground+80 (the retained wheel-contact normal), three lanes.
+fn deck_up(physics: &GamePhysics, skater: &SkaterRuntime) -> f32 {
+    let up = physics.board.part_transforms()[BodyId::Deck.index()].basis.columns[1];
+    let n = raw3(skater.player_input.physical.ground.vector_80);
+    up[0] * n[0] + up[1] * n[1] + up[2] * n[2]
+}
+
+/// |v| over three lanes (retail: x · the refined reciprocal square root, 0 for x = 0).
+fn length3(v: [f32; 3]) -> f32 {
+    (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt()
+}
+
+/// The retail audio-state record (`skate_audio::player::state`) from this tick's physics: what the
+/// bridge `sub_824B0DA8` reads, mapped to the engine's equivalents (field docs there).
+/// - `+332` in the air = state 200..300 with no wheel down (ProcessOutput's KnownAir test); our
+///   engine rarely selects KnownAir itself, so `+236` is our own time in that air phase.
+/// - `+343` / `+372`: the score packet's scorable id (bit 24 or 25 of its flags, else none);
+///   hippy jump = id 234 (`hippyjump`) while in the air.
+/// - `+192` / `+692` latch the grind family / material while grinding (−1 / 143 before the first).
+fn audio_state(physics: &GamePhysics, skater: &SkaterRuntime, f: AudioFrame) -> skate_audio::player::AudioState {
+    use skate_audio::player::state::{AudioState, material_of_tag};
+    let p = &skater.player_input.physical;
+    let flags = &skater.player_state.state_flags;
+    let flag = |byte: usize| flags.get(byte - 52).copied().unwrap_or(false);
+    let ground = &physics.riding.ground;
+    let lines = &physics.riding.wheel_lines;
+    let wheel_contact: [bool; 4] = std::array::from_fn(|i| !f.unridden && ground.parts[i].in_contact);
+    let airborne = (200..300).contains(&f.state) && f.wheels == 0;
+    *f.air_time = air_time_236(*f.air_time, f.state, airborne, f.dt, air_time_follows_state());
+    let grinding = f.on_rail;
+    if p.grinds.grinding_316 != 0 || grinding {
+        *f.grind_family = Some(p.grinds.words_136_140[0] as i32);
+        *f.grind_material = Some(p.grinds.audio_surface_216.min(143));
+    }
+    let score = &skater.animation.motion.score_packet;
+    let scorable = if score.flags & 0x0300_0000 != 0 {
+        score.trick_names.first.and_then(|name| {
+            skater.scoring.data.definitions.iter().find(|d| d.encoded_name == name).map(|d| d.metadata.id as i64)
+        })
+    } else {
+        None
+    };
+    // +468: the conditioner writes |Air+112| / 2.65 while Air440 (Processed2468 bit 22) holds.
+    if skater.player_input.processed.flags_2468 & 0x0040_0000 != 0 {
+        let [x, y, z] = raw3(p.air.jump_velocity_delta_112);
+        *f.jump_velocity = skate_audio::player::state::jump_velocity((x * x + y * y + z * z).sqrt());
+    }
+    let (board, board_velocity) = f.board;
+    // +228: B40+32 = Grinds+128 when positive, else the last one (`sub_827731C8`).
+    if p.grinds.impact_speed_128 > 0.0 {
+        *f.grind_impact = p.grinds.impact_speed_128;
+    }
+    // +668: the conditioner's max of the last 4 Collision+24 = clamp01(|deck acceleration · deck
+    // contact normal| × 0.00125) with the deck in contact (`sub_82C02A80`, `sub_82772748`).
+    let deck = BodyId::Deck.index();
+    let deck_contact = !f.unridden && ground.parts[deck].in_contact;
+    let impact = if deck_contact {
+        let (a, n) = (ground.accelerations[deck], ground.parts[deck].normal);
+        let d = (a.x * n.x + a.y * n.y + a.z * n.z).abs() * f32::from_bits(0x3AA3_D70A);
+        skate_audio::player::clamp01(d)
+    } else {
+        0.0
+    };
+    f.deck_ring[*f.deck_at % 4] = impact;
+    *f.deck_at = (*f.deck_at + 1) % 4;
+    let deck_impact = f.deck_ring.iter().copied().fold(0.0f32, f32::max);
+    // +268..+280: the toes' local velocities in the physical board's frame (Skeleton+192..+216).
+    let toes = skater.foot_physical.output.local_velocity;
+    // Off-board inputs (`player::footsteps` / `clothing` / `step_on`; spec
+    // `.claude/notes/aems-offboard-clothing-spec.md` §3). Foot A = toe part 19 (OffBoard side 1),
+    // foot B = part 15.
+    let world_toes = skater.foot_physical.output.world_velocity;
+    let push_planted = flag(55);
+    // Skeleton+602/+603: the IK's hand targets (limbs 2 / 3) relative to the animated board inside
+    // the deck box padded by physics_skeletonik `A28E50D30B0506A4`.
+    let (half_width, half_length) = skater.foot_physical.deck_box();
+    let hands = [2usize, 3].map(|limb| {
+        let t = skater.foot_ik.state.frames[limb].board[3];
+        skate_audio::player::step_on::hand_in_deck_box([t[0], t[1], t[2]], half_width, half_length, skate_audio::player::step_on::HAND_PADDING)
+    });
+    // Skeleton::FillPhysOut (`sub_82BE1AE8`) publishes, from the physical record and the
+    // skeleton assembly's bodies (assembly +76 + 96·part):
+    // - +144 / +160 = the physical pose translations of toe parts 15 / 19 (the step code's plant
+    //   heights);
+    // - +288 / +304 / +320 = the angular velocity (body +48) of parts 23 / 20 / 16, which the record
+    //   writer turns into +328 = |+288| (the body speed) and +296 / +292 = |y| of +304 / +320 (foot
+    //   A / B "vertical" speeds);
+    // - +560..+572 = |record velocity − Skeleton16176 (the physical COM velocity)| of parts 17, 21,
+    //   4, 8, averaged into +672 = 0.25 · (572 + 568 + 564 + 560).
+    let record = &skater.skeleton.record;
+    let bodies = skater.skeleton.bodies();
+    let spin = |part: usize| {
+        let w = bodies[part].rates.angular_velocity;
+        [w.x, w.y, w.z]
+    };
+    let com16176 = raw3(p.reckoning.vector_16);
+    let limb = |part: usize| {
+        let v = record.velocities[part];
+        length3([v[0] - com16176[0], v[1] - com16176[1], v[2] - com16176[2]])
+    };
+    let limb_speed = (((limb(8) + limb(4)) + limb(21)) + limb(17)) * 0.25;
+    let step_code = f.step_code.update(
+        [p.off_board.flags_306_307[0] != 0, p.off_board.flags_306_307[1] != 0],
+        [skater.player_input.processed.left_surface_2596, skater.player_input.processed.right_surface_2600],
+        [record.pose[15][3][1], record.pose[19][3][1]],
+    );
+    // The ragdoll's body regions (SkeletonCollision, published by `sub_82BD60C8` into
+    // Collision+80..+195 and copied to the audio state +496..+611): per region with a contact
+    // part its tangential (slide) speed (+944 + 4i → +528..+548) and surface tag (+976 + 4i →
+    // +560..+580; the per-frame PhysOut reset leaves 0 without one), and the face point's contact
+    // (specific point 1, byte 4009 → +593).
+    let fb = &skater.collision_feedback;
+    let xz = |v: [f32; 4]| if v[0].abs() - v[2].abs() >= 0.0 { v[0].abs() } else { v[2].abs() };
+    AudioState {
+        dt: f.dt,
+        ground_speed: physics.riding.motion.ground_speed,
+        com_velocity: raw3(p.reckoning.vector_16),
+        com_position: raw3(p.reckoning.vector_64),
+        board_position: board.to_array(),
+        board_velocity: board_velocity.to_array(),
+        wheel_count: f.wheels,
+        wheel_contact,
+        // `+620..+632` / `+636..+648` come from the wheel lines (82C079E0: each wheel's 0.2 m ray), not
+        // from contact: retail keeps wheel 0's material on 100 % of 3-wheel and 96 % of 2-wheel frames
+        // and changes it 0.9 times a second while rolling (GREC, `aems-port/tools/grec_material.py`).
+        // Gating them by contact made every contact flicker a material change, i.e. a Class_Seams
+        // transition hit (5–9 changes/s on wheel 0 in the 20:08 / 20:13 sessions).
+        wheel_material: std::array::from_fn(|i| if f.unridden { 143 } else { material_of_tag(lines.audio_surfaces[i]) }),
+        seam_pattern: std::array::from_fn(|i| if f.unridden { 0 } else { lines.seam_patterns[i] }),
+        wheel_position: {
+            let parts = physics.board.part_transforms();
+            std::array::from_fn(|i| {
+                let p = parts[i].translation;
+                [p.x, p.y, p.z]
+            })
+        },
+        turn: skater.animation_input.fields.turn,
+        slope: skater.ground.pumping.absorption,
+        airborne,
+        air_time: *f.air_time,
+        brake: flag(52),
+        manual_brake: flag(54),
+        balance: flag(60),
+        grinding,
+        trick_active: scorable.is_some(),
+        hippy_jump: airborne && scorable == Some(234),
+        bail: flag(59),
+        bail_end: p.skeleton.over_599 != 0,
+        on_foot: f.state == 500,
+        soft_wheels: skater.player_input.processed.scalar_2764 < 0.5,
+        push_planted: f.push,
+        push_trigger: f.push_trigger,
+        feet_in_deck_box: [p.skeleton.flag_600 != 0, p.skeleton.flag_601 != 0],
+        grind_family: f.grind_family.unwrap_or(-1),
+        grind_material: f.grind_material.unwrap_or(143),
+        local: true,
+        jump_velocity: *f.jump_velocity,
+        audio_trick: -1,
+        scorable: scorable.map_or(-1, |id| id as i32),
+        slip: f.slip,
+        // +690: RevertGround (102) with State+66 set.
+        revert: f.state == 102 && flag(66),
+        // `+308` = OffBoard 311 (the board held in hand).
+        offboard_308: p.off_board.flag_311 != 0,
+        deck_tilt: skater.ground.steering.deck_tilt,
+        deck_spin: f.deck_spin,
+        grind_impact: *f.grind_impact,
+        deck_impact,
+        deck_material: if f.unridden { 143 } else { material_of_tag(ground.part_audio_surfaces[2]) },
+        foot_speed_y: [toes[0][1].abs(), toes[1][1].abs()],
+        foot_speed_xz: [xz(toes[0]), xz(toes[1])],
+        jump_bucket: 0,
+        // `+352`: the host resolves it from the scorable (`PlayerTuning::audio_trick_2`).
+        audio_trick_2: -1,
+        offboard_310: false,
+        deck_spin_xy: f.deck_spin_xy,
+        // `+240` / `+260`: KnownAir's predicted time until landing and jump height (Air+184 / +200).
+        air_until_landing: p.air.scalar_184,
+        jump_height: p.air.jump_height_200,
+        // `+220` the game time scale and `+224` (0 in free skate).
+        time_scale: 1.0,
+        global_224: false,
+        foot_down: [
+            p.off_board.flags_306_307[1] != 0 || p.air.footplant_right_450 != 0 || (push_planted && flag(57)) || flag(52),
+            p.off_board.flags_306_307[0] != 0 || p.air.footplant_left_449 != 0 || (push_planted && !flag(57) && flag(56)),
+        ],
+        foot_material: [
+            material_of_tag(skater.player_input.processed.right_surface_2600 & 0x7F),
+            material_of_tag(skater.player_input.processed.left_surface_2596 & 0x7F),
+        ],
+        foot_xz_speed: [xz(world_toes[1]), xz(world_toes[0])],
+        foot_vertical_speed: [spin(20)[1].abs(), spin(16)[1].abs()],
+        step_code,
+        footstep_strength: skater.animation_input.extra.footstep_strength,
+        // `+300`: the host's LandingBucket (it needs the resolved audio trick).
+        landing_bucket: 1,
+        footplant: p.air.flag_448 != 0,
+        offboard_air: p.filtered_state_0 == 7,
+        push_stroke: flag(56),
+        body_speed: length3(spin(23)),
+        limb_speed,
+        body_slide: std::array::from_fn(|i| if fb.regions[i].part.is_some() { fb.regions[i].tangent_speed } else { 0.0 }),
+        body_tag: std::array::from_fn(|i| if fb.regions[i].part.is_some() { fb.regions[i].material_flags } else { 0 }),
+        body_slide_flag: fb.specific[1].current,
+        hands_on_deck: skate_audio::player::step_on::hands_on_deck(hands, f.state == 500, p.off_board.flag_311 != 0),
+    }
+}
+
 /// A looping voice and the clip it plays.
 #[derive(Default)]
 struct Loop {
@@ -538,8 +949,29 @@ pub(super) fn play(
     time: Res<Time<Real>>,
     menu: Option<Res<crate::graphics_menu::Menu>>,
     replay: Res<crate::replay::Replay>,
+    native: Option<Res<super::native::Native>>,
 ) {
+    let _timing = super::timing::scope(&super::timing::PLAY);
     let events = std::mem::take(&mut cues.events);
+    // The native granular bed (grain_bed.rs) replaces the interim speed-band loop when it runs.
+    let native_bed = native.as_deref().is_some_and(|n| n.bed.is_some());
+    // The native player components (player_audio.rs) replace the metal GRINDS loop, the
+    // sense_of_speed bed cue and the foot-drag pieces when they run.
+    let native_player = native.as_deref().is_some_and(|n| n.player.as_ref().is_some_and(|p| p.components));
+    // The native board contacts (Splice) replace the interim pop layers and landing impacts.
+    let native_contacts = native.as_deref().is_some_and(|n| n.player.as_ref().is_some_and(|p| p.components && p.contacts_on));
+    // SFXObj_Wheels (player_audio.rs) replaces the interim air wheel spin.
+    let native_wheels = native.as_deref().is_some_and(|n| n.player.as_ref().is_some_and(|p| p.components && p.wheels_on));
+    // The native Tricks component (Class_Flips) replaces the interim flip whoosh; the native
+    // rolling layers / rattle replace the interim bed's PatchBank_Rolling_Surfaces / Rolling_Rattles.
+    let native_part = |f: fn(&super::player_audio::PlayerAudio) -> bool| native.as_deref().is_some_and(|n| n.player.as_ref().is_some_and(|p| p.components && f(p)));
+    let native_tricks = native_part(|p| p.tricks_on);
+    // SFXObj_OffBoard's footsteps (on foot, and the push plants on the board) replace the interim
+    // steps and push; the Contacts' hands-on-deck sounds (1124 / 1125 / 1126) replace the interim
+    // "foot on deck" 1126 at a board put-down.
+    let native_footsteps = native_part(|p| p.footsteps_on);
+    let native_rolling = native_part(|p| p.rolling_on);
+    let native_rattle = native_part(|p| p.rattle_on);
     let Some(mut library) = library else { return };
     // Cues raised while silenced are dropped, never played late in a burst.
     if super::silenced(menu.as_deref(), &replay) {
@@ -567,6 +999,7 @@ pub(super) fn play(
             // Retail's measured layers per moment (cues.rs): pop crack + tail
             // impact + deck knock; flip whoosh + feet catching the board; the
             // wheels-down set + an impact family on landing.
+            Event::Pop(_) if native_contacts => {}
             Event::Pop(at) => {
                 for record in cues::POP {
                     layer(&mut player, loops, now, "pop", record, 1.0, at, &mut rng);
@@ -575,9 +1008,19 @@ pub(super) fn play(
                 layer(&mut player, loops, now, "pop_tail", tail, 1.0, at, &mut rng);
             }
             Event::Flip(at) => {
-                player.once("flip", &cues::FLIP, 1.0, at, &mut rng);
-                layer(&mut player, loops, now, "catch", &cues::CATCH, 1.0, at, &mut rng);
+                if !native_tricks {
+                    player.once("flip", &cues::FLIP, 1.0, at, &mut rng);
+                }
+                // The feet catching the board are the native foot taps (`player::contacts`,
+                // 1112..1120) when the native contacts run.
+                if !native_contacts {
+                    layer(&mut player, loops, now, "catch", &cues::CATCH, 1.0, at, &mut rng);
+                }
             }
+            // RETIRED from the native path (user-confirmed 19:19 build): the native contacts play the
+            // landing impact pair, touchdowns and the shoe scuffs (`sk8_foley` 94 / 95, which the
+            // interim LAND_CLOTH was); nothing interim plays at a landing then.
+            Event::Land { .. } if native_contacts => {}
             Event::Land { at, impact } => {
                 // Retail's board contact rule (cues.rs): hollow (wood) table or
                 // normal, each contact kind with its retail chance, variant by
@@ -602,10 +1045,18 @@ pub(super) fn play(
                 // Set down gently: foot on deck, knock, light wheel touch.
                 // Jumped on (caveman): louder, plus the landing set.
                 let (soft, heavy) = board_down_levels(impact);
-                player.play_record("board_down", &cues::BOARD_DOWN, soft, at, &mut rng, &mut loops.patch_order);
-                player.play_record("board_down_knock", &cues::BOARD_DOWN_KNOCK, soft, at, &mut rng, &mut loops.patch_order);
-                player.play_record("board_down_touch", &cues::BOARD_DOWN_TOUCH, soft, at, &mut rng, &mut loops.patch_order);
-                if heavy > 0.0 {
+                if !native_contacts {
+                    player.play_record("board_down", &cues::BOARD_DOWN, soft, at, &mut rng, &mut loops.patch_order);
+                }
+                // With the native contacts the wheels' touchdowns (Contacts sets) and the feet's
+                // deck taps (1112..1120) play from the retail mechanism; the interim knock and
+                // touch would double them. (The foot-on-deck set stays interim: retail's step-on
+                // `sub_824B85B0` needs Skeleton+602/+603, which the engine does not publish.)
+                if !native_contacts {
+                    player.play_record("board_down_knock", &cues::BOARD_DOWN_KNOCK, soft, at, &mut rng, &mut loops.patch_order);
+                    player.play_record("board_down_touch", &cues::BOARD_DOWN_TOUCH, soft, at, &mut rng, &mut loops.patch_order);
+                }
+                if heavy > 0.0 && !native_contacts {
                     player.play_record("board_down_heavy", &cues::LAND, heavy, at, &mut rng, &mut loops.patch_order);
                 }
             }
@@ -616,6 +1067,7 @@ pub(super) fn play(
                 let cue = cues::Cue { samples: cues::BAIL_TIERS[tier], ..cues::BAIL };
                 player.once(["bail_soft", "bail_medium", "bail_hard"][tier], &cue, 1.0, at, &mut rng);
             }
+            Event::Push(_) | Event::Step { .. } if native_footsteps => {}
             Event::Push(at) => player.once("push", &cues::PUSH, 1.0, at, &mut rng),
             Event::Step { at, run, level } => {
                 player.once(if run { "run_step" } else { "step" }, if run { &cues::RUN_STEP } else { &cues::STEP }, level, at, &mut rng)
@@ -661,7 +1113,11 @@ pub(super) fn play(
     let bands = player.library.grain_bands(grain);
     loops.roll.prune(player.voices);
     loops.roll_held += dt;
-    if bands > 0 {
+    if native_bed && loops.roll.voice.is_some() {
+        loops.roll.stop(player.voices, 0.1);
+        loops.roll_band = None;
+    }
+    if bands > 0 && !native_bed {
         let current = loops.roll_band.filter(|(g, _)| *g == grain).map(|(_, b)| b);
         let wanted = band_for((loops.roll_speed / FULL_ROLL_SPEED).clamp(0.0, 1.0), bands, current);
         // A band plays for at least BAND_HOLD before the next speed change.
@@ -694,11 +1150,23 @@ pub(super) fn play(
     let bed = cues::bed_rate(r.speed) * if r.rolling && !r.grinding && !r.airborne { 1.0 } else { 0.0 };
     if bed > 0.0 {
         for (record, rate) in cues::BED_RECORDS {
+            if native_contacts && cues::bed_record_native(record) {
+                continue;
+            }
             if random(&mut rng) < rate * bed * dt {
                 player.play_record("", record, 1.0, r.board, &mut rng, &mut loops.patch_order);
             }
         }
         for (cue, rate) in cues::BED_CUES {
+            // sense_of_speed: SenseOfSpeed rattle / wind; Seams_Bank: Class_Seams; Rolling_Rattles /
+            // PatchBank_Rolling_Surfaces: the native rattle (posted on pushes) and Class_rolling's
+            // continuous layers replace these random one-shots.
+            if native_player && matches!(cue.bank, "sense_of_speed" | "Seams_Bank")
+                || native_rolling && cue.bank == "PatchBank_Rolling_Surfaces"
+                || native_rattle && cue.bank == "Rolling_Rattles"
+            {
+                continue;
+            }
             if random(&mut rng) < rate * bed * dt {
                 player.once_pitched("", cue, 1.0, 1.0, r.board, &mut rng);
             }
@@ -708,14 +1176,17 @@ pub(super) fn play(
     // Grinds: retail's start patch, then on metal the GRINDS loop; on ledges
     // and other surfaces short scrape pieces re-fired every ~63 ms.
     let metal = cues::metal(r.grind_surface);
-    if r.grinding && !loops.was_grinding {
+    // With the native contacts the collision manager plays the grind start (board / truck against
+    // the grind material); the interim start and scrape pieces (Skate_Collisions 954 / 955 are the
+    // skin / denim body-impact sounds, not grind layers) stay silent.
+    if r.grinding && !loops.was_grinding && !native_contacts {
         let start = if metal { &cues::GRIND_METAL_START } else { &cues::GRIND_START };
         player.play_record("grind_start", start, 0.5 + 0.5 * fraction, r.board, &mut rng, &mut loops.patch_order);
         loops.grind_piece_next = cues::GRIND_PIECE_INTERVAL;
     }
     loops.was_grinding = r.grinding;
-    player.hold(&mut loops.grind, r.grinding && metal, &cues::GRIND_METAL, cues::GRIND_METAL.level * (0.5 + 0.5 * fraction), r.board, &mut rng);
-    if r.grinding && !metal {
+    player.hold(&mut loops.grind, r.grinding && metal && !native_player, &cues::GRIND_METAL, cues::GRIND_METAL.level * (0.5 + 0.5 * fraction), r.board, &mut rng);
+    if r.grinding && !metal && !native_contacts {
         loops.grind_piece_next -= dt;
         if loops.grind_piece_next <= 0.0 {
             loops.grind_piece_next += cues::GRIND_PIECE_INTERVAL;
@@ -723,12 +1194,13 @@ pub(super) fn play(
         }
     }
     let sliding = r.sliding && !r.grinding;
-    player.shuffle("powerslide", &mut loops.slide_next, sliding, dt, &cues::POWERSLIDE, cues::POWERSLIDE_SHUFFLE, fraction, r.board, &mut rng);
-    player.shuffle("foot_drag", &mut loops.drag_next, dragging, dt, &cues::FOOT_DRAG, cues::FOOT_DRAG_SHUFFLE, 0.3 + 0.7 * fraction, r.board, &mut rng);
+    // The native Class_wheels_skid / Class_Squeaks (player_audio.rs) replace the interim pieces.
+    player.shuffle("powerslide", &mut loops.slide_next, sliding && !native_player, dt, &cues::POWERSLIDE, cues::POWERSLIDE_SHUFFLE, fraction, r.board, &mut rng);
+    player.shuffle("foot_drag", &mut loops.drag_next, dragging && !native_player, dt, &cues::FOOT_DRAG, cues::FOOT_DRAG_SHUFFLE, 0.3 + 0.7 * fraction, r.board, &mut rng);
 
     // Wheels spin down after take-off; cut when they touch again.
     loops.wheels.prune(player.voices);
-    if r.airborne && !loops.was_airborne && fraction > 0.1 {
+    if r.airborne && !loops.was_airborne && fraction > 0.1 && !native_wheels {
         loops.wheels.stop(player.voices, 0.05);
         if let Some(clip) = player.library.wheels(player.assets, cues::AIR_WHEELS.0) {
             let mut play = Play::effect(cues::AIR_WHEELS.1 * fraction, r.board);
@@ -750,6 +1222,25 @@ pub(super) fn play(
 mod tests {
     use super::*;
 
+    /// `+236` across an ollie as the recomp's TREAT capture has it (session all_20261002_223306,
+    /// 60 Hz ticks): 0 on the ground, 1/60 on the first air tick, still counting on the landing
+    /// tick (state 201, wheels down), 0 once the state leaves the air. Off: 0 on the landing tick.
+    #[test]
+    fn air_time_holds_through_the_landing_tick() {
+        let dt = 1.0 / 60.0;
+        // (state, wheels down) per tick: rolling, takeoff, 3 air ticks, landing tick, rolling.
+        let ticks = [(103, true), (201, false), (201, false), (201, false), (201, false), (201, true), (100, true)];
+        let run = |follow: bool| {
+            let mut t = 0.0f32;
+            ticks.iter().map(|&(state, down)| {
+                t = air_time_236(t, state, (200..300).contains(&state) && !down, dt, follow);
+                (t * 60.0).round() as i32
+            }).collect::<Vec<_>>()
+        };
+        assert_eq!(run(true), [0, 1, 2, 3, 4, 5, 0]);
+        assert_eq!(run(false), [0, 1, 2, 3, 4, 0, 0]);
+    }
+
     #[test]
     fn random_stays_in_unit_range() {
         let mut rng = 0;
diff --git a/crates/skate-game/src/game_audio/state_log.rs b/crates/skate-game/src/game_audio/state_log.rs
new file mode 100644
index 00000000..7d8ea79e
--- /dev/null
+++ b/crates/skate-game/src/game_audio/state_log.rs
@@ -0,0 +1,176 @@
+//! `SKATE_AUDIO_STATE_LOG=<path>`: record the player's per-frame audio situation while playing, as
+//! one TSV row per physics/audio frame in the columns of the e2e scenarios
+//! (`.claude/skills/aems-port/tools/e2e/scenarios.py`) plus the elapsed time and the board / COM
+//! world positions, so real play can be cut into windows and replayed headless into our native
+//! stack and the PoC oracle (`scenarios.py --from-log`). Off (no cost) when unset; buffered,
+//! flushed every 6 rows (~100 ms).
+use std::io::Write;
+use std::sync::OnceLock;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+/// The header (the e2e scenario columns between `ms` and the positions).
+pub(crate) const HEADER: &str = "ms\tframe\tspeed\tturn\twheels\ttag\tair\tair_time\tto_land\tjump_height\tjv\tgrinding\tfamily\tgrind_tag\tbrake\tmanual\tbalance\tscorable\tpush\tslope\ttilt\tslip\tfeet\tstate\tboard_x\tboard_y\tboard_z\tcom_x\tcom_y\tcom_z\tgrind_impact\tdeck_impact\tdeck_tag\tfoot_y0\tfoot_y1\tfoot_xz0\tfoot_xz1\tseam0\tseam3\twheel_x\twheel_z\theading\tlines\tfoot_down\tfoot_tag_a\tfoot_tag_b\thands\tstrength\tfoot_vy_a\tfoot_vy_b\tstep\tbody\tlimb\tslide\tdeck_up\tdeck_contact";
+
+/// One frame of the log.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub(crate) struct Row {
+    pub ms: f64,
+    pub frame: u64,
+    pub speed: f32,
+    pub turn: f32,
+    /// Bit i = wheel i in contact.
+    pub wheels: u32,
+    pub tag: u32,
+    pub air: bool,
+    pub air_time: f32,
+    pub to_land: f32,
+    pub jump_height: f32,
+    /// |Air+112| (m/s) on frames where Air440 holds, else 0.
+    pub jv: f32,
+    pub grinding: bool,
+    pub family: i32,
+    pub grind_tag: u32,
+    pub brake: bool,
+    pub manual: bool,
+    pub balance: bool,
+    pub scorable: i32,
+    pub push: bool,
+    pub slope: f32,
+    pub tilt: f32,
+    /// Lateral board speed / board speed (the sine the e2e probes turn the deck by).
+    pub slip: f32,
+    /// Bit 0 / 1: feet in the deck box.
+    pub feet: u32,
+    pub state: u32,
+    pub board: [f32; 3],
+    pub com: [f32; 3],
+    /// Audio state `+228` (last grind impact), `+668` (deck impact), the deck contact's tag, and
+    /// the toes' local speeds (`+272`/`+268` Y, `+280`/`+276` XZ) — appended 2026-10-02.
+    pub grind_impact: f32,
+    pub deck_impact: f32,
+    pub deck_tag: u32,
+    pub foot_y: [f32; 2],
+    pub foot_xz: [f32; 2],
+    /// The seam patterns of wheels 0 and 3 (`+636` / `+648`), wheel 0's world x, z and the deck's
+    /// heading (atan2 of its At axis, x over z, rad) — appended for Class_Seams replays.
+    pub seam: [u32; 2],
+    pub wheel: [f32; 2],
+    pub heading: f32,
+    /// Wheels whose wheel line hits a surface (bit i = wheel i; `WheelLineState.audio_surfaces`
+    /// non-zero): the audio record's materials come from these lines, not from contact.
+    pub lines: u32,
+    /// The off-board inputs (`player::footsteps` / `step_on`): feet down (bit 0 = A, 1 = B), the
+    /// feet's materials (tag − 1, 143 none), hands on the deck (bits), the footstep strength and the
+    /// feet's vertical speeds — appended for footstep replays.
+    pub foot_down: u32,
+    pub foot_material: [u32; 2],
+    pub hands: u32,
+    pub strength: f32,
+    pub foot_vy: [f32; 2],
+    /// The skeleton inputs (appended for clothing / footstep replays): the step code (`+740`), the
+    /// body speed (`+328`), the limb speed (`+672`), the largest body-region slide speed
+    /// (`+528..+548`); and the loose-board inputs: `up_dot` and the deck contact.
+    pub step: i32,
+    pub body: f32,
+    pub limb: f32,
+    pub slide: f32,
+    pub deck_up: f32,
+    pub deck_contact: bool,
+}
+
+impl Row {
+    pub(crate) fn line(&self) -> String {
+        let b = |v: bool| u8::from(v);
+        format!(
+            "{:.1}\t{}\t{:.6}\t{:.6}\t{}\t{}\t{}\t{:.6}\t{:.6}\t{:.6}\t{:.6}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{:.6}\t{:.6}\t{:.6}\t{}\t{}\t{:.4}\t{:.4}\t{:.4}\t{:.4}\t{:.4}\t{:.4}\t{:.6}\t{:.6}\t{}\t{:.6}\t{:.6}\t{:.6}\t{:.6}\t{}\t{}\t{:.4}\t{:.4}\t{:.5}\t{}\t{}\t{}\t{}\t{}\t{:.4}\t{:.4}\t{:.4}\t{}\t{:.4}\t{:.4}\t{:.4}\t{:.4}\t{}",
+            self.ms, self.frame, self.speed, self.turn, self.wheels, self.tag, b(self.air), self.air_time, self.to_land,
+            self.jump_height, self.jv, b(self.grinding), self.family, self.grind_tag, b(self.brake), b(self.manual),
+            b(self.balance), self.scorable, b(self.push), self.slope, self.tilt, self.slip, self.feet, self.state,
+            self.board[0], self.board[1], self.board[2], self.com[0], self.com[1], self.com[2],
+            self.grind_impact, self.deck_impact, self.deck_tag, self.foot_y[0], self.foot_y[1], self.foot_xz[0], self.foot_xz[1],
+            self.seam[0], self.seam[1], self.wheel[0], self.wheel[1], self.heading, self.lines,
+            self.foot_down, self.foot_material[0], self.foot_material[1], self.hands, self.strength, self.foot_vy[0], self.foot_vy[1],
+            self.step, self.body, self.limb, self.slide, self.deck_up, b(self.deck_contact)
+        )
+    }
+}
+
+/// The writer thread's queue (rows as text). The game thread only formats and enqueues: a disk
+/// flush or OS stall must never block a frame (19:20 listening test: `observe` took 143–751 ms
+/// on three frames while the flush ran on the game thread).
+static QUEUE: OnceLock<Option<std::sync::mpsc::SyncSender<String>>> = OnceLock::new();
+/// Rows dropped because the queue was full (reported by the writer at the end).
+static DROPPED: AtomicU64 = AtomicU64::new(0);
+
+fn queue() -> Option<&'static std::sync::mpsc::SyncSender<String>> {
+    QUEUE
+        .get_or_init(|| {
+            let path = std::path::PathBuf::from(std::env::var_os("SKATE_AUDIO_STATE_LOG")?);
+            let (tx, rx) = std::sync::mpsc::sync_channel::<String>(4096);
+            std::thread::Builder::new()
+                .name("audio-state-log".into())
+                .spawn(move || {
+                    let Ok(file) = std::fs::File::create(&path) else { return };
+                    let mut out = std::io::BufWriter::with_capacity(1 << 16, file);
+                    if writeln!(out, "{HEADER}").is_err() {
+                        return;
+                    }
+                    bevy::log::info!("Game audio: audio state log → {}", path.display());
+                    let mut rows = 0u32;
+                    while let Ok(line) = rx.recv() {
+                        if writeln!(out, "{line}").is_err() {
+                            return;
+                        }
+                        rows += 1;
+                        if rows % 6 == 0 {
+                            let _ = out.flush();
+                        }
+                    }
+                    let _ = out.flush();
+                })
+                .ok()?;
+            Some(tx)
+        })
+        .as_ref()
+}
+
+/// Append a row: formatted here, written by the log thread (never blocks; a full queue drops the
+/// row and counts it).
+pub(crate) fn write(row: &Row) {
+    let Some(tx) = queue() else { return };
+    if tx.try_send(row.line()).is_err() {
+        DROPPED.fetch_add(1, Ordering::Relaxed);
+    }
+}
+
+/// Rows dropped so far (a full queue).
+pub(crate) fn dropped() -> u64 {
+    DROPPED.load(Ordering::Relaxed)
+}
+
+/// Whether the log is requested (checked once per frame by the caller to skip building rows).
+pub(crate) fn enabled() -> bool {
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ON.get_or_init(|| std::env::var_os("SKATE_AUDIO_STATE_LOG").is_some_and(|v| !v.is_empty()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_row_has_the_header_columns_in_order() {
+        let row = Row { ms: 12.5, frame: 3, speed: 5.5, wheels: 15, tag: 3, air: true, family: -1, scorable: 128, state: 201, board: [1.0, 2.0, 3.0], ..Default::default() };
+        let cols: Vec<&str> = HEADER.split('\t').collect();
+        let line = row.line();
+        let vals: Vec<&str> = line.split('\t').collect();
+        assert_eq!(cols.len(), vals.len());
+        let get = |c: &str| vals[cols.iter().position(|x| *x == c).unwrap()];
+        assert_eq!((get("ms"), get("frame"), get("wheels"), get("tag"), get("air")), ("12.5", "3", "15", "3", "1"));
+        assert_eq!((get("family"), get("scorable"), get("state"), get("board_z")), ("-1", "128", "201", "3.0000"));
+        assert_eq!(get("speed").parse::<f32>().unwrap(), 5.5);
+        // The e2e scenario columns are a contiguous run of the header.
+        let scenario = "frame speed turn wheels tag air air_time to_land jump_height jv grinding family grind_tag brake manual balance scorable push slope tilt slip feet state";
+        assert_eq!(cols[1..24].join(" "), scenario);
+    }
+}
diff --git a/crates/skate-game/src/game_audio/timing.rs b/crates/skate-game/src/game_audio/timing.rs
new file mode 100644
index 00000000..089be4f2
--- /dev/null
+++ b/crates/skate-game/src/game_audio/timing.rs
@@ -0,0 +1,97 @@
+//! Opt-in cost readout of the game audio (`SKATE_AUDIO_TIMING=1`): once per second one
+//! `AUDIO_TIMING` log line with the slowest and average time of each audio system on the game
+//! thread, the time spent waiting for the native runtime's lock (game thread and audio thread),
+//! the native render per 256-frame block, and the slowest frame. Off: one relaxed atomic load per
+//! scope. For finding stutter in real play (skill `optimisation`); measuring only, no behaviour.
+use std::sync::OnceLock;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Instant;
+
+use bevy::prelude::*;
+
+pub(crate) struct Stat {
+    name: &'static str,
+    max: AtomicU64,
+    sum: AtomicU64,
+    n: AtomicU64,
+}
+
+impl Stat {
+    const fn new(name: &'static str) -> Self {
+        Self { name, max: AtomicU64::new(0), sum: AtomicU64::new(0), n: AtomicU64::new(0) }
+    }
+    pub(crate) fn add(&self, us: u64) {
+        self.max.fetch_max(us, Ordering::Relaxed);
+        self.sum.fetch_add(us, Ordering::Relaxed);
+        self.n.fetch_add(1, Ordering::Relaxed);
+    }
+    fn take(&self) -> (u64, u64, u64) {
+        (self.max.swap(0, Ordering::Relaxed), self.sum.swap(0, Ordering::Relaxed), self.n.swap(0, Ordering::Relaxed))
+    }
+}
+
+pub(crate) static MIXMAP_FRAME: Stat = Stat::new("mixmap_frame");
+pub(crate) static GRAIN_BED: Stat = Stat::new("grain_bed");
+pub(crate) static OBSERVE: Stat = Stat::new("observe");
+pub(crate) static PLAY: Stat = Stat::new("cues");
+pub(crate) static EMITTERS: Stat = Stat::new("emitters");
+pub(crate) static VOICES: Stat = Stat::new("voices");
+pub(crate) static GAME_LOCK: Stat = Stat::new("game_lock_wait");
+pub(crate) static AUDIO_LOCK: Stat = Stat::new("audio_lock_wait");
+pub(crate) static RENDER: Stat = Stat::new("render_block");
+static FRAME: Stat = Stat::new("frame");
+static ALL: [&Stat; 10] = [&FRAME, &MIXMAP_FRAME, &GRAIN_BED, &OBSERVE, &PLAY, &EMITTERS, &VOICES, &GAME_LOCK, &AUDIO_LOCK, &RENDER];
+
+pub(crate) fn on() -> bool {
+    static ON: OnceLock<bool> = OnceLock::new();
+    *ON.get_or_init(|| std::env::var("SKATE_AUDIO_TIMING").is_ok_and(|v| v == "1"))
+}
+
+/// Records the time from creation to drop into `stat` (when the readout is on).
+pub(crate) struct Scope(Option<(Instant, &'static Stat)>);
+impl Drop for Scope {
+    fn drop(&mut self) {
+        if let Some((t, stat)) = self.0 {
+            stat.add(t.elapsed().as_micros() as u64);
+        }
+    }
+}
+pub(crate) fn scope(stat: &'static Stat) -> Scope {
+    Scope(on().then(|| (Instant::now(), stat)))
+}
+
+/// Lock `m`, recording the wait into `stat`.
+pub(crate) fn lock<'a, T>(m: &'a std::sync::Mutex<T>, stat: &'static Stat) -> std::sync::LockResult<std::sync::MutexGuard<'a, T>> {
+    if !on() {
+        return m.lock();
+    }
+    let t = Instant::now();
+    let g = m.lock();
+    stat.add(t.elapsed().as_micros() as u64);
+    g
+}
+
+/// Once per second: the `AUDIO_TIMING` line (max / average µs and count per stat).
+pub(crate) fn report(time: Res<Time<Real>>, mut clock: Local<f32>) {
+    if !on() {
+        return;
+    }
+    FRAME.add((time.delta_secs_f64() * 1e6) as u64);
+    *clock += time.delta_secs();
+    if *clock < 1.0 {
+        return;
+    }
+    *clock = 0.0;
+    let mut line = String::from("AUDIO_TIMING");
+    for s in ALL {
+        let (max, sum, n) = s.take();
+        if n > 0 {
+            line.push_str(&format!(" {}={}/{}us×{}", s.name, max, sum / n, n));
+        }
+    }
+    let dropped = super::state_log::dropped();
+    if dropped > 0 {
+        line.push_str(&format!(" state_log_dropped={dropped}"));
+    }
+    info!("{line}");
+}
diff --git a/crates/skate-game/src/game_audio/voices.rs b/crates/skate-game/src/game_audio/voices.rs
index fb7e44a5..1e76c34e 100644
--- a/crates/skate-game/src/game_audio/voices.rs
+++ b/crates/skate-game/src/game_audio/voices.rs
@@ -74,6 +74,7 @@ struct Voice {
     envelope: Option<&'static [(f32, f32)]>,
     /// Seconds played (not counting silenced time), for the envelope.
     age: f32,
+    channels: u16,
 }
 
 /// Relative gain of `envelope` at `age` seconds (linear between points,
@@ -102,6 +103,72 @@ pub(crate) struct Voices {
     /// last `sync`, so one-shots can start at their final level.
     mix: [f32; 2],
     silenced: bool,
+    /// Scale on every interim voice: 1 normally; `1 / cues::RETAIL_SCALE` while the native player
+    /// sounds run (`native::follow_volume`), so the retail-measured interim cues sit at their
+    /// measured level against the native voices (which play at retail level) instead of the
+    /// interim mix's rolling-anchored ×2.
+    pub(crate) scale: f32,
+    /// True while the native host runs (`native::follow_volume`): every interim voice then gets
+    /// [`native_fold_gain`], so it reaches the ears as a native voice of the same per-voice gain
+    /// would (Pan2D1 + the output stage's stereo fold) instead of Bevy's own panning.
+    pub(crate) native_fold: bool,
+    /// The listener as of the last `sync` (world → listener-local transform, ear offsets).
+    view: Option<ListenerView>,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct ListenerView {
+    to_local: bevy::math::Affine3A,
+    ears: (Vec3, Vec3),
+}
+
+/// The output stage's stereo fold (`skate_audio::dsp::routes::output_stereo`) of one Pan2D1 row.
+fn fold_row(row: &[f32; 6]) -> (f32, f32) {
+    use skate_audio::dsp::routes::G707;
+    (G707 * row[0] + 0.5 * row[1] + 0.5 * row[3], G707 * row[2] + 0.5 * row[1] + 0.5 * row[4])
+}
+
+/// Gain that makes an interim (Bevy) voice reach the ears with the power a native voice of the
+/// same per-voice gain gets through Pan2D1 and the output stage's stereo fold (aems-voice-graph-spec
+/// §4.9, §6.3; `examples/pan_fold_probe.rs`).
+///
+/// - Non-positional: a mono native voice opens at azimuth 0 → centre → 0.5 per ear; a stereo one
+///   (the bed graph has no panner) routes L→L, R→R → 0.707 per ear. Bevy plays both at 1 per ear.
+/// - Positional (`local` = the source in listener space, Bevy axes: −Z ahead, +X right): native =
+///   a mono Pan2D1 at the azimuth, folded; Bevy = rodio 0.20's spatial ear factors (each ear
+///   ((d_this − d_other)/gap + 1)/4 + 0.5, capped at 1, times the distance term, which stays: it
+///   is the interim layer's own distance model), with the channels summed into one (rodio's
+///   `ChannelVolume`). Multichannel sources compare as uncorrelated channels of equal power.
+pub(crate) fn native_fold_gain(channels: u16, local: Option<Vec3>, ears: (Vec3, Vec3)) -> f32 {
+    use skate_audio::dsp::pan::{ANGLE, DISTANCE, Pan2D};
+    let n = usize::from(channels.clamp(1, 2));
+    match local {
+        None => {
+            let mut pan = Pan2D::new(n);
+            if n > 1 {
+                // The bed graph has no panner: L→L, R→R, which a distance-0 layout reproduces.
+                pan.params[DISTANCE] = 0.0;
+            }
+            let m = pan.matrix();
+            let native: f32 = (0..n).map(|r| fold_row(&m[r])).map(|(l, r)| l * l + r * r).sum();
+            // Bevy: a mono clip is duplicated to both ears (power 2); stereo plays L, R as they are
+            // (power 2 for two channels of unit power).
+            (native / 2.0).sqrt()
+        }
+        Some(p) => {
+            let azimuth = p.x.atan2(-p.z).to_degrees();
+            let mut pan = Pan2D::new(1);
+            pan.params[ANGLE] = azimuth;
+            let (l, r) = fold_row(&pan.matrix()[0]);
+            let (dl, dr) = (p.distance(ears.0), p.distance(ears.1));
+            let gap = ears.0.distance(ears.1).max(1e-6);
+            let side = |d_this: f32, d_other: f32| (((d_this - d_other) / gap + 1.0) / 4.0 + 0.5).min(1.0);
+            let (bl, br) = (side(dl, dr), side(dr, dl));
+            // Rodio sums the channels into one: n uncorrelated channels carry n × the power.
+            let bevy = n as f32 * (bl * bl + br * br);
+            if bevy <= 0.0 { 1.0 } else { ((l * l + r * r) / bevy).sqrt() }
+        }
+    }
 }
 
 /// Largest volume for a clip whose loudest sample is `peak` (0..1 of full scale).
@@ -116,6 +183,23 @@ fn clamp_pitch(pitch: f32) -> f32 {
 }
 
 impl Voices {
+    fn scale_or_one(&self) -> f32 {
+        if self.scale > 0.0 && self.scale.is_finite() { self.scale } else { 1.0 }
+    }
+
+    /// [`native_fold_gain`] while the native host runs, else 1.
+    fn fold_gain(&self, channels: u16, position: Option<Vec3>) -> f32 {
+        if !self.native_fold {
+            return 1.0;
+        }
+        match (position, self.view) {
+            (None, _) => native_fold_gain(channels, None, (Vec3::ZERO, Vec3::X)),
+            (Some(at), Some(view)) => native_fold_gain(channels, Some(view.to_local.transform_point3(at)), view.ears),
+            // No listener yet: as if the sound played ahead.
+            (Some(_), None) => native_fold_gain(channels, Some(Vec3::NEG_Z), (Vec3::new(-0.1, 0.0, 0.0), Vec3::new(0.1, 0.0, 0.0))),
+        }
+    }
+
     /// Whether a new voice for `clip` may start now (`now` = real seconds).
     fn admit(&self, clip: &Clip, now: f64) -> bool {
         let active = self.voices.iter().filter(|v| v.stopping.is_none());
@@ -136,8 +220,9 @@ impl Voices {
         // One-shots start at their final level (no fade, no ramp); loops and
         // faded sounds start silent until `sync` applies the faded-in gain.
         let instant = !play.looping && play.fade_in <= MIN_FADE;
+        let fold = self.fold_gain(clip.channels, play.position);
         let initial = if instant {
-            volume * envelope_at(play.envelope, 0.0) * self.mix[play.category as usize]
+            volume * envelope_at(play.envelope, 0.0) * self.mix[play.category as usize] * self.scale_or_one() * fold
         } else {
             0.0
         };
@@ -159,7 +244,7 @@ impl Voices {
             volume, max_volume: max, pitch: speed, gain: if instant { volume } else { 0.0 }, speed,
             position: play.position, attack: play.fade_in.max(MIN_FADE),
             attack_elapsed: if instant { MIN_FADE } else { 0.0 },
-            stopping: None, pending: 0.0, envelope: play.envelope, age: 0.0,
+            stopping: None, pending: 0.0, envelope: play.envelope, age: 0.0, channels: clip.channels,
         });
         Some(id)
     }
@@ -219,8 +304,14 @@ pub(super) fn sync(
     time: Res<Time<Real>>,
     menu: Option<Res<crate::graphics_menu::Menu>>,
     replay: Res<crate::replay::Replay>,
+    listener: Query<(&GlobalTransform, &SpatialListener), With<super::GameAudioListener>>,
 ) {
+    let _timing = super::timing::scope(&super::timing::VOICES);
     let Some(settings) = settings else { return };
+    voices.view = listener.iter().next().map(|(t, l)| ListenerView {
+        to_local: t.affine().inverse(),
+        ears: (l.left_ear_offset, l.right_ear_offset),
+    });
     let dt = time.delta_secs().clamp(0.0, 0.25);
     let silenced = super::silenced(menu.as_deref(), &replay);
     let master = settings.master().clamp(0.0, 1.0);
@@ -228,8 +319,10 @@ pub(super) fn sync(
         voices.mix[category as usize] = settings.category(category).clamp(0.0, 1.0) * master;
     }
     voices.silenced = silenced;
+    let scale = voices.scale_or_one();
+    let folds: Vec<f32> = voices.voices.iter().map(|v| voices.fold_gain(v.channels, v.position)).collect();
     let mut finished = Vec::new();
-    for v in &mut voices.voices {
+    for (v, fold) in voices.voices.iter_mut().zip(folds) {
         let Ok((sink, spatial, mut playback, mut transform)) = sinks.get_mut(v.entity) else {
             // Not spawned yet (commands from this frame) or despawned elsewhere.
             v.pending += dt;
@@ -250,7 +343,7 @@ pub(super) fn sync(
         v.speed += (v.pitch - v.speed) * (1.0 - (-dt / 0.025).exp());
         let category = settings.category(v.category).clamp(0.0, 1.0);
         let envelope = envelope_at(v.envelope, v.age);
-        let gain = (v.gain * attack * release * envelope).clamp(0.0, v.max_volume) * category * master;
+        let gain = (v.gain * attack * release * envelope).clamp(0.0, v.max_volume) * category * master * scale * fold;
         let speed = v.speed.clamp(0.25, 4.0);
         // Before Bevy creates the sink, keep its initial settings current.
         playback.volume = Volume::Linear(gain);
@@ -286,7 +379,26 @@ mod tests {
     use super::*;
 
     fn clip(name: &str) -> Clip {
-        Clip { handle: Handle::default(), key: name.into(), peak: 1.0 }
+        Clip { handle: Handle::default(), key: name.into(), peak: 1.0, channels: 1 }
+    }
+
+    #[test]
+    fn interim_voices_fold_like_native_ones() {
+        let ears = (Vec3::new(-0.1, 0.0, 0.0), Vec3::new(0.1, 0.0, 0.0));
+        // Non-positional: mono → centre (0.5 per ear vs Bevy's 1), stereo → 0.707.
+        assert!((native_fold_gain(1, None, ears) - 0.5).abs() < 1e-4);
+        assert!((native_fold_gain(2, None, ears) - 0.707).abs() < 1e-3);
+        // Ahead: native 0.5 / 0.5, rodio 0.75 / 0.75 → 2/3.
+        let ahead = native_fold_gain(1, Some(Vec3::new(0.0, 0.0, -10.0)), ears);
+        assert!((ahead - 2.0 / 3.0).abs() < 1e-3, "{ahead}");
+        // Behind: native 0.35 per ear (Ls/Rs), rodio still 0.75 → about −6.6 dB.
+        let behind = native_fold_gain(1, Some(Vec3::new(0.0, 0.0, 10.0)), ears);
+        assert!((20.0 * behind.log10() + 6.6).abs() < 0.3, "{behind}");
+        // Side: native 0.72 / 0.26 (L/Ls pair), rodio 1.0 / 0.5 (power 1.25).
+        let side = native_fold_gain(1, Some(Vec3::new(10.0, 0.0, 0.0)), ears);
+        assert!(side > 0.6 && side < 0.75, "{side}");
+        // Off by default: the interim path is unchanged without the native host.
+        assert_eq!(Voices::default().fold_gain(1, None), 1.0);
     }
 
     #[test]
diff --git a/crates/skate-game/src/physics/foot_physical_output.rs b/crates/skate-game/src/physics/foot_physical_output.rs
index 4f90c06a..0a624687 100644
--- a/crates/skate-game/src/physics/foot_physical_output.rs
+++ b/crates/skate-game/src/physics/foot_physical_output.rs
@@ -25,6 +25,11 @@ impl FootPhysicalOutputs {
             },
         })
     }
+    /// The deck box the feet (and the hands, Skeleton+602/+603) are tested against: DeckWidth / 2
+    /// and DeckFrontEndSize + DeckMidLength / 2.
+    pub fn deck_box(&self) -> (f32, f32) {
+        (self.settings.deck_half_width, self.settings.deck_total_half_length)
+    }
     pub fn publish(&mut self, record: &SkeletonPhysicalRecord, dt: f32) -> FootPhysicalOutput {
         self.output = self.state.update(record, dt, self.settings);
         self.output
diff --git a/docs/hails-additions/02-long-paths.md b/docs/hails-additions/02-long-paths.md
index 1627452e..c5c9b6ff 100644
--- a/docs/hails-additions/02-long-paths.md
+++ b/docs/hails-additions/02-long-paths.md
@@ -45,8 +45,8 @@ the OS setting is sufficient; no code paths need changing.
   the "already enabled" path does nothing; the "disabled" path builds a valid
   PowerShell command (checked with the PowerShell tokenizer); `restart()`
   forwards the original arguments.
-- **Not exercised end to end:** the real UAC prompt with long paths disabled,
-  and the frozen `skate3setup.exe` relaunch.
+- **Tested end to end (2026-10-02, the user):** the real UAC prompt with long
+  paths disabled, and the frozen `skate3setup.exe` relaunch.
 
 ## Notes for upstream
 
diff --git a/docs/hails-additions/05-collision-volumes.md b/docs/hails-additions/05-collision-volumes.md
index 0164a86a..50f7468e 100644
--- a/docs/hails-additions/05-collision-volumes.md
+++ b/docs/hails-additions/05-collision-volumes.md
@@ -16,15 +16,17 @@ volumes. The game's loader (`skate_world::retail_collision_world`, via
 `skate_data::retail_collision::visit_clusters`) turned every triangle into
 solid collision, so these volumes became invisible walls, floors and ceilings.
 
-SkateSchool has seven, all in its global stream (`cSim_Global.xsf`):
+SkateSchool has seven, all in its global stream (`cSim_Global.xsf`). Names
+are those of the matching retail trigger-volume records (see "What the boxes
+are" below):
 
-| Box (X / Y / Z, metres) | Effect in game |
-|---|---|
-| −79…16.5 / −1.53…6.65 / −43…52 | covers the whole school area; the authored start (y 0.11) is inside it |
-| −66…−62 / −1.53…6.65 / −3.6…12.7 | the invisible wall in the spawn area |
-| −11…2.5 / 0…4.16 / −2.6…1.6 (three identical) | invisible block near the origin |
-| level bounds, Y −73…79 | floor under the whole map |
-| one more box | — |
+| Box (X / Y / Z, metres) | Name | Effect in game |
+|---|---|---|
+| −79.1…16.5 / −1.53…6.65 / −43.3…52.3 | `tut_sksc_inthehub_vol_02` | covers the whole school area; the authored start (y 0.11) is inside it |
+| −62.1…−0.5 / −1.53…6.65 / −3.6…12.7 | `tut_sksc_inthehub_vol_01` | the invisible wall in the spawn area |
+| −11.0…2.5 / 0…4.17 / −2.6…1.6 (three identical) | `coach_frank_sksc` / `ws_sksc_coachfrank_instance_01` | invisible block near the origin |
+| −212…578 / −73…79 / −483…492 | `tut_sksc_reset_vol01` | level bounds: floor under the whole map |
+| 104.1…199.7 / −4.1…4.1 / 151.5…247.1 | `tut_sksc_wrongway_vol_01` | — |
 
 Evidence that these are not solid in the original game: every authored
 SkateSchool locator (Coach Frank, the hub, all tutorial stations) is at
@@ -82,7 +84,8 @@ refresh.
   afterwards and are also clear.
 
 Further evidence the volumes are triggers: MegaPark's only box
-(X 61.4–73.2, Y −4.1…4.1, Z −140.8…−132.6) surrounds the stadium's arrival
+(`tele_stadium_to_world_volume_a`, X 61.4–73.2, Y −4.1…4.1,
+Z −140.8…−132.6) surrounds the stadium's arrival
 point from the world (`tele_world_to_stadium_dest_locator_01`, 2 m from its
 centre), and one of Maloof's two boxes lies 14 m from its arrival point from
 DownTown (`tele_dwtn_to_mmcp_dest_locator_01`). The other Maloof box
@@ -97,3 +100,36 @@ DownTown (`tele_dwtn_to_mmcp_dest_locator_01`). The other Maloof box
   boxes, and authored player positions lie inside some). If retail code that
   consumes these volumes (zones/triggers) is ported later, they should be
   routed there instead of dropped.
+
+## What the boxes are (research, 2026-10-02)
+
+Every surfaceless box is the shape of a named **trigger volume**: a volume-set
+record (type `0x00EB0019`: matrix, bounding box, link, instance id, name) in the
+same stream, whose bounding box matches the box to the millimetre. Retail
+registers them as triggers when the stream loads and posts enter/exit events;
+they are never solid. All 12 boxes:
+
+| District | Volumes |
+|---|---|
+| SkateSchool | `coach_frank_sksc`, `ws_sksc_coachfrank_instance_01` (same box, 3 meshes), `tut_sksc_inthehub_vol_01`, `tut_sksc_inthehub_vol_02`, `tut_sksc_reset_vol01`, `tut_sksc_wrongway_vol_01` |
+| MegaPark | `tele_stadium_to_world_volume_a` |
+| MaloofMoneyCup | `tele_mega_ramp_up_volume_01` (X −9.3…−6.5, Z 54.5…56.5), `tele_mmcp_to_dwtn_volume_01` (X 36.2…42.1, Z 12.8…26.6) |
+| DownTown | `dwtn_sessionspot_01_kubetower_volume_01` (X 259–333), `dwtn_sessionspot_02_spillway_volume_02` (X 66.2…105.9, Y 50.2…59.0, Z −244.7…−212.2) |
+
+The `tele_*` volumes are where retail offers a teleport (a yes/no challenge
+prompt). Exporting them as data the game can use (a "which volumes contain this
+point" query) is planned follow-up work; this change only stops them being
+solid. Research source: the TU3 code via the skate3recomp static recompilation
+(reference only).
+
+## Correction (2026-10-02)
+
+An earlier version of this document gave the SkateSchool spawn-wall box as
+X −66…−62. That came from an analysis script using the vendored Python
+collision decoder, which reads the 16-bit compressed vertex deltas as
+**signed**; vertices in clusters spanning more than 32.8 m then wrap by
+65.536 m. The game's Rust decoder (`retail_collision.rs`) reads them unsigned,
+as retail does, so **the game and this change were never affected**: the
+triangle counts and play tests above are unchanged. Re-run with unsigned
+deltas, every box now matches its retail trigger-volume record exactly. The
+real box is X −62.1…−0.5 (`tut_sksc_inthehub_vol_01`).
diff --git a/docs/hails-additions/11-audio.md b/docs/hails-additions/11-audio.md
index 11debb48..9cff97da 100644
--- a/docs/hails-additions/11-audio.md
+++ b/docs/hails-additions/11-audio.md
@@ -1,6 +1,6 @@
 # 11 — Game audio (ambience, rolling, trick cues, footsteps, water)
 
-**Branch:** `gameplay/audio` (from `gameplay/water`; committed 2026-10-02). Upstream form: `audio/retail-audio`, a draft PR marked Work in Progress. **Status:** implemented and tuned
+**Branch:** `gameplay/audio` (from `gameplay/water`; partly committed 2026-10-02; the world-audio work since then is uncommitted until the user's batch commit). Upstream form: `audio/retail-audio`, draft PR #32, marked Work in Progress. **Status:** implemented and tuned
 by ear over ~15 play sessions with the user (2026-10-01). Most cues are confirmed in play; the rest are marked
 **not yet confirmed** below. All sample choices are project choices, not retail event data.
 
@@ -135,12 +135,40 @@ surface it lands on.
 lowest value, drifts back up over ~2 s) and fires when a foot that lifted > 5 cm above rest comes back
 within 2 cm. `AudibleFootStepStrength` only scales the volume.
 
-**Surface → grain** (`cues::grain_for`, audio surface names from the map tooling's `_AUDIO_NAMES`,
-`tools/vendor/university/…/owned_world_material_addon/__init__.py`): 1 asphalt_smooth; 2 asphalt_rough;
-4, 66 concrete_rough; 5, 8, 10, 55, 56 concrete_aggregate (aggregate, dirt, grass, leaves, bush);
-6, 7, 41–46, 90 wood_ramp; metal IDs → metal_smooth; everything else (Concrete_Polished = 3, curbs, tile,
-marble, unlisted) concrete_smooth. Only the "hard" grains exist for every surface, so those are used;
-retail was measured playing the same "hard" grains (concrete_smooth/wood_ramp/asphalt_rough/metal_smooth).
+**Surface → grain (`cues::grain_for`), CORRECTED 2026-10-02 to retail's own surface map.**
+
+The old table was our own guess by surface name. The grain player research
+(`.claude/notes/grain-player-spec.md` §1.4) decoded retail's chain: a wheel's 7-bit audio surface tag →
+material (tag − 1) → the vault's `Sk8::AudioSurfaceMap` → rolling surface 1–14 → grain. The function now
+follows it exactly:
+
+| Rolling surface | Grain | Tags |
+|---|---|---|
+| 1 | asphalt_rough | 2 |
+| 2 | concrete_rough | 4, 66 |
+| 3 | asphalt_smooth | 1, 55, 56, 61, 62, 71–83, 86–88, ≥ 95, 0 (no material): **the default** |
+| 4 | concrete_smooth | 3, 51–54, 57, 60, 63–65, 92, 93 |
+| 5 | wood_ramp | 6, 7, 41–50, 58, 59, 94 |
+| 6 | concrete_aggregate | 5 |
+| 9 | metal_smooth | 9, 11–36, 38–40, 84, 85, 89, 91 |
+
+**What changed audibly:**
+- **Asphalt is the default:** unlisted and high tags now play asphalt_smooth, not concrete_smooth.
+- **Wood:** tags 47–50, 58, 59 and 94 now play wood.
+- **Asphalt:** 55 and 56 now play asphalt, not aggregate.
+- **Concrete:** 51–54, 57, 60, 63–65, 92 and 93 stay concrete_smooth (now explicit).
+- **Metal:** 84 is now metal.
+
+**Still interim, marked in the code:**
+- **No grain in retail.** Rolling surfaces 7 (tags 10, 70), 8 (8), 10 (67), 12 (68, 69) and 13 (37)
+  play a per-surface `Class_rolling` patch (selectors 1, 2, 10, 11, 9), which needs the AEMS evaluator.
+  Until then they keep stand-in grains: aggregate for 8/10/70, metal for 37/67–69.
+- **Uncertain:** tag 90 (rolling surface 0, no grain member) keeps wood_ramp.
+- **Soft wheels:** only the hard members play. Retail picks the soft member when an audio-state flag is
+  set (Motion+200 < 0.5, meaning not decoded yet). Surface 9 has only a hard member.
+- **The speed-band loops are still interim:** retail's grain player reads windows from the sweep (two
+  players per truck, a Bézier speed → position curve, equal-power crossfades, a grain every 0.3 s). See
+  the native-runtime research.
 
 ### Measured retail mapping (2026-10-01)
 The pop/flip/landing/board-down/grind/bail cues above use the retail SPLC patches that a **local
@@ -207,7 +235,105 @@ water "overlapping or playing too many times".
 University: the plaza channel is `fountains_waterlaps_left` (a 37 s loop; patch 347) in a 6 × 4 × 47 m
 ellipsoid, next to `water_fountain` in a 13 × 7 × 61 m one.
 
-### Ambience per map (project choice by bed name; retail switches beds by zone via `.ems` files)
+### Random distant one-shots: sirens, horns, dogs, jets (`random_sets.rs`, 2026-10-02)
+
+Retail has occasional police sirens and other distant city sounds. They come from a location-based
+random one-shot scheduler, not from placed emitters.
+
+**Location → set:**
+- The game queries the district's world-painter region layer `audio_emitters` at the skater's x, z.
+- The layer is 128 m tiles of quadtrees in the `cSim_*.xsf` streams of `worldDIST_<district>.big`.
+- Each leaf holds the key of an `aud_wp_emitters` record (57 sets). Examples:
+  - `e_dwtn_office_buildings`: a sound every 2–5 s at level 0.2–1.0, 23 weighted sounds including city
+    sirens;
+  - `e_dwtn_spillway_brewery` (the Aletown spawn): every 4–8 s, 15 sounds including 5 sirens.
+- Setup exports the sets (`audio_export.random_sets`) and the region tiles (`audio_export.regions`,
+  parser `audio_formats.region_layers`), and decodes their banks. The manifest now has 222 banks.
+
+**Scheduler (from TU3):**
+- At most 2 banks are loaded, each picked by weight.
+- A timer fires the loaded sound that was loaded longest ago, every uniform min..max seconds.
+- Level = sound volume × a 0.1-step random factor in the set's range.
+- A post comes from a random fixed direction (not positional) and ends with its program or its timeout:
+  sirens 19.5 s, dogs 5 s.
+- Each bank's program (layers, delays, pan sweep) is measured per bank in `random_programs.rs` until the
+  AEMS evaluator is ported.
+- Four banks never answer their attribute's selector (`Siren_city_5/6`, `car_horn_city_2/3`), so they
+  stay silent here as in retail.
+
+**Verified:**
+- A recomp trace at the Aletown spawn shows set `e_dwtn_spillway_brewery` firing a sound every 4.5–7.8 s,
+  including `Siren_distant_2` and `Siren_city_8`.
+- Our region lookup returns the same set there, and `e_univ_megapark` at the University start, as the
+  recomp does.
+- A 15-location recomp run (5 teleports each in Downtown, Industrial and University, 45 s at each) gives
+  our lookup the same set as retail on **1,859 of 1,859** position samples, across 15 different sets.
+  Retail's fired sounds fit each place: sirens, horns and a car crash downtown; seagulls at the docks;
+  wolves and coyotes at the Spillway; hawks and rockfalls at the mega-park.
+- Retail fired `Siren_city_5` at Hotel District and no siren sample played, so the banks we keep silent
+  are silent in retail too.
+- **Long runs (5 minutes per location, 2026-10-02)** — *re-verify on clean data: the long_* sessions were deleted
+  (malformed, interleaved trace lines; user, 2026-10-02):*
+  - **All 36 Challenge Map locations** (Downtown 14, Industrial 12, University 10). Our location sets match
+    the game on **26,817 of 26,817** samples, across 28 sets.
+  - The game's ambience zone (trace hook AMBST) equals our `audio_ambience` lookup at every location in
+    all three districts.
+  - Every drawn interval lies within its set's range.
+  - About 60% of intervals fire a sound, matching the 2-loaded-banks rule.
+  - Rare sounds need long listening: `work_whistles` never fired in about 20 minutes of the factory set,
+    nor hawks and rattle_snake at the mega-park or cicadas at the Observatory in 5 minutes each.
+  - Tools: `.claude/skills/audio-tuning/tools/{check_sets_vs_trace,long_run_stats}.py`.
+- Muted in-game run: our engine at Aletown selects the same set and fires sirens, horns, buses and bangs.
+- The small parks have no `audio_emitters` layer, so no random one-shots play there.
+- `SKATE_AUDIO_SET=<name>` forces a set for testing.
+
+### Zone ambience beds (`ambience.rs`, 2026-10-02): replaces the per-map bed choice
+
+**Data:**
+- The zone is the district's region layer `audio_ambience` at the skater's x, z: an `aud_wp_ambiences`
+  record (23 zones) with volume, bed number, fade-out time (+8) and fade-in time (+12).
+- Bed number `NN` is the `ambience.big` stream whose name starts with `NN_`. Index 19 exists twice; retail
+  takes the first in TOC order, `19_reclaimed_b_fix`, and so do we now.
+- `aud_wp_ambience_crossfades` (23 pairs, e.g. `dt_03_main2dt_open`) map a zone pair to a group of the
+  district's `Main_Ambience_Crossfade_DT/Ind/Uni` bank, with a level.
+- Setup exports zones and crossfades (`audio_export.ambience_zones`) and decodes the three crossfade banks.
+
+**Behaviour (TU3 SFXObj_Ambience, reference only):**
+- **One bed at a time.** On a zone change the old bed fades out linearly over the old zone's fade-out
+  time and stops, then the new bed fades in over the new zone's fade-in time. A return during the
+  fade-out fades the same bed back in; a change during a fade-in waits until it ends.
+- **Crossfade layer.** For the whole transition the crossfade group of the pair (either order; group 1,
+  level 1.0 by default) plays: four looping 2 s voices at quad directions, rear voices at ≈0.70 (measured
+  per group, `crossfade_groups.rs`). It stops when the fade-in ends.
+- **Districts.** The parks have no crossfade bank, so no crossfade layer there.
+- **No panning.** Beds aren't positional.
+- **Old installs.** Without zone data (manifest v3) the old per-map table below is the fallback.
+
+**Verified (muted run, DownTown):**
+- The spawn is `dt_less_busy`. Moving into `dt_main` played crossfade group 2 at level 1.75 (the data's
+  `dt_02_less_busy2dt`), then the `dt_main` bed.
+- The teleport to Aletown played group 3 at 1.25 (`dt_03_main2dt_open`), and `06_dt_open` started after
+  `dt_main`'s 1.75 s fade-out.
+- The teleport to Hotel District used the same pair in reverse.
+
+**Bed level (verified 2026-10-02):** the Ambience MixMap's bed output carries a **−11 dB base**. Retail
+captures at four zones were checked with `.claude/skills/audio-tuning/tools/check_bed_level.py`: the bed's
+5-channel stream × zone volume, folded like the recomp's capture.
+
+| Zone (volume) | Retail median | Predicted with −11 dB | Without |
+|---|---|---|---|
+| dt_open (0.75) | −42.1 dBFS | −42.1 | −31.1 |
+| dt_main (0.6) | −39.2 | −38.7 | −27.7 |
+| dt_rez (0.75) | −44.2 | −43.6 | −32.6 |
+| indu_quarry (0.8) | −47.7 | −47.8 | −36.8 |
+
+The bed gain is now zone volume × 10^(−11/20) × `cues::RETAIL_SCALE`. Our levels run at 2 × retail, so
+this keeps retail's bed-to-player balance. Before this the beds were 11 dB too loud relative to retail.
+
+**Not decoded yet:** the other MixMap outputs feeding the bed (pitch, low-pass), the crossfade level
+(taken as full scale), and ducking. Trace hooks for them are listed in the notes.
+
+### Ambience per map: fallback only (installs without zone data; project choice by bed name)
 
 | Map | Bed |
 |---|---|
@@ -263,6 +389,9 @@ ellipsoid, next to `water_fountain` in a 13 × 7 × 61 m one.
 - **Validation of the ear-picked samples:** every group the user picked is exactly one retail record in
   `Skate_Collisions`: pop 1074–1078 = record 818, landing 1088–1092 = records 824/825, heavy 1097–1100 =
   records 832/833, board-down 0/1/2 = records 125/126/127, splash 476–478 = part of record 869.
+- **Corrected 2026-10-02 from the retail Splice code** (`sub_82975CC8` / `sub_82976860`): member `+4` is the gain,
+  `+8` the pitch, `+44` the gain spread, `+48` the pitch randomisation, `+64` the probability (the field roles
+  above and PR #4's were swapped); the native Splice player uses these (see "Board contacts, skid and squeaks").
 - **Splash now plays record 869** (three layers: 169 at 75 % probability + one of 476–478 + one of 171/172).
 - Setup exports each SPLC bank's patch tree in `audio_manifest.json` (`patches`, manifest v3).
 - PR #4's own pop/landing ids are different, layered patches (e.g. container 1097 → records 745–750, each
@@ -324,8 +453,14 @@ Each step came from the user's report of an in-play session plus the `AUDIO_*` l
 ## Files
 
 - New: `tools/asset_pipeline/audio_formats.py`, `audio_export.py`, `test_audio_formats.py`,
-  `tools/audio_audition.py`, `crates/skate-game/src/game_audio/{mod,library,voices,ambience,cues,skate_events,water}.rs`,
+  `tools/audio_audition.py`, `crates/skate-game/src/game_audio/{mod,library,voices,ambience,cues,skate_events}.rs`,
   `crates/skate-data/examples/audio_surfaces.rs`.
+- 2026-10-02 world audio:
+  - `game_audio/emitters.rs` replaces `water.rs`;
+  - new `random_sets.rs`, `random_programs.rs` (generated), `crossfade_groups.rs` (generated);
+  - `ambience.rs` rewritten for the zone beds; `library.rs` reads manifest v4;
+  - `audio_formats.py`: `.ems` reader, `name_id`, region layers; `audio_export.py`: emitters, location
+    sets, zones and crossfades, regions, emitter and crossfade banks.
 - Changed: `tools/asset_pipeline/{asset_exports,install,versions,group_receipts}.py`,
   `tools/asset_pipeline/test_versions.py` and `tools/test_setup_assets.py` (hand-written group lists),
   `crates/skate-core/src/physics/board_ground.rs` (+ test), `crates/skate-game/src/{main,app,config,graphics_menu,physics}.rs`,
@@ -347,15 +482,1721 @@ Each step came from the user's report of an in-play session plus the `AUDIO_*` l
 - **Not yet done:** full `regression-check` pass and a setup refresh through the installer path (only the
   `audio` group should rebuild).
 
+### Native audio runtime: research (2026-10-02)
+The measured per-bank tables (`emitters.rs` PROFILES, `random_programs.rs`, `crossfade_groups.rs`, the
+`cues.rs` tables) are interim. The plan is to replace them with our own implementation of the retail
+runtime:
+- the AEMS patch-program evaluator;
+- the voice graph: sample player, resampler, RBJ Q = 1 filters, gain with a 64-sample de-click,
+  6-channel pan, sends;
+- the MixMap mixer and the granular rolling bed.
+Specs written so far: evaluator (all 40 opcodes, checked against the recompiled game across all 376
+banks), voice graph, and a prior-art survey. The MixMap and grain player specs are in progress.
+
+**Design goal: modular and moddable (2026-10-02).**
+- Each subsystem sits behind a clear boundary: formats, evaluator, voice graph, mixer and buses, MixMap,
+  grain player, world systems, output host.
+- Every sound resolves by its retail identity (bank + patch, sample, set/zone key) through a content
+  layer: mod override first, then retail. Mods can replace samples, banks and programs, location sets,
+  emitters and ambience.
+- The Lua SDK grows from today's play/update/stop of mod WAVs. Planned: posting retail sounds, setting
+  globals, reading MixMap values, hooking game audio events (to replace, suppress or layer), and mod
+  emitters on the same voice graph and buses. The existing commands keep working.
+
+The evaluator research found that upstream #4's evaluator mishandles op 5 (CallFunction), so its
+sample-selection functions never run, and lacks ops 19/20/38. Measurements taken through it are therefore
+reliable for timing, layers and pans, but not for which sample a function-driven bank (sirens, dogs, birds)
+picks.
+
+### Native AEMS runtime: implementation (2026-10-02, `crates/skate-audio`)
+**Problem.** Every world bank's behaviour was a measured table. Retail runs each bank's own patch
+program through the AEMS evaluator and a fixed voice graph.
+
+**Approach.** A new engine-independent crate, `crates/skate-audio` (`#![forbid(unsafe_code)]`, no Bevy, no
+dependencies), written from our specs (`.claude/notes/aems-evaluator-spec.md`,
+`aems-voice-graph-spec.md`):
+- `formats/`: ABKC module banks (modules, programs, templates, interface exports, the `S10A` sample bank),
+  MOIR Csis projects, EA SNR sample headers. Bank load rejects opcodes ≥ 40 and programs whose block
+  walk does not end at the template size.
+- `eval/`: the evaluator. Instance memory is a byte copy of the module's template, read and written as
+  big-endian words at retail's offsets, so programs run untranslated. All 40 opcodes, including 19/20
+  (n-ary min/max) and 38 (ControlClass, a child post); the shared 6-word RNG from zero; the 6-block tick
+  with tick scale f32 31.999998; Csis classes (constructor clients, newest bank first), functions
+  (synchronous delivery, seen at the subscriber's next op 37) and global variables (notify on change);
+  post / redeliver / release with refcounted nodes; Destroy releasing voices and child posts; the
+  Player op (open applies the full input set, changed inputs pushed, query → time left / time current,
+  restart only on a 0 → 1 edge, no restart of a voice that died while paused).
+- `dsp/`: Resample (16.16 linear with retail's weight constant 0x377FFC9C, ≤ 4×), High/LowPassIir2
+  (RBJ Q = 1, bypass outside 24 Hz … 0.999·Nyquist), Gain (64-sample de-click), Send (64/65 ramp, 16-tap
+  release fold), Pan2D1 (6 outputs, pairwise constant power with centre extraction, distance spread,
+  multichannel layouts, 64-sample matrix ramp), the route tables and the output stage's stereo fold
+  (0.707·L + 0.5·C + 0.5·Ls, clamp ±1, no master gain).
+- `mixer.rs`: voices built from those modules (first block silent = format change, 16-frame stop fade,
+  loops, source-time remaining/elapsed for the Player op), implementing the evaluator's `VoiceHost`;
+  routing codes (ids ≥ 9) are parsed and kept, every voice mixes into the default bus.
+- `runtime.rs`: evaluator + mixer on one 256-frame block clock (render, then tick: a walk's voice
+  commands apply from the next block, as retail drains its command ring per block).
+
+**Game side.** `game_audio/native.rs` hosts it: off by default; `SKATE_AEMS=1` or `"native": true` in
+`settings/audio.json` turns it on. All Csis projects install at startup, `emitter_utility` is posted as at
+boot, banks load on first use (their WAVs as PCM) and unload on map change; one device-paced rodio stream
+pulls 48 kHz stereo; volume = master × ambience, paused while silenced. So far only the `.ems` world
+emitters use it (`emitters.rs`): with it on, **every** emitter record whose bank is in the install plays
+its retail program (DownTown: 176 of 176 records, against 30 with a measured profile), posting
+`c_emitter` with w0 32767, w1 = dry level (our falloff level; MixMap not ported), w3 = azimuth
+(0 = ahead, clockwise, 65536 = 360°), w4 4096, w5 25000, w8 = the attribute patch; redelivered every
+frame, released when the listener leaves. Location sets, zone beds, crossfades and skate cues keep their
+tables.
+
+**Setup.** `audio_export.aems_files` copies every `.csi` (archive order) and the exported banks' `.abk`
+files plus `emitter_utility.abk` byte for byte into `private/audio/aems/` (52 MB), listed under the
+manifest's `aems` key; manifest version 5 (`library.rs` reads 3..5). All 376 banks keep their rebase and
+interface lists after the sample data, so the whole file is needed. S10A slot i = WAV i on all 376 banks.
+
+**Evidence.**
+- Format census against the spec on every disc bank (`tests/disc_banks.rs`): 376 banks / 385 modules
+  parse; opcode counts equal the spec's census exactly; every op 0/1/2/37 block sits on the laid-out
+  subscription state; op 5/27/38 block sizes match their layouts; 1,059 exports resolve except exactly
+  the 4 the spec lists; 291 banks bind to `c_emitter`.
+- **Evaluator vs the PoC oracle** (our probe `aems_golden` in the local PoC worktree, with its op 5
+  fixed and n-ary min/max added locally, never committed; identical mock voice device on both sides):
+  **234 of 235 scripts identical — 88,597 device calls (open / set / azimuth / release / end) and 599
+  voice opens, 0 differences.** Scripts: one per emitter and location-set bank in the manifest
+  (utility at boot, release at 20 s), both crossfade banks with group changes, sirens posted twice, and
+  28 player/world classes (grinds, footsteps, cloth, seams, rolling, traffic, crowds incl. op 20, car
+  alarms, moveables, flips…) with moving payloads. Every opcode used on the disc ran except 38. Before
+  the PoC's op 5 was fixed, 30 scripts differed, all at the first sample choice of a function-driven
+  bank: the native port delivers `*_msg` calls, as retail does (spec §11).
+- The remaining script, Tazer (op 38), has no oracle: `tazer_control_class_owns_and_releases_its_child`
+  checks the child post's lifecycle (refcount 3 while the child lives, 1 after it ends itself; parent
+  release clears every instance, node and voice).
+- **Voice graph vs the PoC's replay-verified kernels** (`tests/dsp_oracle.rs`, vectors from our local
+  probe `dsp_vectors`): Resample **16,384 / 16,384 samples bit-exact** (8 steps from 1/65536 to the 4×
+  clamp); LPF coefficients **40 / 40 words bit-exact** (image trig); biquad kernel **16,384 / 16,384
+  bit-exact** over 8 cutoffs (25 Hz … 23975 Hz) after fitting retail's per-position association of the
+  fused multiply-adds black-box against the oracle (`fit_biquad_association`, every position 100 %);
+  gain ramp 1,013 / 1,024 bit-exact, the rest 1 ulp (lane arithmetic for irregular steps not recovered).
+- Pan gains match all 13 worked cases of the spec (≤ 1.5e-4).
+- Headless renders (`examples/aems_render.rs`, real banks and WAVs through the whole graph and the
+  stereo fold): water_fountain relay −28 dBFS RMS, trees_rustle gusts −38…−44, Siren_city_4 two layers
+  then silence after its sample; about 2,000× real time.
+
+**Files.** New: `crates/skate-audio/**` (lib, `tests/disc_banks.rs`, `tests/dsp_oracle.rs`, examples
+`aems_replay`, `aems_list`, `aems_render`), `crates/skate-game/src/game_audio/native.rs`. Changed:
+`Cargo.toml` (workspace member), `Cargo.lock`, `crates/skate-game/Cargo.toml`, `game_audio/{mod,library,emitters}.rs`,
+`tools/asset_pipeline/audio_export.py` (+ test). Local tools: `.claude/skills/aems-port/tools/`.
+
+**Verification run.** `cargo test -p skate-audio --release`: 45 unit + 3 disc + 3 oracle tests pass
+(2 ignored fit tests). `cargo test -p skate-game --release --bin skate3rust`: `game_audio` 35/35, the
+whole suite 354 passed with only the known `pipelines_accept_valid_group_outputs_when_fingerprint_changes`
+failure. Pipeline tests (`test_audio_formats`, `test_versions`, `test_setup_assets`) 32/32. One muted
+start with `SKATE_AEMS=1` on DownTown: runtime on, 176/176 records, `trees_rustle` started natively,
+no panic; with it off, the old 30/176 path unchanged. **Needs a listening check in game by the user.**
+
+**Not modelled yet / open** (marked UNCERTAIN in the specs, nothing invented): the environment send
+(Send A) and effect returns (Send B, codes 4096/8192/16384), the material buses and 512/2048 buses (their
+authored values are not recovered), so every voice mixes dry into the default bus; the sample-group
+"level %" byte (not applied); pause/resume Send modes; loop time-left semantics (we report time left in
+the current pass); SndPlayer pre-roll; the gain ramp's last ulp; who writes `c_emitter` w0 (we pass
+32767) and the MixMap channels that should feed w1/w2/w3 (done since, next section). Next: retiring
+`random_programs.rs`, `crossfade_groups.rs` and the cue tables one at a time.
+
+### MixMap and the granular rolling bed: implementation (2026-10-02, `crates/skate-audio`)
+**Problem.** The native runtime's `c_emitter` words were stubs (dry = our falloff level, no send, fixed
+pitch/filter), and the rolling bed was our own approximation: each `.grain` recording cut into 6 looped
+speed bands. Retail mixes every audio object through the MixMap (`MixMapSK8.mxb`: 247 controllers feeding
+per-object volumes, pitches, filters and pans) and plays the bed with a granular player.
+
+**Root cause / retail mechanism** (specs `.claude/notes/mixmap-spec.md`, `grain-player-spec.md`): the
+MixMap is a fixed graph of input products (A), distance/azimuth lookups with Doppler (B), AHR/ADSR ducks
+(F), clamped sums (C) and output sums (E) evaluated once per 60 Hz frame; the bed is two GrainPlayers per
+truck reading windows of one slow-to-fast recording around a speed-driven read position, picked without
+repeats and cross-faded with square-root fades, rescheduled every 256-frame block.
+
+**Change.**
+- `crates/skate-audio/src/mixmap/`: `format.rs` (file decoding), `tables.rs` (POW/LOG/CURVE/SEMI/FINE by
+  formula, the four FINE ulps and three image floats as stored: K = ±0x3FFF1FC4, 16.666, 16.66667), the
+  evaluator `mod.rs` (instances per slot, cross-slot reference expansion, input runs by curve kind, the
+  one-tick lags, envelopes, Doppler slew, the output conversions and their quirks: 0 mB → 32730, pitch
+  below −4800 → 0, a disabled block writes −10000 read back as 22768) and `keys.rs` (controller keys).
+  Owner readers `level` / `raw` / `pitch_4096` / `filter_hz`. Ported from our own Python reference
+  evaluator (`audio-tuning/tools/re/mxb_tool.py`), no PR #4 code.
+- `crates/skate-audio/src/grain/`: `format.rs` (`.grain` header, stored duration, the run-length varint
+  seek table, EAAC header), `player.rs` (GrainPlayer: the pick with its 16-entry recent list and collapse
+  rule, the per-block scheduler with the drift cut and timer × pitch in sustain, voices SndPlayer1 →
+  Resample → square-root GainFader → Send into the player's mono bus), `board.rs` (per-surface tuning,
+  the Bézier speed → position curve in retail's factored single-precision form, the A/B records, push
+  envelope, slews, the rocket record), `bed.rs` (2 trucks × players A/B with their chains HighPass →
+  LowPass → Gain → Pan2D1 → default bus; the rocket straight into the default bus; one title-wide
+  generator seeded with the image constants). `runtime.rs` renders the bed on the block clock after the
+  AEMS voices.
+- Game (`SKATE_AEMS=1` only; the default path is unchanged): `native.rs` loads the MixMap and runs
+  `mixmap_frame` before the cue systems (fixed 1/60 s steps): inputs Master.in1–4 / Music.in1, 2, 5 /
+  Reverb.in5 = 32767, Pause.in0 while the menu is open, the local player's PlayerPhysics speed words
+  (image scales, clamped), no-contact, wheel count, brake and id 9 = 0, its two 3DObjPos blocks (board seen
+  from the camera, 0.25 m pull-back), Contacts.in1 on landings, the board owner's 0/4/6 pulses. The 5
+  emitter states are the MixMap Emitter instances: `emitters.rs` writes each state's 3-D input and posts
+  `c_emitter` with w1 = out4 × level, w2 = out8 × level, w3 = out0, w4 = out5 (pitch reader), w5 = out6.
+  `grain_bed.rs` drives the bed when the install has the whole recordings: surface routing (one sounding
+  truck, `cues::grain_for`), records from SkateBoard level(1)/(2)/pitch(3), chains from level(11)/(12)/
+  raw(0) and the graph-1 level ramp, the rocket above 35 km/h; the interim speed-band loop then stays
+  silent. Volumes: stream = master, AEMS voices × ambience, bed × effects.
+- Setup (`audio_export.py`): `mixmap_file` copies `MixMapSK8.mxb` to `aems/` (`manifest.aems.mixmap`);
+  `grain_whole` keeps each member's whole decoded recording (`grains/<stem>.wav`) and raw `.grain`;
+  `grain_tuning` exports the vault's grain class, owner class and `Sk8::AudioSurfaceMap` exactly
+  (`manifest.grain_player`). All keys are optional, so the manifest version stays 5. Dev installs:
+  `.claude/skills/aems-port/tools/stage_grain_mixmap.py` adds them without a full setup run.
+
+**Evidence.**
+- **MixMap vs the PoC's port** (PR #4's MixMap run locally as a black box, `mixmap_golden`) **and our
+  Python reference**: 3 golden scripts, 1,500 evaluations, **87,000 / 87,000 output cells identical**
+  (`aems-port/tools/mixmap_compare.py`). golden1/2: ambience fade/crossfade, emitter distance/angle,
+  player speed and Doppler, pause/menu/reverb/HOM ducks, dt changes; golden3 (new): 10 Collision
+  instances, a Traffic drive-by with Doppler and sign-flip resets, the ADSR envelopes (F133/F137/F138 with
+  retrigger), F24, Jitter-driven sums, a dt change.
+- Disc census: 14 slots; 547 input entries, 853 A, 635 B, 350 F, 240 C, 1044 E; 154 output blocks;
+  **247 controllers** (= the retail capture). Generated tables equal the image's (all 512/602/512/12/100
+  entries and the four float constants).
+- **Grain picks: all 16 golden sequences** (A and B params × positions 0 / 0.25 / 0.63 / 1 × generator
+  from zero and from the image seed, 24 picks each) **and the 3 candidate tilings identical** to the PoC's
+  vectors; **positions bit-exact on all 31 POS rows** (concrete_rough_hard and default, 0–80 km/h) after
+  using retail's factored Bézier rounding.
+- The 14 disc members parse (`tests/disc_grains.rs`): single-entry seek tables, pre-roll 384, stored
+  durations; `cues::grain_for` agrees with the install's own AudioSurfaceMap for every grain surface
+  (tags 0–127).
+- Board outputs with our inputs (`examples/board_mix_probe.rs`): grain pitch 0.790 at rest, 0.864 at
+  1 m/s, 0.996 from 5 km/h (retail medians 3209 / ~3500 / ~4080 of 4096); high-pass 77 Hz and low-pass
+  24971 Hz (retail modal 77 / 24971 — 1109 Hz with id 9 = 32767, which is how id 9 = 0 for the local
+  player was confirmed); gain A 0.23–0.26 from 5 km/h (retail p90 7859 = 0.24).
+- Whole bed headless (`examples/grain_bed_render.rs`, concrete_rough_hard): 6.6 grain starts/s after the
+  bind (retail modal 6/s for one truck), at most 4 voices, stereo RMS −40.7 dBFS at 5 km/h rising to
+  −33.3 dBFS at 40 km/h (the recording's own rise plus the MixMap).
+- Unchanged: the evaluator oracle still 234/235 scripts identical.
+
+**Verification run.** `cargo test -p skate-audio --release`: 63 unit + 3 disc-bank + 1 disc-grain + 3 DSP
+oracle tests pass (2 ignored fit tests). `cargo test -p skate-game --release --bin skate3rust`: `game_audio`
+40/40; the whole suite 359 passed with only the known
+`pipelines_accept_valid_group_outputs_when_fingerprint_changes` failure. Pipeline tests
+(`test_audio_formats`, `test_versions`, `test_setup_assets`) 34/34. All headless; **the bed and the new
+emitter words need a listening check in game by the user (`SKATE_AEMS=1`).**
+
+**Files.** New: `crates/skate-audio/src/mixmap/{mod,format,tables,keys,tests}.rs`,
+`crates/skate-audio/src/grain/{mod,format,player,board,bed}.rs`, `crates/skate-audio/tests/disc_grains.rs`,
+examples `mixmap_golden`, `board_mix_probe`, `grain_bed_render`, `game_audio/grain_bed.rs`. Changed:
+`skate-audio` `lib.rs`, `runtime.rs`; `game_audio/{mod,native,emitters,library,skate_events}.rs`;
+`tools/asset_pipeline/audio_export.py` (+ tests). Local tools: `aems-port/tools/mixmap_compare.py`,
+`stage_grain_mixmap.py`; golden3 in `.local/audio-re/mixmap/`.
+
+**Not modelled / open** (nothing invented):
+- MixMap inputs without a game source yet stay 0: Jitter (random every frame in retail), VU meter,
+  Menu/NIS/HOM/Challenge flags, Contacts 2/6, Rail, OffBoard, HandGrabs, PlayerPhysics 3/5/6/11/12/13, the
+  skater-frame azimuths (camera frame used for both), relative speeds (no Doppler), the second player.
+  Retail's medians of gain A (0.06 at 5 km/h, 0.08–0.17 above) are lower than ours (0.23–0.26, near
+  retail's p90); the missing inputs (Jitter scales A63, for one) are the first suspects.
+- Bed: turn intensity (state +204 not mapped), slope, the seam-pattern envelope and the special latch are
+  not wired, so player B (the turning / downhill layer) is silent; FrequencyShiftSsb (allpass
+  coefficients not recovered), graph 3 (clip + shelf copy), the wobble gains and the environment send
+  are not modelled; the fade curve is our equal-power form of retail's square-root code (exact
+  rsqrte/Newton rounding not reproduced); the `Class_rolling` surfaces still use grain stand-ins; in the
+  air the last member keeps playing (retail UNCERTAIN); soft-wheel members unused.
+- Emitter positions reach the MixMap one frame late (inputs written in the cue systems, ticked at the
+  next frame's start).
+- `mixmap-spec.md` §6.2 said PlayerPhysics.in9 = 32767 for the local player; the PoC's input writer and
+  the board's 77 Hz high-pass say 0. With 0 the ambience bed's speed duck (A[Player.5], up to −3 dB) is
+  active — the ambience beds are not native yet, so nothing changes there today.
+
+### Player inputs and the first native player components (2026-10-02, `skate_audio::player`)
+**Problem.** The native runtime left most MixMap inputs at 0 (Jitter, Contacts 2/6, Rail, OffBoard,
+PlayerPhysics 3/5/6/11/12/13, relative speeds), the rolling bed had no turn, slope, seam or special
+input (player B silent), and every player sound still came from the measured cue tables.
+
+**Retail mechanism** (read in the TU3 recompilation; word tables cross-checked with upstream PR #4's
+driver notes): per 60 Hz frame the audio-state bridge `sub_824B0DA8` fills one record per player; the
+state controller writes PlayerPhysics (`sub_824B19C8`); every component *processes* (owner inputs,
+posts, releases), the MixMap evaluates once, then every component *updates* its held packets from the
+owner's outputs and redelivers them.
+
+**Change** (`crates/skate-audio/src/player/`, engine independent, unit-tested):
+- `state.rs`: the audio-state record (`AudioState`, retail offsets in the docs). The game fills it in
+  `skate_events::observe` (`audio_state`): ground speed, COM velocity/position (SystemReckoning),
+  board position/velocity, per-wheel contact / material (tag − 1, 143 none) / **seam pattern** (new
+  in `skate-core` `WheelLineState.seam_patterns`, tag bits 12..15, the part `board_ground.rs` used to
+  drop), turn (`animation_input.fields.turn` = Processed+2676), slope `+712` (pumping absorption),
+  KnownAir (state 200..300 with no wheel down) and our own air timer, the State52/54/59/60 flags
+  (brake, manual brake, bail, balance), trick active / hippy jump (the score packet's scorable id with
+  flag bits 24/25), feet in the deck box (Skeleton 600/601), soft wheels (wheel hardness
+  Processed+2764 < 0.5), latched grind family / material.
+- `inputs.rs`: PlayerPhysics 0–14 (3 = 0 and 13 = 0, see below; 11 = the bail-camera byte held 110
+  frames after a bail — PR #4's capture shape, writer unidentified), Contacts (1 landing pulse, 2 the
+  landing class from the per-wheel air buckets of `sub_824B2350`: ≥ 1 s air → 32767, ≥ 0.62 s →
+  16000; 6 the landing-flag material), Rail 0/1, OffBoard 0.
+- `jitter.rs`: `SFXObj_Jitter`, 24 bounded random walks from the vault (6 write inputs 0–5), own
+  instance of the title generator.
+- `objpos.rs`: the 3DObjPos writer as retail binds it — 60010010 follows the skater's COM (with its
+  velocity), 60010020 the board; camera distance from the camera itself, frame-A azimuth from the
+  0.25 m pulled-back origin, horizontal-plane angles, **signed relative speeds** (Doppler) and the
+  sign-flip bits 31/30.
+- `components.rs`: `Class_grind` (poster `sub_824C28B0`, constructor `sub_824AF8C8`, updater
+  `sub_824C39E0`: layer by family, the family-0 layer-1 companion, V/F levels per grind surface, speed
+  word capped at 9000, the updater's w10 = 1 quirk for family 0), `SenseOfSpeed_rattle` /
+  `SenseOfSpeed_wind` (`sub_824E7980` / `sub_824E7CB0`: rattle ≥ 30 km/h ground speed, wind ≥ 15 km/h
+  COM speed or 1 km/h while bailing), `Class_foot_drag` (`sub_824BB540` / `sub_824AF498` /
+  `sub_824BEEE8`: brake or manual brake, Contacts outputs 4/5/16/17/18/22, foot-drag surface).
+- `grain/board.rs`: turn intensity (`sub_824C8588`: min(clamp(|COM v|·0.24, 0, cap)·turn, cap),
+  forced 0 by a latch, signed slew with the rise step when the target is above), the manual / trick
+  latches, slope levels (owner inputs 2/3, A79 = +244 mB on gain A downhill) and the seam-pattern gain
+  envelope (`sub_824CA448` / `sub_824CA318`: **one** linear ramp from 1 to a random gain per pattern
+  change, then hold — the grain spec's "random walk" corrected; only spidercrack has a wobble ≠ {1, 1}).
+- `mixer.rs`: per-bank volume groups (world / player, our user volumes) and a voice snapshot for
+  diagnostics.
+
+**Game side.** `game_audio/player_audio.rs` hosts it inside `native::mixmap_frame` (inputs → process →
+tick → update). `grain_bed.rs` now feeds turn, special, downhill and the seam envelope into the records
+and picks the **soft** members when the wheels are soft. With `SKATE_AEMS=1` the components run
+(`SKATE_AEMS_PLAYER=0` keeps them off); their banks (GRINDS, sense_of_speed, FOOT_DRAG) load at start
+in the player group (effects volume) and stay across map changes; the interim metal GRINDS loop, the
+sense_of_speed bed cue and the foot-drag pieces are then silent. The default path (native off) is
+unchanged. Setup: `audio_export.player_tuning` exports the AudioSurfaceMap rows, Jitter channels, seam
+wobbles, grind levels (grind surface keys from the image table `0x82249F90`, as constants), wheel
+landing buckets and — only with a TU3 image, so not in setup — the landing-flag materials; dev
+installs: `.claude/skills/aems-port/tools/stage_player_tuning.py`.
+
+**Two values read as "0 for the local player".** PlayerPhysics.in13 is |state+96 − `[G+0x2F078]`+32|:
+`G+0x2F078` is the audio-state record array (player 0 first), so for the local player both are its own
+COM velocity (PR #4 read it as a listener distance). In3 is a facing factor of two PhysOut slot-0
+vectors we have not identified; only A25 reads it, as a factor of the combo emphasis (Music.in3 = 0
+outside combos).
+
+**Evidence.**
+- **Wind level vs retail**: SenseOfSpeed level(4) (= wind w7) at matched COM speeds against PR #4's
+  retail medians: 25 km/h 339 / 343 (−0.10 dB), 30 km/h 693 / 730 (−0.45 dB), 35 km/h 1239 / 1194
+  (+0.32 dB), 40 km/h 2074 / 2017 (+0.24 dB) — test `wind_level_matches_the_retail_medians`.
+- **Components through the real banks, MixMap and voice graph** (test
+  `components_play_their_retail_banks`, 3 s each; gain = master × dry): Class_grind metal 6 m/s
+  median 0.018 / max 0.199, ledge (family 0, two layers) 0.026 / 0.237 — retail Class_grind 0.004–0.11
+  / ≤ 0.28 (session 20261001_211347 — deleted, re-verify on clean data), GRINDS 0.004 / p90 0.027 / max 0.083 (all_20261002_163809);
+  wind + rattle 55 km/h 0.033 / 0.132, 40 km/h 0.004 / 0.015 — retail sense_of_speed 0.003 / p90 0.093
+  / max 0.387; foot drag 4 m/s 0.023 / 0.057 — retail FOOT_DRAG 0.006 / p90 0.075 / max 0.281.
+- Unit tests: Jitter walk bounds and a hand-computed step; 3DObjPos signs and flip bits; landing
+  buckets; grind posts (one layer, family 0 two layers, release, speed cap); rattle/wind thresholds and
+  words; foot drag words; turn intensity cap/slew/latch; latches; slope; seam envelope draw and ramp.
+- Python: `PlayerTuning` export test (leaf channels, parent chain, zero-block patterns, grind defaults).
+- Unchanged: evaluator oracle, MixMap oracle, DSP oracle tests.
+
+**The bed's gain A, investigated** (test `bed_gain_a_with_the_full_inputs`, straight rolling, camera
+3.5 m behind and 1.4 m above):
+
+| km/h | level(1) before (no Jitter) | level(1) with Jitter p10 / p50 / p90 | gain A, turn 0 | gain A / B, turn 0.5 |
+|---|---|---|---|---|
+| 5 | 0.228 | 0.156 / 0.187 / 0.217 | 0.187 | 0.156 / 0.094 |
+| 15 | 0.239 | 0.192 / 0.212 / 0.230 | 0.212 | 0.127 / 0.261 |
+| 30 | 0.250 | 0.231 / 0.243 / 0.249 | 0.243 | 0.146 / 0.301 |
+| 45 | 0.253 | 0.224 / 0.242 / 0.251 | 0.242 | 0.146 / 0.283 |
+
+- Jitter (A63, A69: small ducks scaled by Jitter.in0/in2/in3) lowers gain A by 1.7 dB at 5 km/h and
+  0.4 dB from 30 km/h; the p90 under Jitter (0.217–0.251) sits on retail's level(1) p90 of 0.240.
+  So the MixMap side matches retail.
+- Retail's lower medians (0.06 at 5 km/h, 0.07–0.17 above, PR #4's table) are of the *record* gain:
+  level(1) × (1 − max(I, Bk)) × special × seam, pooled over a session with turning, braking, manuals
+  and mixed surfaces; a turn of 0.5 alone takes gain A to 0.13–0.15. The 163809 session's per-start
+  grain levels (A and B pooled, idle and air time included) are lower still (asphalt_smooth_hard
+  median 0.000 / p90 0.032; concrete_rough_hard 0.009 / 0.071), as expected when every start at rest
+  or in the air counts. **Not settled:** a straight-roll retail measurement at turn 0 (GREC hook, grain
+  spec §5.3) would close it; we invented no factor.
+
+**Not modelled / open:** `Class_wheels_skid` (needs slip `+232`: the vault pair 45 / −0.75 of holder
+`0xBA9837A6CF4C26ED` does not fit PR #4's formula as written — check `sub_82772E18`), Class_Seams,
+squeaks, rolling rattle, Class_rolling, cloth/body slide, footsteps, Class_Flips / Treatment, and the
+SPLC Contacts (pops, landings, touchdowns: a Splice player plus the unrecovered pop bank pick
+`sub_824B9AD8`) — their interim cues play. Contacts.in6 needs the TU3 material key table (dev only).
+Grind SPLC starts/pieces (collision manager `sub_824D2318`) stay interim. The bool-class word of
+Class_grind (a global setting) is 0. Owner input 5 (heading rate), skid input 1, PlayerPhysics 4/5 and
+Rail.in1 reach no MixMap output. Retail's B layer is silent ≥ 40 km/h in PR #4's capture; ours would
+sound with a turn input there (level(2) 0.72 at 40 km/h) — check in game.
+
+**Later stages (data from the main session):** traffic (horn `sub_824D6BE8`, skids `sub_824D7440`,
+engine `aud_traffic_engine`; vehicle positions in VEHSTATE lines for Doppler validation; no special
+skitch sounds) and pedestrian speech (not AEMS: streamed from `livingworldspeech.big` with
+`*_Events.evt` / `hdr.big` / `sth.big` event tables; reaction → clip map in
+`.local/research/npc/speech_161849.txt`; summary `.claude/todo/audio-world-npc.md`,
+`.claude/notes/npc-livingworld-re.md` §5b–§6e). AI skaters are full skaters with their own board
+objects (voice budget question). Retail sessions with per-bank levels: `all_20261002_163809`, `all_20261002_164620` (clean trace; traffic horn / skid /
+engine-class and ped-footstep levels for the world stages).
+
+**In-game listening checklist** (`SKATE_AEMS=1`; `SKATE_AEMS_PLAYER=0` to hear the interim cues
+instead):
+1. Roll straight at 10–30 km/h on asphalt: the bed is 1–2 dB quieter at a crawl than before (Jitter)
+   and breathes slightly.
+2. Carve left/right at ~15 km/h: a second, slightly different-sounding layer (player B) comes in with
+   the turn and the main layer dips; straight again → B fades out within ~10 frames.
+3. Manual: the bed drops (special gain 0.65) and the turn layer stays off until four wheels are down.
+4. Roll down a slope / pump a transition: when `+712` (our pumping absorption; what retail means by it
+   is UNCERTAIN) goes negative the bed gets a little louder (A79, up to +244 mB) and B joins in —
+   listen for a bed that swells on every pump (that would mean the mapping is wrong).
+5. Ride over a spidercrack pavement: one dip of the bed (to 0.6–0.8) per pattern change.
+6. Change the board's wheels to soft (hardness < 0.5): the soft grain members play.
+7. Grind a metal rail and a concrete ledge: GRINDS loops (native) plus the interim start / scrape
+   pieces; the old interim metal loop is gone.
+8. Ride fast (> 30 km/h): rattle comes in; the wind from 15 km/h of body speed, louder with speed;
+   bail at speed: wind keeps blowing while tumbling (1 → 10 km/h range).
+9. Brake with the foot (and manual brake): native foot drag instead of the interim pieces (the interim
+   one was confirmed by ear — compare).
+
+**Files.** New: `crates/skate-audio/src/player/{mod,state,tuning,inputs,jitter,objpos,components}.rs`,
+`crates/skate-game/src/game_audio/player_audio.rs`, `.claude/skills/aems-port/tools/stage_player_tuning.py`.
+Changed: `skate-core` `physics/board_ground.rs` (+ test), `skate-audio` `lib.rs`, `mixer.rs`,
+`runtime.rs`, `mixmap/keys.rs`, `grain/board.rs`, `examples/grain_bed_render.rs`;
+`game_audio/{mod,native,grain_bed,library,skate_events}.rs`; `tools/asset_pipeline/audio_export.py`
+(+ test).
+
+**Verification run.** `cargo test -p skate-audio --release`: 77 unit + 3 disc-bank + 1 disc-grain + 3 DSP
+oracle tests pass (2 ignored fit tests). `cargo test -p skate-game --release --bin skate3rust --
+game_audio::` 42/42. `skate-core` 621 pass; the 2 failures (`predictive_contacts_and_retention_match_full_scan_for_every_primitive`,
+`a_moving_group_8_body_reaches_native_impact_feedback_for_a_stationary_actor`) fail identically with
+our change reverted (pre-existing in release builds). The whole `skate-game` suite: 361 passed, only the
+known `pipelines_accept_valid_group_outputs_when_fingerprint_changes` failure. Pipeline tests
+(`test_audio_formats`, `test_versions`, `test_setup_assets`) 35/35. All headless;
+**needs the listening check above.**
+
+### Board contacts, skid and squeaks; the end-to-end PoC comparison (2026-10-02, `skate_audio::splice`, `player::contacts`)
+**User listening check of the previous stage** (native build staged 16:59, `SKATE_AEMS=1`): "definitely closer,
+but it still needs tuning"; rolling "wasn't quite right as far as sync and being too loud"; grinds "sounded ok but …
+not at the right octave … just wasn't the same sound"; overall "pretty underwhelmed". Decision: "the PoC sounded
+closer, use it as a reference" → the end-to-end PoC comparison harness below. A note on the reference: on one launch
+of the PoC build the wheels-over-cracks (seam) sounds played louder/harsher, rattle-like; on the next launch at the
+same spot they were the normal, quieter version; not reproduced since — a first-play effect of the PoC (it decodes XMA
+into a PCM cache at run time). **Requirement recorded for our port:** the first trigger of every sample must sound like
+the later ones (decoded before use, same gain/filter path): the native banks decode their WAVs when they load, and
+`splice::tests::the_first_trigger_of_a_sample_renders_like_the_next` renders a sample twice, bit-identical.
+
+**Problem.** Pops, landings and touchdowns, powerslides and squeaks still came from the measured cue tables; the
+native build had no Splice (SPLC) player at all, so with the native components on the board's impacts were the
+interim samples at interim levels, and the rolling bed dominated the mix.
+
+**Retail mechanism** (read in the TU3 recompilation; addresses are facts, the code is ours):
+- **Splice player** (`sub_82975700` start, `sub_829757D0` voices, `sub_82975A60` / `sub_82975CC8` draws,
+  `sub_82975B08` per frame, `sub_82976860` voice frame, `sub_82976360` start, `sub_82976CF0` / `sub_82976FF0` fades,
+  `sub_82976DD8` picks): an id below the bank's record count is a record, then containers (one record picked), past
+  both the last record. One voice per group; a member by pick mode (0 random, 2 shuffled halves from the disc's state
+  word, else sequential), skipped unless rand/32768 ≤ its probability (`+64`). Member fields (corrected): `+4` gain,
+  `+8` pitch, `+16` pan offset (× block[4]; −127 = no panner), `+20/+52` delay, `+24` start, `+28` length, `+32/+36`
+  fade-in end / fade-out start, `+40` curve (0: 1−cos, 1: (1−cos)², 2: linear, 3: sin, 4: sin² over π/2), `+44` gain
+  spread (gain × [s, 1/s], linear in 2U−1), `+48` pitch randomisation. Record `+8` gain and `+12 + U·+16` pitch
+  factor. A voice stops when its elapsed time (advancing by the previous frame's pitch × dt) passes
+  `+8 / pitch × +28 + 0.16` or the sample ends. The CRT `rand()` (MS LCG) drives every draw.
+- **Contacts** (`SFXObj_Contacts`; vault class `0xC26949FCB638A2CA` `default`): frame order `sub_824B8218` →
+  manual landing `sub_824BB330` → touchdowns `sub_824B86E0` → process `sub_824B90D8` (pop `sub_824B9CC8` on entering
+  the air with an audio trick other than −1/31/32/35/36; landing `sub_824BA630`) → update `sub_824BE1B8` after the
+  tick. Pop: selector 2/1/0 by the jump velocity `+468` (|Air+112|/2.65 while Air440) over 0.42/0.25, ids
+  1097–1099 (1103–1105 on a hollow surface), gain trunc(level(2) × [0.5, 0.75, 1.0]) (hollow [0.58, 0.76, 0.99]);
+  roll 1111 above 4 m/s; ollie 1096 and landing impact 1095 for the local player (levels 12/13). Touchdowns: per wheel
+  the conditioner's landed latch (`sub_82772FD8`) and the bridge bucket `+448`; kind 0 four wheels, 1 a pair from
+  nothing, 2 the last pair, 3 one wheel, 4 manual landing; set = table[tier][3·kind + variant] (tier `sub_824BA310` =
+  2·hollow + soft wheels; the second voice of a bucket-2 landing reads tier 0), gain trunc(level(3) × K[tier][…]).
+  The block every sound gets: [level/32767, pitch(1)/4096, raw(0)·360/65535, dt, 1 (local 3-D), 1].
+- **Class_wheels_skid** (`sub_824C7438` / `sub_824C72F0` / `sub_824AF678` / `sub_824C7A20`): held while the
+  predicate holds — any slip (with a wheel down; slip `+232` = clamp((|deck velocity · deck Ri| + 0.75)/45, 0, 1),
+  `sub_82772E18`, vault holder `0xBA9837A6CF4C26ED` 45 and −0.75: **settled**, so straight rolling keeps a skid at slip
+  word 1), not grinding (unless family 4), no audio trick but a grab; without slip the revert flag `+690` / counter.
+  w10 = clamp(counter + trunc(90 × slip), 0, 90).
+- **Class_Squeaks** (`sub_824C7738` / `sub_824AFF48` / `sub_824C7DD0`): both feet in the deck box and > 1 wheel, posted
+  once |deck tilt `+264`| × 114.59 ≥ 15, a tilt sign change reposts; w9 = deck spin |`+488`| / 1.5 × 1000 (< 50 → 0).
+
+**Change.**
+- `crates/skate-audio/src/splice/` (`format.rs` patch tree, `mod.rs` player, tests): the Splice player; its voices
+  are mixer voices (`Mixer::open_direct` / `set_direct`: SndPlayer1 → Resample → Gain → Pan2D1 → default bus).
+  `Runtime::splice`, `Runtime::splice_host()`.
+- `player/contacts.rs`: the Contacts component (pop, roll, ollie, landing impact, touchdowns with the second voice,
+  manual landing) behind the `SpliceHost` trait. `player/components.rs`: `Skid`, `Squeaks`.
+- `player/state.rs`: `jump_velocity` (+468), `audio_trick` (+348, resolved by the host from the scorable through the
+  vault's eSk8AudioTricks), `scorable`, `slip` (+232), `revert` (+690), `deck_tilt` (+264), `deck_spin` (+488);
+  `state::slip`, `state::jump_velocity`. `tuning.rs`: `audio_tricks`, `name_hash` (lookup8).
+- Game: `player_audio.rs` runs the contacts (when `Skate_Collisions`' patch tree is in the install) and the skid /
+  squeaks; `native.rs` loads the Splice banks with their WAVs at start; `skate_events.rs` fills the new state fields
+  (deck Ri / At from the part transform) and silences the interim pop layers, landing impacts and powerslide pieces
+  when the native ones run; `library.rs` reads `aems.splice` and `player_tuning.audio_tricks`.
+- Setup: `audio_export.splice_trees` writes each SPLC bank's patch tree to `aems/<stem>.splc` (`manifest.aems.splice`;
+  optional key, version unchanged); `player_tuning.audio_tricks`. Dev install: `aems-port/tools/stage_splice.py`
+  (manifest backup `.local/audio-re/audio_manifest.before-splice-stage.json`) and `stage_player_tuning.py`.
+- **Audio state log** (`game_audio/state_log.rs`): `SKATE_AUDIO_STATE_LOG=<path>` writes one TSV row per frame in the
+  e2e scenario columns plus elapsed ms and board / COM positions (buffered, flushed every 6 rows, no cost when unset,
+  with or without `SKATE_AEMS`). `scenarios.py --from-log LOG --cut A-B NAME` turns a window of it into a scenario both
+  stacks render.
+
+**End-to-end comparison with the PoC** (`.claude/skills/aems-port/tools/e2e/`: `scenarios.py` writes per-frame
+situations; our probe `game_audio::e2e::e2e_render` and the PoC's local probe render them headless to raw 6-channel
+f32; `compare.py` folds both the same way and compares per segment: RMS, octave bands, centroid, pitch, onsets).
+Ours vs PoC, RMS dB of the common fold:
+
+| situation | before this stage | after |
+|---|---|---|
+| straight roll 10 / 20 / 30 / 45 km/h | +0.4 / +0.1 / 0.0 / 0.0 (bands ≤ ±1 dB) | same |
+| speed sweep 0 → 40 → 0 km/h | +2.3 … −0.7 (+1.3…+2.3 below 8 km/h) | same |
+| ollie at 20 km/h: air / after the landing | −24.4 / −9.2 (no pop, no landing) | −1.0 / 0.0 |
+| powerslide 20 → 8 km/h | −9.6 / −8.9 / −4.6 (no skid) | +0.4 / 0.0 / −1.0 |
+| foot brake | −1.0 … −1.3 | −0.7 … −1.1 |
+| carve ±0.8 turn at 20 km/h | +3.4 | +3.4 |
+| manual at 15 km/h | −4.3 | −4.3 |
+| metal rail / concrete ledge grind | −3.1 / +1.7, different spectrum | +0.7 / +2.0, different spectrum |
+
+Causes of the remaining differences, each checked against retail rather than the PoC:
+- **Grinds:** the PoC plays every grind as surface 2 (its "user-accepted interim" policy, GRINDS samples 94/95);
+  retail's GRINDS voices in all_20261002_164620 / 20261001_211347 / long_dt_c (the last two deleted: re-verify on
+  clean data) are samples 13/14, 20–23, 55/56
+  (= our surfaces 0/1 and 4–9 through the program, `aems-port/tools/grind_census.py`), never 94/95, with pitch ratio
+  p50 0.98–1.00 and LPF 24971 / HPF 0 like ours (`tools/retail_voices.py`). So **pitch and sample choice are retail;
+  the PoC's grind is not**. Retail's grind sound is mostly the collision manager's Splice layers (ledge start 954 with
+  464 events, 968, 958, 969, 876–878 in 164620, levels 0.1–0.4) with GRINDS underneath (p50 0.007, p90 0.15): those
+  layers are the next port (below) and the likely reason ours "isn't the same sound". **Corrected in the next
+  section:** 954 / 955 / 956 are body-impact (skin / denim / arm) sounds, mostly outside grinds; the collision
+  manager's grind part is one start contact (board / truck against the grind material).
+- **Carve:** our B layer follows the turn input (`sub_824C8588`, from the retail code); the PoC's B record stays 0 in
+  this harness even with its SkateBoard level(2) at 0.68–0.71. Retail's capture medians of gain B (0.01–0.10) are
+  pooled over mostly straight frames. Not changed; checking it needs the GREC hook below.
+- **Manual:** ours applies the grain spec's special gain 0.65 to gain A in a manual (−3.7 dB); the PoC does not. Kept
+  (retail code reading); a GREC session settles it.
+- **Rolling level ("too loud"):** the native bed equals the PoC's to ±0.4 dB at every speed, so the bed itself is not
+  louder than the PoC. What differs is the host: our stereo fold is the title's table (0.707·L + 0.5·C + 0.5·Ls, spec)
+  while the PoC trims its downmix (0.6 × (L + 0.707·C + 0.5·Ls), not retail) — ours is 1.4 dB (front) to 4.4 dB
+  (surround) hotter for the same mix — and until this stage the impacts that retail puts 17–23 dB over the bed were
+  missing, so the bed was all there was. Against the retail capture (`tools/e2e/retail_windows.py`) the bed cannot be
+  isolated: the capture's floor at rest is −32 dBFS (ambience, emitters) and only three clean straight-roll windows
+  exist; the per-voice levels agree (retail grain voices p50 0.15 / p90 0.27, ours gain A 0.21–0.24).
+- **"Sync":** nothing headless shows a lag (our and the PoC's envelopes follow the same speed sweep); the in-game
+  path adds the device buffer and the bed is fed per rendered frame. The audio state log replays real play into both
+  stacks to look at this with the user's own runs.
+
+**Contacts against retail** (all_20261002_164620 report, per-sample audible level medians): roll 1111 retail
+0.13–0.18, ours 0.16–0.24; pop selector 1 (1098) retail 0.07–0.40, ours 0.15–0.35; touchdown kind 0 (1052) retail
+0.42–0.64, ours 0.22–0.48. Ollie 1096 and landing impact 1095 are silent outside combos in both: their outputs 12/13
+carry the envelope F[Global.135] triggered by Music.in3 (the combo emphasis), which no one writes yet — retail's
+medians (0.01–0.12) are consistent with that.
+
+**Not modelled / open:** the owner buses of the Splice voices (eEQChain presets, Contacts levels 14/15 as send levels)
+— they mix dry; the landing's collision-manager pair contact; foot taps / scuffs on the deck (`sub_824B95A0`,
+board knocks 1112/1115 — frequent and loud in retail, next with the collision manager); the grind start contact
+`sub_824BB0E0`; body / deck impacts; Music.in3 (combo emphasis); `+308`, `+720`, `+814` (not published); the slip's
+B40+16 ring. Still interim: seams (`Class_Seams`, `sub_824C14C8` / `sub_824C1698` / `sub_824C1CA0` grid / `sub_824C1F18`),
+rolling rattle, `Class_rolling`, footsteps, cloth / body slide, flips / treatment, the collision manager
+(`sub_824D2318`, `sub_82486EF0` posts from landing, grind start, body and deck impacts).
+
+**Verification run.** `cargo test -p skate-audio --release`: 90 unit + 3 disc-bank + 1 disc-grain + 3 DSP oracle
+(2 ignored fit tests). `cargo test -p skate-game --release --bin skate3rust`: 362 passed, only the known
+`pipelines_accept_valid_group_outputs_when_fingerprint_changes` failure (game_audio 43/43). `cargo test -p skate-game
+--release --no-run` builds every target. Pipeline tests (`test_audio_formats`, `test_versions`, `test_setup_assets`)
+37/37. All headless. **Needs the user's listening check** (checklist below).
+
+**In-game listening checklist** (`SKATE_AEMS=1`; `SKATE_AEMS_PLAYER=0` for the interim cues):
+1. Ollie on concrete at ~20 km/h: a crack (pop) at take-off with a short roll; landing on four wheels: one impact (plus
+   a heavier second layer after ≥ 1 s of air). The interim pop/landing layers are gone.
+2. Land on two wheels then the other two (nose/tail first): two separate touchdowns.
+3. Manual, then put all four wheels down: one manual-landing touchdown.
+4. Ollie on wood (a hollow surface): a different, hollower pop and touchdowns.
+5. Powerslide: skid noise that follows the slide (louder the more sideways), with board squeaks when both feet are on
+   the board and the deck tilts past 15°; straight rolling has no audible skid.
+6. Compare the overall balance: impacts should now sit well above the rolling bed.
+7. Optional: play with `SKATE_AUDIO_STATE_LOG=<file>` set so we can replay your exact runs headless.
+
+**Ready to retire after that check:** `cues::POP`, `cues::POP_TAIL`, `cues::LAND_NORMAL` / `LAND_HOLLOW` /
+`LAND_KIND_CHANCE` / `land_tier` / `land_scale` and `cues::LAND` (the native contacts replace them),
+`cues::POWERSLIDE` / `POWERSLIDE_SHUFFLE`; `cues::LAND_CLOTH` and the board-down / bail / step / splash cues stay.
+
+**Next stage:** the collision manager (Splice layers of grinds, landings, impacts; then grind start, foot taps), seams,
+rolling rattle, `Class_rolling`, footsteps, cloth / body slide, flips / treatment; Music.in3.
+
+**Files.** New: `crates/skate-audio/src/splice/{mod,format,tests}.rs`, `crates/skate-audio/src/player/contacts.rs`,
+`crates/skate-game/src/game_audio/{e2e,state_log}.rs`, `.claude/skills/aems-port/tools/{e2e/scenarios.py,
+e2e/compare.py, e2e/retail_windows.py, retail_voices.py, grind_census.py, splc_fields.py, vault_fields.py, img.py,
+stage_splice.py}`. Changed: `skate-audio` `lib.rs`, `mixer.rs`, `runtime.rs`, `player/{mod,state,tuning,inputs,
+components}.rs`; `game_audio/{mod,library,native,player_audio,grain_bed,skate_events}.rs`;
+`tools/asset_pipeline/audio_export.py` (+ tests). The PoC probe (`player_audio/e2e.rs` in the PoC worktree) is local.
+
+### Collision manager, wheel spin, foot taps; the second listening test and the retail bed data (2026-10-02, `player::collision`, `player::wheels`)
+**User's second listening test** (native build 18:02, `SKATE_AEMS=1`, relayed by the main session): (1) carving "too
+easily triggered, just turning a little bit causes them to trigger"; (2) background ambience and noises like cars "a
+little loud and don't sound like they're in the distance enough"; (3) "when jumping the rolling sound continues to
+play"; (4) "manuals sound completely wrong"; (5) falling in water "almost right, maybe a tiny bit too loud"; (6)
+grinding "still not in sync properly and doesn't play out the continuous grinding noise as in retail"; (7) "after
+riding and then picking up the board, the riding noise continues too long"; (8) the put-down board sound "much better
+but not quite right; it should sound like wheels hitting the ground and whatever effects the original engine uses
+aren't being recreated".
+
+**Validation data used.**
+- Retail **GREC** session `all_20261002_180430` (11 min, the user playing the recomp; hook on `sub_824C6BD8` added by
+  the main session from our spec, tool `.claude/skills/aems-port/tools/grec_level.py`; credit: skate3recomp by
+  @mchughalex, run locally): per-frame grain records A/B of both trucks, turn intensity, brake slew, state words.
+- Our engine's **real-play log** `.local/audio-state-logs/state_20261002_181631.tsv` (`SKATE_AUDIO_STATE_LOG`, the
+  user's own 4 min of play), cut with `scenarios.py --from-log` into `log_jump`, `log_ollie`, `log_manual`,
+  `log_grind`, `log_pickup`, `log_carve` (`.local/audio-re/e2e-log/`) and rendered headless.
+- Clean retail level sessions only (`all_20261002_163809`, `all_20261002_164620`, `all_20261002_180430`); the
+  sessions with malformed trace lines were deleted by the user (see "re-verify" notes in this document).
+
+**The bed's low-speed level ("~5–6 dB too loud") — not confirmed.** The pooled straight-roll medians (`grec_level.py`:
+0.104 at 5–10 km/h, 0.114 at 10–15, 0.188 at 15–20, 0.233 at 30–35) mix in frames the bed is meant to be quiet
+in: the `+336` word (brake, push) and the `+340` word (balance, **grinding**, trick) are not filtered, a paused game
+(material 4 at 25–30 km/h: speed fixed at 7.9362 m/s for ~10 s, gain 0), the seam envelope (`+1456` 0.74–0.98 on
+material 1), a second board owner (`40C34020`, material 65) and Doppler moments (pitch A 1.18–1.24). On **clean**
+frames (`.claude/skills/aems-port/tools/grec_clean.py`: four wheels, |turn| ≤ 0.02, I/Bk ≈ 0, both words 0, 30 settled
+rows, gain ÷ seam envelope) retail's level(1) is 0.219 (material 2, 5–10 km/h), 0.21 (material 40, 10–15), 0.229–0.244
+(20–30), 0.245–0.25 (30–50) — our MixMap gives 0.231–0.256 at the test camera (3.5 m), i.e. within ~1 dB (Jitter −0.4
+dB). On clean carves A/(1−I) = 0.20–0.27 (= level(1)) and B/I = 0.61–0.83 (ours level(2) 0.62–0.78): the bed formula
+is retail's. Not changed. Open: the board's camera distance (B[Player.2] roll-off: 5 m −0.6 dB, 7 m −1.8, 10 m −3.9) is
+not in GREC — adding the `0x60010020` block's input 1 to the hook would settle the residual. Analysis:
+`.local/audio-re/grec_180430_clean.txt`.
+
+**(1) Carving.** Our turn intensity follows `sub_824C8588` exactly: I vs |turn input| medians ours / retail 0.1 →
+0.06 / 0.066, 0.3 → 0.18 / 0.185, 0.5 → 0.24 / 0.30, 1.0 → 0.50 / 0.60 (cap 0.8 vs retail p90 0.99 on some
+surfaces). The difference is upstream: **our turn input (`Turn` animation attribute, ProcessedPhysIn+2676) is almost
+binary** — in the user's log 29 % of riding frames sit at |turn| = 1.0 and 7 % in between, retail 16 % / 25 %; a stick
+movement takes our value 0 → 0.5 → 0.75 → 1.0 in three frames. After the stick returns our I decays for ~13 frames
+(retail's input decays through the middle values, so retail's I is 0 at turn 0: p90 0.0 vs ours 0.196). That is the
+animation side (the `Turn` scalar our animation graph publishes), not audio; reported to the main session. No audio
+change.
+
+**(3) Rolling in the air / (4) manuals: `SFXObj_Wheels` was missing.** In the air our bed goes silent within ~5
+frames (the MixMap's no-wheels duck F[Player.0] on level(1), confirmed headless on `log_jump`: gain A 0.25 → 0 in 3
+frames). What kept playing was the interim `AIR_WHEELS` loop — `Whls_spins_Jump_1` from its beginning at a constant
+level for the whole air time. Retail (`sub_824CD6F8` / `sub_824CDC70` / `sub_824CDD28`, our port `player/wheels.rs`):
+a **spin-down recording started part-way in**, t0 = 14 s × (1 − clamp01(speed / 50 km/h)) (vault `0xC1831BDB6CB1B1EA`
+`0x03B710C80E1AC13E`), slot 0 in the air, slot 1 **while balancing (manuals)**, the jump and manual recordings
+alternating, gain Wheels level(1) (level(5) while balancing), pitch(2); stopped on landing / when the manual ends.
+Retail levels (164620): `Whls_spins_Jump_1` 92 starts median 0.240, `Whls_spins_Man_1` 81 / 0.264. Ours on the user's
+log: manual 0.20–0.21 (level(5)), air 0.21–0.24 after the pop. In manuals the bed itself matches retail (GREC manual rows gain A
+0.141–0.157 at 10–40 km/h; ours 0.13–0.15); the missing spinning wheels were the wrong part. The +150 Hz frequency
+shift of the special state is still not modelled.
+
+**(6) Grinding: the collision manager** (`CSTATEMGR_Collision`, our port `player/collision.rs`; full mechanism in the
+module docs): `sub_82486EF0` posts a 48-byte message (materials A/B, impact tiers, position, two contact levels) to an
+LRU router over ten slots; each slot's `SFXObj_Collision` (`sub_824D1E00` / `sub_824D1F68` / `sub_824D2318`) starts one
+Splice voice per material — the sample from the material's AudioSurface record (layout read from the disc schema,
+`tools/vault_layout.py`) by its **kind** (the TU3 table at `0x8302D6E8`: 0 Skate_Collisions, 1 Skate_Metal, 2
+HOM_Set_1), its tier and the other material's collision class — and updates it from the slot's Collision controller
+outputs (category level 12..21, pitch 1/22, azimuth from the slot's 3-D block at the message position). Contact levels
+`sub_82496C58` (the 13E20D39 window record), impact bands `sub_82497088` (the 7DAFF70B record). Ported posters:
+- **grind start** `sub_824BB0E0`: truck 96 (board 95 for families 1, 2, 5) against the grind material, tier by the
+  last grind impact `+228` over Class_grind's 0.25 / 0.5, 0.5 s cooldown;
+- **landing pair** `sub_824BA630`: on a landing-flag material only (66 materials: the metals and a few others), board
+  95 against the first landed wheel's material, tier by the latched air time / 0.4 over 0.1 / 0.3, levels × 0.65 / 1;
+- **deck impact** `sub_824BD000`: board 95 (113 on foot or bailing) against the deck contact's material, each by its
+  impact band on `+668` = max of the last 4 clamp01(|deck acceleration · deck normal| × 0.00125); a band-2 hit posts
+  a second message at tier 1 × the window record's `+40`; 6-frame cooldown. Needs the deck contact's tag:
+  `skate-core` `BoardGroundState.part_audio_surfaces` (CollisionInfo+4/+8/+12, + test).
+**Correction of the previous section:** Skate_Collisions sounds 954 / 955 / 956 / 947 / 948 are the **skin / denim /
+arm / leg** body-impact sounds (materials 107, 108/109, 100, 99), posted by the body-impact posters (`sub_824BC188`,
+ragdoll `sub_824E3BE0`); only 29 of 464 events of 954 in 164620 fall within 1.5 s of a GRINDS voice. The interim
+grind start (954) and the re-fired "scrape pieces" (955 every 63 ms) were body sounds, which is part of why grinds were
+"not the same sound"; with the native contacts they are now silent. Retail's grind = Class_grind's GRINDS loop
+(native since the previous stage) plus this start contact. Retail pitch of the start samples (163809 MOD lines):
+streams 690–692 p10 0.44 / p50 0.61–0.95 — the material's pitch word 2096 (0.51) shows in retail too. The body
+posters are **not ported**: they need the skeleton's per-region contacts (Collision+80..195, `sub_82BD60C8`), which
+the engine does not compute. "Sync" of the continuous grind layer: GRINDS starts on the grind's first frame in the
+log replay (`log_grind`).
+
+**Foot taps and scuffs** (`sub_824B95A0` → `sub_824B9508` / `sub_824B9268`, `sub_824B9948` / `sub_824B97A8`, updates
+`sub_824BEBD8` / `sub_824BF4A8`): a foot coming back into the deck box (Skeleton 600/601) after more than 25 ms out
+taps the deck — first foot 1112–1114, second 1115–1117, both 1118–1120 by toe speed (≥ 2 / ≥ 5 m/s, Skeleton+196/+212),
+hippy-jump set 1176–1178 — at Contacts level(8); a foot in the box moving faster than 0.35 m/s across the deck (max |x|,
+|z| of its local velocity) scuffs it (`sk8_foley` 95 / 94) at level(9). Retail (164620): board knocks 1112 ×152 / 1115
+×132 (sample medians 0.11–0.41), sk8_foley 94/95 ×434/×488 (0.06–0.25); ours on the log 0.2–0.3. The engine already
+publishes the toe velocities (`FootPhysicalOutput.local_velocity`). The soft variants (`+484` from the unidentified
+`+769` flag) are unused.
+
+**(8) Board put-down.** Natively the wheels' touchdown sets (Contacts) and the feet's deck taps now play from the
+retail mechanism; the interim knock (1119) and wheel touch (1054) doubled them and are silent with the native
+contacts. The interim foot-on-deck set (1126) stays: retail's step-on / step-off (`sub_824B85B0` → `sub_824B8310` 1124
+in the air / 1125 on the ground, `sub_824B8448` 1126) needs Skeleton+602/+603 (feet planted on the deck), which the
+engine does not publish. The owner buses (eEQChain presets) are still not modelled — that is the "effects" part.
+
+**(2) Distance / (5) water: the interim layer's ×2.** Every interim cue plays at measured retail level × `RETAIL_SCALE`
+(2.0), a factor anchored to the interim rolling loop (by ear). The native player sounds play at retail level, so with
+them on, the interim layer (zone beds, location-set one-shots incl. cars, crossfades, splash, steps, bails) was 6 dB
+hot relative to retail's balance. With the native player components running the interim voices now play at the
+measured level (`Voices.scale` = 1/RETAIL_SCALE, `native::follow_volume`); the default path is unchanged. Measured
+remainder (open, item 7 of the plan): our native host folds 6 channels to stereo with the title's table, so a mono voice
+at per-voice gain g reaches each ear at 0.5 g (front) … 0.35 g (rear) (`examples/pan_fold_probe.rs`), while an
+interim Bevy voice reaches 0.75 g (spatial, near) or g (beds) — the interim layer is still ~3–6 dB above the native
+one. The distance cue retail adds through the emitters' positional send (MixMap out8 into the send buses) is not
+modelled (buses not ported).
+
+**(7) Riding noise after picking up the board — not reproduced.** In the `log_pickup` replay every voice is silent
+within 0.1 s of state 500 (no wheels → the no-contact duck) and wind within 0.75 s. Retail's wind (SenseOfSpeed) also
+keeps running on COM speed. Needs the user's timestamp (or a fresh state log) of the moment.
+
+**Music.in3 ("combo emphasis") — a game-mode flag, not a gap.** `SFXObj_Music`'s process `sub_824D1208` writes in3 =
+32767 when `sub_824898C8` holds: a bit of `*(0x83083C38)+0x2F0D0` (bit 13), or the manager's `+932` with `+476`, or the
+manager's mode `+1060` = 8. None is part of free skating, so outputs 12/13 (ollie 1096, landing impact 1095) stay
+gated — retail 164620: 1095 69 events, sample medians 0.002–0.115. Left at 0.
+
+**First-trigger rule.** The grain recordings are now decoded when the bed is created (`grain_bed::Bed::new`), not at
+first use; the wheel-spin streams and the Skate_Metal / sk8_foley Splice banks are decoded at start like
+Skate_Collisions.
+
+**End-to-end vs the PoC** (standard scenarios, RMS of the common fold, ours / PoC): rolling ±0.4 dB (unchanged),
+ollie air −0.9, after landing 0.0; ledge grind +2.0 (start contact), metal +0.7; manual −4.0 (special gain; ours now
+adds the wheel spin, +28 dB in the 125 Hz band); carve +3.4 (unchanged). Log replays (`.local/audio-re/e2e-log/`, ours
+only): grind start voices Skate_Metal 194 + Skate_Collisions 619 on the first grind frame, GRINDS 0.66; knocks after
+landings; wheel spin in the air and in the 6.5-s manual.
+
+**Files.** New: `crates/skate-audio/src/player/{collision,wheels}.rs`, `crates/skate-audio/examples/pan_fold_probe.rs`,
+`.claude/skills/aems-port/tools/{vault_layout,find_field,grec_clean}.py`, `.claude/skills/aems-port/tools/e2e/
+voices_summary.py`. Changed: `skate-audio` `player/{mod,state,tuning,contacts}.rs`, `runtime.rs` (stream bank);
+`skate-core` `physics/board_ground.rs` (+ test); `skate-game` `game_audio/{player_audio,native,e2e,library,
+skate_events,grain_bed,state_log,voices}.rs`; `tools/asset_pipeline/audio_export.py` (`collision_tuning`, the image's
+material kind / key table as constants) + test; `aems-port/tools/e2e/scenarios.py` (real-play extra columns).
+Dev install: `stage_player_tuning.py` re-run (`player_tuning.collision`, optional key; manifest backup
+`.local/audio-re/audio_manifest.before-collision-stage.json`).
+
+**Verification run.** `cargo test -p skate-audio --release`: 102 unit tests + the disc / oracle tests pass (collision 5,
+wheels 3, contacts 8). `cargo test -p skate-game --release --bin skate3rust`: 362 passed, only the known
+`pipelines_accept_valid_group_outputs_when_fingerprint_changes` failure (game_audio 43/43); `--no-run` builds every
+target. `skate-core` lib: 621 pass, the 2 known pre-existing failures. Pipeline tests (`test_audio_formats`,
+`test_versions`, `tools/test_setup_assets`) 38/38. All headless; **needs the user's listening check**.
+
+**In-game listening checklist** (`SKATE_AEMS=1`):
+1. Ollie at ~20 km/h: in the air a wheel-spin that is already slowing down (fainter and lower the slower you go), gone
+   on landing — no rolling sound in the air.
+2. Manual at ~15 km/h: the lifted wheels spin down audibly under a quieter bed; ends with the manual.
+3. Grind a metal rail and a concrete ledge: a hit at the start (truck or board on the rail, metal ring on rails), then
+   the continuous GRINDS layer; no repeated skin/denim "pieces" any more.
+4. Land a jump on a metal surface (e.g. a rail top or metal ramp): an extra board-on-metal contact over the
+   touchdowns.
+5. Slam the deck onto a ledge / board slide hard: a deck hit (board 95 against the ledge).
+6. Lift a foot and put it back on the deck (pushing, after an ollie): a board knock; dragging a foot on the deck: a shoe
+   scuff.
+7. Put the board down from walking: the wheels' touchdown and a knock when the feet land on it.
+8. World balance: ambience beds, cars, sirens and the splash are 6 dB quieter than in the 18:02 build.
+9. Carving: unchanged (the turn input is the cause; see (1)).
+
+**Ready to retire after that check:** `cues::GRIND_START`, `GRIND_PIECES`, `GRIND_PIECE_INTERVAL`,
+`GRIND_METAL_START` (collision grind start), `cues::AIR_WHEELS` (SFXObj_Wheels), `cues::BOARD_DOWN_KNOCK`,
+`BOARD_DOWN_TOUCH` (taps / touchdowns); plus the previous stage's list.
+
+**Not modelled / open:** body impacts (needs skeleton region contacts), step-on / step-off (Skeleton+602/+603), the
+owner buses / eEQChain presets and the emitters' send buses, the HOM override (global `+564`), the stamp counter of the
+LRU (we use the post order), Class_Seams (next), rolling rattle, Class_rolling, footsteps, cloth / body slide,
+flips / treatment, the +150 Hz special shift, the turn input (animation), camera distance in GREC.
+
+### Listening tests 3–5, the native-audio stutter, the riderless board (2026-10-02, `SKATE_AEMS=1`)
+
+**Stutter (19:01 build).** User: tricks with `SKATE_AEMS=1` were "super stuttery … kinda impossible to do anything".
+No build was running at the time.
+- *Measured first.* A headless replay of the user's state log (`state_20261002_190234.tsv` through the e2e
+  harness, `E2E_TIMING=1`) puts the native player audio on the game thread at p50 26 µs, p99 140 µs and max 1.5 ms per
+  frame. Render is p50 16 µs per 256-frame block. The audio work itself was not the cause.
+- *Root cause.* `native.rs` spawned the native output stream with `PlaybackSettings::LOOP`. Bevy turns LOOP into rodio
+  0.20's `repeat_infinite()`, which wraps the source in `Buffered`. That has three effects:
+  - It pulls **32,768 samples (64 blocks, 341 ms) at a time inside the device callback**. The runtime's mutex is
+    taken 64 times back to back every 341 ms, so the game thread waits behind the burst.
+  - It keeps every chunk forever: about 23 MB of memory per minute.
+  - It adds up to 341 ms of variable latency between a game event and its sound.
+  - Burst cost (`examples/voice_load_probe.rs`): 24 voices ≈ 64 × 130 µs ≈ 8 ms per burst; 96 voices ≈ 33 ms. The
+    19:01 build added voices (collision manager, contacts, wheel streams), which lengthened the bursts.
+- *Fix.* `PlaybackSettings::ONCE`. The stream never ends, so it plays forever without buffering. Same block
+  sequence, about 5 ms latency. Test `native::tests::the_stream_renders_one_block_per_pull_unless_looped`: a looped
+  stream renders 64 blocks on its first pull, ONCE renders 1.
+- *Readout for real play.* `SKATE_AUDIO_TIMING=1` (`game_audio/timing.rs`) logs one `AUDIO_TIMING` line per second.
+  It gives max, average and count for each audio system, the game-thread and audio-thread lock waits, the render
+  per block and the slowest frame. It also reports `state_log_dropped=N` when rows were dropped.
+
+**Third listening test (19:19 build, ONCE fix).** User:
+- "much better for almost every sound";
+- "only every now and again did a grind not quite sound right";
+- "the ambience sounded great";
+- "the rolling sound was almost perfect, there was one instance where it ran a tiny bit long after I jumped";
+- "a few tiny hitches … should still be looked into at the end";
+- "the landings and pops sounded almost perfect!".
+
+User-confirmed, ready to retire in the "remove the interim cue tables" step (not deleted yet): `cues::POP`,
+`POP_TAIL`, `LAND_NORMAL` / `LAND_HOLLOW` / `LAND_KIND_CHANCE` / `land_tier` / `land_scale`, `cues::LAND`,
+`cues::POWERSLIDE*`.
+
+**Hitches in `observe` (19:20 session, `AUDIO_TIMING`).** The per-second maximum of `observe` was 751 ms, 554 ms
+and 143 ms on three frames. The median was 36 µs. `observe` wrote the `SKATE_AUDIO_STATE_LOG` rows on the game thread,
+and a flush or OS stall blocked the frame.
+- Fix: `state_log::write` now only formats the row and does a `try_send` into a bounded queue of 4,096 rows. A
+  thread, `audio-state-log`, creates the file, writes the rows in order and flushes every 6 rows. When the queue is
+  full the row is dropped and counted, and the count shows in AUDIO_TIMING.
+- Two other hitches (197 ms and 144 ms frames) had every audio system under 0.2 ms. They are not audio, and are
+  noted for the frame-timing todo.
+- The remaining small costs belong to the final optimisation pass (below): mixmap_frame p90 220 µs, grain_bed
+  58 µs, render_block 157 µs, game lock wait at most 131 µs.
+
+**"Riding sound continues too long" (19:29 session) — the riderless board.**
+- Replaying the windows headless (`.local/audio-re/e2e-1929`; new tool
+  `aems-port/tools/e2e/frame_levels.py`, which prints per-frame folded dBFS and per-voice-group gains next to the
+  state) shows the bed is not lingering after takeoff: gain A drops to 0 within 3 frames of air.
+- The audible part came after the air phase. Our engine put the skater into Offboard (state 500) and Wipeout (300),
+  and in those states the **riderless board's** contacts (`physics.riding.ground`) kept flickering: 1/8/12/15 wheels
+  at 3–7 m/s.
+- At 39.3 s that produced a bed + Class_wheels_skid burst at **−28.8 dBFS**: skid voice gain 0.245, grain 0.176,
+  against −53 dBFS in the air just before.
+- Retail's audio record reports no wheels through such stretches. The clean GREC sessions show whole stretches moving
+  at speed with wheels 0, air 0 and material 143, with no flicker (e.g. 180430 at 246 s, 22 m/s for more than 1 s;
+  five stretches over 20 frames).
+- Fix (`skate_events::board_unridden`, audio only): in states 300 and 500–502 the record gets wheel count 0, no wheel
+  or deck contacts, materials 143 and seam 0. Ground speed is kept, as retail does. The interim cues see
+  `rolling = false` there too.
+- After the fix: **−79 dBFS**, then silence. In state 300 the bed stops at once.
+- UNCERTAIN: the record writer itself (+152 bits 20–22) is not located; this rests on the measured retail behaviour.
+- Physics note for the main session: the user called these "mid-air tricks", but our engine moved the skater into
+  Offboard or Wipeout.
+
+**Walking with the board (19:32 test).** The user picked the board up and put it down repeatedly while walking:
+"sounded right, nothing out of ordinary fired". The log still shows 23 skid posts and 48 wind post/release cycles in
+state 500. Those voices are held at about 0 by the MixMap, the speed and the no-contact inputs. **Post counts are
+not audible sound**: measure the rendered level before calling something a bug. The wasted posts belong to the
+optimisation pass.
+
+**Air tricks #1 and #3 (19:38 session, "played in the air and at the landing").** All 8 tricks rendered headless
+(`.local/audio-re/e2e-1938`):
+- In the air: the bed is at 0 within 4 frames, and every trick sits at −49…−56 dBFS.
+- The pop's roll layer (id 1111 → record 742, samples 625/626/260) plays at **gain 0** throughout, as in retail:
+  163809 has 3 and 7 voices of streams 625/626, gain median 0.000. Its trigger is retail's (`sub_824B9CC8`: ground
+  speed above 12 / 8 / 4 m/s, vault `C26949FCB638A2CA`, or byte +344).
+- Our "+344" stand-in is `audio_trick ≥ 0`. Retail's +344 is record+148 bit 23, meaning unrecovered. All three ids
+  are 1111, so this changes nothing.
+- The audible in-air voice is SFXObj_Wheels' spin-down: 0.21–0.36, against retail's Whls_spins_Jump_1 median 0.240.
+  It is a recording of wheels spinning down, entered 5.6 s in at 30 km/h, and can sound like rolling. It is retail's
+  mechanism, the same in all 8 tricks.
+- At landing: #3 lands on a new surface (tag 3 → 4), so the grain bed rebinds, as retail's does.
+- The only state difference between #1/#3 and the rest is one frame of state 103 with no wheels and not airborne
+  before the air phase. It does not change the native render.
+- Open: the interim layer and frame pacing are not in e2e. A short retail ollie at about 30 km/h in the recomp would
+  settle the spin-down.
+
+**Grinds (19:20 session, "now and again a grind didn't sound right").** Six grinds: families 0/2/3/4 on tags 3/4,
+including a family change 0 → 3 mid-grind (states 401 → 403 at 28.25 s). The GRINDS voices follow the family (slots
+13/14 → 6/7/8). The routing records show the GRINDS voices go to eEQChain bus 5 (jittered EQ, below) and to the
+FlangeSub return. That return is not modelled yet and is the remaining audible difference on grinds.
+
+**Interim voices through the native fold** (native mode only, `voices::native_fold_gain`):
+- With the native host running, every interim (Bevy) voice gets the gain that makes it reach the ears with the power
+  a native voice of the same per-voice gain has after Pan2D1 and the stereo fold.
+- Non-positional: mono 0.5, stereo 0.707.
+- Positional: by azimuth, compared with rodio's ear factors. Ahead −3.5 dB, behind −6.6 dB.
+- **rodio 0.20's spatial source is mirrored.** It gives the ear *farther* from the source the larger factor:
+  ((d_this − d_other)/gap + 1)/4 + 0.5. With the native host on, the listener's ears are swapped so interim sounds
+  come from the right side. The default path (no native host) is unchanged; a decision for the main session.
+
+### The buses: environment (reverb) network, eEQChain buses, owner one-shot buses; Class_Seams (2026-10-02, `skate_audio::bus`, `player::seams`)
+
+**Why.**
+- User: ambience and cars "don't sound like they're in the distance".
+- User: the board put-down's "effects the original engine uses aren't recreated".
+- Every voice used to mix dry into one bus.
+
+The specs come from our reading of the TU3 code with two research agents: `.claude/notes/aems-env-bus-spec.md` and
+`.claude/notes/aems-eqchain-buses-spec.md`. They supersede §6 of the voice-graph spec.
+
+**Environment network** (`bus/env.rs`; boot `sub_826DD3A8` → `sub_8248EEE8`):
+- *Input.* `[[0x830CFDEC]+52]` is never 0 in retail, so **every standard voice has Send A**: pre-gain, N → 1 mono,
+  level = VOL × FXWET0 (property 5).
+- *Graph.* EnvSendSub (199) splits into two sides A/B. Per side:
+  - EnvSub (200): Gai0 → PeakingIir2, with the EQ frequency swept by the LFO task;
+  - RvrbSub (201): pre-delay Del0 → **ReverbModel1** (six Moorer combs with prime delays from the space size, then
+    one all-pass; T60 / size / brightness) → Gai0 → two rvrbfiltsub (HPF → LPF → Gai0 → Pan2D1 at 270° / 90°, LFE
+    0.5);
+  - two rvrbdelaysub echo taps (Del0 with feedback → HPF → LPF → Gai0 → Pan2D1). Their delay and pan are swept per
+    block by the "LFO Task" (`sub_82490B60`).
+  - Everything goes into SFX Master.
+- *Presets.* 24 vault presets (`204CAC1FD77088B8`, `aud_reverb/reverbNN`, 44 values by record offset) applied as
+  `sub_8248DD18` posts them.
+- *Preset choice.* The district's `audio_reverb` region layer at the skater (default reverb01). A change loads the
+  other side with weight 0 and crossfades the two weights linearly over 1 s of game time (`sub_824DE548`).
+- *Emitters.* FXWET0 is the MixMap send word: out8 = −2600 mB + camera-distance roll-off 4 → 70 m. A near emitter
+  gets a wet tail and echoes; a far one loses them. Its dry level has no distance roll-off. That is retail's
+  distance cue. The zone ambience bed has no Send A.
+- New DSP modules: `dsp/delay.rs` (whole-sample delay, ±0.99 feedback, 128-sample tap crossfade),
+  `dsp/reverb.rs` (ReverbModel1) and `dsp/peaking.rs` (PeakingIir2, plus the DCl0 hard clip).
+
+**eEQChain buses** (`bus/eqchain.rs`; `sub_82490CA0`, resolver `sub_82491108`, re-roll `sub_824916E8`, clear
+`sub_82491180`):
+- *Graph.* Eight buses (order 253): DCl0 → PI20 → PI20 → SFX Master. Index 8 = SFX Master itself.
+- *Buses 0–4* (vault `AA801D9FC0ADBBBF`, records from the image table 0x8224DC78) re-roll all six EQ values on the
+  first create-flagged use after each clear. Each value is b + (k·(a − b))·0.1, with k = r mod 11 from our instance
+  of the title generator (no draw when a == b). Validated by the agent against retail: every non-default PEAK line of
+  buses 0–2 sits on that grid (all_163809: 228/228, 207/207, 2013/2016).
+- *Buses 5–7* take the shared jitter walk's values: keys `E17029CE…` and five more. These are channels of our
+  existing `SFXObj_Jitter` table, now exported with their keys.
+- *Clear.* Every second game frame, or every frame when frames are longer than 20 ms.
+- *Who uses which bus:*
+  - routing records 0–7 / 10–17 (+10 = may re-roll) on AEMS voices. GRINDS → bus 5, skid → 5, foot drag / wind /
+    rattle → 7, as the programs' records say;
+  - pop → owner bus at Contacts level(14), then bus 0;
+  - touchdowns and the manual landing → owner bus at level(15), then bus 0;
+  - landing impact → bus 1;
+  - foot taps and scuffs → bus 1;
+  - collision manager → SFX Master (its Collision SubMix bus, `sub_824D25E0`, is UNCERTAIN).
+
+**Owner one-shot buses** (`sub_82488DD0`): Sub0 → Sen0 (env, at the owner's level when built) → Sen0 (eEQChain bus).
+Modelled per voice: the panned output summed 6 → 1 × the level goes into the env input, and the voice's output goes
+to the bus.
+
+**SFX Master / output.** The trace has SFX Master's gain at 1 and LPF/HPF open, so it is an identity here; its DCl0
+level is not traced. Retail's output-channel byte 0x8306705D is **always 6** (Dac setup `sub_82B20EF8`): retail
+hands 6 channels to the console, and the stereo downmix is the platform's. The recomp host's is 0.4·(FL + SL +
+0.5·C). We keep the title's own N = 2 table (0.707 / 0.5 / 0.5) as our stereo fold. That is the game's matrix,
+though retail does not run it. No change.
+
+**Class_Seams** (`player/seams.rs`; ctor `sub_824C1198`, create `sub_824C13D0`, process `sub_824C14C8`, trigger
+`sub_824C1698`, crossing `sub_824C1CA0` / `sub_824C1BA8`, hit `sub_824C1DF8`, update `sub_824C1F18`):
+- *Packets.* Four 20-word per-wheel packets, held for the component's life.
+- *Material change.* A hit with the transition surface.
+- *Grid mode.* The wheels' world positions are rotated by the pattern's angle and divided by its grid. One hit per
+  axle per line crossing, after the minimum frames; the rear axle is skipped in manuals.
+- *Distance mode* (slats): front then rear hits every `spacing` of ground speed × 100 × dt.
+- *Update.* MixMap Cracks outputs.
+- *Kept retail quirks:*
+  - the cells start at 0x7FFFFFFF and the frame counter runs per axis, so the first frame at speed fires one hit per
+    axle;
+  - the turn word slews ±100 per packet write.
+- *Engine inputs.* AudioState gets `wheel_position` (the wheel bodies' world positions). The engine already
+  published the seam patterns (`WheelLineState.seam_patterns`). The state log gains `seam0`, `seam3`, `wheel_x`,
+  `wheel_z` and `heading` for replays.
+- *Tuning.* The pattern fields are exported with the seam wobbles. Seams_Bank joins the player banks and is decoded at
+  start (first-trigger rule).
+
+**Evidence and numbers.**
+- *Dry identity.* With `E2E_BUSES=0` the 12 standard e2e renders are bit-identical to the previous stage's on 7.
+  The other 5 differ by at most 1.2e-7 (relative 1.4e-7), only from the changed summation order through the bus
+  inputs.
+- *Wet.* Env + EQ on: the wet part is −6.7 / −6.9 dB under the dry on grinds (EQ bus 5 included), −9.7 / −9.9 dB on
+  brake and slide, −22.6 dB on the ollie, and below −40 dB on plain rolling (the bed has no Send A; its graph-2 env
+  send is not modelled yet).
+- *Send A against retail* (`.local/audio-re/envbus/senda_bank.py` on 163809, per-voice send medians):
+
+  | bank | ours (mean) | retail (median) |
+  |---|---|---|
+  | GRINDS | 0.0142, send/gain 0.16 | 0.0062 / 0.19 |
+  | WHEEL_SKID | 0.0256 / 0.28 | 0.0160 / 0.51 |
+  | FOOT_DRAG | 0.0037 / 0.13 | 0.0112 / 0.17 |
+  | owner buses | 0.079 | 2590/32767 = 0.079 in the capture |
+  | sense_of_speed | **0** | 0.0150 |
+  | Skate_Collisions Splice voices | none | 0.0146, send/gain 0.35 |
+
+  sense_of_speed: the programs post property 5 = 0 in our evaluator; the source of retail's value is not found
+  (open). Skate_Collisions: retail's Splice voice graph has a Send A, its level rule is not recovered (open).
+- *Seams through the real bank.* Sidewalk pattern at 10 / 20 / 30 km/h: voice gain median 0.045–0.049, p90
+  0.054–0.063. square_8 at 20 km/h: 0.027 / 0.050. Retail Seams_Bank per voice (163809): non-zero p10 0.010 /
+  median 0.074. First hit = later hits.
+- *Cost.* Env network about 21 µs per block. All buses add about 105 µs per block at p50 (render p50 19 → 124 µs,
+  budget 5,333). The eEQChain buses filter every block and are the main share: an optimisation-pass item.
+
+**Dev install.** `aems-port/tools/stage_bus_tuning.py` adds `bus_tuning` and refreshes `player_tuning` (jitter keys,
+seam pattern fields). Manifest backup: `.local/audio-re/audio_manifest.before-bus-stage.json`. Both keys are optional
+and older builds ignore them. Setup writes the same keys (`audio_export.bus_tuning`).
+
+**Not modelled / open.**
+- The FlangeSub returns (routing 4096 / 8192 / 16384: GRINDS uses one).
+- Reverb-zone emitters (type 5: zone fades and the pan rotation).
+- The grain chain's graph-2 env send (level(13)).
+- The Splice voices' own Send A and Collision SubMix.
+- sense_of_speed's FXWET0.
+- The reverb module's timer delay before a new preset is heard (applied at the next block here).
+- PI20 not bit-exact (no replay vectors).
+- The +150 Hz manual frequency shift.
+- Rolling rattle, Class_rolling, footsteps, cloth, flips/treatment.
+- Step-on (Skeleton+602/+603).
+
+**Final stage of the plan: an optimisation pass with adversarial reviews** (skill `.claude/skills/optimisation`,
+foundation). Measure first (AUDIO_TIMING in real play, e2e timing headless). Change one thing at a time and keep
+behaviour identical: e2e renders bit-identical, or a documented tolerance. An independent reviewer tries to break
+each change, looking for hidden output changes and fake speed-ups. Then re-measure (worst case and 1 % lows).
+Candidates: eEQChain buses that filter silence, per-block `Vec` allocations in the mixer, the wind/rattle and skid
+post/release thrash, the remaining small game-thread hitches.
+
+### Listening test 6 (20:06 build): seams on brick and in the University park (2026-10-02)
+
+User: DownTown (Aletown) brick "played too often or out of sync"; in the University's big park "an odd noise while
+riding … when going over seams … too much reverb added possibly". Logs `state_20261002_200832.tsv` /
+`_201324.tsv` (the clock restarts at each map load: cut by rows, `scenarios.py --cut rA-B`), rendered headless
+(`.local/audio-re/e2e-2008*`, `e2e-rev-*`).
+
+**Surfaces.** The brick is tag 66 with seam pattern 13 (`mini_tile`: 0.08 m grid, angle 30°) and tag 5 / pattern 7;
+the park is tag 41 (Wood_1) / pattern 9 (`irregular_large`, 0.7 m, gain 0.41).
+
+**Cause 1 — materials gated by contact (fixed).** The audio record's wheel materials (`+620..+632`) and seam patterns
+(`+636..+648`) come from the wheel lines (82C079E0: each wheel's 0.2 m ray), not from contact. Our `audio_state`
+gated them by `in_contact`, so every contact flicker was a material change, and Class_Seams fires a *transition* hit
+(AudioSurfaceMap word 9 + 5, a different sound) on every change.
+- Retail (GREC, `aems-port/tools/grec_material.py`, 180430, 683 s rolling): wheel 0 keeps its material on 100 % of
+  3-wheel frames and 96 % of 2-wheel frames; it changes 0.9 times a second.
+- Ours (contact-gated): wheel 0 changed 5.0 / 8.9 / 6.6 times a second in the 20:08 / 20:13 / 19:29 logs, 19–27 changes
+  a second over all wheels (the park's wheel mask changes 16–19 times a second).
+- Fix: `skate_events::audio_state` takes both from the lines (still 143 / 0 for the riderless board). The state log has
+  a new `lines` column; `e2e.rs` replays it (older logs: every line hits while a wheel is down; `E2E_CONTACT_MATERIALS=1`
+  replays the old gating).
+- Park windows: transition hits 243 → 80 (of 635 → 531 hits) in `mp_seams2`, 118 → 40 in `mp_seams`; brick 58 → 36.
+  Scripted e2e: 11 of 12 renders bit-identical, `manual15` differs (the lifted truck keeps its material) within 0.1 dB.
+
+**Cause 2 — interim seams and knocks still playing beside the native ones (fixed).** In native mode the interim
+riding bed (`cues::BED_CUES`) still fired random `Seams_Bank` samples (about 0.45 a second, at random times: "out of
+sync"), and `BED_RECORDS` fired the deck knocks 1112 / 1115 / 1119 and the scuffs `sk8_foley` 94 / 95 that the native
+foot taps / scuffs play; the interim `CATCH` knock (1115, 0.22 s after a flip) doubled the native taps too. All
+silent now when the native player / contacts run (`cues::bed_record_native`).
+
+**Hit rate on brick: not above retail.** Ours on tag 66 / pattern 13 at ~8 m/s: 100–220 Class_Seams hits a second
+(the 0.08 m grid; 116 a second over the brick window, 224 in the 30 km/h sweep), heard as about 11 seam voices a second — the program sees the
+one-frame w7 pulse only at its 32 ms walks, as in retail. Retail on the same material (wheel-0 material 65 = tag 66,
+180430 seconds 443 / 451 / 452): 27–40 Seams_Bank voices a second, per-voice gain median 0.088 (ours 0.07–0.09).
+
+**Sample variety (resolved in Listening test 8: the missing `Start_up_Play_ctl` boot utility, no trace needed).** A sweep of the packet words through the real program
+(`player_audio::tests::seam_samples_by_words`, `SEAM_SWEEP=word:value`) shows the program picks one sample per
+(surface w10, speed w8, soft w11): surface 1 → sample 80 (72 at speed word 0, 88 at 10000), soft → 170. So at a steady
+speed ours repeats one or two samples (80 / 32 on the brick). Retail on tag 66 plays 45, 83, 170, 80, 176, 34 … in
+the same seconds — the soft-wheel set (170 / 176) and other surface blocks appear. Which words differ in retail is not
+known: a recomp hook on the Class_Seams packet (`sub_824C1DF8` / `sub_824C1F18`, words 7–18 per wheel) would settle it.
+
+**Reverb in the park: retail's preset, strong echoes.** The University's `audio_reverb` region gives preset
+`407AFA1D6C7CEAD8` everywhere the user rode (DownTown: `68A9E6020DF2076D`). Retail used it too: in 163809 the env
+EQ's sweep runs from 928.8 Hz = 1161 × (1 − 0.2) with gain 0.1 and Q 20, that preset's values. It has two echo taps
+at 0.17 / 0.18 s, gain 1.0, feedback 0.2, with a ±20 % delay wobble, which makes short seam hits audibly slap back.
+Rendered bus part on the park window: −16.1 dB re dry with it, −22.6 dB with reverb01, −21.1 dB with DownTown's.
+The seams' Send A matches retail (send / gain 0.22, retail median 0.225). Our env network's wet level has not been
+checked against retail *output* (no trace of the network's return); a capture of a seam hit in the park would.
+
+### Listening test 7: rolling "busy", "continues into jumps", "rougher than it is" (2026-10-02)
+
+User: rolling "can sound faster or like more is happening than actually is"; "sometimes while jumping the rolling on
+ground sound continues"; "the materials sound rougher than they are for some things". Logs
+`state_20261002_203746.tsv` / `_204047.tsv` (University, 0 malformed lines), plus a recomp trace-all session at the
+same spot (`all_20261002_204336`, clean).
+
+**Cause 1: interim rolling one-shots still playing beside the native layers (fixed, not yet in a test build).**
+The interim bed table (`cues::BED_CUES`) still fired random `Rolling_Rattles` (0.31/s × bed rate, level 0.44) and
+`PatchBank_Rolling_Surfaces` (0.14/s) samples under `SKATE_AEMS=1`. In 21 s of riding that is about 7.7 rattles and
+3.5 surface one-shots. Retail posts the rattle only on a push and plays the surface layers as continuous textures
+gated by the MixMap. These samples last 0.3–1.9 s, so one started just before takeoff rang on into the jump: about a
+1 in 3 chance per jump for a rattle at this session's speeds. `skate_events.rs` now skips both entries whenever the
+native rattle / rolling layers run (`PlayerAudio::rattle_on` / `rolling_on`). The native layers themselves go quiet
+within 10 frames of takeoff: SkateBoard MixMap levels 1, 6, 7, 9 and 10 are 0 with no wheels down
+(`skate-audio/tests/rolling_banks.rs::layers_go_quiet_after_takeoff`).
+
+**Surface choice matches retail.** Retail's wheel-0 material (GREC `+620`) is 3 = tag 4 (concrete_rough) for all
+32.5 s of four-wheel rolling, the same tag our engine reports (17.2 s of tag 4, 0.7 s of tag 64). Speeds match too
+(retail median 11.0 m/s, p90 12.0; ours 9.4 / 12.1). So "rougher than it is" is not a wrong surface. The rendering
+of `concrete_rough_hard` and the layering on top of it are being compared with the retail capture.
+
+**Retail facts for the other layers.** The SenseOfSpeed rattle's gain is not gated on wheel contact (level 832 at 31 km/h
+both on the ground and in the air), so it keeps playing in jumps and posts again as the speed crosses 30 km/h. That is
+parity with retail. Retail keeps the riding speed during jumps (±5 km/h).
+
+### Listening test 8: concrete "too rough", brick "firing too often, sounds faster" (2026-10-02, build 21:04)
+
+User (build with the grain chain, board layers, seams taken from the wheel lines, interim cues off): rolling was
+"much better", but "the same concrete still sounds too rough"; brick "sounds better but is still firing too much or
+too often and sounds like you're going faster than you are". Logs `state_20261002_210721.tsv` (University, 22.8 s on
+tag 4 at a mean 31 km/h) and `_210845.tsv` (University, then DownTown; 21.6 s on tag 66 / seam pattern 13 at a mean
+19 km/h). Both logs are clean. Rendered headless (`.local/audio-re/seams8/`): brick 15 / 21 / 32 km/h, concrete
+on patterns 2 / 8 / 11.
+
+**Cause: a missing boot utility froze the Seams program's sample choice (fixed).** We traced the Class_Seams program
+op by op (new example `skate-audio/examples/program_trace.rs`). Every player's sample index is built as
+table(surface w10) + table(speed w8) + soft wheels + one of three globals, `send_random_0_to_9a` / `9b` / `9c`. The
+program calls the function `rnd_call` on a hit. Only `Common.abk` implements that function, through its class
+`Start_up_Play_ctl`. Retail posts that class once at audio boot, after `c_emitter_utility` and before
+`c_foley_utility` (retail's three boot POSTs; upstream PR #4's player does the same). On each call it runs three
+RandomShuffle draws over 0–9 and writes them into the globals. We neither loaded nor posted it, so the globals stayed
+at their defaults (7 / 0 / 0) and each (surface, speed, soft) word set always played sample 0 of its block of eight:
+- brick played 80 and 32 every time; retail 180430 plays all of 32–39 and 80–87;
+- concrete played 32, 104 and 112; retail 204336 plays all of 32–39, 104–111 and 112–119.
+
+At 20–30 hits a second, the same transient repeated as a regular buzz, which reads as "too often", "faster" and
+"rough".
+
+**What matched already (no change):**
+- *Speed word.* w8 = clamp01((state+208 − 0.5) × 0.08) × 10000, with +208 in m/s. Constants `0x8209975C` 0.5 and
+  `0x8208EDA4` 0.08 come from `sub_824C1F18`; ours is identical. The speed table moves the block 72 → 80 → 88 with
+  speed; retail plays 80–87 at 30 km/h, as ours does.
+- *Seam hit gating.* We re-read `sub_824C1698` (per axle: one wheel, minimum frames since the partner wheel's hit,
+  frame counter per axis), `sub_824C1CA0` (grid cell, surface-3 scale only for class 10) and `sub_824C1BA8`
+  (rotation). They match the port.
+- *Rate.* We compared at matched speed and seam pattern, looking up the pattern at retail's WPPOS position in our
+  logs:
+
+  | surface | retail | ours, after the fix |
+  |---|---|---|
+  | concrete, pattern 8, 30–40 km/h | 21 voices/s, 16 walks/s | 28 voices/s, 18 frames/s (36 km/h) |
+  | concrete, pattern 8, 40–50 km/h | 28 voices/s | — |
+  | brick (material 65), 30 km/h | 27–40 voices/s | 29–31 voices/s |
+- *Per-voice level.* Ours is 0.045–0.053 on concrete against retail's 0.052–0.074 (by block), and 0.08–0.09 on brick.
+  Ours is not louder than retail.
+- *Concrete's other layers.* The spidercrack layer 5 only plays on seam pattern 1; these windows are on patterns
+  2 / 8 / 11. Graph 3 (the high-speed copy) only starts above 46 km/h; these windows top out at 44.7 km/h.
+
+**Fix:**
+- `audio_export.AEMS_EXTRA_BANKS` now includes `Common.abk` (it is programs only, with no samples).
+- `native.rs` loads it and posts `Start_up_Play_ctl` after `c_emitter_utility`, and keeps it across map unloads.
+- The e2e test and the player tests do the same (`seams::UTILITY_BANK` / `UTILITY`).
+- For an existing dev install: `stage_extra_banks.py --tag seams-utility Common`, which now also stages program-only
+  utility banks.
+
+**Verification:**
+- Hits are unchanged (722 in brick21).
+- Each eight-sample block is now used evenly. In brick21, 32–39 and 80–87 each get 2–10 starts.
+- Whole-mix level: −0.6 to +0.05 dB.
+- `E2E_SEAM_UTILITY=0` renders are byte-identical to the 21:04 renders.
+- New test `player_audio::seam_hits_shuffle_their_samples`: 146 voices in 5 s on brick at 30 km/h, all 16 samples.
+
+**Open:**
+- On cells our logs mark as pattern 11 (sidewalk, 3 m grid), retail 204336 played 2 seam voices in 1.5 s of moving
+  at 40 km/h; ours plays about 12 frames a second at 33 km/h. The sample is too small to call: most of retail's
+  "pattern 11" seconds come from a stopped stretch with the speed still held. A recomp trace of `+636` (wheel 0's seam
+  pattern) next to WPPOS would settle whether retail sees pattern 11 there.
+- Our boot order is foley utility, then `c_emitter_utility`, then `Start_up_Play_ctl`. Retail's is emitter,
+  Start_up, foley. The three share one RNG, so draw order differs from retail; behaviour does not.
+
+### The board's other layers, the grain chain, tricks / treatment, the effect returns (2026-10-02, `player::{rolling, tricks, treatment}`, `grain::chain`, `bus::{flange, zones}`)
+
+Specs (our reading of the TU3 code with research agents): `.claude/notes/aems-board-layers-spec.md`,
+`aems-grain-chain-spec.md`, `aems-tricks-treatment-spec.md`, `aems-bus-leftovers-spec.md`.
+
+**SFXObj_SkateBoard's rolling layers** (`player/rolling.rs`):
+- *Surface routing* (`sub_824C5CA8`, surface of a truck `sub_824C82A8`, member `sub_824C8370`): two trucks, the
+  primary one reading wheel 0's material, the other wheel 3's; one sounding truck per distinct surface. A truck
+  that leaves its surface hands the sound to the silent truck instead of stopping it (retail never stops the
+  local player's last sounding truck; the MixMap's level(1) mutes it in the air). GREC 180430 agrees: neither
+  truck running on 621 of 310k frames. The bed now binds and stops from these events (`GrainEvent`) and the
+  routing writes SkateBoard inputs 0 / 6; `grain_bed.rs` keeps its old one-truck routing only when the native
+  rolling layers are off.
+- *Class_rolling* (constructor `sub_824C4C18`): the non-grain rolling surfaces 7, 8, 10, 11, 12, 13 post a
+  per-surface patch (selectors 1, 2, 10, 12, 11, 9) instead of a grain — this replaces the interim stand-ins in
+  `cues::grain_for` (tags 8 / 10 / 70 → aggregate, 37 / 67–69 → metal) on the native path. Rolling surface 0
+  (tag 90) binds asphalt_rough_hard with the `default` collection's tuning (open question closed).
+- *Held layers 0 and 3* (posted once at board create, `sub_824C9830` / `sub_824C9948`) and *layer 5* while wheel 0
+  is on the spidercrack pattern (`sub_824C9F68` / `sub_824CA038`).
+- *Rolling_Rattle_Class* (`sub_824C6198`, `sub_824B0248`, `sub_824C80C0`): re-posted on every push plant while the
+  primary truck is on a grain surface (sample = 3 × surface code + speed band).
+- *c_board_slide* (`sub_824CB3C8` / `sub_824B0670` / `sub_824CB4C0`): the loose board on its back / side while the
+  rider bails or walks. The `up_dot` vectors are UNCERTAIN (deck up · world up stands in).
+- Every Class_rolling post reaches all four banks bound to the class, so setup now exports
+  `PatchBank_SpiderCracks`, `PatchBank_Objects` and `PatchBank_RocksBounce` (and `Treatments`).
+- Levels through the real banks (per-start peaks, agent's `tests/rolling_banks.rs`): Rolling_Rattles 0.34–0.37
+  (retail p90 0.30–0.36, max 0.37); SpiderCracks max 0.355 (retail max 0.29–0.35); held layer slot 15 median 0.030,
+  p90 0.046 (retail 0.007–0.010 / 0.044–0.121); Objects up to 0.20 (retail p90 0.03–0.22); board_scrapes max
+  0.06–0.10 (retail p90 0.10–0.12). First rattle = later rattles. In the air every layer is silent within 10 frames
+  (SkateBoard levels 1, 6, 7, 9, 10 are 0 without wheels).
+
+**The grain bus chain** (`sub_824C8878`; `dsp/fss.rs`, `dsp/shelf.rs`, `grain/chain.rs`):
+- *FrequencyShiftSsb* (`sub_82B22898`): two cascades of two allpass sections (fixed image constants at
+  `0x82FCE2B0`) form an I/Q pair on the shared biquad kernel; out = I·cos φ − Q·sin φ with retail's polynomial
+  sin / cos; at 0 Hz it is the I path (an allpass), never a bypass. Phase error of the Hilbert pair ±0.6° at
+  100 Hz–1 kHz.
+- *Values per frame* (`sub_824C9058`): A = (special ? +150 Hz : 0) + the push shift envelope + D × A's shift per slope;
+  B = B's base shift (−10 Hz; wood −25, metal −20) + push shift + D × B's per slope. **This is the +150 Hz manual
+  shift.**
+- *Graph 3* (the high-speed copy): send 0 below 46 km/h → 3.0 at 70 km/h, DCl0 ±0.09, the wobble gain, HS20 5 kHz ×
+  0.65. *Wobbles* (`sub_824CB078` / `sub_824CB180`) and the graph-1 level ramp, with the quirk that truck 1 never
+  receives a wobble. *Graph 2*: the env send level(13)/32767 (pre-pan mono) into the reverb network, the
+  FlangeSub send level(21)/(22) carried but not rendered (no bed → return route yet).
+- Retail (`dsp_20261002_185826`, `.local/audio-re/grain-chain/chain_check.py`): the graph-3 send matches exactly (189
+  posts), graph-1 / graph-3 gain = the level ramp within 1e-4, wobble depth 0.290 / 0.240 against the caps 0.30 /
+  0.25, only truck 0's graph-3 gains change.
+- e2e: **manual15 went from −4.0 dB to +0.1 dB against the PoC** (A × 0.65 and +150 Hz; centroid 652 → 763 Hz, PoC
+  77x). Rolling scenarios unchanged (≤ 0.1 dB). Graph 3 adds about +5.7 dB at 60–85 km/h (not compared with a
+  retail capture).
+
+**Tricks and Class_Treatment** (`player/tricks.rs`, `player/treatment.rs`):
+- *Class_Flips* (`sub_824CBFB8` → `sub_824AFAD8`) posts on the first air frame of a trick (not at the pop: retail
+  median one frame after the jump-velocity write), held while airborne with the same audio trick, released at the
+  landing; ids −1 / 35 / 36 post nothing. *cloth_trick* A as soon as the trick registers (~215 ms before the air),
+  B with the scorable's second audio trick (`+352`, vault field `A2C5C22C5BE725F8`, now exported as
+  `player_tuning.audio_tricks_2`) when the trick ends.
+- *Class_Treatment* (`sub_824DD408` / `sub_824B0080` / `sub_824DD6F0`): posted once, streams the predicted time to
+  landing (Air+184) and jump height; its landing streams 13 / 14 start ~0.37 s before touchdown.
+- Levels through the real banks vs retail: flip whooshes 0.370 (retail 0.347–0.365), flips slot 5 0.133 (0.134),
+  cloth_trick 0.18–0.24 (0.21–0.25), Treatments 13 / 14 0.0736 / 0.0184 (0.0746 / 0.0186). First flip = second.
+- Treatments slots 16 / 17 (the long-air layer) play in the recomp too, at our level (section "Treatments slots
+  16 / 17" below). The game-mode globals (G+96, X+1060, G+4) are free-skate defaults.
+- The interim `cues::FLIP` is silent with the native Tricks.
+
+**Effect returns and the other bus leftovers** (`bus/flange.rs`, `bus/zones.rs`, mixer Send B):
+- *FlangeSub returns* (`sub_82490270`, presets `sub_824DDF58`, levels `sub_824DF220`): Del0 (≤ 15 ms) → PI20 → env
+  send → Gai0 → Pn21 → SFX Master, the delay swept 0.2–3.8 ms at 0.5 Hz (A) / 0.2–0.8 ms at 0.25 Hz (B). Routing
+  4096 → A: GRINDS; 8192 → A: WHEEL_SKID_BANK; 16384 → B: Flips. Send B = the post-gain mono at property 11; retail
+  GRINDS 0.0499 / skid 0.0561 (= Rail out6 / SkateBoard out20, which our components post). On a grind the return
+  is a centred copy 26 dB under the dry voice. Presets exported as `bus_tuning.flange`.
+- *Send A corrections:* retail sense_of_speed Send A **is 0** (its updater writes w6 = property 5 = 0 every frame) and
+  Splice voices have **no Send A** (graph `PITCH GAIN SEND6`). The 0.0150 / 0.0146 in "The buses" came from a trace
+  script that attributed every line to an owner's last PLAY of the session (`.local/audio-re/busleft/senda_bank_fixed.py`
+  is the corrected one). Nothing to port.
+- *Collision SubMix* (`sub_824D25E0`): collision voices play mono into their submix with an env send at the
+  category's Collision output (≈ 0.100 near the camera, as the trace) and the AudioSurfaceMap words 12–16 eEQChain bus
+  (all 8 = SFX Master in the vault). On by default (`SKATE_AEMS_SUBMIX=0` = the old direct route).
+- *SFXObj_Reverb's selector* (`sub_824DE548`, zone blend `sub_824DEEF0`) runs in retail's order (`env.update`): the
+  first region preset fades in over 1 s from reverb01. The reverb-zone emitters (`.ems` attribute type 5) are not
+  wired: one record on the disc (`1F94F2F815C00368` → preset `BEEFC8E3DE04FBAE`). *Superseded: 1,040 records, now wired
+  — see "FootStep SubMix, the skeleton inputs, …".*
+- Not applied: the global env-send scale (manager +104 = Reverb out4): it depends on Reverb.in5, whose writer is
+  unknown (the trace says in5 = 0; our hosts write 32767, which would drop every env send 4 dB). *Superseded: the writer
+  is `sub_824DF468` (by the preset number); applied — see "FootStep SubMix, the skeleton inputs, …".*
+
+**Footsteps, clothing, hands on the deck** (`player/footsteps.rs`, `player/clothing.rs`, `player/step_on.rs`; spec
+`.claude/notes/aems-offboard-clothing-spec.md`):
+- *SFXObj_OffBoard* (`sub_824E9270`, poster `sub_824E9FD8`, updater `sub_824EAEA8`): two held
+  `playercharacter_footstep` packets (25 words) plus the foot-down Splice sounds (surface layers `sub_82493E60`,
+  step layers `sub_82493690`), the walking voices (`sk8_foley` 62 / 63 / 64; Skate_Collisions 1121–1123 with the
+  board in hand) and the jump take-off / apex voices. On the board the push plants and the brake count as feet
+  down, so this also plays the push steps.
+- *Clothing* (`sub_824DBB68`): `c_cloth_falls` at a bail, the push foley `sk8_foley` 73 / 74 (eEQChain bus 0),
+  `c_body_slide`.
+- *Hands on the deck*: Skeleton+602/+603 are the IK's **hand** targets (limbs 2 / 3) inside the padded deck box, not
+  the feet. 1124 / 1125 (hand on, air / ground) and 1126 (hand off) play when the board is picked up or put down
+  by hand (Contacts `sub_824B85B0`). The interim "1126 = foot on deck" was a wrong mapping and is silent natively.
+- Caller 824D8164 (the 1017 `sk8_foley` 62/63/64 events in 164620) is `SFXObj_PedestrianSFX` — pedestrian footsteps,
+  not the player.
+- Levels vs retail per-voice medians: walking foley 62 / 63 0.387 / 0.244 (retail 0.387 / 0.244); step layer 82 equal
+  per sample; board in hand 0.155–0.28 (0.17–0.34); metal surface 0.082 (0.082); push foley 0.257 (0.18–0.26);
+  hand on 0.125–0.153 (0.13–0.16), hand off 0.062–0.070 (0.071–0.081); Foley_Cloth +7 dB (guessed inputs below).
+- Engine inputs: feet down (OffBoard 306 / 307, Air 449 / 450, push flags, brake), the feet's surfaces
+  (`processed.right/left_surface`), toe world speeds, footstep strength, the hand targets — published. APPROXIMATE:
+  the feet's vertical speeds (toe world velocity y), the body speed (COM speed). Not published: the step code
+  (Skeleton+144/+160), the limb speeds and the ragdoll body-part slide records (body slide stays silent). The
+  FootStep SubMix chain (HPF → LPF → PI20 → env → pan per sound) is passed through but not rendered by the mixer.
+- Setup exports per material `B1CF62EA632CF13F` (has footsteps), `37320DF00471F91A` / `9D6068AB16703650` (gains).
+  `SKATE_AEMS_FOOTSTEPS=0` keeps the interim steps. The interim `STEP` / `RUN_STEP` / `PUSH` / `BOARD_DOWN` cues are
+  silent with the native footsteps / contacts. The state log gains `foot_down`, `foot_tag_a/b`, `hands`, `strength`,
+  `foot_vy_a/b` for replays.
+
+**Retired interim cues (native path).** The native path no longer reaches `POP`, `POP_TAIL`, `LAND*`, `land_tier`,
+`land_scale`, `LAND_CLOTH` (= the native scuffs `sk8_foley` 95), `POWERSLIDE*` (user-confirmed), nor `CATCH`, `FLIP`,
+the interim bed's Rolling_Rattles / PatchBank_Rolling_Surfaces / Seams_Bank / sense_of_speed cues and its knocks /
+scuffs, `STEP` / `RUN_STEP` / `PUSH` / `BOARD_DOWN` (native replacements, not user-confirmed). The tables stay for the default path (native off).
+
+**Cost.** Render p50 87–117 µs → 114–178 µs per block over the e2e scenarios (the grain chain ≈ +27 µs per bound
+truck, mostly `mul_add` library calls); game thread p50 32–38 µs → 35–38 µs per frame. `voice_load_probe 96`: p50
+512–520 µs with or without the returns (budget 5,333).
+
+**e2e against the PoC (all on, `.local/audio-re/e2e-on2`).** Unchanged within 0.3 dB everywhere except manual
+(−4.0 → +0.1 dB, the chain) and the slide (st101 segments +3.0 → +2.2, +0.8 → +0.8, −0.2 → +0.6 dB against the PoC: the skid's flange
+return and the rolling layers). With every new part off (`E2E_ROLLING=0 … E2E_CHAIN=0 E2E_FLANGE=0`) 11 of 12 renders are
+bit-identical to the previous stage; roll45 differs by the graph-1 wobble (−36 dB under the signal), which the
+host now posts.
+
+
+### Listening after the components stage (2026-10-02, builds 21:04 and 21:12)
+
+User verdicts, verbatim:
+- Rolling "is much better, it just has issues with certain surfaces":
+  - University concrete (session `state_20261002_210721`, tag 4, about 31 km/h): "the same concrete still sounds too
+    rough on our engine".
+  - DownTown brick (`state_20261002_210845`, tag 66 / seam pattern 13, about 19 km/h): "the brick surface sounds better
+    but is still firing too much or too often and sounds like your going faster than you are".
+- Footsteps, clothing and hands on the deck (`state_20261002_212254`): "the footsteps sound great, cant tell on the
+  clothing but nothing intrusive sounding. pickup / put down sounds were great."
+
+Consequences:
+- Footsteps and the hand pick-up / put-down are user-confirmed. The interim STEP / RUN_STEP / PUSH / BOARD_DOWN* cues
+  join the confirmed retirements.
+- Both surface reports are being measured against retail (recomp sessions `all_20261002_204336` at the same University
+  spot and `all_20261002_180430` on brick). The lead is the Class_Seams packet words, especially whether our speed word
+  has the scale retail's program expects: a wrong scale would pick the "fast" samples at low speed.
+### FootStep SubMix, the skeleton inputs, the Reverb inputs, the reverb zones (2026-10-02, `bus::submix`, `skate_events`, `bus::env`, `emitters::reverb_zones`)
+
+**The FootStep SubMix** (`sub_82494188`, spec `.claude/notes/aems-offboard-clothing-spec.md` §2.5; `bus/submix.rs`):
+- One mono graph per foot sound slot of `SFXObj_OffBoard` (two feet × four slots), built once:
+  `Sub0 → HI20 → LI20 → PI20 → Sen0 (env bus) → Pn21 (1 → 6) → Sen0 (SFX Master)`.
+- The slot's Splice voices play into Sub0. Their 6-channel final Send sums L, C, R, Ls, Rs into the
+  mono input; LFE is dropped.
+- At each start of the slot's sound, `sub_82494550` posts the slot's EQ record (HPF, LPF, PI20
+  centre / gain / Q), the holder's env level and its azimuth.
+- The graph keeps those values, its filter history, its send ramps and its panner matrix until the
+  next start. `SpliceHost::set_submix` now reaches the mixer (`Output::Submix`, `Route::mono`).
+- Off: `SKATE_AEMS_FOOTSTEP_SUBMIX=0` or `E2E_FOOTSTEP_SUBMIX=0` (the old direct route).
+- UNCERTAIN: Sen0 #2's level (never posted, 1.0) and Pn21's law (class defaults); the release
+  de-click of a voice goes to SFX Master as for the other buses.
+- Effect: the step layers keep the slot's open EQ, so they come out as before. A replay of the
+  user's walking (state log 21:22, rows 462–948) differs by 5e-8. The EQ records apply to the
+  surface layers (metal surface 5, special surface 7, and materials with their own footstep record).
+
+**The engine inputs the components were missing** (no `skate-core` change; read from what the engine
+already keeps; `skate_events::audio_state`). Retail's Skeleton::FillPhysOut (`sub_82BE1AE8`) and the
+record writer (`sub_827A1B78`) read back from the TU3 code:
+
+| audio state | retail | ours |
+|---|---|---|
+| `+740` step code | Skeleton `+144` / `+160` = the physical pose translations of toe parts 15 / 19 (Skeleton 9024 / 9280) at the OffBoard 306 / 307 plants | `StepCode::update(flags_306_307, left / right surface, record.pose[15/19][3].y)` |
+| `+296` / `+292` foot "vertical" speeds | \|y\| of Skeleton `+304` / `+320` = the **angular** velocity (body `+48`; `+32` is linear) of the assembly bodies of parts 20 / 16 (assembly `+76 + 96·part`) | \|angular_velocity.y\| of `skeleton.bodies()[20 / 16]` (was the toes' linear speed, a proxy) |
+| `+328` body speed | \|Skeleton `+288`\| = the angular speed of part 23's body | \|`bodies()[23]` angular velocity\| (was \|COM v\|, a proxy) |
+| `+672` limb speed | 0.25 · (572 + 568 + 564 + 560): \|record velocity − Skeleton16176 (physical COM velocity)\| of parts 8, 4, 21, 17 | the same from `skeleton.record.velocities` and `reckoning.vector_16` (was 0) |
+| `+528..+548` slide speeds | the ragdoll regions' tangential speed (SkeletonCollision `+944 + 4i`, published by `sub_82BD60C8` into Collision `+80..`; 0 without a contact part) | `collision_feedback.regions[i].tangent_speed` (was 0: body slide never played) |
+| `+560..+580` slide tags | the regions' surface tags (`+976 + 4i`; the per-frame PhysOut reset leaves 0 without a part) | `regions[i].material_flags` |
+| `+593` | SkeletonCollision byte 4009 = the face point's contact this frame (specific point 1) | `collision_feedback.specific[1].current` |
+| loose board `up_dot` | SkateboardReckoning `+80` (the effective deck basis' Y = the physical deck up) · Ground `+80` (the retained wheel-contact normal); deck contact Collision `+3475`, material Collision `+12` − 1 | `skate_events::deck_up`; contact and material read raw (the riderless-board gate of the record's wheel fields does not cover them) |
+
+- Lengths use `f32::sqrt`. Retail uses x · the twice-refined reciprocal-sqrt estimate; the two
+  differ by about 1 ulp.
+- The state log appends `step`, `body`, `limb`, `slide`, `deck_up` and `deck_contact`.
+  `scenarios.py --from-log` copies them and the e2e replay reads them when present. Older logs keep
+  the old defaults.
+
+**Reverb.in0..6 and the global env scale** (`sub_824DF468`, `sub_824DF390`; `bus::env::reverb_inputs`):
+- *Who writes them.* `SFXObj_Reverb`'s update starts with `sub_824DF468`. It writes Reverb.in0..in6
+  = 0, then 32767 into one input.
+- *Which input.* It comes from the number of the preset on the side being faded to (record `+48` =
+  the NN of reverbNN, jump table `0x824DF3D0`):
+
+  | presets | input |
+  |---|---|
+  | 1–5 | in4 |
+  | 6–8 | in0 |
+  | 9, 13, 14, 17, 18 | in1 |
+  | 10 | in2 |
+  | 21 | in3 |
+  | 11, 12, 15, 16, 22 | in5 |
+  | 19, 20, 23, 24 | in6 |
+
+- *What it changes.* In5 drives F213 (Reverb out4 −400 mB) and F141 (music). In1 drives the
+  emitter / ambience ducks F21 / F40 / F41 and others.
+- So our fixed in5 = 32767 was wrong. At reverb01 the MixMap now gives out4 = 32730 (scale 0.99887,
+  as the retail trace showed), and inside a reverb11 zone 20603 (−4 dB).
+- The scale is applied each frame after the tick (`EnvNetwork::scale_frame`).
+- Off: `SKATE_AEMS_REVERB_INPUTS=0` or `E2E_REVERB_INPUTS=0` (fixed in5 = 32767, no scale).
+
+**The reverb-zone emitters** (`emitters::reverb_zones` → `native::reverb_frame` → `EnvNetwork::update`):
+- *The earlier count was wrong.* The previous stage counted "one record". The disc has **1,040**
+  eVolumeType-5 records in 24 attributes, each naming a reverb preset (`99FD793BC30CF0FA`; reverb02…24):
+  - `reverb_downtown`: 616 records;
+  - `reverb_industrial`: 240;
+  - `reverb_university`: 133;
+  - the parks' `sfx_` files: 51.
+- *Which files load.* The map database (`F4917ACACAFAF913` field `65FA976EF23A314E`) lists the files
+  a map loads. The districts load `music_`, `sfx_`, `reverb_`, `speakers_` and `crowds_`; the parks
+  load one file.
+- *Per frame.* The zones holding the camera (sphere / ellipsoid with inner core, as for the sound
+  emitters) are listed in the order they were reached. The retail selector blends and rotates the
+  reverb toward them.
+- *Setup.* The emitter export adds `reverb` (16 hex digits) to kind-5 records (`_value` now reads
+  an untyped `Attrib::RefSpec` as class + key). Dev install: `aems-port/tools/stage_reverb_zones.py`,
+  backup `.local/audio-re/audio_manifest.before-reverb-zone-stage.json`.
+- Off: `SKATE_AEMS_REVERB_ZONES=0`.
+- Test `emitters::a_downtown_reverb_zone_selects_its_preset_and_raises_reverb_in5`: in the core of a
+  `1F94F2F815C00368` zone, reverb11 fades in and commits, in5 = 32767, and out4 32730 → 20603.
+
+**Boot order.** Retail posts `c_emitter_utility` → `Start_up_Play_ctl` → `c_foley_utility`. They share
+one random generator, so the native host now posts in that order (the foley utility used to come
+first, from the optional banks).
+
+**Treatments slots 16 / 17** (settled 2026-10-02: the recomp plays them too):
+- *Problem.* Ours plays Treatments 16 / 17 quietly in every ollie. Our recomp sessions seemed to show
+  they never play there, so `+240` (w8, the predicted time to landing) looked wrong around takeoff.
+- *Evidence.* The user's TREAT session (`all_20261002_223306`, University: plain ollies, one ~2 s air
+  off a ramp; hook on `sub_824DD6F0`, 57,323 lines, 0 malformed) logs Class_Treatment's inputs per
+  rendered frame:
+
+  | input | ground | first air tick | in the air | landing tick | after |
+  |---|---|---|---|---|---|
+  | `+240` predicted time to landing | 0 | the whole prediction (0.70–0.77 s ollies, 2.01 s ramp) | −1/60 per tick | still counting (0.019, can go below 0) | 0 |
+  | `+236` air time | 0 | 1/60 | +1/60 per tick | still counting (0.767) | 0 |
+  | `+260` jump height | 0 | 0.22 m | rises to 1.19–1.21 m (ollies) | held | 0 |
+  | `+224` (G+4 byte) | 0 | 0 | 0 | 0 | 0 |
+
+  Values change per 60 Hz physics tick; the recomp updates the packet about 345 times a second. Our
+  audio state publishes the same shape: `+240` is KnownAir's Air+184 from the physics port.
+- *Root cause.* A measurement error. Treatments 16 / 17 are byte-identical to sense_of_speed 3 / 4.
+  `retail_voices.py` matches PLAY payloads against the disc and took the first archive hit, so the
+  recomp's 16 / 17 voices were counted as sense_of_speed. Their sample addresses sit in the
+  Treatments bank's memory (0x4B22…/0x4B23…, next to 13 / 14 at 0x4B21…). The real sense_of_speed
+  3 / 4 voices are at 0x4AFF…/0x4B00…. Only 10 samples on the disc are shared across banks.
+- *The recomp vs ours.* We replay the recomp's own per-frame inputs through our Class_Treatment, bank
+  and evaluator (`tests/player_tricks.rs` `treatment_replay_of_the_recomp_capture`).
+  - Voice counts:
+
+    | slot | 13 | 14 | 15 | 16 | 17 |
+    |---|---|---|---|---|---|
+    | the recomp | 18 | 18 | 1 | 18 | 18 |
+    | ours (replay) | 18 | 18 | 1 | 20 | 20 |
+
+  - In the 15 airs of 0.6–1.0 s, both play 16 and 17 once per air. The recomp starts them a median
+    87 ms after takeoff, ours a median 88 ms after (42–380 ms).
+  - Peak gains: the recomp 0.0042–0.0287 (median 0.0149), ours 0.0054–0.0320 (median 0.0155, +0.3 dB).
+- *Change.*
+  - No change to 16 / 17 or `+240`.
+  - `retail_voices.py` now resolves duplicate samples by sample address (`play_resolve_all.json`;
+    `--no-disambiguate` gives the old attribution).
+  - `+236` now counts through the landing tick, as the recomp's does. It is Air+176, the time in the
+    air *state*, and the state is still 200..300 on that tick (`skate_events::air_time_236`). Before,
+    it dropped to 0 a tick early. Switches: `SKATE_AEMS_AIR_TIME_STATE=0` / `E2E_AIR_TIME_STATE=0`.
+  - The e2e scenarios now pass `to_land` / `jump_height` as `+240` / `+260`. Before they were 0, so
+    the e2e renders had no Treatments voices at all. Switch: `E2E_AIR_WORDS=0`.
+- *Files.*
+  - `crates/skate-game/src/game_audio/skate_events.rs` (`air_time_236`, test
+    `air_time_holds_through_the_landing_tick`)
+  - `crates/skate-game/src/game_audio/e2e.rs`
+  - `crates/skate-audio/tests/player_tricks.rs` (the TREAT replay, a real test, and the diagnostic
+    `treatment_replays_the_recomp_capture`; the `_by_late_prediction` diagnostic is removed)
+- *Verification.*
+  - skate-audio: all tests pass. game_audio: 48 pass.
+  - e2e on 13 scenarios, including a real-play cut with three ollies (`ollies_log`):
+    - with both switches off, every render is bit-identical to the previous renders;
+    - the `+236` hold alone is bit-identical too, even with Treatments playing (it also gives identical
+      voices in the replay);
+    - with the air words on, `ollie20` / `ollies_log` gain Treatments 13 / 14 at 0.0746 / 0.0186 (the
+      recomp: 0.0746 / 0.0186) and 16 / 17 at 0.013–0.030 (+0.01 dB overall).
+
+**Evidence.**
+- skate-audio: 180 lib tests plus the data tests pass (new: submix ×2, Reverb inputs).
+- game_audio: 47 tests pass (new: the zone test).
+- Python: 27 tests pass (new: the reverb RefSpec).
+- e2e with every new part off is bit-identical to the previous stage (`.local/audio-re/e2e-on2`) on
+  11 of 12 scenarios. ollie20 differs in its random flip / cloth sample picks; that comes from the
+  other agents' work since 20:53, not from these parts, which consume no random numbers.
+- All on against all off: ≤ 3.8e-5 peak difference and −0.00 dB on every scenario. That is the env
+  scale's −0.01 dB on the wet path, plus the submix.
+- Tools: `aems-port/tools/e2e/render_diff.py DIR_A DIR_B`, renders in `.local/audio-re/skel/`.
+
+### Listening test 9: University water "overplaying itself, doubling or restarting" (2026-10-02, build 21:57)
+
+**Report.** At (344.2, 68.03, −322.5), beside the dark water channel by the plaza trees: "It sounds like it is
+overplaying itself and doubling or restarting? its hard to tell." Session `state_20261002_215843` (0 malformed),
+`SKATE_AEMS=1`.
+
+**What played.** The state log puts the user off board and still at (344.5, −322.5) from 29 s to 119 s. In that window
+the only water is `.ems` record #27, `water_fountain` (13 × 7 × 61 m ellipsoid, patch 81), posted once and never
+re-posted (03:59:08 → 04:01:00). Record #50, `fountains_waterlaps_left` (6 × 4 × 47 m, patch 347), was reached only
+while walking along the channel (20.7–26.7 s, 46.1–47.2 s, 122.7–131.5 s). Its 4 m vertical semi-axis around y = 67.7
+puts the listener (the camera) near its edge.
+
+**Double-play candidates, all ruled out headless.**
+- Interim water: with the native runtime the `PROFILES` relay is off for every bank in the install (log tag
+  `(native)`). `water.rs` is gone. Splashes fire only on water entry, and there were none. No location set played
+  water (only birds and jets).
+- Two records: University's other fountain record (#46) is 109 m away. #27 and #50 overlap, and retail plays both
+  together too (sessions `all_20261002_180430` and `214002` show both banks in the same seconds).
+- Cross-talk between banks: every `c_emitter` post reaches every loaded `c_emitter` bank. With `water_fountain`,
+  `fountains_waterlaps_left` and `trees_rustle` loaded and posts 81 and 347 live, only the matching bank plays
+  (`emitter_scene_probe`).
+- Re-posting: release ends the post's voices at once. A re-post starts one fresh relay, never a second one. Two
+  voices at most per fountain post over 15 minutes.
+
+**What the programs do** (`crates/skate-audio/examples/emitter_scene_probe.rs`, real banks and WAVs, redelivered every
+60 Hz frame as `emitters.rs` does):
+- `water_fountain` is a two-player relay of ten 1.6–2.5 s one-shots at pitch 0.82–0.94. Each player has its own op-8
+  shuffle bag (two op 8 blocks, 316 and 540).
+- The next piece opens when the current one has about 0.17 s of source time left: 0.19–0.26 s before it ends in wall
+  time.
+- Over 15 minutes that gives 14.4 starts per 30 s. The same piece plays twice in a row 11 % of the time (48 / 432),
+  because the two bags are independent. Each bag avoids its own repeats (0 repeats one start apart).
+- `fountains_waterlaps_left` is one 37.46 s loop (loop start frame 189, clean wrap). It restarts from the top on
+  every post.
+
+**Retail, earlier sessions.** `.claude/skills/aems-port/tools/retail_relay.py` lists a bank's PLAYs with their gaps.
+- `water_fountain`: retail starts every 1.73–2.53 s, about one piece length apart (gap / length 0.99–1.07 at
+  the traced rate). That matches the relay above. No back-to-back repeat in the 5 retail transitions, which is too
+  few to tell from 11 %.
+- `fountains_waterlaps_left`: retail re-posts it on fresh players 2–14 s apart as the listener crosses its edge, the
+  same restart-on-entry as ours.
+
+**Retail at the spot (WATERRELAY, `all_20261002_222155`, clean).** The user walked to the channel and stood at
+(346.0, −325.7) from about 61 s to 104 s. The fountain was posted once (c_emitter POST at 47.76 s, first piece 34 ms
+later) and played 24 pieces. Run `retail_relay.py SESSION water_fountain [--from MS]`.
+- **Steady stretch while standing (66.8–102.2 s), 18 starts:**
+  - Each relay turn draws from its own bag: A = 6 7 1 4 5 3 0 8 2 9 | 0 7, B = 6 7 1 8 2 9 0 5 3 4 | 6 8 (the first
+    three of each come from the approach stretch). Each is a complete pass of all ten pieces with no repeat. The
+    first pick of the next pass is never the last pick of the pass before. This is op 8 exactly as ported (avoid
+    flag at the wrap), with one bag per player, as in the bank (`emitter_scene_probe` prints both bags: range 10,
+    identity set).
+  - Back-to-back same piece: 1 of 17 (6 %; the 0 → 0 where bag A wraps). Ours is 11 % (48 / 432). With 17
+    transitions, retail's count is consistent with 11 % (P(≤ 1) ≈ 0.43).
+  - Cadence: gap / piece length p10 / p50 / p90 0.99 / 1.07 / 1.09, against ours 0.99 / 1.04 / 1.08. That is
+    15.3 starts per 30 s against our 14.4. The two retail outliers (1.19 and 1.58) sit on a recomp stall: no PLAY
+    and a 411 ms GREC gap at 76.4–77.6 s.
+- **Approach stretch (47.8–64.2 s, listener walking in):** the first six pieces came in identical pairs (6 6 7 7
+  1 1): both bags made the same first three picks. They were also slow (gap / length 1.10–1.88, no overlap). Ours
+  doesn't do this. A fresh post draws both bags in its first walk and B's draw is never played (`PROBE_SHUFFLES=1`
+  prints every draw). Two explanations failed: a shared bag (ruled out by the steady stretch), and a slower relay
+  from the pitch word alone (w4 2600 slows ours but keeps the bags apart). The session has no MOD (pitch) lines, so
+  this is parked. It doubles **more** than ours, so it isn't what the user heard while standing.
+- `fountains_waterlaps_left`: two brief activations while the listener settled (PLAY 57.78 s and 62.60 s, each
+  voice's player reused for other sounds within 1.1 s / 1.6 s), then silent while standing. That is the same
+  restart-on-entry and edge behaviour as ours. One difference: the second start came 0.57 s after its post (62.03 s)
+  instead of ~20 ms, probably retail reloading the bank (it unloads banks no node uses; we keep them until the map
+  changes).
+
+**Verdict.** No doubling bug, and no code change. In the standing case the user reported, our relay matches retail
+in mechanism (per-player op-8 bags, wrap rule), repeat rate and cadence. The "restarting" is authored:
+- each piece's attack lands over the previous piece's tail;
+- now and then the same splash plays again about 0.2 s before it ends;
+- while walking, the channel loop starts over at each re-entry.
+
+Open (parked):
+- The approach-stretch pairing (both bags making the same picks), which needs an op-8 draw hook or MOD lines to
+  settle.
+- The re-post bank-reload delay.
+
+Side finding: the user's session logs
+`OFFBOARD_GROUND_RESULT_NONFINITE` every frame while the user stood there (physics, off-board ground job). It did not
+interrupt the emitter and is not audio, but it needs its own look.
+
+**Files.** New: `crates/skate-audio/examples/emitter_scene_probe.rs` (scene probe; prints the op-8 bags and, with
+`PROBE_SHUFFLES=1`, every draw); local tool `.claude/skills/aems-port/tools/retail_relay.py` (`--from/--to`, bags
+by relay turn).
+
+### Listening test 9 (seams): brick and University concrete; the console's 30 fps seam cadence (2026-10-02, build 21:34)
+
+(Numbered with the water report above: both come from the same round of listening.)
+
+**Problem.** The 21:34 build loads `Start_up_Play_ctl`. With it, the user said of both surfaces: "both sound better but
+still need work". Earlier reports, verbatim:
+- University concrete: "the same concrete still sounds too rough on our engine".
+- DownTown brick: "still firing too much or too often and sounds like your going faster than you are".
+
+Sessions (all clean, 0 malformed lines):
+- Aletown brick: ours `state_20261002_213757`, the recomp `all_20261002_214002`.
+- University at the PCU Library: ours `state_20261002_214224`, the recomp `all_20261002_214346`.
+- A later recomp session with new seam hooks: `all_20261002_223306`.
+  - SEAMPAT logs `+636`/`+648`/`+620`/`+208`, the frame time and the four wheel positions on every Class_Seams process
+    call.
+  - SEAMHIT logs every hit.
+
+Tools are in `.local/audio-re/seams9/`:
+- `pairs.py`, `tagrate.py`, `agg.py`, `blocks.py`, `window_compare.py`, `hit_prominence.py`;
+- `seampat.py` and `seamhit_match.py` for the hook session;
+- `recomp_fps.py`.
+
+Program probe: `skate-audio/examples/seam_pulse_probe.rs`. It drives the real Seams program and samples with per-block
+w7 sequences or with a host model.
+
+**Mechanism (asm).** `sub_82485190`, the audio manager, runs once per rendered frame: process (vtable +16), then the
+MixMap tick, then update (+20).
+- On every call, Class_Seams' process (`sub_824C14C8`) clears w7, then fires a hit when a wheel's grid cell changed.
+- The program walks every 32 ms and sees only the latest w7.
+- So a hit's pulse lasts one rendered frame, and that length decides how many hits the program sees and which of its two
+  players start.
+
+Every hit starts a "base" block (samples 32–47, the same on every surface) and a surface block (80–87 on brick, 104–119
+on concrete). The share of base-block voices works as a fingerprint of the pulse length:
+
+| pulse length | base-block share |
+|---|---|
+| one 60 Hz tick | 2–32 % |
+| 3–5 ms | 45–57 % |
+| 33 ms | every hit is seen |
+
+**The recomp is not the console.** The recomp renders uncapped. In 223306 it calls the process every 2.9 ms (frame-time
+field median 2.5 ms). The speed changes on 18 % of calls (the 60 Hz physics step); the wheel positions change on 37 %
+(the rendered pose, between the two rates). So the recomp's pulses last about 3 ms. On the shipped game (about 30 fps)
+they last one 33.3 ms frame.
+
+Measured in the recomp:
+- Base-block share: 41–50 % in all sessions.
+- Rates: 25–36 voices/s on brick (tag 66), 21–30 on concrete (tag 4, pattern 8).
+- Pattern 11 (sidewalk), **settled.** The recomp reads `+636` = 11 there (SEAMPAT). It fires 15–21 hits a second at
+  20–40 km/h, but plays only about 0.5 voices per hit: 7.5 voices/s in 223306, about 3 in 214346. The sparse sidewalk
+  comes from its short pulse, not from the pattern.
+- Our cell computation matches retail's. From the logged positions, 400 of 520 grid hits coincide with a cell change of
+  that wheel on the same call.
+
+**Change: the console cadence at any frame rate.** User decision, verbatim: "match the shipped game, use the 30 fps
+cadence however lets scale up and account for the higher framerates that the rust engine is going to be running at".
+- **Virtual calls.** `player::seams::Seams::frame` runs on every rendered frame (`PlayerAudio::seam_frame`, from
+  `native::mixmap_frame`). It makes virtual process calls on a fixed 30 Hz grid of real time.
+- **Wheel positions.** Each virtual call reads the wheel positions at its own time, interpolated along the rendered
+  trajectory: the physics samples interpolated by `Time<Fixed>::overstep_fraction`, as the presentation does. So it sees
+  the same crossings the console samples.
+- **The pulse.** A hit's w7 is redelivered at once and cleared on the audio clock after 6 or 7 blocks (6.25 on average,
+  one console frame), via `SeamCommand::RedeliverAt` and the new `Runtime::redeliver_at`.
+- **The update half** (levels, the turn word's per-write slew) also runs once per console frame.
+- **The 60 Hz tick** only creates the packets and writes Cracks.in0 (`process_tick`), latched from any hit since the
+  last tick.
+- **Below 30 fps,** several virtual calls run in one frame.
+- **Default and off switch.** On by default. `SKATE_AEMS_SEAM_PULSE=0` restores the old path: the whole process per
+  60 Hz tick, at the physics positions.
+
+**Proof of frame-rate independence.** E2E `E2E_FPS=f` runs the game's host at f fps. Over all straight rolling above
+10 km/h in both logs, voices per second and base-block share per tag:
+
+| tag | 30 fps family (30 / 29.7 / 30.3 / 20) | 59–370 fps (59, 60, 61, 140, 144, 150, 240, 360, 365, 370) |
+|---|---|---|
+| 3 | 16.9–20.6, 50–59 % | 17.5–21.0, 47–60 % |
+| 5 | 32.9–37.6, 10–30 % | 28.0–41.0, 7–32 % |
+| 66 brick | 18.4–20.7, 10–15 % | 16.6–21.0, 3–22 % |
+| 4 concrete | 17.4–20.1, 20–26 % | 17.7–22.7, 19–38 % |
+
+- Grid hits are the same at every frame rate: 2121–2141 (brick log) and 1189–1207 (University log).
+- Per-voice gain is the same at every frame rate.
+- The 30 fps spread is phase noise in the program's shuffle, and every higher frame rate falls inside it.
+- Unit test `seams::tests::console_cadence_is_frame_rate_independent`:
+  - hits within 2 % from 30 to 365 fps (5 % at 20 fps);
+  - every pulse lasts 6 or 7 blocks, with a mean of 6.25.
+- For comparison, our old 60 Hz host (the 21:34 build) gave tag 66 at 25.8 voices/s with a 25 % base share, and tag 4
+  at 26.0 voices/s with 20 %.
+
+**Against the recomp (a high-fps reference, not the target).**
+
+| | ours, console cadence | the recomp |
+|---|---|---|
+| brick | ~19 voices/s, base ~14 % | 25–36 voices/s, 46–50 % |
+| concrete | ~19 voices/s, base ~23 % | 21–30 voices/s, 41–49 % |
+| sidewalk | 14–32 voices/s (every hit is seen) | 3–7.5 voices/s (short pulses) |
+
+A per-call model run at the recomp's own rate matched the recomp within about 20 % on rate and share, so the mechanism
+reproduces both machines. No console capture exists to check the 30 fps numbers directly.
+
+**Other comparisons (no change).**
+- Grain bed (the sounding truck's player A), the recomp vs ours:
+
+  | window | gain | position |
+  |---|---|---|
+  | concrete, 43 km/h | 0.237 vs 0.245 | 0.78 vs 0.78 |
+  | brick | 0.208 vs 0.196 | 0.494 vs 0.494 |
+- Rattles: about one per push in both.
+- Spidercracks and Class_rolling: none in these windows.
+- Octave spectrum above 125 Hz: within about 2 dB. The recomp's capture also holds ambience bass.
+
+**Open.**
+- **Grain pitch.** The recomp's GREC pitch is about 0.97 (0.966–0.991 by band). Ours is 0.995 in e2e, where the
+  listener is synthetic and gives no Doppler. SkateBoard pitch(3) carries the MixMap's Doppler term, so in game the
+  camera decides it. Not yet measured in our game.
+- **Hit prominence.** A hit's high-frequency rise over the rolling median is 2.8–6.0 dB in the recomp's capture and
+  5.5–11 dB in ours. Voice gain matches, so the cause is downstream: pitch, bus or masking.
+- **Other per-frame rules.** On the console the whole audio manager is per rendered frame at 30 fps. That covers the
+  MixMap tick (dt 1/30), the eEQChain jitter every second frame (15 Hz on the console, 30 Hz in ours), the Doppler slew
+  per evaluation, and other components' one-frame pulses. Only Class_Seams follows the console cadence so far. These are
+  listed for the host owner.
+- **Landed latch.** Wheel 0's landed latch stays per 60 Hz tick.
+
+**Validation.**
+- skate-audio: 181 lib tests and the data tests pass.
+- `game_audio::`: 47 tests pass.
+- The `--no-run` build and `cargo check` pass.
+- Default e2e renders (one call per row, the old path) are byte-identical to the 21:34-era renders of both logs.
+
+**Files.**
+- Changed:
+  - `skate-audio/src/player/seams.rs` (`frame`, `process_tick`, `expire`, `RedeliverAt`, the Cracks latch);
+  - `skate-audio/src/runtime.rs` (`redeliver_at`);
+  - `skate-game/src/game_audio/{native,player_audio,e2e}.rs`.
+- New: `skate-audio/examples/seam_pulse_probe.rs`.
+- E2E switches: `E2E_FPS`, `E2E_CALLS`, and `E2E_SUBSTEPS` (diagnostic: the whole host N times per row).
+
+## Credits
+
+The retail measurements in this document were taken with **[skate3recomp](https://github.com/mchughalex/skate3recomp)**
+by @mchughalex, a native static recompilation of Skate 3. It is built on the
+[rexglue SDK](https://github.com/rexglue/rexglue-sdk) and credits [Xenia](https://github.com/xenia-project/xenia)'s
+research. We ran it locally with trace hooks and scripted teleports; it has no licence, so nothing from it is
+included here. Upstream PRs #4 / #1 by @andrewnakas (research notes) were also a key reference.
+Setup decodes the disc's EA-XMA audio with [vgmstream](https://github.com/vgmstream/vgmstream) (pinned
+r2117, hash-checked).
+
+Research for the native audio runtime (specs in progress, 2026-10-02) also draws on:
+- [dbalatoni13/nfsmw](https://github.com/dbalatoni13/nfsmw) (CC0): a matching decompilation of Need for
+  Speed: Most Wanted's EA audio library. Official AEMS opcode and bank-header names and state layouts.
+- [BurnoutDecomp/BP-Decomp_Workflow](https://github.com/BurnoutDecomp/BP-Decomp_Workflow) and
+  [BurnoutDecomp/b5-decomp](https://github.com/BurnoutDecomp/b5-decomp): RenderWare Audio plug-in
+  identities, the SndPlayer1 and filter/resampler details, opcode names. b5-decomp has no licence, so it
+  is reference only.
+- [mitsevox/tw2004](https://github.com/mitsevox/tw2004) (CC0): Tiger Woods 07 RenderWare Audio function
+  listings.
+No code from these is included.
+
+The native runtime (`crates/skate-audio`) is our own code written from our specs. Its oracle was the PoC
+worktree of upstream PR #4 by @andrewnakas (no licence; run locally as a black box: our probes drive its
+evaluator and replay-verified DSP kernels; two local fixes to it, never committed). Its facts (offsets,
+opcode numbers, constants) come from our reading of skate3recomp (no licence, reference only) and the disc
+banks; official names from dbalatoni13/nfsmw (CC0).
+
+The MixMap port and the granular rolling bed (2026-10-02) rest on upstream PR #4 / #1 by @andrewnakas
+(no licence, reference only): they found that the bed is a granular player and recovered the MixMap's
+function map, stage order and input writers, the GrainPlayer object, pick and scheduler, the board
+records, the bus chains, the vault field roles and the instance counts. Their MixMap port and grain
+functions, run locally in the PoC worktree, are our golden oracle (MixMap 87,000 cells, pick / position
+vectors); the order of retail's single-precision operations in the Bézier, the speed scales and the
+`id 9 = 0 for the local player` rule were read from their documentation. EA's record names (MixCtl,
+3DMixCtl, EvtMixCtl, SubMixCh, MasterMixCh, Preset) come from
+[BurnoutDecomp/b5-decomp](https://github.com/BurnoutDecomp/b5-decomp)'s NFSMix headers (no licence,
+reference only). Spot checks and addresses: skate3recomp (no licence, reference only). Data: the user's
+own Skate 3 disc and TU3 image (`MixMapSK8.mxb`, `grains.big`, `skatercollections.vlt`; never
+committed), decoded with [vgmstream](https://github.com/vgmstream/vgmstream). No code from any of these
+is included.
+
+The player inputs and components (2026-10-02) are our own code from our reading of the retail functions
+in the skate3recomp generated code (no licence, reference only; addresses in the source docs) and the
+user's vault. Upstream PR #4's `player-audio-retail-drivers.md` and `mixmap/inputs.rs` notes by
+@andrewnakas (no licence, reference only) gave the function map, the packet word tables, the Jitter /
+Contacts / 3DObjPos writer descriptions and the retail wind and grain capture tables we validate
+against. The retail level tables come from our local recomp trace sessions
+(`.local/recomp/sessions/20261001_211347` — deleted 2026-10-02, re-verify on clean data — and
+`all_20261002_163809`). No code from any of these is included.
+
+The Splice player, the board contacts, skid and squeaks (2026-10-02) are our own code from our reading of the retail
+functions in the skate3recomp generated code (no licence, reference only; addresses in the docs) and the user's vault
+(`skatercollections.vlt`). Upstream PR #4's driver notes by @andrewnakas (no licence, reference only) gave the
+Contacts / skid / squeak function map and word tables we checked against the code; their PoC, run locally as a black
+box through our own headless probe, is the end-to-end oracle. No code from either is included.
+
+The collision manager, the wheel spin, the foot taps / scuffs (2026-10-02) are our own code from our reading of the
+retail functions in the skate3recomp generated code (no licence, reference only; addresses in the module docs) and
+the user's vault (field layouts from the disc's own schema, `skaterschema.vlt`). The bed validation data (GREC hook)
+was recorded with skate3recomp by @mchughalex, run locally by the user. Upstream PR #4's driver notes and
+`collision_states.rs` docs by @andrewnakas (no licence, reference only) gave the manager's map (router, ten slots,
+message layout, the material table at `0x8302D6E8`) that we re-read and corrected in the code (the update reads the
+category output's level; materials ≥ 143 take pitch output 1; the impact bands come from the `+24` RefSpec). No code from
+either is included.
+
+The environment network, the eEQChain buses, the owner one-shot buses and Class_Seams (2026-10-02) are our own code
+from our reading of the retail functions in the skate3recomp generated code (no licence, reference only; addresses in
+the specs `.claude/notes/aems-env-bus-spec.md`, `.claude/notes/aems-eqchain-buses-spec.md` and the module docs), the
+TU3 image and the user's vault; validated against the user's own recomp traces (skate3recomp by @mchughalex, run
+locally). BurnoutDecomp/b5-decomp's reconstructed ReverbModel1 and Delay (no licence) were read only to orient; the
+DSP follows the TU3 asm. Upstream PR #4's notes by @andrewnakas (no licence, reference only) named the eEQChain
+holder fields, the owner bus builder and the Class_Seams function map. No code from any of these is included.
+
 ## Open questions
 
 - Main bail body-impact sound (Bodyslide is only a layer); landing weight layer level; metal grind pick
   (54–56) by ear; powerslide, wheel spin, push sound, fountain bank, caveman jump-on — not yet confirmed.
-- Some surface → grain choices may be off; soft vs hard grains are probably wheel hardness (only hard used).
-- Retail plays rolling granularly; this plays banded loops.
+- Surface → grain now follows retail (2026-10-02); still open: the `Class_rolling` surfaces (interim stand-ins), tag 90, and what selects the soft-wheel grains.
+- Retail plays rolling granularly; the default path plays banded loops, `SKATE_AEMS=1` plays the native
+  granular bed (player B silent until turn/slope inputs exist; FSS, graph 3, wobble not modelled).
+- MixMap inputs: VU (output meter) and the menu/NIS/HOM/Challenge flags stay 0; the bed's gain A matches
+  retail's level(1) p90 with Jitter wired, the lower retail medians need a straight-roll trace at turn 0
+  (see "Player inputs and the first native player components").
+- Native player components still to port: seams, rattle, Class_rolling, cloth, body slide, footsteps,
+  flips/treatment, the body-impact and step-on posters (need skeleton region contacts / Skeleton+602/+603 from the
+  engine). Native since 2026-10-02: skid, squeaks, the Contacts pops / landings / touchdowns, the collision manager
+  (grind start, landing pair, deck impacts), foot taps / scuffs, the wheel spin. Music.in3 is a game-mode flag
+  (0 in free skate), so the ollie voice and the landing impact stay gated as in retail.
+- The turn input (`Turn` animation attribute) is almost binary in our engine (29 % of riding frames at 1.0 vs
+  retail 16 %; 7 % in between vs 25 %): carving layers trigger too easily (user, 18:02 build). Animation side.
+- The interim layer still bypasses the native host's 6→2 fold (~3–6 dB above native voices of the same per-voice
+  level); the send buses (distance cue) are not modelled.
+- User listening check 2026-10-02 (native build 16:59): rolling "too loud" and "not in sync", grinds "not the
+  same sound" — see "Board contacts, skid and squeaks; the end-to-end PoC comparison" for what the measurements
+  show; the PoC reference had a one-off louder/harsher seam sound on one launch (first-play decode).
 - Zone ambience from `.ems` emitters (beds per map are a name-based guess); manual wheel spin
   (`Whls_spins_Man_1`); music.
 - ~615 MB of PCM (mostly ambience): a compressed format would need an encoder at setup.
 - Retail's own sample choices could be measured from a recompiled build that logs which bank data the
   game decodes (local research only, not part of this change).
 - `AUDIO_*` logging is verbose for a release build.
+- Native runtime: the unmodelled buses and sends (the MixMap's emitter send word w2 now has a value but no
+  bus to go to), loop time-left, `c_emitter` w0, and the gain ramp's last ulp (see "Native AEMS runtime:
+  implementation" and "MixMap and the granular rolling bed").
+- Buses (2026-10-02): the FlangeSub effect returns (GRINDS routes to one), reverb-zone emitters (type 5), the grain
+  chain's graph-2 env send, the Splice voices' own Send A (retail Skate_Collisions median 0.0146) and Collision SubMix,
+  sense_of_speed's FXWET0 (retail median 0.015, ours 0), the reverb module's timer delay; SFX Master's DCl0 level.
+- The riderless-board gate (states 300 / 500–502 report no wheels) rests on retail's measured record; the writer of
+  record +152 bits 20–22 is not located.
+- rodio 0.20's spatial panning is mirrored (the default path still uses it; native mode swaps the ears).
+- 19:38 air tricks #1 / #3: the audible in-air voice is retail's wheel spin-down; a retail ollie at ~30 km/h would
+  settle whether ours sounds like it.
+- Port stage 2026-10-02 (rolling layers, chain, tricks, footsteps, returns), still open: the FlangeSub send of the grain chain
+  (no bed → return route); the bool-class word `0x11A631878B239355`; the seam pattern retail sees on University's sidewalk
+  cells (pattern 11, "Listening test 8"). The seam sample variety is fixed: it was the missing `Start_up_Play_ctl` boot
+  utility ("Listening test 8"). Closed 2026-10-02 (stage "FootStep SubMix, the skeleton inputs, …"): the FootStep SubMix, the
+  step code, limb / body speeds, ragdoll slide records, the loose-board vectors, Reverb.in0..6 + the env scale, the reverb
+  zones (1,040 records, not one), the boot order.
+- Treatments 16 / 17 (settled: the recomp plays them too). Two details remain:
+  - On the ~2 s ramp air the recomp started them 538 / 577 ms after takeoff, ours at once (gain
+    0.05 vs 0.10). A 30 ms blip in the air just before that takeoff may explain it; one event only.
+  - In 2 of 7 airs under 0.5 s ours plays a 0.004–0.005 voice where the recomp plays none.
+- Earlier recomp figures for sense_of_speed (voice counts, the FXWET0 / Send A medians in "The buses") included
+  Treatments 16 / 17 voices: `retail_voices.py` read them as sense_of_speed 3 / 4. Redo them with the fixed tool.
+- FootStep SubMix: Sen0 #2's level and Pn21's law are unread (class defaults); a released voice's de-click tail skips the
+  submix's filters (as for every bus).
+- Reverb zones: `vfunc92` (the zone attribute check) is taken as always passing; the music / speakers / crowds `.ems` files
+  are loaded only for their zone records (their other record types are not played yet).
+- The Send A table in "The buses" is superseded for sense_of_speed (0, as retail) and the Splice voices (none):
+  `.local/audio-re/busleft/senda_bank_fixed.py`.
diff --git a/docs/hails-additions/PULL-REQUESTS.md b/docs/hails-additions/PULL-REQUESTS.md
index 9ef4be29..30016675 100644
--- a/docs/hails-additions/PULL-REQUESTS.md
+++ b/docs/hails-additions/PULL-REQUESTS.md
@@ -11,12 +11,12 @@ verification, open questions).
 | A | Setup fix | Setup: enable Windows long paths for the pro roster (ISO argument-order half dropped: upstream fixed it in `713fe70`/`7ae67f2`) | [02](02-long-paths.md) ([01](01-iso-extraction.md) superseded upstream) | `0a88f7a`; PR branch `setup/xiso-option-order-and-long-paths` = `4352417` + merge of upstream `7ae67f2` (`d7cd6a2`, upstream lines at both ISO call sites) | — | Draft upstream [#23](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/23), retitled; diff vs upstream `main` = `tools/setup.py` only |
 | B | Feature (input) | SDL3 gamepad input with XInput fallback | [03](03-sdl3-gamepad-input.md) | `3d485c8` | — | Draft upstream [#24](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/24) |
 | C | Gameplay data | Authored map spawns and headings | [04](04-map-spawns.md) | `b495ed6`, `f00b329` | — | Draft upstream [#27](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/27) |
-| D | Gameplay data | Skip collision volumes that have no surface IDs | [05](05-collision-volumes.md) | `dec7ade` | — | Draft upstream [#25](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/25) |
+| D | Gameplay data | Skip collision volumes that have no surface IDs | [05](05-collision-volumes.md) | `dec7ade`, `d68c3ee` (comment: the boxes are retail trigger volumes) | — | Draft upstream [#25](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/25); description corrected 2026-10-02 (SkateSchool box coordinates, see doc 05 "Correction") |
 | E | Performance | Indexed stock collection lookups (game startup −5.5 s) | [07](07-collections-index.md) | `810defa` | — | **Merged upstream** as [#26](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/26) (2026-10-02, `4003812`) |
 | F | Tooling | Streaming map validator (`--validate-maps`) wired into setup | [06](06-map-validator.md) | `18f41a3` | E (speed only) | Draft upstream [#28](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/28) |
 | H | Gameplay + rendering | Water: detection and bail, shallow water solid / deep water floats, board floats, water camera + vignette, entry splash, water look (family 33 cube blur + tint, anti-tiling, body-size calming, slower waves), animated water (frame-state buffer fix, ocean PCA from default.xex, XEX2 unpacker), ripple scale | [09](09-water.md) | `gameplay/water` (`af1b350`…`55776dc`), upstream branch `water/retail-water` (`8a6e328`, one commit on `60efdef`) | — (carries #28's `install.py` `spawn()` split verbatim) | Draft upstream [#30](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/30) |
 | I | Test fix | `sky_shader_validates`: add the `VERTEX_POSITIONS` shader def Bevy sets for real meshes | [10](10-sky-shader-test.md) | `b7865d0` | — | Not opened; tiny, can go upstream alone |
-| J | Feature (audio) | Game audio: setup group `audio` extracts/decodes the disc's audio (vgmstream r2117), per-map ambience, water emitters, rolling by surface and speed band, trick/landing/grind/bail/splash cues, footsteps from foot strikes, volume settings and `--mute` | [11](11-audio.md) | `gameplay/audio` (`98c52b6`, `d9a1818`); upstream branch `audio/retail-audio` (`f1ad166` on #30's `8a6e328`, `main` 7ae67f2 merged) | H (branched from `gameplay/water`; uses its water detection — `collision_feedback.flags.material_12`, `is_water_tag`). Overlaps upstream #4/#1 (retail-exact player audio via transcribed game code + memory image; not adopted — see doc 11): both edit `tools/asset_pipeline/asset_exports.py` and `install.py`, different asset layouts | Draft upstream [#32](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/32), **Work in Progress**: the measured cue tables are interim while the retail audio engine is reverse engineered and re-created natively (doc 11) |
+| J | Feature (audio) | Game audio: setup group `audio` extracts/decodes the disc's audio (vgmstream r2117), per-map ambience, water emitters, rolling by surface and speed band, trick/landing/grind/bail/splash cues, footsteps from foot strikes, volume settings and `--mute` | [11](11-audio.md) | `gameplay/audio` (`98c52b6`, `d9a1818`); upstream branch `audio/retail-audio` (`f1ad166` on #30's `8a6e328`, `main` 7ae67f2 merged) | H (branched from `gameplay/water`; uses its water detection — `collision_feedback.flags.material_12`, `is_water_tag`). Overlaps upstream #4/#1 (retail-exact player audio via transcribed game code + memory image; not adopted — see doc 11): both edit `tools/asset_pipeline/asset_exports.py` and `install.py`, different asset layouts | Draft upstream [#32](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/32), **Work in Progress**. Branch has the first version; the world-audio work (.ems emitters, location-set one-shots/sirens, zone ambience) is done locally and goes up with the next batch commit; native AEMS runtime (`crates/skate-audio`, new workspace crate) implemented 2026-10-02 behind `SKATE_AEMS=1` (world emitters only), then the MixMap mixer (emitter words) and the granular rolling bed (`grain/`, `game_audio/grain_bed.rs`; setup keeps the whole grains, copies `MixMapSK8.mxb`, exports the grain tuning), then the player inputs and the first native player components (`skate_audio::player`, `game_audio/player_audio.rs`: Class_grind, SenseOfSpeed, Class_foot_drag; setup exports `player_tuning`; `skate-core` `WheelLineState.seam_patterns`), then the Splice board contacts / skid / squeaks and the collision manager, wheel spin and foot taps / scuffs (`player/{contacts,collision,wheels}.rs`; `skate-core` `BoardGroundState.part_audio_surfaces`; setup `player_tuning.collision`), then the buses (reverb network, eEQChain, flanger returns, collision submix) and Class_Seams, the board layers (`player/rolling.rs`), the grain bus chain (`grain/chain.rs`, `dsp/{fss,shelf}.rs`), tricks / treatment, and footsteps / clothing / hands on the deck (`player/{tricks,treatment,footsteps,clothing,step_on}.rs`; setup adds four Class_rolling banks, `bus_tuning.flange`, `player_tuning.audio_tricks_2`, per-material footstep fields and 16 grain-chain vault keys). All uncommitted, all on #32's checklist (updated 2026-10-02 21:30). The seam sample shuffle is in (Listening test 8: retail's boot utility `Start_up_Play_ctl`; setup now copies `Common.abk`). Listening: landings, pops, footsteps and the hand pick-up / put-down confirmed; rolling "is much better, it just has issues with certain surfaces"; after the shuffle, concrete and brick "both sound better but still need work". Plan, in order: (1) surface parity from the paired sessions (ours / recomp at the Aletown brick and the University PCU Library); (2) footstep submix, remaining engine inputs, reverb-zone emitters (1,040 records), Reverb inputs / global env-send scale, utility boot order (done headless 2026-10-02, doc 11 "FootStep SubMix, the skeleton inputs, …"; needs the listening check; setup exports the zones' `reverb` preset); (3) native as the default, interim cue tables removed; (4) the optimisation pass; (5) world / NPC audio stages as follow-ups. #32's description carries the same status and plan (updated 2026-10-02 evening). Latest listening (build 21:57): "rolling sounds better, griding sounds better, walking sounds better"; a University fountain's "doubling/restarting" is retail's relay of short pieces, with the repeat rate being analysed from the user's WATERRELAY retail session. Seams: retail runs them per rendered frame; per the user's decision ours targets the 360's ~30 fps cadence, frame-rate independent (done, default; user: "seams sound much better. overall much better <3"). Plan step (1) done; (2) Treatments 16/17 from the TREAT trace settled 2026-10-02: the recomp plays them too (their samples equal sense_of_speed 3/4, so the trace tool misread them); `+236` now counts through the landing tick, and the e2e scenarios pass the air words (doc 11 "Treatments slots 16 / 17"). Keep #32's description current (standing rule) When #32 is ready for merge, all of it goes up as ONE commit titled `New audio who dis`, only with the user's explicit permission at that time. |
 | G | Performance (setup) | Skip decoding duplicate stream copies; run the customiser beside the maps; parallel clothing library and pro roster, plus a native RefPack DLL in `Build.ps1` | [08](08-setup-performance.md) | `8327e94` (+ overlap hunks of `install.py` in `18f41a3`) | — | Draft upstream [#29](https://github.com/SK8-ENGINE/skate-3-rust-engine/pull/29) |
 | K | Gameplay fix (physics) | Board/skater solver: 50 constraint iterations (retail live value) instead of `RWMaxIterations` = 25 | [12](12-solver-iterations.md) | uncommitted (on `gameplay/audio` working tree) | — (one-file change in `physics/settings.rs`) | Ready apart from the asset-gated `customiser_equipment_reaches_ground_force_and_torque` question (doc 12) |
 
diff --git a/docs/hails-additions/README.md b/docs/hails-additions/README.md
index 9bbf7825..67b5e5cd 100644
--- a/docs/hails-additions/README.md
+++ b/docs/hails-additions/README.md
@@ -10,13 +10,13 @@ Each document stands alone. File paths are relative to the repository root.
 | # | Change | Area | Status |
 |---|---|---|---|
 | 1 | [ISO extraction argument order](01-iso-extraction.md) | Setup (Python) | Superseded: upstream fixed it the same way (`713fe70`, `7ae67f2`, 2026-10-02); dropped from PR A |
-| 2 | [Windows long paths during setup](02-long-paths.md) | Setup (Python) | Done; UAC path not exercised end to end |
+| 2 | [Windows long paths during setup](02-long-paths.md) | Setup (Python) | Done; UAC prompt and frozen relaunch tested end to end (2026-10-02) |
 | 3 | [SDL3 gamepad input](03-sdl3-gamepad-input.md) | Game (Rust), build scripts, vendored `sdl3-sys` | Done, verified in play with an Xbox Elite Series 2 |
 | 4 | [Authored map spawns](04-map-spawns.md) | Asset pipeline (Python) | Done, all 10 maps confirmed in play |
 | 5 | [Invisible collision volumes](05-collision-volumes.md) | Game data loader (Rust) | Done, all four affected maps confirmed in play |
 | 9 | [Water](09-water.md) | Game physics, camera and rendering (Rust), setup, diagnostics | Matched to retail footage (RPCS3): shallow water solid, deep water floats, board floats, water camera + vignette, entry splash, canal water look matched, small bodies calmer |
 | 10 | [Sky shader validation test](10-sky-shader-test.md) | Game tests (Rust) | Done; all six shader validation tests pass |
-| 11 | [Game audio](11-audio.md) | Setup (Python, vgmstream), game audio (Rust) | Tuned by ear over ~15 play sessions: rolling, pop/landing, board-down, footsteps, foot drag, splash, grab whoosh confirmed; bail impact, metal grinds, landing weight, fountains and some other cues not yet confirmed; regression pass pending |
+| 11 | [Game audio](11-audio.md) | Setup (Python, vgmstream), game audio (Rust) | Work in progress (draft #32). Player cues tuned against retail traces; retail world audio done: .ems emitters, location-set one-shots (sirens; 1,859/1,859 retail match over 15 locations), zone ambience beds. Native AEMS runtime (`crates/skate-audio`: evaluator + voice graph) implemented behind `SKATE_AEMS=1` for the world emitters; 234/235 PoC-oracle scripts identical, DSP kernels bit-exact; MixMap + granular rolling bed; player MixMap inputs and the first native player components (grind, wind/rattle, foot drag; wind level within 0.5 dB of retail); needs a listening check. |
 | 12 | [Board solver: 50 constraint iterations](12-solver-iterations.md) | Game physics (Rust) | Done; maps identical, water traces as expected; one asset-gated customiser test fails (open question) |
 
 ## Environment used for verification
diff --git a/tools/asset_pipeline/audio_export.py b/tools/asset_pipeline/audio_export.py
index c6f95e1c..c0762257 100644
--- a/tools/asset_pipeline/audio_export.py
+++ b/tools/asset_pipeline/audio_export.py
@@ -17,10 +17,10 @@ import wave
 from pathlib import Path
 
 from tools.owned_game.big import BigArchive
-from .audio_formats import (downmix_pcm16, ems_emitters, grain, loop_bands, name_id, scan_snr, splc_patches,
-                            splc_streams, standalone)
+from .audio_formats import (REGION_PROCESSOR, downmix_pcm16, ems_emitters, grain, loop_bands, name_id, region_layers,
+                            scan_snr, splc_patches, splc_streams, standalone)
 
-VERSION = 4
+VERSION = 5
 
 # Each rolling grain is a recording that sweeps from slow to fast rolling (about
 # 10 dB louder and brighter by the end). It is cut into this many speed bands,
@@ -38,7 +38,7 @@ AMBIENCE = (
     '01_dt_apt', '02_dt_less_busy', '03_dt_rez', '04_dt_main', '05_dt_parks', '06_dt_open',
     '07_univ_mt_high', '08_univ_mt_low', '09_univ_campus', '10_univ_housing',
     '11_indu_shipyard', '12_indu_drydock', '13_indu_quarry', '14_reclaimed_a', '15_indu_new_factory',
-    '16_spillway', '17_space_park', '18_skate_school', '19_reclaimed_b', '20_indu_old_factory',
+    '16_spillway', '17_space_park', '18_skate_school', '19_reclaimed_b_fix', '20_indu_old_factory',
     '21_interior_arena_amb', '22_interior_tunnel_amb',
 )
 
@@ -49,6 +49,9 @@ BANKS = (
     'WHEEL_SKID_BANK.abk', 'FOOT_DRAG.abk', 'fstep_skateshoe1_sm.abk', 'Bodyslide.abk',
     'Rolling_Rattles.abk', 'Seams_Bank.abk', 'PatchBank_Rolling_Surfaces.abk', 'sense_of_speed.abk',
     'water_misc.abk', 'Foley_Cloth.abk',
+    # The native player components' other banks: every bank bound to Class_rolling (a post reaches
+    # each), and Class_Treatment's (skate_audio::player::{rolling, treatment}).
+    'PatchBank_SpiderCracks.abk', 'PatchBank_Objects.abk', 'PatchBank_RocksBounce.abk', 'Treatments.abk',
     # Water emitters on the map's water (game_audio/water.rs) and splash tails.
     'water_lapping.abk', 'water_lapping_pond.abk', 'fountains_waterlaps_left.abk',
     'water_fountain.abk', 'ocean_wave_small.abk',
@@ -116,6 +119,19 @@ def _grain_bands(source: Path, folder: Path, prefix: str) -> list[dict]:
     return bands
 
 
+def grain_whole(stem: str, member: bytes, decoded: Path, folder: Path) -> dict:
+    """The whole recording for the native grain player (crates/skate-audio/src/grain): the raw
+    `.grain` member (header, stored duration, seek table, EAAC stream; parsed and validated by the
+    game) and its decoded PCM, read from a frame = rate × start seconds (grain-player-spec §2.6).
+    Call after the bands are cut: the decoded WAV is moved into place."""
+    info = grain(member)
+    (folder/(stem + '.grain')).write_bytes(member)
+    target = folder/(stem + '.wav')
+    shutil.move(decoded, target)
+    return {'file': f'grains/{stem}.wav', 'grain': f'grains/{stem}.grain', 'duration': info.duration,
+            **_wav_info(target)}
+
+
 def _streams(name: str, data: bytes):
     streams = splc_streams(data) if data[:4] == b'SPLC' else scan_snr(data)
     if not streams:
@@ -138,21 +154,48 @@ EMITTER_FIELDS = {
     'Hash_6D18B8674D7E5337': 'kind',  # Sk8::Audio::eVolumeType: 1 = looping emitter, 5 = reverb zone
     'Hash_F209C093F40A4CCC': 'falloff',  # eVolumeFalloffType: 0 = (1-d)^2, 1 = 1-d, else flat
     'Hash_9908F2D75D7381BD': 'seconds',  # float, 10 by default (meaning not verified)
+    'Hash_99FD793BC30CF0FA': 'reverb',  # reverb zones (kind 5): the reverb preset (class 204CAC1FD77088B8)
 }
 
 
-def emitter_attributes(collections: list[dict]) -> dict[int, dict]:
-    """Each emitter sound's attributes by sound id, with inherited fields resolved."""
-    records = {c['key']: c for c in collections if c['class'] == EMITTER_CLASS}
+# Location sets of random distant one-shots (sirens, dogs, bangs...): class
+# `aud_wp_emitters`. Each set fires one of its sounds (weighted) at a random
+# interval and level within its ranges (docs/hails-additions/11-audio.md).
+RANDOM_SET_CLASS = 'Hash_39A2DE0232912CE5'
+RANDOM_SET_FIELDS = {
+    'Hash_29C68772F509F5A9': 'min_level',
+    'Hash_B6AD5C13F4A403B3': 'max_level',
+    'Hash_B1E6821F7F31E517': 'min_interval',
+    'Hash_A306BD1F4023A642': 'max_interval',
+    'Hash_5CA06CA086D8F953': 'sounds',  # RefSpec array of EMITTER_CLASS records
+    'Hash_07DDABF96E5F2731': 'weights',  # Int32 array, one per sound
+}
 
-    def value(field):
-        if field['type'].endswith('Text'):
-            return field['data']
-        raw = bytes.fromhex(field['data'])
-        if field['type'].endswith('Float'):
-            return round(struct.unpack('>f', raw)[0], 6)
-        return struct.unpack('>i', raw)[0]
 
+def _value(field):
+    """A converted collection field: float, int, text, or a list for arrays
+    (RefSpec items become the referenced record's u64 key)."""
+    kind = field['type']
+    if 'array' in field:
+        items = field['array']['items']
+        if kind.endswith('RefSpec'):
+            return [int(item[16:32], 16) for item in items]
+        return [_value({'type': kind, 'data': item}) for item in items]
+    if kind.endswith('Text'):
+        return field['data']
+    if kind == 'Attrib::RefSpec':  # single untyped reference: the class key, then the record's
+        return int(field['data'][16:32], 16)
+    if 'RefSpec' in kind:  # single reference (ClassRefSpec_<class>): the record's u64 key first
+        return int(field['data'][:16], 16)
+    raw = bytes.fromhex(field['data'])
+    if kind.endswith('Float'):
+        return round(struct.unpack('>f', raw)[0], 6)
+    return struct.unpack('>i', raw)[0]
+
+
+def _resolved(collections: list[dict], cls: str, wanted: dict[str, str]) -> dict[int, dict]:
+    """Records of one class by u64 key, with inherited fields resolved through parents."""
+    records = {c['key']: c for c in collections if c['class'] == cls}
     resolved = {}
     for key in records:
         chain, cursor = [], key
@@ -162,13 +205,85 @@ def emitter_attributes(collections: list[dict]) -> dict[int, dict]:
         fields = {}
         for record in reversed(chain):
             for name, field in record['fields'].items():
-                if name in EMITTER_FIELDS:
-                    fields[EMITTER_FIELDS[name]] = value(field)
-        if key.startswith('Hash_'):
-            resolved[int(key[5:], 16)] = fields
+                if name in wanted:
+                    fields[wanted[name]] = _value(field)
+        # Named records (e.g. `spacepark`) are keyed by the name's id, like the hashed ones.
+        resolved[int(key[5:], 16) if key.startswith('Hash_') else name_id(key)] = fields
     return resolved
 
 
+def emitter_attributes(collections: list[dict]) -> dict[int, dict]:
+    """Each emitter sound's attributes by sound id, with inherited fields resolved."""
+    return _resolved(collections, EMITTER_CLASS, EMITTER_FIELDS)
+
+
+# Zone ambience: the region layer `audio_ambience` holds `aud_wp_ambiences` keys. Each zone names
+# its bed by number (01_dt_apt .. 22_interior_tunnel_amb in ambience.big) with a volume and two times;
+# `aud_wp_ambience_crossfades` records join two zones to a group of the district's
+# Main_Ambience_Crossfade bank (docs/hails-additions/11-audio.md).
+ZONE_CLASS = 'Hash_656AAE7BB40F6C7F'
+ZONE_FIELDS = {
+    'volume': 'volume',
+    'Hash_4042D2F96C4E4B8C': 'bed',  # bed number (prefix of the ambience.big stream name)
+    'Hash_17C3EB9C543E1210': 'time_a',
+    'Hash_2E2ABEBF53F107EC': 'time_b',
+}
+CROSSFADE_CLASS = 'Hash_5FD3F641DB66DF9A'
+CROSSFADE_FIELDS = {
+    'Hash_F3041C272479768A': 'from',
+    'Hash_9124706DB04F6C30': 'to',
+    'Hash_69359D816F0054B7': 'group',
+    'Hash_875BA75341DC8391': 'level',
+    'Hash_BA23AD9BAC046BAF': 'value_ba23',
+    'Hash_8B068A069DFE9597': 'value_8b06',
+    'Hash_542D1F3AAF8E371A': 'value_542d',
+}
+CROSSFADE_BANKS = ('Main_Ambience_Crossfade_DT.abk', 'Main_Ambience_Crossfade_Ind.abk', 'Main_Ambience_Crossfade_Uni.abk')
+
+
+def ambience_zones(collections: list[dict], names: list[str]) -> tuple[dict, list[dict]]:
+    """Zones by key ({name, bed stream, volume, times}) and crossfades ({name, from, to, group,
+    level, ...} with zone keys as 16 hex digits)."""
+    known = {name_id(n): n for n in names}
+    beds = {int(name.split('_', 1)[0]): name for name in AMBIENCE}
+    zones = {}
+    for key, fields in _resolved(collections, ZONE_CLASS, ZONE_FIELDS).items():
+        zones[f'{key:016X}'] = {'name': known.get(key), 'bed': beds.get(fields.get('bed', 0)),
+                                **{k: fields[k] for k in ('volume', 'time_a', 'time_b') if k in fields}}
+    crossfades = []
+    for key, fields in _resolved(collections, CROSSFADE_CLASS, CROSSFADE_FIELDS).items():
+        if 'from' not in fields or 'to' not in fields:
+            continue  # the class default
+        crossfades.append({'name': known.get(key), **{k: (f'{v:016X}' if k in ('from', 'to') else v)
+                                                      for k, v in fields.items()}})
+    return zones, sorted(crossfades, key=lambda c: c['name'] or '')
+
+
+def random_sets(collections: list[dict], attributes: dict[int, dict], names: list[str],
+                by_file: dict[str, str]) -> tuple[dict, set[str]]:
+    """Each location set's ranges and sounds (bank, patch, volume, timeout, weight),
+    named where `names` has the set's name, and the banks they use."""
+    known = {name_id(n): n for n in names}
+    listed, banks = {}, set()
+    for key, fields in _resolved(collections, RANDOM_SET_CLASS, RANDOM_SET_FIELDS).items():
+        weights = fields.get('weights') or []
+        sounds = []
+        for index, sound in enumerate(fields.get('sounds') or []):
+            attrs = attributes.get(sound, {})
+            bank = by_file.get(attrs.get('bank_file', '').lower())
+            if not bank:
+                continue
+            banks.add(bank)
+            sounds.append({'sound_id': f'{sound:016X}', 'bank': Path(bank).stem, 'patch': attrs.get('patch', 0),
+                           'volume': attrs.get('volume', 1.0), 'seconds': attrs.get('seconds', 10.0),
+                           'weight': weights[index] if index < len(weights) else 10})
+        listed[f'{key:016X}'] = {
+            'name': known.get(key), 'sounds': sounds,
+            **{k: fields[k] for k in ('min_level', 'max_level', 'min_interval', 'max_interval') if k in fields},
+        }
+    return listed, banks
+
+
 def emitters(files: BigArchive, attributes: dict[int, dict] | None = None) -> tuple[dict, set[str]]:
     """Every `.ems` file's records with their sound's attributes and bank (None
     when the disc has no such bank), and the banks placed by sound emitters."""
@@ -193,6 +308,8 @@ def emitters(files: BigArchive, attributes: dict[int, dict] | None = None) -> tu
             on_disc = by_file.get(named.lower()) if named else None
             bank = on_disc or banks.get(record['sound_id'])
             record.update(sound)
+            if 'reverb' in record:
+                record['reverb'] = f"{record['reverb']:016X}"
             record['bank'] = Path(bank).stem if bank else None
             record['sound_id'] = f"{record['sound_id']:016X}"
             if bank and stem.startswith(SOUND_EMITTERS):
@@ -201,15 +318,673 @@ def emitters(files: BigArchive, attributes: dict[int, dict] | None = None) -> tu
     return listed, placed
 
 
-def _collections(game_root: Path, work: Path) -> list[dict]:
-    """The disc's skatercollections records (the same conversion the core group runs)."""
+# Region layers the engine uses: the location's random one-shot set (`aud_wp_emitters`), and
+# for later the zone ambience bed (`aud_wp_ambiences`) and reverb (`aud_reverb`).
+AUDIO_REGION_LAYERS = ('audio_emitters', 'audio_ambience', 'audio_reverb')
+
+
+def regions(game_root: Path, work: Path) -> dict:
+    """Each map's audio region layers from its district streams:
+    {map: {layer: [{box, nodes, keys (16 hex digits)}]}}."""
+    import sys
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'vendor/university/tools/vanilla_map_extraction/tools'))
+    from skate3_streams import read_atoc, read_sfil
+    out = {}
+    for archive in sorted((game_root/'data/content').glob('worldDIST_*.big')):
+        district = archive.stem.removeprefix('worldDIST_')
+        big = BigArchive(archive)
+        index = next((e for e in big.entries if e.path.endswith('_Sim.xst')), None)
+        if index is None:
+            continue
+        folder = work/'regions'/district
+        folder.mkdir(parents=True, exist_ok=True)
+        (folder/'index.xst').write_bytes(big.read(index))
+        records = read_atoc(folder/'index.xst')
+        by_id = {r.asset_id: r for r in records}
+        layers, seen = {}, set()
+        for entry in big.entries:
+            name = Path(entry.path).name
+            if not (name.startswith('cSim_') and name.endswith('.xsf')):
+                continue
+            (folder/name).write_bytes(big.read(entry))
+            for asset in read_sfil(folder/name, records, require_all_records=False, record_index=by_id):
+                if asset.record.processor_id != REGION_PROCESSOR or asset.record.asset_id in seen:
+                    continue
+                seen.add(asset.record.asset_id)
+                for layer in region_layers(asset.data):
+                    if layer['layer'] in AUDIO_REGION_LAYERS:
+                        layers.setdefault(layer['layer'], []).append(
+                            {'box': layer['box'], 'nodes': layer['nodes'], 'keys': [f'{k:016X}' for k in layer['keys']]})
+        out[district] = layers
+    return out
+
+
+def _collections(game_root: Path, work: Path) -> tuple[list[dict], list[str]]:
+    """The disc's skatercollections records (the same conversion the core group
+    runs) and the record names listed in its summary report."""
+    import re
     from . import install as engine
     from .vlt import convert as convert_vlt
     database = work/'database'
     engine.extract(game_root/'data/big/db.big', database, lambda e: Path(e.path).name.lower() in {
-        'skaterschema.bin', 'skaterschema.vlt', 'skatercollections.bin', 'skatercollections.vlt'})
+        'skaterschema.bin', 'skaterschema.vlt', 'skatercollections.bin', 'skatercollections.vlt',
+        'skatercollections_summaryreport.txt'})
     names = (engine.TOOLS/'asset_pipeline/names.txt').read_text(encoding='utf-8').splitlines()
-    return convert_vlt(database/'data/db/skaterschema', database/'data/db/skatercollections', names)['collections']
+    converted = convert_vlt(database/'data/db/skaterschema', database/'data/db/skatercollections', names)
+    report = database/'data/db/skatercollections_summaryreport.txt'
+    text = report.read_text(encoding='latin-1') if report.exists() else ''
+    return converted['collections'], re.findall(r'\.class/([A-Za-z0-9_]+)\.xml', text)
+
+
+# Banks the native AEMS runtime needs besides the played ones (crates/skate-audio): the utility
+# whose timers and shuffles feed the `*_snd` / `random_*_gbl` globals other banks read, and Common
+# (class Start_up_Play_ctl: the `rnd_call` shuffles behind `send_random_0_to_9a/b/c`, which pick the
+# Seams_Bank sample of every seam hit).
+AEMS_EXTRA_BANKS = ('emitter_utility.abk', 'Common.abk')
+
+# The MixMap mixer's data (crates/skate-audio/src/mixmap): a loose file next to the archives.
+MIXMAP_FILE = 'MixMapSK8.mxb'
+
+
+def mixmap_file(audio_root: Path, output: Path) -> str | None:
+    """Copy MixMapSK8.mxb byte for byte into output/'aems' (checked: big-endian header with 1..64
+    slots and an in-file slot table); return its manifest path, or None if the disc has none."""
+    source = audio_root/MIXMAP_FILE
+    if not source.is_file():
+        return None
+    data = source.read_bytes()
+    if len(data) < 16:
+        raise ValueError(f'{MIXMAP_FILE}: truncated')
+    slots, table = struct.unpack_from('>II', data, 4)
+    if not 1 <= slots <= 64 or table + 4 * slots > len(data):
+        raise ValueError(f'{MIXMAP_FILE}: not a MixMap ({slots} slots, table at {table:#x})')
+    (output/'aems').mkdir(parents=True, exist_ok=True)
+    (output/'aems'/MIXMAP_FILE).write_bytes(data)
+    return f'aems/{MIXMAP_FILE}'
+
+
+# The granular rolling bed's tuning (.claude/notes/grain-player-spec.md §1.4–1.5): the grain class
+# (one collection per `.grain` member, inheriting from `default`), the board owner class (rocket
+# layer, chain ramps) and the material → rolling surface table. Field roles from upstream PR #4's
+# notes; values are read exactly (f32) because the port compares bit patterns.
+GRAIN_CLASS = 'Hash_7AB23C11B6ADA2DE'
+GRAIN_OWNER_CLASS = 'Hash_6E878344774A7999'
+GRAIN_FIELDS = {
+    'Hash_2C073BF8BC45063B': 'grain_file',
+    'Hash_4890392C91829954': 'max_kmh',
+    'Hash_CEC749561306022A': 'b_slope_gain',
+    'Hash_D380D303C64CF6F8': 'b_slope_ramp_kmh',
+    'Hash_1F459FC797B2C6BA': 'a_shift_per_slope_hz',
+    'Hash_5C9AA28695C17004': 'turn_cap',
+    'Hash_145D8340A9440DA3': 'b_base_shift_hz',
+    'Hash_7FFF3A8AD44809EF': 'b_shift_per_slope_hz',
+    'Hash_281FF01081475899': 'turn_rise_step',
+    'Hash_63764B8C7EB9EC9B': 'turn_fall_step',
+    'Hash_6BDC44AE7C3C79D0': 'special_gain',
+    'Hash_F62BC5EBD8E5DDE8': 'special_shift_hz',
+    'Hash_2D751DEB89BB5E33': 'push_ramp_kmh',
+    'Hash_E239B03F0E890686': 'push_scale_low',
+    'Hash_B87ECDDAAB0F8404': 'push_scale_high',
+    'Hash_C658A7923FC7B99E': 'push_shift_low_hz',
+    'Hash_A15AD56E225ADBA6': 'push_shift_high_hz',
+    'Hash_B3D7468820AFC661': 'push_scale_attack_ms',
+    'Hash_DAC9DA910EF0316C': 'push_scale_hold_ms',
+    'Hash_0C3D5DBC262ED276': 'push_scale_return_ms',
+    'Hash_09A5CC79BA2178E7': 'push_shift_attack_ms',
+    'Hash_3206FD96427EA4D2': 'push_shift_hold_ms',
+    'Hash_DB597F672CA47138': 'push_shift_return_ms',
+    'Hash_57A78D3BE8D47BB3': 'slope_down_divisor',
+    'Hash_8DD4C3FC8DAF4059': 'slope_up_divisor',
+}
+GRAIN_CURVE_FIELD = 'Hash_A985FBAA9326718D'   # 4×4 floats; column 1 of rows 3, 2, 1, 0 = P0..P3
+GRAIN_PARAMS_FIELD = 'Hash_D18D1174735E5CDE'  # GrainParams: {attack, sustain, release, window, drift} per player
+GRAIN_OWNER_FIELDS = {
+    'Hash_7508154FF73DDCED': 'rocket_start_kmh',
+    'Hash_1185E9A69919B051': 'rocket_top_kmh',
+    'Hash_9BC13FA19CC4DF00': 'rocket_gain_word',
+    'Hash_88AA96B08FD16914': 'g1_level_start_kmh',
+    'Hash_3FFB5107C82BA3E0': 'g1_level_end_kmh',
+    'Hash_D3E8894CA25A4F71': 'g1_level_floor',
+    # The board chains (`sub_824CA938`, skate_audio::grain::chain::ChainTuning): the graph-1 ->
+    # graph-3 send by speed, graph 3's clip and high shelf, the gain wobbles' speed ramp, segment
+    # times and ranges for A's and B's chains.
+    'Hash_0D665393E2EDC605': 'g3_send_start_kmh',
+    'Hash_28E708782445747F': 'g3_send_end_kmh',
+    'Hash_D900C07BE7C5450F': 'g3_send_max',
+    'Hash_E64C04ED542DABC8': 'g3_clip',
+    'Hash_55BEB30353F244A9': 'g3_shelf_hz',
+    'Hash_45516395725ED16B': 'g3_shelf_gain',
+    'Hash_281A501B22B6CCDF': 'wobble_start_kmh',
+    'Hash_54CDE019E31FC04E': 'wobble_end_kmh',
+    'Hash_36AE41817640FE04': 'wobble_a_ms_low',
+    'Hash_71EE27313BD30F21': 'wobble_a_ms_high',
+    'Hash_437D128B53669C34': 'wobble_a_low',
+    'Hash_02885338DD5D7DCA': 'wobble_a_high',
+    'Hash_2055BBF39C152FA9': 'wobble_b_ms_low',
+    'Hash_F5240AFADA3B3FFC': 'wobble_b_ms_high',
+    'Hash_F916E153393C5F24': 'wobble_b_low',
+    'Hash_0A36F90732016D85': 'wobble_b_high',
+}
+SURFACE_MAP = ('Hash_C1831BDB6CB1B1EA', 'Hash_C489459A0C07D154', 'Hash_4CA607558B1CF440')
+
+
+def _exact(field):
+    """A converted field read without rounding: f32 as the exact float, ints, text; arrays as lists
+    (an item holding several floats becomes a list of them)."""
+    kind = field.get('type', '')
+    if 'array' in field:
+        return [_exact({'type': kind, 'data': item}) for item in field['array']['items']]
+    data = ''.join(field.get('data', '').split())
+    if kind.endswith('Text'):
+        return field['data']
+    if kind.endswith('Float'):
+        floats = [struct.unpack('>f', bytes.fromhex(data[i:i + 8]))[0] for i in range(0, len(data), 8)]
+        return floats[0] if len(floats) == 1 else floats
+    if kind.endswith('Int32') and len(data) == 8:
+        return struct.unpack('>i', bytes.fromhex(data))[0]
+    return data
+
+
+def _floats(field) -> list[float]:
+    data = ''.join(field.get('data', '').split())
+    return [struct.unpack('>f', bytes.fromhex(data[i:i + 8]))[0] for i in range(0, len(data) - 7, 8)]
+
+
+def grain_tuning(collections: list[dict]) -> dict:
+    """{'surfaces': {member stem: tuning}, 'default': tuning, 'owner': {...}, 'surface_map': [95 ints]}
+    with inherited fields resolved through `default`."""
+    records = {c['key']: c for c in collections if c['class'] == GRAIN_CLASS}
+
+    def resolve(key, field):
+        seen = 0
+        while key in records and seen < 32:
+            if field in records[key]['fields']:
+                return records[key]['fields'][field]
+            key, seen = records[key].get('parent', ''), seen + 1
+        return None
+
+    def tuning(key):
+        out = {}
+        for field, name in GRAIN_FIELDS.items():
+            value = resolve(key, field)
+            if value is not None:
+                out[name] = _exact(value)
+        curve = resolve(key, GRAIN_CURVE_FIELD)
+        if curve is not None:
+            m = _floats(curve)
+            if len(m) == 16:
+                out['bezier'] = [m[13], m[9], m[5], m[1]]
+        params = resolve(key, GRAIN_PARAMS_FIELD)
+        if params is not None:
+            items = params['array']['items'] if 'array' in params else [params['data']]
+            out['params'] = [_floats({'data': item}) for item in items]
+        return out
+
+    surfaces = {}
+    for key in records:
+        entry = tuning(key)
+        member = entry.pop('grain_file', '')
+        if member:
+            surfaces[Path(member).stem] = entry
+    owner = {}
+    owners = {c['key']: c for c in collections if c['class'] == GRAIN_OWNER_CLASS}
+    default_owner = owners.get('default', {'fields': {}})['fields']
+    for field, name in GRAIN_OWNER_FIELDS.items():
+        if field in default_owner:
+            owner[name] = _exact(default_owner[field])
+    if GRAIN_PARAMS_FIELD in default_owner:
+        field = default_owner[GRAIN_PARAMS_FIELD]
+        items = field['array']['items'] if 'array' in field else [field['data']]
+        owner['rocket_params'] = _floats({'data': items[0]})
+    surface_map = []
+    holder = next((c for c in collections if c['class'] == SURFACE_MAP[0] and c['key'] == SURFACE_MAP[1]), None)
+    if holder and SURFACE_MAP[2] in holder['fields']:
+        for item in holder['fields'][SURFACE_MAP[2]]['array']['items']:
+            surface_map.append(int(''.join(item.split())[8:16], 16))
+    default = tuning('default')
+    default.pop('grain_file', None)
+    return {'surfaces': surfaces, 'default': default, 'owner': owner, 'surface_map': surface_map}
+
+
+# The native player components' vault tuning (crates/skate-audio/src/player/tuning.rs). Field roles
+# from our reading of the retail code (sub_824EF0B8, sub_824CA448, sub_824C2E48/sub_824C2D00,
+# sub_824BA630, sub_824B2350), cross-checked with upstream PR #4's notes.
+JITTER_CLASS = 'Hash_0AB9F005A2C8FBC7'
+JITTER_FIELDS = {'Hash_8F956FBAD301AE26': 'enabled', 'Hash_E7D491E2EB228F54': 'id', 'Hash_B66AAD957873A8B3': 'params'}
+SEAM_CLASS = 'Hash_7242F32831ED3332'
+SEAM_PATTERNS = ('spidercrack', 'square_2_x_2', 'square_4_x_4', 'square_8_x_8', 'square_12_x_12', 'square_24_x_24',
+                 'irregular_small', 'irregular_medium', 'irregular_large', 'slats', 'sidewalk',
+                 'brick_tile_random_size', 'mini_tile', 'special_1', 'special_2')
+SEAM_FIELDS = {'Hash_FA3A57801765A2F8': 'gain_low', 'Hash_32A9692F1B826274': 'gain_high',
+               'Hash_F713CB547B1DF920': 'ms_low', 'Hash_0608B3129FF81F12': 'ms_high'}
+# Class_Seams (`sub_824C1698` / `sub_824C1CA0` / `sub_824C1F18`): the pattern record (+0 gain, +4 grid
+# angle, +8 grid z, +12 grid x, +16 class = w13) and its attributes (mode: 0 none, 1 grid, 2 distance;
+# minimum frames between hits; speed threshold; distance spacing; level = w18); holder `default`
+# `1911176187FB9B1F` = the grid scale on surface 3 for class-10 patterns.
+SEAM_PATTERN_FIELDS = {'Hash_199170BB1C52EE64': 'gain', 'Hash_D18F436B5764F260': 'angle',
+                       'Hash_534B0A719762E2E8': 'grid_z', 'Hash_107A78BA11A2B813': 'grid_x',
+                       'Hash_5FAD918A2DE5459A': 'class', 'Hash_CA81764BF5A85E34': 'mode',
+                       'Hash_DAE803A0CBD286D1': 'min_frames', 'Hash_F7BCA67F0A1FC92E': 'speed_threshold',
+                       'Hash_A3BC1976039FA00A': 'spacing', 'Hash_2F29F40384863C8C': 'level',
+                       'Hash_1911176187FB9B1F': 'surface3_scale'}
+GRIND_CLASS = 'Hash_049861E8F9A8D16B'
+# Grind surface 0..13 → collection: the image's key table at 0x82249F90 (TU3), as facts.
+GRIND_SURFACE_KEYS = (0x72766EB54205429A, 0x849358CD45882044, 0x8DB0436F6B3405D5, 0xA36240FD856EEBA2,
+                      0x8212F939B27CB441, 0x8710D7DAA28B90E7, 0x80AD71A0341B4AEB, 0x29FC132BB19BE7C9,
+                      0xFD4F9F04AE61311B, 0x7CBD549861AE837E, 0xBDDCF1000271E0F7, 0x0C4C7B1701C3EA1B,
+                      0x3696D249613957DD, 0xEDB51E711C25AA58)
+GRIND_V = ('Hash_0ECECDAC28B2B979', 'Hash_58070BF511809903', 'Hash_72BA0780A8FA25D6', 'Hash_721A50C80028AD69')
+GRIND_F = ('Hash_69969AF1BE6BB367', 'Hash_0555484D6D4A3128', 'Hash_C21983A2160ED3AC', 'Hash_69A5FC53091ED1F8')
+MATERIAL_CLASS = 'Hash_D40CB4C0FFE45676'
+MATERIAL_FOOTSTEPS = 'Hash_B1CF62EA632CF13F'
+MATERIAL_STEP_GAIN = 'Hash_37320DF00471F91A'
+MATERIAL_STEP_LANDING_GAIN = 'Hash_9D6068AB16703650'
+LANDING_FLAG = 'Hash_1EBF9D2EB0DD56BA'
+# The TU3 image's material → AudioSurface collection key table (16-byte stride, key at +8).
+MATERIAL_KEY_TABLE = 0x8302D6E8
+WHEEL_CLASS = 'Hash_C26949FCB638A2CA'
+# eSk8AudioTricks (one collection per trick, key = hash64 of the lowercase scorable name): the audio
+# trick id the board contacts and the trick foley read (state +348).
+TRICK_CLASS = 'Hash_6918469984A8C596'
+TRICK_FIELD = 'Hash_8C3025DB4D1761AF'
+# The scorable's second audio trick (state +352, record +184; the Tricks component's cloth_trick B).
+TRICK_FIELD_2 = 'Hash_A2C5C22C5BE725F8'
+WHEEL_BUCKET = {'Hash_6D3D91A9BA7ADCDC': 'wheel_bucket_high', 'Hash_2A70BB8A382574E4': 'wheel_bucket_low'}
+
+# The collision manager's per-material table (crates/skate-audio/src/player/collision.rs): the TU3
+# image's material table at 0x8302D6E8 (16-byte stride: +0 the kind word = the Splice bank family
+# 0 Skate_Collisions / 1 Skate_Metal / 2 HOM_Set_1, −1 none; +8 the AudioSurface collection key =
+# hash64 of the lowercase material name), copied here as facts so setup needs no image.
+MATERIAL_KINDS = (0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                  1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                  1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, -1, 0, 0, 0,
+                  0, 0, 0, 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+MATERIAL_KEYS = (
+    0x84EF7A70636ED529, 0x9182CCAD63479434, 0x49A5B1F124E53FDE, 0x49F167E3FC3A008B, 0xD7EFFA5849BB7B15,
+    0x72B4ECCDC6CEE6E8, 0xAF8EAB3B0227FD48, 0x54D22F1336F8B796, 0x42CD19124AE613EB, 0x0613243A490D11EA,
+    0xA4B6334D87D72CC7, 0x3738E9708EB6C776, 0x1BFF6E5CA982683A, 0x5BBDF4492AC7FB47, 0x22132549704E8733,
+    0x1F2ACA29DEBE0729, 0x500227DC11D198AC, 0xB7DBFE813D021524, 0x6EAACF19DDD07B5A, 0x60EC16F48C0BE620,
+    0x791C508A6E1205EA, 0x42337BA2D862B622, 0x10ED41289D47F052, 0xBD556D5B135BBF8E, 0xB74F55A0A96516A0,
+    0x3B214D295DB514F7, 0xA7AB65A3C044B3DA, 0xE96D23CB66372699, 0xB062804C25EDD8A7, 0xA8EF0E67A39D62D9,
+    0xF7141297FEB29B5D, 0x0DEB3D61CAED9567, 0x7AC77169773C0CE4, 0x0193A08E3EDA269B, 0xDBF3EC4C65A69F5D,
+    0x3A43FEE3639BA301, 0x309033B5E5872675, 0xEF0C2293B7888864, 0xD807FA29ADE65957, 0x10017676688AA504,
+    0xD8F132C02494531F, 0x5D4D49C598C7C2E3, 0xD3184F6BD8E629CC, 0xA227D8D1EB22C467, 0x7D5F7C90590CD76C,
+    0xE351230372B8AA43, 0xC65BAF14769DFCEB, 0x13D19F33ABDEFDA4, 0x6B170B796C325537, 0x8640A18245382F66,
+    0xC53FA0D15249C949, 0x9988214E2D3F25C2, 0x6A0D63DA93EF3459, 0x99433514E821A363, 0xF002CCA1F7FD6978,
+    0x947A2EEC879CF0C4, 0xC5C3FCD994414A11, 0x45EF058BC984C7E8, 0x03745EEB6C08A0B7, 0xF3D78078D942C1F5,
+    0x3E93846A0C0904EF, 0x71D3FF58545A7240, 0x36F1FB399593A42E, 0xCA39C5BF26B5A8CE, 0x98CD99EC1E257D5A,
+    0x94BFC99C9D77FBE9, 0x3F4E33C9A0B9B05E, 0xDC7B09876FB19FFF, 0x8BD87DE72E1A3157, 0x0613243A490D11EA,
+    0x0613243A490D11EA, 0x0613243A490D11EA, 0xBFBDAC657253E431, 0x73235D7F8A764EA3, 0x070B3A354E4B91E8,
+    0x6C322F848110963C, 0x07FB54E5A776E0DD, 0x4EE7754C40081FFB, 0x59BA34C2182DFAED, 0x761C67A1D52C27D8,
+    0x5AAA7F375D3FAFD7, 0x7CAF97EA114D54A9, 0xA029E9DED863C78E, 0xB13FD71EA972B2E7, 0x061A5C9D1EB44C60,
+    0x0526D0B41AA7E7F3, 0xD7A4B6C19268884E, 0x0023C43AFE5425C2, 0x0B56CDEC643B3C5C, 0xA5C4BE35A6484D2A,
+    0x44C45991DF83F528, 0x954AB2622DDDCDAE, 0xB2BD1F28DDE601B0, 0x09A0A000A6C314BE, 0x0000000000000000,
+    0xF512E3A5DFD6C51C, 0x27CDE290C32867A9, 0x379CADECE541E342, 0xFC139EC967F75F74, 0xAB73644DAB95C51A,
+    0x65AF5100E77A2982, 0x0DB9BC878EC6B280, 0xFB0158EFB8889A2A, 0x87684DAC4583AED5, 0xDC73596A59C3A8B9,
+    0xF16BBF49DDEA88A9, 0xC83E4BE38A953FAA, 0xD2E3F99A952DC96B, 0x66153E29A9E4F5F0, 0xB025A0D5D09BAD53,
+    0xC54DB3B091215CA0, 0xF2E9CB8F28FAED2D, 0x7410CAC4852F5168, 0x76535DC1C13DC342, 0x56AE4185FFB27F3B,
+    0xBC46374D5FE945CC, 0x4E3F3F3D686C1376, 0xFD06F928C97B0C13, 0x272430E460312991, 0x8CDC59AF8D2FE8C0,
+    0x3C39F714BDF14002, 0x582E3694A7D7A81C, 0xDAB71EE7131FB16F, 0x5C7F8A8CD61ADC6A, 0xD715DAADCCFE3707,
+    0xD1104F0408894184, 0x0180D422774A2E76, 0x7EE4E115095A35FE, 0xE6ACC17E8C6E545D, 0x897D82A74C3DD55F,
+    0x9322B76721A7E961, 0x88E70FFEEB920FAC, 0xE5E4636B15D921E1, 0xB2B199D7B0CC6E56, 0x361AF94AF4738607,
+    0xBC8EB5FAC4FBFCAA, 0xDE485796A9BF0518, 0x4E988E099EB988FA, 0xBFA1E3CB2AC6A29F, 0xBA3A875662F7B1A3,
+    0x90C5D36FD10D6A3C, 0x93046C79A53E24D9, 0x93610C96EB08CDAD,
+)
+# AudioSurface record (class D40CB4C0FFE45676) fields by their layout offset (skaterschema): +52 gain,
+# +56 pitch-override flag, +68 pitch, +72 category (eMaterialNicotineType), +124 landing flag; the
+# sample ids sub_824967F8 picks: per kind [tier 2, tier 0 × class 0/1/2, tier 1 × class 0/1/2]
+# (kind 2: optional HOM_Set_1 fields, tier 0 class 0 through sub_824825D0).
+MATERIAL_IDS = (
+    ('Hash_9203DF6FD029B377', 'Hash_BFABF634D2B1E45A', 'Hash_9ABFC64574AB2F9F', 'Hash_BCD5E888294F7B15',
+     'Hash_EF9BD81F9CFF725F', 'Hash_A3ADCA7B19287B5D', 'Hash_C676C87F862C0490'),
+    ('Hash_F54277A83E0170FD', 'Hash_66A95889604DED36', 'Hash_595537EBA0196BE7', 'Hash_79DD0E6659793D0E',
+     'Hash_B722B88FE44B046E', 'Hash_1411108A7E9CC74A', 'Hash_50796F92F3DE449B'),
+    ('Hash_3EA2579C2F3BB23B', 'Hash_137C683BFB506ECA', 'Hash_2A2830137430BB02', 'Hash_79BDE00B04DF51B9',
+     'Hash_5432B35224E4B1C1', 'Hash_3FCBE0407F833721', 'Hash_53311C6761F135A1'),
+)
+MATERIAL_GAIN, MATERIAL_PITCH_FLAG, MATERIAL_PITCH = 'Hash_875BA75341DC8391', 'Hash_57E3031C18C769A1', 'Hash_C090F2C1F048F17B'
+MATERIAL_PITCH_ALT, MATERIAL_CATEGORY = 'Hash_3A3DD47E8DAFE796', 'Hash_D5EF686287A57AFE'
+# RefSpecs: +0 the contact-level windows (class 13E20D398E385A56, sub_82496C58 / sub_82496F50), +24 the
+# impact bands (class 7DAFF70B3A91CD5D, sub_82497088).
+MATERIAL_WINDOWS, MATERIAL_BANDS = 'Hash_82B1451A90152514', 'Hash_E228508FE0F53970'
+WINDOW_CLASS = 'Hash_13E20D398E385A56'
+WINDOW_FIELDS = ('Hash_036F313CEBC664FD', 'Hash_8001982DA2E91D6A', 'Hash_E24D9CB4000A53AC', 'Hash_1A83AD0330976744',
+                 'Hash_24B725E05CEB027E', 'Hash_CBBB19E302CE1A17', 'Hash_75DC915E876A9DC9', 'Hash_711F1F54903E76C9',
+                 'Hash_C8DED1BC20B9D6A5', 'Hash_B8870D2001033E0F')
+WINDOW_SCALE = 'Hash_1A5F7E8CCABBB0A2'
+WINDOW_FIELDS_2 = ('Hash_41F2E2456A97752A', 'Hash_2638FF12C8FBBCCB', 'Hash_166BAB2FD5B60560', 'Hash_0D6EF57A39AF0C93')
+BAND_CLASS = 'Hash_7DAFF70B3A91CD5D'
+BAND_FIELDS = ('Hash_C8DED1BC20B9D6A5', 'Hash_B8870D2001033E0F', 'Hash_7D8DEDD338D45482', 'Hash_D660AC459139BDF4')
+# Poster tuning: (class, collection, field, name).
+COLLISION_POSTERS = (
+    ('Hash_049861E8F9A8D16B', 'default', 'Hash_086B66C3D4FFEE8F', 'grind_split'),
+    ('Hash_049861E8F9A8D16B', 'default', 'Hash_B2ACAFDBCD963C93', 'grind_high'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_6D68BC2D1A23C29A', 'landing_air'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_85FDC8BF696BCA5C', 'landing_board'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_3462CBB16DCA696E', 'landing_split'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_590495E420B399E5', 'landing_high'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_31DEEF8FA219950F', 'landing_scale_a'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_0EC6EEF5366FEA85', 'landing_scale_b'),
+    ('Hash_6EBA5BCD3E38A98A', 'default', 'Hash_27D3C5DC3282B59D', 'deck_cooldown'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_823D59FB46324175', 'scuff_speed'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_733C45DF5B638ECB', 'scuff_ids'),
+    ('Hash_C26949FCB638A2CA', 'default', 'Hash_F2866EE0540CDF05', 'scuff_ids_soft'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_6BFB6A3F22AAF797', 'tap_off_ms'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_B63CC740D29AD118', 'tap_speed'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_7D1CA200987AA109', 'tap_mid'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_E1F87C4937E3CCA2', 'tap_high'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_6F133132EF3F8063', 'tap_first'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_E518088F4E61203A', 'tap_second'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_4CFF36855CA04B6F', 'tap_both'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_3AC5AA2D2010B49C', 'tap_special'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_DB56952676D7122E', 'tap_first_soft'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_0ACFCB7E532B7A0B', 'tap_second_soft'),
+    ('Hash_923CCB46EF5BF5BA', 'Hash_F1647BFB782BE97F', 'Hash_7EA37827E4228614', 'tap_other_soft'),
+)
+
+
+def _words(field) -> list[int]:
+    """Signed 32-bit words of a field (arrays: one per item, first word)."""
+    items = field['array']['items'] if 'array' in field else [field.get('data', '')]
+    out = []
+    for item in items:
+        data = ''.join(item.split())
+        if len(data) >= 8:
+            out.append(struct.unpack('>i', bytes.fromhex(data[:8]))[0])
+        elif data:
+            out.append(int(data[:2], 16))
+    return out
+
+
+def _scalar_or_list(field):
+    """A scalar or array field: floats for Float types, else signed words."""
+    if field.get('type', '').endswith('Float'):
+        items = field['array']['items'] if 'array' in field else [field.get('data', '')]
+        values = [struct.unpack('>f', bytes.fromhex(''.join(i.split())[:8]))[0] for i in items]
+    else:
+        values = _words(field)
+    return values if 'array' in field else (values[0] if values else 0)
+
+
+def collision_tuning(resolve, by_class) -> dict:
+    """{'materials': [143 rows], 'posters': {...}}: the collision manager's material table and the
+    vault values its posters read. `resolve(cls, key, field)` follows the parent chain."""
+    def ref_key(field):
+        data = ''.join(field.get('data', '').split()) if field else ''
+        return 'Hash_' + data[16:32].upper() if len(data) >= 32 else None
+
+    def word(cls, key, f, default=0):
+        v = resolve(cls, key, f)
+        return _words(v)[0] if v is not None and _words(v) else default
+
+    rows = []
+    for m in range(143):
+        kind, key = MATERIAL_KINDS[m], 'Hash_%016X' % MATERIAL_KEYS[m]
+        row = {'kind': kind}
+        if key not in by_class.get(MATERIAL_CLASS, {}):
+            row['missing'] = True
+        if 0 <= kind < 3:
+            row['ids'] = [word(MATERIAL_CLASS, key, f) for f in MATERIAL_IDS[kind]]
+        row['gain'] = word(MATERIAL_CLASS, key, MATERIAL_GAIN)
+        row['pitch'] = word(MATERIAL_CLASS, key, MATERIAL_PITCH, 4096)
+        row['pitch_flag'] = word(MATERIAL_CLASS, key, MATERIAL_PITCH_FLAG) != 0
+        alt = resolve(MATERIAL_CLASS, key, MATERIAL_PITCH_ALT)
+        if alt is not None:
+            row['pitch_alt'] = _words(alt)[0]
+        row['category'] = word(MATERIAL_CLASS, key, MATERIAL_CATEGORY)
+        row['landing'] = word(MATERIAL_CLASS, key, LANDING_FLAG) != 0
+        # SFXObj_OffBoard's footstep layer of the material (`sub_82493E60`, skate_audio::player::
+        # footsteps::FootstepMaterial): +125 has footsteps, +48 / the landing gain (x 32767).
+        row['footsteps'] = word(MATERIAL_CLASS, key, MATERIAL_FOOTSTEPS) != 0
+        row['step_gain'] = word(MATERIAL_CLASS, key, MATERIAL_STEP_GAIN, 32767)
+        row['step_landing_gain'] = word(MATERIAL_CLASS, key, MATERIAL_STEP_LANDING_GAIN, 32767)
+        windows_key = ref_key(resolve(MATERIAL_CLASS, key, MATERIAL_WINDOWS))
+        if windows_key and windows_key in by_class.get(WINDOW_CLASS, {}):
+            w = [word(WINDOW_CLASS, windows_key, f) for f in WINDOW_FIELDS]
+            w += [word(WINDOW_CLASS, windows_key, f) for f in WINDOW_FIELDS_2]
+            row['windows'] = w
+            scale = resolve(WINDOW_CLASS, windows_key, WINDOW_SCALE)
+            row['scale'] = _scalar_or_list(scale) if scale is not None else 0.0
+        bands_key = ref_key(resolve(MATERIAL_CLASS, key, MATERIAL_BANDS))
+        if bands_key and bands_key in by_class.get(BAND_CLASS, {}):
+            row['bands'] = [(_scalar_or_list(v) if (v := resolve(BAND_CLASS, bands_key, f)) is not None else 0.0) for f in BAND_FIELDS]
+        rows.append(row)
+    posters = {}
+    for cls, key, field, name in COLLISION_POSTERS:
+        v = resolve(cls, key, field)
+        if v is not None:
+            posters[name] = _scalar_or_list(v)
+    return {'materials': rows, 'posters': posters}
+
+
+def _word(field) -> int:
+    """The first 32-bit word of a field as a signed int (enums, bools as stored)."""
+    data = ''.join(field.get('data', '').split())
+    return struct.unpack('>i', bytes.fromhex(data[:8].ljust(8, '0')))[0] if data else 0
+
+
+# The environment (reverb) network's presets (.claude/notes/aems-env-bus-spec.md §3, §6): vault class
+# `204CAC1FD77088B8` (`aud_reverb/reverbNN`), fields in record-offset order 0..172 (the layout the disc's
+# schema gives; +48 is the preset number). `sub_8248DD18` reads them by offset.
+REVERB_CLASS = 'Hash_204CAC1FD77088B8'
+REVERB_FIELDS = ('48376C6D695CDDBB', '4E7CDD2F6C41296F', '22FB428A30D3602C', '66588E403F254F64', '8968075E7CBACC4E',
+                 'FA81EA055905EB17', '2490987C531FB4E9', '5075CFC3C70ACB30', '1812369BC788F71F', 'D548E99383500988',
+                 '4C50D4334042E446', '4ABF29854AA8167A', '3F9A78465CFFC183', '578AB8D6BF494236', 'C8A4239F7CBBF072',
+                 'B3BB9F5129BBCFB5', '2EBE3CBF5E339625', '533ED00D3783EF02', '8249454FFE32EA2B', 'DECBDDB58AC61519',
+                 '2DA3FDBA90F64924', 'C76E3B36EC05F9E0', '27D28928F58346B1', '30DCBFB636929C6A', '103E1FD179ADA674',
+                 'F38B7E9560E0AA84', 'C7F29E4229F528B6', '3E80A0539763F3DF', 'EDA35434B3617A0A', '024737095437438A',
+                 'E9E26ECCA2D28D11', '81504B05719020A0', '433B43350289C6CE', 'FC50736430148B30', '35B87D3598BAD8E5',
+                 '58C65800CA17ACD9', '9BAA927DA7AA8970', '7492F9438252B839', '843273C75A0984F5', '7B2416B80E3BA149',
+                 'D6812FA712AACD13', '796D8327E0995ECC', 'B388DAFB738410FC', 'EECADFA12642D9F3')
+# The eight eEQChain ("material") buses (.claude/notes/aems-eqchain-buses-spec.md §1.3): vault class
+# `AA801D9FC0ADBBBF`, collection per bus from the TU3 image table 0x8224DC78 (facts), the enable flag,
+# the clip level and the six (a, b) range pairs PI20#1 freq / gain / Q, PI20#2 freq / gain / Q.
+EQ_BUS_CLASS = 'Hash_AA801D9FC0ADBBBF'
+# The two FlangeSub effect returns (`sub_824DDF58` -> `sub_8248FE68`): class 4CDD7CDC1A955D5C,
+# collection A (voice routing 4096 / 8192) and B (16384); nine floats by record offset 0..32.
+FLANGE_CLASS = 'Hash_4CDD7CDC1A955D5C'
+FLANGE_KEYS = ('C6290FFCB9E84CD9', 'DFDFFAD67CCBA322')
+FLANGE_FIELDS = ('DE9BF5C10AB2C866', '113F78E17495296F', '3C0376079AD9A56C', '7D3294EC1C443CBD', 'CD44B25FAD9E48D9',
+                 'EDEE41D561FA8CE5', '9C890EC62D3BC5C6', 'D10D7F661896AC30', '9024FC56E2314F9F')
+EQ_BUS_KEYS = ('42DDFA3F5011BAB4', 'DA24A51DDC51EDF3', '201C88714085E3C3', '8AF23914D89E4AF0',
+               'F7CFA0A8D2F98BDE', '8AA93567C056736B', '87D5F21D9A71736A', 'BFA2D9D8C138F925')
+EQ_BUS_ENABLE = 'Hash_C6DA68C12A3822D2'
+EQ_BUS_CLIP = 'Hash_2086A0CE99C39A86'
+EQ_BUS_RANGES = (('5B48CBEB3EB440D2', '2B77D4F58AF71CCF'), ('7317CC02098BDFF6', '90A94DDDA5F804CB'),
+                 ('F30B7500D67E206B', 'B4190B5C42432FA2'), ('3264F689300A522A', '1DA611DA4DE5A67A'),
+                 ('54868EDE952EF581', '25853859640A3796'), ('594D91B30B95483A', 'CDF599CDEC9C7C64'))
+
+
+def bus_tuning(collections: list[dict]) -> dict:
+    """{'reverb': {key: [44 values by record offset]}, 'eq_buses': [8 × {'enabled', 'clip', 'ranges'}]}
+    for the native runtime's environment network and eEQChain buses. Values exact (f32)."""
+    by_class: dict[str, dict] = {}
+    for c in collections:
+        by_class.setdefault(c['class'], {})[c['key']] = c
+
+    def resolve(cls, key, field):
+        records, seen = by_class.get(cls, {}), 0
+        while key in records and seen < 32:
+            if field in records[key]['fields']:
+                return records[key]['fields'][field]
+            key, seen = records[key].get('parent', ''), seen + 1
+        if key != 'default' and 'default' in records:
+            return records['default']['fields'].get(field)
+        return None
+
+    out: dict = {}
+    if REVERB_CLASS in by_class:
+        presets = {}
+        for key in by_class[REVERB_CLASS]:
+            if not key.startswith('Hash_'):
+                continue
+            row = []
+            for i, h in enumerate(REVERB_FIELDS):
+                v = resolve(REVERB_CLASS, key, 'Hash_' + h)
+                row.append(0 if v is None else (_word(v) if i == 12 else _exact(v)))
+            presets[key[5:]] = row
+        out['reverb'] = presets
+    if EQ_BUS_CLASS in by_class:
+        buses = []
+        for key in EQ_BUS_KEYS:
+            k = 'Hash_' + key
+            enable = resolve(EQ_BUS_CLASS, k, EQ_BUS_ENABLE)
+            clip = resolve(EQ_BUS_CLASS, k, EQ_BUS_CLIP)
+            ranges = []
+            for a, b in EQ_BUS_RANGES:
+                va, vb = resolve(EQ_BUS_CLASS, k, 'Hash_' + a), resolve(EQ_BUS_CLASS, k, 'Hash_' + b)
+                ranges.append([_exact(va) if va else 0.0, _exact(vb) if vb else 0.0])
+            buses.append({'enabled': bool(enable and ''.join(enable['data'].split()).startswith('01')),
+                          'clip': _exact(clip) if clip else 100.0, 'ranges': ranges})
+        out['eq_buses'] = buses
+    if FLANGE_CLASS in by_class:
+        returns = []
+        for key in FLANGE_KEYS:
+            values = [resolve(FLANGE_CLASS, 'Hash_' + key, 'Hash_' + f) for f in FLANGE_FIELDS]
+            if any(v is None for v in values):
+                break
+            returns.append([_exact(v) for v in values])
+        if len(returns) == 2:
+            out['flange'] = returns
+    return out
+
+
+def player_tuning(collections: list[dict], image: bytes | None = None, image_base: int = 0x82000000) -> dict:
+    """{'surface_table': [95 × 18 ints], 'jitter': [...], 'seam_wobbles': [16], 'grind': [14],
+    'landing_materials': [...], 'wheel_bucket_high', 'wheel_bucket_low'}. `image` (optional, the
+    TU3 image from `image_base`) supplies the material key table; without it the landing-flag list
+    is empty."""
+    from .vlt import hash64
+    by_class: dict[str, dict] = {}
+    for c in collections:
+        by_class.setdefault(c['class'], {})[c['key']] = c
+
+    def resolve(cls, key, field):
+        records, seen = by_class.get(cls, {}), 0
+        while key in records and seen < 32:
+            if field in records[key]['fields']:
+                return records[key]['fields'][field]
+            key, seen = records[key].get('parent', ''), seen + 1
+        return None
+
+    out: dict = {}
+    holder = by_class.get(SURFACE_MAP[0], {}).get(SURFACE_MAP[1])
+    if holder and SURFACE_MAP[2] in holder['fields']:
+        rows = []
+        for item in holder['fields'][SURFACE_MAP[2]]['array']['items']:
+            data = ''.join(item.split())
+            words = [struct.unpack('>i', bytes.fromhex(data[i:i + 8]))[0] for i in range(0, min(len(data), 144) - 7, 8)]
+            rows.append(words + [0] * (18 - len(words)))
+        out['surface_table'] = rows
+    jitter = by_class.get(JITTER_CLASS, {})
+    if jitter:
+        parents = {c.get('parent', '') for c in jitter.values()}
+        leaves = sorted((k for k in jitter if k not in parents and k.startswith('Hash_')), key=lambda k: int(k[5:], 16))
+        channels = []
+        for key in leaves:
+            enabled = resolve(JITTER_CLASS, key, 'Hash_8F956FBAD301AE26')
+            ident = resolve(JITTER_CLASS, key, 'Hash_E7D491E2EB228F54')
+            params = resolve(JITTER_CLASS, key, 'Hash_B66AAD957873A8B3')
+            if params is None:
+                continue
+            channels.append({'enabled': bool(enabled and enabled['data'].startswith('01')),
+                             'id': _exact(ident) if ident else 0, 'params': _floats(params), 'key': key[5:]})
+        out['jitter'] = channels
+    if SEAM_CLASS in by_class:
+        wobbles = []
+        for key in ['default'] + ['Hash_%016X' % hash64(name) for name in SEAM_PATTERNS]:
+            entry = {}
+            for field, name in {**SEAM_FIELDS, **SEAM_PATTERN_FIELDS}.items():
+                value = resolve(SEAM_CLASS, key, field)
+                if value is not None:
+                    entry[name] = _word(value) if name == 'mode' else _exact(value)
+            wobbles.append(entry)
+        out['seam_wobbles'] = wobbles
+    if GRIND_CLASS in by_class:
+        surfaces = []
+        for k in GRIND_SURFACE_KEYS:
+            key = 'Hash_%016X' % k
+            v = [resolve(GRIND_CLASS, key, f) for f in GRIND_V]
+            f = [resolve(GRIND_CLASS, key, f) for f in GRIND_F]
+            surfaces.append({'v': [_exact(x) if x else 1.0 for x in v], 'f': [_exact(x) if x else 1.0 for x in f]})
+        out['grind'] = surfaces
+    wheel = by_class.get(WHEEL_CLASS, {}).get('default')
+    if wheel:
+        for field, name in WHEEL_BUCKET.items():
+            if field in wheel['fields']:
+                out[name] = _exact(wheel['fields'][field])
+    if TRICK_CLASS in by_class:
+        for name, field in (('audio_tricks', TRICK_FIELD), ('audio_tricks_2', TRICK_FIELD_2)):
+            tricks = {}
+            for key in by_class[TRICK_CLASS]:
+                value = resolve(TRICK_CLASS, key, field) if key.startswith('Hash_') else None
+                if value is not None and len(''.join(value.get('data', '').split())) == 8:
+                    tricks[key[5:]] = struct.unpack('>i', bytes.fromhex(''.join(value['data'].split())))[0]
+            out[name] = tricks
+    if image is not None and MATERIAL_CLASS in by_class:
+        flagged = []
+        at = MATERIAL_KEY_TABLE - image_base
+        for m in range(143):
+            if at + 16 * m + 16 > len(image):
+                break
+            key = 'Hash_%016X' % struct.unpack_from('>Q', image, at + 16 * m + 8)[0]
+            value = resolve(MATERIAL_CLASS, key, LANDING_FLAG)
+            if value is not None and value['data'].startswith('01'):
+                flagged.append(m)
+        out['landing_materials'] = flagged
+    if MATERIAL_CLASS in by_class:
+        out['collision'] = collision_tuning(resolve, by_class)
+        if 'landing_materials' not in out:
+            out['landing_materials'] = [m for m, row in enumerate(out['collision']['materials']) if row['landing']]
+    return out
+
+
+def aems_files(files: BigArchive, output: Path, banks) -> dict:
+    """Copy the native AEMS runtime's inputs into output/'aems', byte for byte: every Csis project
+    (`.csi`, in archive order, the order the runtime installs them) and the ABKC module banks among
+    `banks` plus AEMS_EXTRA_BANKS. The runtime runs each bank's own patch programs; its samples stay
+    the decoded WAVs (S10A slot i = banks/<stem>/<i>.wav, the same order scan_snr finds them)."""
+    folder = output/'aems'
+    folder.mkdir(parents=True, exist_ok=True)
+    by_name = {Path(e.path).name: e for e in files.entries}
+    projects = [Path(e.path).name for e in files.entries if e.path.lower().endswith('.csi')]
+    for name in projects:
+        (folder/name).write_bytes(files.read(by_name[name]))
+    copied = {}
+    for bank in sorted(set(banks) | set(AEMS_EXTRA_BANKS)):
+        entry = by_name.get(bank)
+        if entry is None or not bank.lower().endswith('.abk'):
+            continue
+        data = files.read(entry)
+        if data[:4] != b'ABKC':
+            continue
+        (folder/bank).write_bytes(data)
+        copied[Path(bank).stem] = f'aems/{bank}'
+    return {'projects': [f'aems/{name}' for name in projects], 'banks': copied}
+
+
+def splice_trees(files: BigArchive, output: Path, banks) -> dict:
+    """Copy the patch tree (header, records, containers, groups: everything before the sample table)
+    of each SPLC bank among `banks` into output/'aems'/<stem>.splc for the native Splice player
+    (crates/skate-audio `splice`); its samples stay the decoded WAVs (sample n = banks/<stem>/<n>.wav).
+    Returns {stem: path}."""
+    folder = output/'aems'
+    by_name = {Path(e.path).name: e for e in files.entries}
+    out = {}
+    for bank in sorted(set(banks)):
+        entry = by_name.get(bank)
+        if entry is None or not bank.lower().endswith('.bnk'):
+            continue
+        data = files.read(entry)
+        if data[:4] != b'SPLC':
+            continue
+        splc_patches(data)  # validates the walk ends exactly at the sample table
+        tree = 60 + struct.unpack_from('>I', data, 8)[0]
+        folder.mkdir(parents=True, exist_ok=True)
+        (folder/f'{Path(bank).stem}.splc').write_bytes(data[:tree])
+        out[Path(bank).stem] = f'aems/{Path(bank).stem}.splc'
+    return out
 
 
 def convert(game_root: Path, private: Path, work: Path, vgmstream: Path, report, log) -> dict:
@@ -245,11 +1020,12 @@ def convert(game_root: Path, private: Path, work: Path, vgmstream: Path, report,
         source = BigArchive(audio_root/archive)
         folder = work/kind
         folder.mkdir()
-        names = []
+        names, members = [], {}
         for entry in source.entries:
             if not entry.path.endswith(suffix):
                 continue
             stem, data = Path(entry.path).stem, source.read(entry)
+            members[stem] = data
             stream = grain(data).stream if suffix == '.grain' else scan_snr(data)[0]
             (folder/(stem + '.snr')).write_bytes(standalone(data, stream))
             names.append(stem)
@@ -258,7 +1034,8 @@ def convert(game_root: Path, private: Path, work: Path, vgmstream: Path, report,
         for stem in names:
             decoded = folder/(stem + '.snr.wav')
             if kind == 'grains':
-                manifest[kind][stem] = {'bands': _grain_bands(decoded, output/kind/stem, f'{kind}/{stem}')}
+                bands = _grain_bands(decoded, output/kind/stem, f'{kind}/{stem}')
+                manifest[kind][stem] = {'bands': bands, **grain_whole(stem, members[stem], decoded, output/kind)}
                 continue
             target = output/kind/(stem + '.wav')
             shutil.move(decoded, target)
@@ -267,7 +1044,19 @@ def convert(game_root: Path, private: Path, work: Path, vgmstream: Path, report,
     report('Decoding sound effect banks')
     files = BigArchive(audio_root/'audiofiles.big')
     by_name = {Path(e.path).name: e for e in files.entries}
-    manifest['emitters'], placed = emitters(files, emitter_attributes(_collections(game_root, work)))
+    collections, record_names = _collections(game_root, work)
+    manifest['grain_player'] = grain_tuning(collections)
+    manifest['player_tuning'] = player_tuning(collections)
+    manifest['bus_tuning'] = bus_tuning(collections)
+    attributes = emitter_attributes(collections)
+    manifest['emitters'], placed = emitters(files, attributes)
+    by_file = {Path(e.path).name.lower(): Path(e.path).name for e in files.entries}
+    manifest['random_sets'], random_banks = random_sets(collections, attributes, record_names, by_file)
+    placed |= random_banks
+    manifest['zones'], manifest['crossfades'] = ambience_zones(collections, record_names)
+    placed |= set(CROSSFADE_BANKS)
+    report('Reading audio regions')
+    manifest['regions'] = regions(game_root, work)
     for bank in BANKS + tuple(sorted(placed - set(BANKS))):
         if bank not in by_name:
             raise KeyError(f'sound bank {bank} is missing from the disc')
@@ -291,5 +1080,11 @@ def convert(game_root: Path, private: Path, work: Path, vgmstream: Path, report,
             # Retail's own layering/randomisation per sound (audio_formats.splc_patches).
             manifest['patches'][stem] = splc_patches(data)
 
+    report('Copying the AEMS banks and projects')
+    manifest['aems'] = aems_files(files, output, BANKS + tuple(placed))
+    mixmap = mixmap_file(audio_root, output)
+    if mixmap:
+        manifest['aems']['mixmap'] = mixmap
+    manifest['aems']['splice'] = splice_trees(files, output, BANKS)
     (output/'audio_manifest.json').write_text(json.dumps(manifest, indent=1), encoding='utf-8')
     return manifest
diff --git a/tools/asset_pipeline/audio_formats.py b/tools/asset_pipeline/audio_formats.py
index 5e788ab6..ee5c36ba 100644
--- a/tools/asset_pipeline/audio_formats.py
+++ b/tools/asset_pipeline/audio_formats.py
@@ -294,3 +294,65 @@ def ems_emitters(data: bytes) -> list[dict]:
             'scalars': list(fields[8:12]), 'sound_id': fields[12], 'gains': list(fields[13:17]),
         })
     return emitters
+
+
+# World-painter region layers (district `cSim_*.xsf` streams, RW4 arenas with ATOC processor
+# 0xAB329A6A). Each 128 m tile holds, per layer, a quadtree of axis-aligned (x, z) boxes whose
+# leaves index a table of u64 keys. Layers the game names (`name_id` of each):
+REGION_LAYERS = (
+    'test_layer0', 'test_layer1', 'livingworld_npc_census', 'livingworld_vehicle_census', 'districts',
+    'district_locations', 'livingworld_security_guard_areas', 'audio_ambience', 'audio_emitters',
+    'challenge_zone_races', 'audio_reverb', 'rendering_colorcube', 'cameras_race', 'services',
+    'livingworld_dmo_safety', 'rendering_fog', 'rendering_sky', 'rendering_exposure', 'rendering_bloom',
+)
+REGION_PROCESSOR = 0xAB329A6A
+_LAYER_RECORD, _QUADTREE, _KEY_TABLE = 0x00EB000F, 0x00EB0010, 0x00EB0011
+NO_KEY = 0xFFFF
+
+
+def region_layers(arena: bytes) -> list[dict]:
+    """Every region layer in one arena: layer name, box (centre x, z, half x, z), quadtree
+    nodes (four child indices, then the value; child 0 = NO_KEY marks a leaf) and keys."""
+    names = {name_id(name): name for name in REGION_LAYERS}
+    count, directory = _u32(arena, 0x20), _u32(arena, 0x30)
+    entries = [struct.unpack_from('>6I', arena, directory + 24 * i) for i in range(count)]
+    layers = []
+    for entry in entries:
+        if entry[5] != _LAYER_RECORD:
+            continue
+        tree_index, table_index = struct.unpack_from('>II', arena, entry[0])
+        layer = struct.unpack_from('>Q', arena, entry[0] + 8)[0]
+        tree, table = entries[tree_index][0], entries[table_index][0]
+        cx, cz = struct.unpack_from('>ff', arena, tree)
+        hx, hz = struct.unpack_from('>ff', arena, tree + 16)
+        nodes_count, nodes_at = struct.unpack_from('>II', arena, tree + 32)
+        nodes = [list(struct.unpack_from('>5H', arena, tree + nodes_at + 10 * i)) for i in range(nodes_count)]
+        keys_count, keys_at = _u32(arena, table + 4), _u32(arena, table + 12)
+        keys = []
+        for i in range(keys_count):
+            at = _u32(arena, table + keys_at + 8 * i)
+            low, high = struct.unpack_from('>II', arena, table + at)  # stored low word first
+            keys.append((high << 32) | low)
+        layers.append({'layer': names.get(layer, f'{layer:016X}'), 'box': [cx, cz, hx, hz], 'nodes': nodes, 'keys': keys})
+    return layers
+
+
+def region_key(layer: dict, x: float, z: float) -> int | None:
+    """The key a region layer holds at (x, z), or None (outside, or a leaf without a key)."""
+    cx, cz, hx, hz = layer['box']
+    nodes = layer['nodes']
+    if not nodes or abs(x - cx) > hx or abs(z - cz) > hz:
+        return None
+    index = 0
+    while True:
+        node = nodes[index]
+        if node[0] == NO_KEY:
+            return None if node[4] == NO_KEY else layer['keys'][node[4]]
+        hx, hz = hx * 0.5, hz * 0.5
+        for child, (sx, sz) in enumerate(((-1, -1), (-1, 1), (1, -1), (1, 1))):
+            ccx, ccz = cx + sx * hx, cz + sz * hz
+            if abs(x - ccx) <= hx and abs(z - ccz) <= hz:
+                index, cx, cz = node[child], ccx, ccz
+                break
+        else:
+            return None
diff --git a/tools/asset_pipeline/test_audio_formats.py b/tools/asset_pipeline/test_audio_formats.py
index a163ba49..dd07f626 100644
--- a/tools/asset_pipeline/test_audio_formats.py
+++ b/tools/asset_pipeline/test_audio_formats.py
@@ -212,3 +212,251 @@ class EmitterAttributes(unittest.TestCase):
         self.assertEqual(sound, {'volume': 0.5, 'seconds': 10.0, 'kind': 1, 'falloff': 1,
                                  'bank_file': 'water_fountain.abk', 'patch': 81})
         self.assertNotIn(0xBBB, emitter_attributes(collections))
+
+    def test_a_reverb_zone_names_its_preset_record(self):
+        from tools.asset_pipeline.audio_export import EMITTER_CLASS, emitter_attributes
+        # Attrib::RefSpec holds the class key, then the record key (the reverb preset).
+        ref = {'type': 'Attrib::RefSpec', 'data': '204CAC1FD77088B8BEEFC8E3DE04FBAE0000000000000000'}
+        kind = {'type': 'Sk8::Audio::eVolumeType', 'data': struct.pack('>i', 5).hex().upper()}
+        collections = [{'class': EMITTER_CLASS, 'key': 'Hash_1F94F2F815C00368', 'parent': '',
+                        'fields': {'Hash_99FD793BC30CF0FA': ref, 'Hash_6D18B8674D7E5337': kind}}]
+        zone = emitter_attributes(collections)[0x1F94F2F815C00368]
+        self.assertEqual(zone, {'reverb': 0xBEEFC8E3DE04FBAE, 'kind': 5})
+
+
+class AemsFiles(unittest.TestCase):
+    def test_copies_projects_in_archive_order_and_only_abkc_banks(self):
+        import tempfile
+        from pathlib import Path
+        from types import SimpleNamespace
+        from tools.asset_pipeline.audio_export import aems_files
+
+        blobs = {
+            'data/audio/b.csi': b'MOIR-b', 'data/audio/a.csi': b'MOIR-a',
+            'data/audio/water.abk': b'ABKC-water', 'data/audio/emitter_utility.abk': b'ABKC-util',
+            'data/audio/odd.abk': b'XXXX', 'data/audio/sfx.bnk': b'SPLC',
+        }
+        entries = [SimpleNamespace(path=path) for path in blobs]
+        archive = SimpleNamespace(entries=entries, read=lambda e: blobs[e.path])
+        with tempfile.TemporaryDirectory() as tmp:
+            out = Path(tmp)
+            listed = aems_files(archive, out, ['water.abk', 'odd.abk', 'sfx.bnk', 'missing.abk'])
+            self.assertEqual(listed['projects'], ['aems/b.csi', 'aems/a.csi'])
+            self.assertEqual(listed['banks'], {'emitter_utility': 'aems/emitter_utility.abk', 'water': 'aems/water.abk'})
+            self.assertEqual((out/'aems/water.abk').read_bytes(), b'ABKC-water')
+            self.assertFalse((out/'aems/odd.abk').exists())
+
+
+class MixMapFile(unittest.TestCase):
+    def test_copies_the_mixmap_and_rejects_other_files(self):
+        import tempfile
+        from pathlib import Path
+        from tools.asset_pipeline.audio_export import mixmap_file
+
+        with tempfile.TemporaryDirectory() as tmp:
+            root, out = Path(tmp)/'audio', Path(tmp)/'out'
+            root.mkdir()
+            self.assertIsNone(mixmap_file(root, out))
+            data = struct.pack('>IIIi', 0, 2, 16, -1) + struct.pack('>ii', 24, -1) + b'\0' * 32
+            (root/'MixMapSK8.mxb').write_bytes(data)
+            self.assertEqual(mixmap_file(root, out), 'aems/MixMapSK8.mxb')
+            self.assertEqual((out/'aems/MixMapSK8.mxb').read_bytes(), data)
+            (root/'MixMapSK8.mxb').write_bytes(struct.pack('>IIIi', 0, 900, 16, -1))
+            with self.assertRaises(ValueError):
+                mixmap_file(root, out)
+
+
+class GrainTuning(unittest.TestCase):
+    def test_members_inherit_from_default_and_keep_exact_floats(self):
+        from tools.asset_pipeline.audio_export import (GRAIN_CLASS, GRAIN_CURVE_FIELD, GRAIN_OWNER_CLASS,
+                                                        GRAIN_PARAMS_FIELD, SURFACE_MAP, grain_tuning)
+
+        hexf = lambda *v: struct.pack(f'>{len(v)}f', *v).hex().upper()
+        f32 = lambda v: {'type': 'EA::Reflection::Float', 'data': hexf(v)}
+        text = lambda v: {'type': 'EA::Reflection::Text', 'data': v}
+        curve = [1, 1, 0, 0, 0.47, 0.7069, 0, 0, 0.25, 0.3621, 0, 0, 0, 0, 0, 0]
+        collections = [
+            {'class': GRAIN_CLASS, 'key': 'default', 'parent': '', 'fields': {
+                'Hash_4890392C91829954': f32(74.0), 'Hash_5C9AA28695C17004': f32(0.8),
+                GRAIN_CURVE_FIELD: {'type': 'EA::Reflection::Matrix44', 'data': hexf(*curve)},
+                GRAIN_PARAMS_FIELD: {'type': 'GrainParams', 'array': {'items': [hexf(0.1, 0.2, 0.1, 1.6, 0.05),
+                                                                                hexf(0.2, 0.1, 0.2, 1.5, 0.05)]}}}},
+            {'class': GRAIN_CLASS, 'key': 'Hash_03721D0FA99A03C8', 'parent': 'default', 'fields': {
+                'Hash_2C073BF8BC45063B': text('concrete_rough_hard.grain'), 'Hash_4890392C91829954': f32(60.0)}},
+            {'class': GRAIN_OWNER_CLASS, 'key': 'default', 'parent': '', 'fields': {
+                'Hash_7508154FF73DDCED': f32(35.0),
+                'Hash_9BC13FA19CC4DF00': {'type': 'EA::Reflection::Int32', 'data': '000055F0'},
+                GRAIN_PARAMS_FIELD: {'type': 'GrainParams', 'data': hexf(0.1, 0.4, 0.1, 2.4, 0.1)}}},
+            {'class': SURFACE_MAP[0], 'key': SURFACE_MAP[1], 'parent': '', 'fields': {
+                SURFACE_MAP[2]: {'type': 'Sk8::AudioSurfaceMap', 'array': {'items': ['00000000 00000003', '00000001 00000001']}}}},
+        ]
+        t = grain_tuning(collections)
+        member = t['surfaces']['concrete_rough_hard']
+        self.assertEqual(member['max_kmh'], 60.0)
+        self.assertEqual(member['turn_cap'], struct.unpack('>f', struct.pack('>f', 0.8))[0])
+        self.assertEqual(member['bezier'], [0.0, struct.unpack('>f', struct.pack('>f', 0.3621))[0],
+                                            struct.unpack('>f', struct.pack('>f', 0.7069))[0], 1.0])
+        self.assertEqual(len(member['params']), 2)
+        self.assertEqual(t['default']['max_kmh'], 74.0)
+        self.assertEqual(t['owner']['rocket_gain_word'], 22000)
+        self.assertEqual(t['owner']['rocket_start_kmh'], 35.0)
+        self.assertAlmostEqual(t['owner']['rocket_params'][3], 2.4, places=6)
+        self.assertEqual(t['surface_map'], [3, 1])
+
+
+class PlayerTuning(unittest.TestCase):
+    def test_jitter_leaves_seams_grind_and_surface_rows(self):
+        from tools.asset_pipeline.audio_export import (GRIND_CLASS, GRIND_SURFACE_KEYS, JITTER_CLASS, SEAM_CLASS,
+                                                        SURFACE_MAP, player_tuning)
+        from tools.asset_pipeline.vlt import hash64
+
+        hexf = lambda *v: struct.pack(f'>{len(v)}f', *v).hex().upper()
+        f32 = lambda v: {'type': 'EA::Reflection::Float', 'data': hexf(v)}
+        i32 = lambda v: {'type': 'EA::Reflection::Int32', 'data': '%08X' % v}
+        on = {'type': 'EA::Reflection::Bool', 'data': '01000000'}
+        spider = 'Hash_%016X' % hash64('spidercrack')
+        collections = [
+            {'class': JITTER_CLASS, 'key': 'default', 'parent': '', 'fields': {
+                'Hash_B66AAD957873A8B3': {'type': 'Sk8::Audio::eJitterParams', 'data': hexf(0, 0, 0, 0)}}},
+            {'class': JITTER_CLASS, 'key': 'Hash_B355C0AD39002103', 'parent': 'default', 'fields': {
+                'Hash_8F956FBAD301AE26': on}},
+            {'class': JITTER_CLASS, 'key': 'Hash_02D9546BE518D5A1', 'parent': 'Hash_B355C0AD39002103', 'fields': {
+                'Hash_B66AAD957873A8B3': {'type': 'Sk8::Audio::eJitterParams', 'data': hexf(16384, 16383, 100, 1)},
+                'Hash_E7D491E2EB228F54': i32(4)}},
+            {'class': SEAM_CLASS, 'key': 'default', 'parent': '', 'fields': {
+                'Hash_FA3A57801765A2F8': f32(1.0), 'Hash_32A9692F1B826274': f32(1.0),
+                'Hash_F713CB547B1DF920': i32(0), 'Hash_0608B3129FF81F12': i32(0)}},
+            {'class': SEAM_CLASS, 'key': spider, 'parent': 'default', 'fields': {
+                'Hash_FA3A57801765A2F8': f32(0.75), 'Hash_F713CB547B1DF920': i32(30),
+                'Hash_CA81764BF5A85E34': {'type': 'Sk8::Audio::eSurfacePatternStyle', 'data': '00000002'},
+                'Hash_107A78BA11A2B813': f32(3.0), 'Hash_D18F436B5764F260': i32(30)}},
+            {'class': GRIND_CLASS, 'key': 'Hash_%016X' % GRIND_SURFACE_KEYS[0], 'parent': '', 'fields': {
+                'Hash_0ECECDAC28B2B979': f32(0.0), 'Hash_C21983A2160ED3AC': f32(0.5)}},
+            {'class': SURFACE_MAP[0], 'key': SURFACE_MAP[1], 'parent': '', 'fields': {
+                SURFACE_MAP[2]: {'type': 'Sk8::AudioSurfaceMap', 'array': {'items': ['00000000 00000003 00000000 00000002 00000001']}}}},
+        ]
+        t = player_tuning(collections)
+        # Leaves only (the two parents are not channels), fields through the parent chain.
+        self.assertEqual(t['jitter'], [{'enabled': True, 'id': 4, 'params': [16384.0, 16383.0, 100.0, 1.0],
+                                        'key': '02D9546BE518D5A1'}])
+        self.assertEqual(len(t['seam_wobbles']), 16)
+        self.assertEqual(t['seam_wobbles'][1], {'gain_low': 0.75, 'gain_high': 1.0, 'ms_low': 30, 'ms_high': 0,
+                                                'mode': 2, 'grid_x': 3.0, 'angle': 30})
+        self.assertEqual(t['seam_wobbles'][2], {}, 'no collection: retail reads the zero block')
+        self.assertEqual(t['grind'][0], {'v': [0.0, 1.0, 1.0, 1.0], 'f': [1.0, 1.0, 0.5, 1.0]})
+        self.assertEqual(t['grind'][1], {'v': [1.0] * 4, 'f': [1.0] * 4})
+        self.assertEqual(t['surface_table'], [[0, 3, 0, 2, 1] + [0] * 13])
+        self.assertNotIn('landing_materials', t)  # needs the TU3 image
+
+    def test_bus_tuning_reverb_presets_by_offset_and_eq_bus_ranges(self):
+        from tools.asset_pipeline.audio_export import (EQ_BUS_CLASS, EQ_BUS_KEYS, EQ_BUS_RANGES, REVERB_CLASS,
+                                                        REVERB_FIELDS, bus_tuning)
+        hexf = lambda *v: struct.pack(f'>{len(v)}f', *v).hex().upper()
+        f32 = lambda v: {'type': 'EA::Reflection::Float', 'data': hexf(v)}
+        collections = [
+            {'class': REVERB_CLASS, 'key': 'default', 'parent': '', 'fields': {
+                'Hash_' + REVERB_FIELDS[5]: f32(1.5), 'Hash_' + REVERB_FIELDS[12]: {'type': 'EA::Reflection::Int32', 'data': '00000000'}}},
+            {'class': REVERB_CLASS, 'key': 'Hash_A2782D75A971CC8C', 'parent': 'default', 'fields': {
+                'Hash_' + REVERB_FIELDS[6]: f32(70.0), 'Hash_' + REVERB_FIELDS[12]: {'type': 'EA::Reflection::Int32', 'data': '00000001'}}},
+            {'class': EQ_BUS_CLASS, 'key': 'default', 'parent': '', 'fields': {
+                'Hash_2086A0CE99C39A86': f32(100.0), 'Hash_C6DA68C12A3822D2': {'type': 'Bool', 'data': '00'}}},
+            {'class': EQ_BUS_CLASS, 'key': 'Hash_' + EQ_BUS_KEYS[0], 'parent': 'default', 'fields': {
+                'Hash_C6DA68C12A3822D2': {'type': 'Bool', 'data': '01'},
+                'Hash_' + EQ_BUS_RANGES[0][0]: f32(450.0), 'Hash_' + EQ_BUS_RANGES[0][1]: f32(150.0)}},
+        ]
+        b = bus_tuning(collections)
+        r = b['reverb']['A2782D75A971CC8C']
+        self.assertEqual(len(r), 44)
+        self.assertEqual((r[5], r[6], r[12]), (1.5, 70.0, 1), 'inherited T60, own size, int preset number')
+        self.assertNotIn('default', b['reverb'])
+        self.assertEqual(len(b['eq_buses']), 8)
+        self.assertEqual(b['eq_buses'][0]['ranges'][0], [450.0, 150.0])
+        self.assertTrue(b['eq_buses'][0]['enabled'])
+        self.assertFalse(b['eq_buses'][1]['enabled'], 'a missing record reads default')
+        self.assertEqual(b['eq_buses'][1]['clip'], 100.0)
+
+    def test_audio_tricks_resolve_through_parents_by_name_hash(self):
+        from tools.asset_pipeline.audio_export import TRICK_CLASS, TRICK_FIELD, player_tuning
+        from tools.asset_pipeline.vlt import hash64
+
+        trick = lambda v: {'type': 'Sk8::Audio::eSk8AudioTricks', 'data': '%08X' % (v & 0xFFFFFFFF)}
+        ollie, base = 'Hash_%016X' % hash64('ollie'), 'Hash_%016X' % hash64('basetrick')
+        t = player_tuning([
+            {'class': TRICK_CLASS, 'key': base, 'parent': '', 'fields': {TRICK_FIELD: trick(-1)}},
+            {'class': TRICK_CLASS, 'key': ollie, 'parent': base, 'fields': {TRICK_FIELD: trick(28)}},
+            {'class': TRICK_CLASS, 'key': 'Hash_0000000000000001', 'parent': base, 'fields': {}},
+        ])
+        self.assertEqual(t['audio_tricks'], {ollie[5:]: 28, base[5:]: -1, '0000000000000001': -1})
+        self.assertEqual(t['audio_tricks_2'], {}, 'no second field in these records')
+
+    def test_collision_materials_follow_the_image_keys_and_refspecs(self):
+        from tools.asset_pipeline.audio_export import (BAND_CLASS, MATERIAL_CLASS, MATERIAL_KEYS, MATERIAL_KINDS,
+                                                        WINDOW_CLASS, player_tuning)
+
+        hexf = lambda *v: struct.pack(f'>{len(v)}f', *v).hex().upper()
+        i32 = lambda v: {'type': 'EA::Reflection::Int32', 'data': '%08X' % (v & 0xFFFFFFFF)}
+        sc = lambda v: {'type': 'Skate_Collisions', 'data': '%08X' % v}
+        ref = lambda cls, key: {'type': 'Attrib::RefSpec', 'data': cls[5:] + '%016X' % key + '0' * 16}
+        board = 'Hash_%016X' % MATERIAL_KEYS[95]
+        self.assertEqual(MATERIAL_KINDS[95], 0)
+        self.assertEqual(MATERIAL_KINDS[8], 1)
+        collections = [
+            {'class': MATERIAL_CLASS, 'key': 'default', 'parent': '', 'fields': {
+                'Hash_875BA75341DC8391': i32(32767), 'Hash_C090F2C1F048F17B': i32(4096),
+                'Hash_3A3DD47E8DAFE796': i32(4096), 'Hash_1EBF9D2EB0DD56BA': {'type': 'EA::Reflection::Bool', 'data': '00'}}},
+            {'class': MATERIAL_CLASS, 'key': board, 'parent': 'default', 'fields': {
+                'Hash_875BA75341DC8391': i32(28000), 'Hash_9203DF6FD029B377': sc(993), 'Hash_BFABF634D2B1E45A': sc(876),
+                'Hash_D5EF686287A57AFE': i32(6), 'Hash_82B1451A90152514': ref(WINDOW_CLASS, 7),
+                'Hash_E228508FE0F53970': ref(BAND_CLASS, 8)}},
+            {'class': WINDOW_CLASS, 'key': 'Hash_0000000000000007', 'parent': '', 'fields': {
+                'Hash_036F313CEBC664FD': i32(10000), 'Hash_0D6EF57A39AF0C93': i32(22000),
+                'Hash_1A5F7E8CCABBB0A2': {'type': 'EA::Reflection::Float', 'data': hexf(0.5)}}},
+            {'class': BAND_CLASS, 'key': 'Hash_0000000000000008', 'parent': '', 'fields': {
+                'Hash_C8DED1BC20B9D6A5': {'type': 'EA::Reflection::Float', 'data': hexf(0.4)},
+                'Hash_D660AC459139BDF4': {'type': 'EA::Reflection::Float', 'data': hexf(0.025)}}},
+            {'class': 'Hash_C26949FCB638A2CA', 'key': 'default', 'parent': '', 'fields': {
+                'Hash_85FDC8BF696BCA5C': {'type': 'Sk8::Audio::eAudioMaterialTypes', 'data': '0000005F'},
+                'Hash_733C45DF5B638ECB': {'type': 'sk82_cloth_foley', 'data': '00020002',
+                                          'array': {'items': ['0000005F', '0000005E']}}}},
+        ]
+        t = player_tuning(collections)
+        rows = t['collision']['materials']
+        self.assertEqual(len(rows), 143)
+        b = rows[95]
+        self.assertEqual((b['kind'], b['gain'], b['pitch'], b['category']), (0, 28000, 4096, 6))
+        self.assertEqual(b['ids'][:2], [993, 876], 'tier 2, tier 0 class 0 of the Skate_Collisions family')
+        self.assertEqual(b['windows'][0], 10000)
+        self.assertEqual(b['windows'][13], 22000, '+56 is the last window word')
+        self.assertAlmostEqual(b['scale'], 0.5)
+        self.assertAlmostEqual(b['bands'][0], 0.4, places=6)
+        self.assertAlmostEqual(b['bands'][3], 0.025, places=6)
+        self.assertNotIn('windows', rows[0], 'no record of its own: the zero record')
+        self.assertEqual(rows[94]['kind'], -1)
+        self.assertEqual(t['collision']['posters'], {'landing_board': 95, 'scuff_ids': [95, 94]})
+        self.assertEqual(t['landing_materials'], [])
+
+
+class SpliceTrees(unittest.TestCase):
+    def test_copies_the_patch_tree_of_splc_banks_only(self):
+        import tempfile
+        from pathlib import Path
+        from types import SimpleNamespace
+        from tools.asset_pipeline.audio_export import splice_trees
+
+        # One record with one group of one member (sample 0), no containers, one sample; the
+        # sample table starts right after the tree (offset from byte 60).
+        member = struct.pack('>H', 0) + b'\0' * 70
+        tree = struct.pack('>4s', b'SPLC') + b'\0' * 56
+        record = b'\0' * 4 + struct.pack('>H', 0) + b'\0' + bytes([1]) + b'\0' * 28
+        group = b'\0' * 8 + bytes([1, 0]) + b'\0' * 2
+        body = record + group + member
+        header = bytearray(tree)
+        struct.pack_into('>IIIII', header, 8, len(body), 1, 0, 0, 1)
+        bank = bytes(header) + body + b'SAMPLETABLE'
+        blobs = {'data/audio/Skate_Collisions.bnk': bank, 'data/audio/water.abk': b'ABKC'}
+        archive = SimpleNamespace(entries=[SimpleNamespace(path=p) for p in blobs], read=lambda e: blobs[e.path])
+        with tempfile.TemporaryDirectory() as tmp:
+            out = Path(tmp)
+            listed = splice_trees(archive, out, ['Skate_Collisions.bnk', 'water.abk', 'missing.bnk'])
+            self.assertEqual(listed, {'Skate_Collisions': 'aems/Skate_Collisions.splc'})
+            self.assertEqual((out/'aems/Skate_Collisions.splc').read_bytes(), bank[:60 + len(body)])