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)])