diff --git a/crates/skate-audio/src/bus/mod.rs b/crates/skate-audio/src/bus/mod.rs
index 5b344fc6..17a4f475 100644
--- a/crates/skate-audio/src/bus/mod.rs
+++ b/crates/skate-audio/src/bus/mod.rs
@@ -9,6 +9,7 @@
 pub mod env;
 pub mod eqchain;
 pub mod flange;
+pub mod speech_echo;
 pub mod submix;
 pub mod zones;
 
@@ -52,6 +53,8 @@ pub struct Buses {
     pub flange: flange::FlangeReturns,
     /// The FootStep SubMix graphs (`player::footsteps`).
     pub submix: submix::FootSubmixes,
+    /// The speech stream slots' echo submixes (`world::speech_player`).
+    pub speech_echo: speech_echo::SpeechEchoes,
 }
 
 impl Default for Buses {
@@ -65,6 +68,7 @@ impl Default for Buses {
             flange_active: [false; 2],
             flange: flange::FlangeReturns::default(),
             submix: submix::FootSubmixes::default(),
+            speech_echo: speech_echo::SpeechEchoes::default(),
         }
     }
 }
@@ -100,6 +104,7 @@ impl Buses {
     /// SFX Master.
     pub fn render(&mut self, master: &mut [[f32; BLOCK]; 6]) {
         self.submix.render(&mut self.env_in, master);
+        self.speech_echo.render(&mut self.env_in);
         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);
diff --git a/crates/skate-audio/src/bus/speech_echo.rs b/crates/skate-audio/src/bus/speech_echo.rs
new file mode 100644
index 00000000..55cc2a9a
--- /dev/null
+++ b/crates/skate-audio/src/bus/speech_echo.rs
@@ -0,0 +1,132 @@
+//! The speech stream slots' echo submixes (`sub_82C5E2D8`, built once per stream slot; parameters
+//! posted every frame by `sub_82C5CEF0`; spec `audio-specs/world-speech.md` "Speech details
+//! resolved"): `Sub0 → HI20 → Del0 → LI20 → Pn21 → Sen0 (→ the environment bus)`.
+//!
+//! The slot's speech voice feeds Sub0 through its pre-gain Send (the owner's level 21 for a ped,
+//! 13 for a skater, × the voice's float). Per frame the stream system posts HI20 = the owner's
+//! filter 22 (skater 14), LI20 = filter 23 (skater 15) and, when it changed, Del0's delay = the
+//! camera distance × the speech record's factor / 344 m/s, at most 0.15 s. Pn21 and Sen0 keep their
+//! class defaults (azimuth 0, level 1.0).
+//!
+//! Modelled mono: the graph's two channels carry the one mono speech signal and the env bus input
+//! is mono, so the Pn21 → Sen0 path is a unity tap (the two-channel routing's exact gains are not
+//! traced). The graph keeps its filter history and delay line between lines, as retail's persists.
+use super::env::Level;
+use crate::dsp::biquad::{Iir2, Kind};
+use crate::dsp::delay::Delay;
+use crate::{BLOCK, MIX_RATE};
+
+/// Echo slots: retail builds one per stream slot (3 speech channels × 2 streams).
+pub const SLOTS: usize = 6;
+/// Del0's line length (s): the delay is posted at most 0.15 s (`0x820964B4`).
+pub const MAX_DELAY: f32 = 0.15;
+
+#[derive(Clone, Debug)]
+pub struct SpeechEcho {
+    /// Sub0: the voices' sends add here (mono).
+    pub input: Box<[f32; BLOCK]>,
+    hpf: Iir2,
+    delay: Delay,
+    lpf: Iir2,
+    env: Level,
+    /// Something was sent into it since it was built (the graph renders from then on).
+    active: bool,
+}
+
+impl Default for SpeechEcho {
+    fn default() -> Self {
+        Self {
+            input: Box::new([0.0; BLOCK]),
+            hpf: Iir2::new(Kind::HighPass),
+            delay: Delay::new(MAX_DELAY, 1),
+            lpf: Iir2::new(Kind::LowPass),
+            env: Level::running(1.0),
+            active: false,
+        }
+    }
+}
+
+/// What the stream system posts to a slot's echo each frame.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct EchoParams {
+    pub high_pass: f32,
+    pub low_pass: f32,
+    /// Del0 (s); None = unchanged since the last post.
+    pub delay: Option<f32>,
+}
+
+impl SpeechEcho {
+    pub fn set(&mut self, p: &EchoParams) {
+        self.hpf.cutoff = p.high_pass;
+        self.lpf.cutoff = p.low_pass;
+        if let Some(d) = p.delay {
+            self.delay.delay = d.min(MAX_DELAY);
+        }
+        self.active = true;
+    }
+
+    fn render(&mut self, env_in: &mut [f32; BLOCK]) {
+        if !self.active {
+            return;
+        }
+        let mut mono = *self.input;
+        self.input.fill(0.0);
+        {
+            let mut planes: [&mut [f32]; 1] = [&mut mono[..]];
+            self.hpf.process(&mut planes, MIX_RATE as f32);
+            self.delay.process(&mut planes);
+            self.lpf.process(&mut planes, MIX_RATE as f32);
+        }
+        self.env.add(&mono, &mut env_in[..]);
+    }
+}
+
+/// The slots' graphs.
+#[derive(Clone, Debug, Default)]
+pub struct SpeechEchoes {
+    pub slots: Vec<SpeechEcho>,
+}
+
+impl SpeechEchoes {
+    pub fn slot(&mut self, i: usize) -> Option<&mut SpeechEcho> {
+        if i >= SLOTS {
+            return None;
+        }
+        if self.slots.len() < SLOTS {
+            self.slots.resize_with(SLOTS, SpeechEcho::default);
+        }
+        self.slots.get_mut(i)
+    }
+
+    pub fn render(&mut self, env_in: &mut [f32; BLOCK]) {
+        for s in self.slots.iter_mut() {
+            s.render(env_in);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_echo_delays_and_filters_its_input_into_the_env_bus() {
+        let mut e = SpeechEchoes::default();
+        let s = e.slot(1).unwrap();
+        s.set(&EchoParams { high_pass: 0.0, low_pass: 96_000.0, delay: Some(0.01) });
+        s.input[0] = 1.0;
+        let mut out = Vec::new();
+        for _ in 0..4 {
+            let mut env = [0.0f32; BLOCK];
+            e.render(&mut env);
+            out.extend_from_slice(&env);
+        }
+        // The impulse comes out 480 samples (10 ms) later.
+        let at = out.iter().position(|v| v.abs() > 0.5).unwrap();
+        assert_eq!(at, 480);
+        assert!(e.slot(7).is_none());
+        // A capped delay.
+        e.slot(0).unwrap().set(&EchoParams { delay: Some(1.0), ..Default::default() });
+        assert_eq!(e.slots[0].delay.delay, MAX_DELAY);
+    }
+}
diff --git a/crates/skate-audio/src/mixer.rs b/crates/skate-audio/src/mixer.rs
index 3531bd42..9b68b3f0 100644
--- a/crates/skate-audio/src/mixer.rs
+++ b/crates/skate-audio/src/mixer.rs
@@ -18,6 +18,7 @@ use std::sync::Arc;
 use crate::dsp::biquad::{Iir2, Kind};
 use crate::dsp::gain::Gain;
 use crate::dsp::pan::{self, Pan2D};
+use crate::dsp::peaking::PeakingIir2;
 use crate::dsp::resample::{Resampler, ratio};
 use crate::dsp::routes::to_six;
 use crate::dsp::send::{Mode, Send, fold_release};
@@ -122,6 +123,10 @@ struct Voice {
     /// A direct voice's own Send A level (speech streams, [`Mixer::set_direct_dsp`]): replaces
     /// master × FXWET0 when set.
     env_direct: Option<f32>,
+    /// The speech stream graph ([`Mixer::set_stream_dsp`]): `Resample → PI20 → Send A → Gain →
+    /// HI20 → LI20 → Pan2D1 → Send` (`sub_82C5C318`) instead of the voice graph's filters before
+    /// Send A. None for every other voice.
+    stream: Option<Box<StreamDsp>>,
     /// Stop fade: (source index where it starts, per-channel last sample).
     fade: Option<(u64, [f32; 8])>,
     done: bool,
@@ -164,6 +169,23 @@ impl Voice {
         at as f64 / f64::from(self.header.rate)
     }
 
+    /// The environment send: the channels summed to mono into the env bus at the voice's level.
+    fn env_send(&mut self, src: &[[f32; BLOCK]; 6], channels: usize, buses: &mut Buses, user: f32) {
+        self.env.target = match self.env_direct {
+            Some(level) => level * user,
+            None => 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[..]);
+        }
+    }
+
     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];
@@ -184,28 +206,49 @@ impl Voice {
         // `tests/render_alloc.rs`).
         {
             let mut planes = src.each_mut().map(|c| &mut c[..]);
-            self.hpf.process(&mut planes[..channels], MIX_RATE as f32);
-            self.lpf.process(&mut planes[..channels], MIX_RATE as f32);
+            match self.stream.as_deref_mut() {
+                // The speech stream graph: the PEAK first, the filters after the gain.
+                Some(stream) => stream.peak.process(&mut planes[..channels], MIX_RATE as f32),
+                None => {
+                    self.hpf.process(&mut planes[..channels], MIX_RATE as f32);
+                    self.lpf.process(&mut planes[..channels], 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 = match self.env_direct {
-            Some(level) => level * user,
-            None => 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;
+        if self.stream.is_none() {
+            self.env_send(&src, channels, buses, user);
+        } else if let Some(stream) = self.stream.as_deref_mut()
+            && let Some(slot) = stream.echo_slot
+        {
+            // The pre-gain Send into the stream slot's echo submix (mono sum, as Send A).
+            stream.echo.target = stream.echo_level * user;
+            if !stream.echo.silent()
+                && let Some(echo) = buses.speech_echo.slot(usize::from(slot))
+            {
+                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;
+                    }
                 }
+                stream.echo.add(&mono, &mut echo.input[..]);
             }
-            self.env.add(&mono, &mut buses.env_in[..]);
         }
         {
             let mut planes = src.each_mut().map(|c| &mut c[..]);
             self.gain.target = self.master * self.dry;
             self.gain.process(&mut planes[..channels]);
+            if self.stream.is_some() {
+                self.hpf.process(&mut planes[..channels], MIX_RATE as f32);
+                self.lpf.process(&mut planes[..channels], MIX_RATE as f32);
+            }
+        }
+        // The speech stream's environment send is its post-filter Send (`sub_82C5CEF0` posts it the
+        // owner's second level; its pre-gain Send feeds the stream slot's echo submix, not ported).
+        if self.stream.is_some() {
+            self.env_send(&src, channels, buses, user);
         }
         // 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.
@@ -262,6 +305,22 @@ impl Voice {
     }
 }
 
+//// A speech stream voice's own modules (`sub_82C5C318`'s graph): the PEAK and the pre-gain Send
+/// into its slot's echo submix.
+#[derive(Clone, Debug)]
+struct StreamDsp {
+    peak: PeakingIir2,
+    echo_slot: Option<u8>,
+    echo_level: f32,
+    echo: Level,
+}
+
+impl Default for StreamDsp {
+    fn default() -> Self {
+        Self { peak: PeakingIir2::default(), echo_slot: None, echo_level: 0.0, echo: Level::new(0.0) }
+    }
+}
+
 /// 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)];
@@ -425,6 +484,7 @@ impl Mixer {
             group,
             fade: None,
             env_direct: None,
+            stream: None,
             done: false,
         });
         Some(self.next)
@@ -452,6 +512,34 @@ impl Mixer {
         }
     }
 
+    /// A speech stream's per-frame values (`world::speech_player::VoiceParams`): the voice takes
+    /// the stream graph (PEAK, Send A, Gain, then the filters; `sub_82C5C318`) from now on.
+    /// `peak` = (centre Hz, linear gain, Q), `env` = Send A.
+    pub fn set_stream_dsp(&mut self, voice: u32, hpf: f32, lpf: f32, env: f32, peak: [f32; 3]) {
+        if let Some(v) = self.voice(voice) {
+            v.hpf.cutoff = hpf;
+            v.lpf.cutoff = lpf;
+            v.env_direct = Some(env);
+            let s = v.stream.get_or_insert_with(Default::default);
+            s.peak.freq = peak[0];
+            s.peak.gain = peak[1];
+            s.peak.q = peak[2];
+        }
+    }
+
+    /// A speech stream's echo send: its pre-gain Send into echo slot `slot` (`crate::bus::speech_echo`)
+    /// at `level`, and the slot's posted values.
+    pub fn set_stream_echo(&mut self, voice: u32, slot: u8, level: f32, params: &crate::bus::speech_echo::EchoParams) {
+        if let Some(v) = self.voice(voice) {
+            let s = v.stream.get_or_insert_with(Default::default);
+            s.echo_slot = Some(slot);
+            s.echo_level = level;
+        }
+        if let Some(e) = self.buses.speech_echo.slot(usize::from(slot)) {
+            e.set(params);
+        }
+    }
+
     /// Register (or replace) one sample of a bank: streamed sounds (speech takes) are decoded on
     /// demand instead of with the whole bank.
     pub fn set_bank_sample(&mut self, bank: usize, slot: u16, header: SampleHeader, pcm: Arc<Pcm>) {
@@ -593,6 +681,7 @@ impl VoiceHost for Mixer {
             group,
             fade: None,
             env_direct: None,
+            stream: None,
             done: false,
         });
         Some(self.next)
diff --git a/crates/skate-audio/src/world/mod.rs b/crates/skate-audio/src/world/mod.rs
index 4c1d4afa..b83d1f11 100644
--- a/crates/skate-audio/src/world/mod.rs
+++ b/crates/skate-audio/src/world/mod.rs
@@ -13,7 +13,8 @@
 //!   `SFXObj_TrafficHorn` (`TRAFFIC_HORN`, `c_car_alarm`) and `SFXObj_TrafficSkids`
 //!   (`TRAFFIC_SKID`);
 //! - [`peds`]: `SFXObj_PedestrianSFX`'s footsteps (`livingword_footstep` packets and the
-//!   `sk8_foley` Splice steps) and `SFXObj_PedestrianSpeech`'s speech requests;
+//!   `sk8_foley` Splice steps), `SFXObj_PedestrianSpeech`'s speech requests (and its phone ring),
+//!   `SFXObj_PedBodyFall`'s fall one-shots and `SFXObj_Tazer`'s `c_tazer` packet;
 //! - [`skaters`]: NPC (AI) skaters' board sounds — the local player's components for the Player
 //!   slot's second instance, which retail gives to one NPC skater within 30 m of the camera;
 //! - [`speech`]: the streamed speech archives (`livingworldspeech.big`): the clip index and the
@@ -32,6 +33,7 @@
 pub mod keys;
 pub mod owners;
 pub mod peds;
+pub mod skater_speech;
 pub mod skaters;
 pub mod speech;
 pub mod speech_manager;
@@ -52,6 +54,8 @@ pub enum WorldSlot {
     Skid,
     /// `livingword_footstep`: foot A (PedestrianSFX `+40`) = 0, foot B (`+224`) = 1.
     PedFootstep(u8),
+    /// `c_tazer` (SFXObj_Tazer `+36`, while the ped audio state's tazer byte `+80` is set).
+    PedTazer,
 }
 
 /// A world owner: the game object (vehicle or ped id the engine system hands out) and the slot.
diff --git a/crates/skate-audio/src/world/peds.rs b/crates/skate-audio/src/world/peds.rs
index 96f7318f..96fbd784 100644
--- a/crates/skate-audio/src/world/peds.rs
+++ b/crates/skate-audio/src/world/peds.rs
@@ -10,13 +10,18 @@
 //!     these (recomp `all_20261002_164620`: 1017 events).
 //! - [`PedSpeech`] = `SFXObj_PedestrianSpeech` (vtable `0x822FBF40`): process `sub_824D9908`
 //!   hands the speech manager a request whenever the ped's speech value (`SendSpeechEvent`'s
-//!   `speechvalue` in the state graphs) changes ([`super::speech`] resolves it to a clip).
+//!   `speechvalue` in the state graphs) changes ([`super::speech`] resolves it to a clip); value
+//!   49 rings a phone first and asks for 64 when the ring ends, value 29 repeats on a timer;
+//! - [`PedBodyFall`] = `SFXObj_PedBodyFall`: a Skate_Collisions fall sound per `BodyFallType`
+//!   animation event;
+//! - [`PedTazer`] = `SFXObj_Tazer`: the `c_tazer` packet while the ped tazes.
 //!
 //! The ped side ([`PedState`]) is the record the objects read: the ped audio state `[object+32]`
-//! (feet `+73`/`+74`, footsteps on `+68`, kind `+96`, class `+132`, speech value `+136`,
-//! materials `+140`/`+144`, the speech distance pair `+148`/`+156`) and the owner `[object+28]`
-//! (speed `+128`, weight `+144`). Which LW ped fields fill them is not traced; a ped system fills
-//! [`PedState`] from its own animation (foot plants) and AI (speech values).
+//! (feet `+73`/`+74`, footsteps on `+68`, `BodyFallType` `+76`, tazer `+80`, kind `+96`, class
+//! `+132`, speech value `+136`, materials `+140`/`+144`, the speech distance pair `+148`/`+156`)
+//! and the owner `[object+28]` (speed `+128`, weight `+144`); the manager `sub_824F2890` fills it
+//! from the packed ped audio entries (spec G2). A ped system fills [`PedState`] from its own
+//! animation (foot plants, fall events) and AI (speech values, tazing).
 use super::{WorldCommand, WorldSlot};
 use crate::player::contacts::SpliceHost;
 use crate::player::footsteps::{Curve, footstep_surface};
@@ -107,6 +112,13 @@ pub struct PedState {
     pub speaker: super::speech_manager::Speaker,
     /// Which PedestrianSpeech outputs a line plays at ([`super::speech_player::ped_level_ids`]).
     pub level_select: super::speech_player::PedLevelSelect,
+    /// `S+80`: the ped is tazing (the manager's bit 17 of the ped audio entry `+4`; set while the
+    /// state graph's `TazeEntity` state runs, `pedestrian_wanttotaze.xml`): SFXObj_Tazer holds its
+    /// `c_tazer` packet while it is set ([`PedTazer`]).
+    pub tazing: bool,
+    /// `S+76`: the ped animation's `BodyFallType` event value (entry `+16`, a float; 0 = none). Each
+    /// change to a non-zero value starts one PedBodyFall sound ([`PedBodyFall`]).
+    pub body_fall: f32,
 }
 
 impl Default for PedState {
@@ -127,6 +139,51 @@ impl Default for PedState {
             voice: 0,
             speaker: super::speech_manager::Speaker::default(),
             level_select: super::speech_player::PedLevelSelect::default(),
+            tazing: false,
+            body_fall: 0.0,
+        }
+    }
+}
+
+/// The ped objects' one-shot values (setup export `world_tuning.ped_objects`; the defaults are the
+/// shipped records and the image's constants, as [`PedFootstepTuning`]'s are). Mods can override
+/// every field through the world tuning.
+#[derive(Clone, Debug, PartialEq)]
+pub struct PedObjectTuning {
+    /// SFXObj_PedBodyFall's Skate_Collisions containers by `BodyFallType` [8, 9, any other]
+    /// (vault class `923CCB46EF5BF5BA` record `DFEFC9212E0CBD2C`, fields `552899F3BF9927CC` /
+    /// `A3E8A9381F4222E1` / `C0FFD1E535F218E2`; holder `*(0x830CFDA4)+124`).
+    pub body_fall_ids: [u32; 3],
+    /// Their Splice bank (retail's table index 0).
+    pub body_fall_bank: String,
+    /// The eEQChain bus they resolve (eEQChain holder field `B4C4F86A53963BA2`, absent from the
+    /// shipped database: the lookup's default 0), created on resolve.
+    pub body_fall_eq: u8,
+    /// The phone ring of speech value 49 (`sub_824D9C70`): Splice bank index 6 and its container
+    /// (class `C1831BDB6CB1B1EA` record `cellphone` field `031EFDF991638985`).
+    pub ring_bank: String,
+    pub ring_id: u32,
+    /// The speech value requested when the ring ends (`sub_824D9AD8`: 64 → `4402_cell_greet`).
+    pub ring_answer: i32,
+    /// The photographer's repeat (value 29 while the game flag is set): the request repeats each
+    /// time this many seconds have accumulated (the image's 1.0 at `0x8231A844`).
+    pub photo_repeat: f32,
+    /// How long a tazer hold lasts when the engine does not say (the state graph's `TazerCycTime`,
+    /// `pedestrian_wanttotaze.xml` `TazeEntity`: 2.0 s; the recomp's bursts last 2.0 / 2.1 s).
+    pub tazer_seconds: f32,
+}
+
+impl Default for PedObjectTuning {
+    fn default() -> Self {
+        Self {
+            body_fall_ids: [1184, 948, 1183],
+            body_fall_bank: "Skate_Collisions".into(),
+            body_fall_eq: 0,
+            ring_bank: "CellPhone_Rings".into(),
+            ring_id: 5,
+            ring_answer: 64,
+            photo_repeat: 1.0,
+            tazer_seconds: 2.0,
         }
     }
 }
@@ -286,29 +343,244 @@ pub struct SpeechRequest {
 }
 
 /// `SFXObj_PedestrianSpeech`'s state.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct PedSpeech {
-    /// `+36`: the speech value last handed on.
+    /// `+36`: the speech value last handed on (the constructor `sub_824D90D8` sets 68).
     pub last: i32,
+    /// `+160`: the photographer's repeat timer (seconds).
+    pub photo_timer: f32,
+    /// `+148`: the phone ring of value 49 (a Splice sound).
+    pub ring: Option<SoundId>,
+    /// Rings started (diagnostics).
+    pub rings: u64,
+}
+
+impl Default for PedSpeech {
+    fn default() -> Self {
+        Self { last: 68, photo_timer: 0.0, ring: None, rings: 0 }
+    }
 }
 
 impl PedSpeech {
-    /// vfunc 9 (`sub_824D9908`): a request when the value changes. Value 49 goes to a separate
-    /// handler (`sub_824D9C70`, not ported) and 29 (the photographer, `PictureTaking`) has a repeat
-    /// timer (`+160`) gated by a global flag, not ported.
-    pub fn process(&mut self, owner: u64, s: &PedState) -> Option<SpeechRequest> {
+    /// vfunc 9 (`sub_824D9908`): a request when the value changes.
+    /// - **29** (the photographer, `PictureTaking`): while the game flag `photo` is set (system
+    ///   byte `*(0x830CFDC4)+912`, meaning not traced) the timer `+160` accumulates `dt`; when it
+    ///   has reached [`PedObjectTuning::photo_repeat`] it restarts at 0 and the request repeats.
+    /// - **49** (the phone, sent by the code, not the state graphs): the old ring is stopped and
+    ///   the ring Splice starts (`sub_824D9C70`; no request now: [`Self::update`] requests the
+    ///   answer when it ends).
+    /// - 7 / 8 → 30 after a 29, else 51.
+    pub fn process(&mut self, owner: u64, s: &PedState, dt: f32, photo: bool, t: &PedObjectTuning, host: &mut dyn SpliceHost) -> Option<SpeechRequest> {
         let value = s.speech_value;
-        if value == self.last {
+        let mut repeat = false;
+        if photo && value == 29 {
+            if self.photo_timer >= t.photo_repeat {
+                repeat = true;
+                self.photo_timer = 0.0;
+            } else {
+                self.photo_timer += dt;
+            }
+        }
+        if value == self.last && !repeat {
             return None;
         }
         let previous = self.last;
         self.last = value;
         if value == 49 {
+            if let Some(old) = self.ring.take() {
+                host.release(old);
+            }
+            host.set_route(crate::bus::Route::default());
+            self.ring = host.start(&t.ring_bank, t.ring_id, [0.0, 1.0, 0.0, dt, 1.0, 1.0]);
+            self.rings += u64::from(self.ring.is_some());
             return None;
         }
         let value = if matches!(value, 7 | 8) { if previous == 29 { 30 } else { 51 } } else { value };
-        let flag = if s.speech_measure > s.speech_limit { 1 } else { 2 };
-        Some(SpeechRequest { owner, value, flag })
+        Some(SpeechRequest { owner, value, flag: Self::flag(s) })
+    }
+
+    /// The near / far flag of a request (1 when `S+148` > `S+156`, else 2).
+    pub fn flag(s: &PedState) -> i32 {
+        if s.speech_measure > s.speech_limit { 1 } else { 2 }
+    }
+
+    /// The end of vfunc 10 (`sub_824D9AD8`): the ring follows the speaker's speech outputs (`main`
+    /// = the main level PedestrianSpeech copies for its lines, `out` the owner's outputs: pitch 1,
+    /// azimuth raw 0). When the ring has ended it is freed and the ped requests
+    /// [`PedObjectTuning::ring_answer`] (64, `4402_cell_greet`) with its words.
+    pub fn update(&mut self, owner: u64, s: &PedState, main: i32, out: &dyn Outputs, dt: f32, t: &PedObjectTuning, host: &mut dyn SpliceHost) -> Option<SpeechRequest> {
+        let ring = self.ring?;
+        if host.alive(ring) {
+            host.update(ring, [main as f32 * LEVEL, out.pitch(1) as f32 * PITCH, out.raw(0) as f32 * DEGREES, dt, 0.0, 1.0]);
+            return None;
+        }
+        host.release(ring);
+        self.ring = None;
+        Some(SpeechRequest { owner, value: t.ring_answer, flag: Self::flag(s) })
+    }
+
+    pub fn release(&mut self, host: &mut dyn SpliceHost) {
+        if let Some(ring) = self.ring.take() {
+            host.release(ring);
+        }
+    }
+}
+
+/// `SFXObj_PedBodyFall` (Pedestrian object 2, vtable `0x822FCB18`, factory `sub_824F0880`): process
+/// `sub_824F0AB8`, update `sub_824F0E50`. When the ped's `BodyFallType` (`S+76`) changes to a
+/// non-zero value, one Skate_Collisions sound starts through the collision Splice object
+/// (`sub_82497F48`: a mono submix on the eEQChain bus, env send from the last update; each type
+/// follows its own volume / pitch outputs, [`PedBodyFall::update`]): type 8 and
+/// type 9 each round-robin two slots (`+40/+44`, index `+60`; `+48/+52`, index `+64`), any other
+/// value one slot (`+56`); a slot's old sound is stopped first. The recomp shows the pattern of
+/// retail's knock-down animations (sessions 163809 / 164620 / 214002 / 222155 / audiox: 75 starts,
+/// 9 → 948, 8 → 1184, other → 1183, e.g. 9, +0.1 s other, +0.5 s 9, +0.16 s 9).
+#[derive(Clone, Debug, Default)]
+pub struct PedBodyFall {
+    /// `+36`: the value last seen.
+    last: f32,
+    /// Type 8 / type 9 slot pairs and their next index.
+    pairs: [[Option<SoundId>; 2]; 2],
+    next: [usize; 2],
+    /// The other types' slot.
+    single: Option<SoundId>,
+    /// level(7) as of the last update (the env send latched at a start).
+    env: i32,
+    /// Sounds started and the last container (diagnostics, checks).
+    pub starts: u64,
+    pub last_id: u32,
+}
+
+impl PedBodyFall {
+    /// vfunc 9 (`sub_824F0AB8`).
+    pub fn process(&mut self, s: &PedState, t: &PedObjectTuning, host: &mut dyn SpliceHost) {
+        let v = s.body_fall;
+        if v == self.last || v == 0.0 {
+            self.last = v;
+            return;
+        }
+        let kind = v as i32;
+        let (id, sound) = match kind {
+            8 => (t.body_fall_ids[0], &mut self.pairs[0][self.next[0]]),
+            9 => (t.body_fall_ids[1], &mut self.pairs[1][self.next[1]]),
+            _ => (t.body_fall_ids[2], &mut self.single),
+        };
+        if let Some(old) = sound.take() {
+            host.release(old);
+        }
+        host.set_route(crate::bus::Route {
+            output: crate::bus::Output::Eq(t.body_fall_eq),
+            create: true,
+            owner_env: self.env.clamp(0, 32767) as f32 * LEVEL,
+            mono: true,
+        });
+        *sound = host.start(&t.body_fall_bank, id, [0.0, 1.0, 0.0, 0.0, 1.0, 1.0]);
+        if sound.is_some() {
+            self.starts += 1;
+            self.last_id = id;
+        }
+        match kind {
+            8 => self.next[0] = (self.next[0] + 1) % 2,
+            9 => self.next[1] = (self.next[1] + 1) % 2,
+            _ => {}
+        }
+        self.last = v;
+    }
+
+    /// vfunc 10 (`sub_824F0E50`): every live sound follows the owner with its type's own volume /
+    /// pitch pair (type 8: out1 / out2, type 9: out3 / out4, other: out5 / out6; MixMap E23 / E24:
+    /// −2511 / −2155 / −1844 mB at the source): [volume / 32767, pitch / 4096, raw(0) × 360/65535,
+    /// dt, 0, 1], env send level(7) / 32767; an ended one is freed.
+    pub fn update(&mut self, out: &dyn Outputs, dt: f32, host: &mut dyn SpliceHost) {
+        self.env = out.level(7);
+        let deg = out.raw(0) as f32 * DEGREES;
+        let block = |v: usize, p: usize| [out.level(v) as f32 * LEVEL, out.pitch(p) as f32 * PITCH, deg, dt, 0.0, 1.0];
+        let (a, b) = self.pairs.split_at_mut(1);
+        let groups: [(&mut [Option<SoundId>], (usize, usize)); 3] = [(&mut a[0][..], (1, 2)), (&mut b[0][..], (3, 4)), (std::slice::from_mut(&mut self.single), (5, 6))];
+        for (sounds, (v, p)) in groups {
+            for sound in sounds.iter_mut() {
+                let Some(id) = *sound else { continue };
+                if host.alive(id) {
+                    host.update(id, block(v, p));
+                } else {
+                    host.release(id);
+                    *sound = None;
+                }
+            }
+        }
+    }
+
+    /// A sound of this object is live (the host takes the outputs only then).
+    pub fn sounding(&self) -> bool {
+        self.single.is_some() || self.pairs.iter().flatten().any(Option::is_some)
+    }
+
+    /// The update without a live sound: only level(7) is kept (the next start's env send).
+    pub fn latch_env(&mut self, level7: i32) {
+        self.env = level7;
+    }
+
+    pub fn release(&mut self, host: &mut dyn SpliceHost) {
+        for sound in self.pairs.iter_mut().flatten().chain(std::iter::once(&mut self.single)) {
+            if let Some(id) = sound.take() {
+                host.release(id);
+            }
+        }
+    }
+}
+
+pub const TAZER_CLASS: &str = "c_tazer";
+pub const TAZER_BANK: &str = "Tazer";
+pub const TAZER_WORDS: usize = 9;
+
+/// `SFXObj_Tazer` (Pedestrian object 3, vtable `0x822FCB60`, factory `sub_824F12D0`): process
+/// `sub_824F1478` posts the `c_tazer` packet (`sub_824B7950`, 9 words) when the ped audio state's
+/// tazer byte (`S+80`) is set and none is held, and releases it when the byte clears; update
+/// `sub_824F1560` rewrites it from the owner's outputs. The program (`Tazer.abk`) owns a child post
+/// to `c_tazer_grn_play` through AEMS op 38 and plays the zap burst while the packet is held: in
+/// the recomp (session 164620) every post was followed by Tazer starts 8, 7, then shuffles of 0–6
+/// at ~190 / 190 / 130 / 90–100 ms (49 starts over the session's three zaps).
+#[derive(Clone, Debug, Default)]
+pub struct PedTazer {
+    pub packet: Option<[i32; TAZER_WORDS]>,
+    /// Posts (diagnostics).
+    pub posts: u64,
+}
+
+impl PedTazer {
+    /// `sub_824B7950`: [32767, 0, 4096, 0, 25000, 0, 0, 0, the audio game block's G+4 byte (0 or 1)].
+    pub fn post_words(game_flag: bool) -> [i32; TAZER_WORDS] {
+        [32767, 0, 4096, 0, 25000, 0, 0, 0, i32::from(game_flag)]
+    }
+
+    /// vfunc 9 (`sub_824F1478`). `game_flag` = the audio game block's G+4 byte (`AudioState::global_224`,
+    /// 0 in free skate).
+    pub fn process(&mut self, owner: u64, s: &PedState, game_flag: bool) -> Vec<WorldCommand> {
+        if s.tazing {
+            if self.packet.is_none() {
+                let words = Self::post_words(game_flag);
+                self.packet = Some(words);
+                self.posts += 1;
+                return vec![WorldCommand::Post { owner, slot: WorldSlot::PedTazer, class: TAZER_CLASS, words: words.to_vec() }];
+            }
+        } else if self.packet.take().is_some() {
+            return vec![WorldCommand::Release { owner, slot: WorldSlot::PedTazer }];
+        }
+        Vec::new()
+    }
+
+    /// vfunc 10 (`sub_824F1560`): w1 = raw 0, w2 = pitch 1 (≤ 8192), w6 = level 3, w7 = level 2.
+    pub fn update(&mut self, owner: u64, out: &dyn Outputs) -> Vec<WorldCommand> {
+        let Some(w) = self.packet.as_mut() else { return Vec::new() };
+        w[1] = out.raw(0).clamp(0, 65535);
+        w[2] = out.pitch(1).clamp(0, 8192);
+        w[6] = out.level(3).clamp(0, 32767);
+        w[7] = out.level(2).clamp(0, 32767);
+        vec![WorldCommand::Redeliver { owner, slot: WorldSlot::PedTazer, words: w.to_vec() }]
+    }
+
+    pub fn release(&mut self, owner: u64) -> Vec<WorldCommand> {
+        if self.packet.take().is_some() { vec![WorldCommand::Release { owner, slot: WorldSlot::PedTazer }] } else { Vec::new() }
     }
 }
 
@@ -322,6 +594,7 @@ mod tests {
         starts: Vec<(String, u32, [f32; 6])>,
         released: Vec<SoundId>,
         next: u32,
+        dead: bool,
     }
 
     impl SpliceHost for Host {
@@ -333,7 +606,7 @@ mod tests {
         }
         fn update(&mut self, _: SoundId, _: [f32; 6]) {}
         fn alive(&self, _: SoundId) -> bool {
-            true
+            !self.dead
         }
         fn release(&mut self, s: SoundId) {
             self.released.push(s);
@@ -389,16 +662,85 @@ mod tests {
 
     #[test]
     fn speech_requests_on_value_changes_with_the_remap() {
+        let t = PedObjectTuning::default();
+        let mut h = Host::default();
         let mut sp = PedSpeech::default();
         let mut s = PedState { speech_value: 10, speech_measure: 5.0, speech_limit: 3.0, ..Default::default() };
-        assert_eq!(sp.process(1, &s), Some(SpeechRequest { owner: 1, value: 10, flag: 1 }));
-        assert_eq!(sp.process(1, &s), None);
+        assert_eq!(sp.process(1, &s, 0.033, false, &t, &mut h), Some(SpeechRequest { owner: 1, value: 10, flag: 1 }));
+        assert_eq!(sp.process(1, &s, 0.033, false, &t, &mut h), None);
         s.speech_value = 29;
-        sp.process(1, &s);
+        sp.process(1, &s, 0.033, false, &t, &mut h);
         s.speech_value = 7;
         s.speech_measure = 1.0;
-        assert_eq!(sp.process(1, &s), Some(SpeechRequest { owner: 1, value: 30, flag: 2 }));
+        assert_eq!(sp.process(1, &s, 0.033, false, &t, &mut h), Some(SpeechRequest { owner: 1, value: 30, flag: 2 }));
         s.speech_value = 8;
-        assert_eq!(sp.process(1, &s).map(|r| r.value), Some(51));
+        assert_eq!(sp.process(1, &s, 0.033, false, &t, &mut h).map(|r| r.value), Some(51));
+        // A fresh speaker starts from 68 (the constructor): value 0 is a change.
+        assert_eq!(PedSpeech::default().process(1, &PedState::default(), 0.033, false, &t, &mut h).map(|r| r.value), Some(0));
+    }
+
+    #[test]
+    fn the_photographer_repeats_while_the_flag_is_set() {
+        let t = PedObjectTuning::default();
+        let mut h = Host::default();
+        let mut sp = PedSpeech::default();
+        let s = PedState { speech_value: 29, ..Default::default() };
+        let fired: Vec<usize> = (0..95).filter(|_| sp.process(1, &s, 1.0 / 30.0, true, &t, &mut h).is_some()).collect();
+        // The change, then each time 1.0 s has accumulated: the frame that reaches it only adds,
+        // the next one fires and restarts at 0.
+        assert_eq!(fired.len(), 4, "{fired:?}");
+        assert_eq!(fired[0], 0);
+        assert!((30..=32).contains(&(fired[1] - fired[0])) && (30..=32).contains(&(fired[2] - fired[1])), "{fired:?}");
+        let mut sp = PedSpeech::default();
+        let n = (0..95).filter(|_| sp.process(1, &s, 1.0 / 30.0, false, &t, &mut h).is_some()).count();
+        assert_eq!(n, 1, "no repeat without the flag");
+    }
+
+    #[test]
+    fn value_49_rings_and_asks_for_the_answer_when_the_ring_ends() {
+        let t = PedObjectTuning::default();
+        let mut h = Host::default();
+        let mut sp = PedSpeech::default();
+        let s = PedState { speech_value: 49, speech_measure: 30.0, speech_limit: 20.0, ..Default::default() };
+        assert_eq!(sp.process(3, &s, 0.033, false, &t, &mut h), None);
+        assert_eq!(h.starts.len(), 1);
+        assert_eq!((h.starts[0].0.as_str(), h.starts[0].1), ("CellPhone_Rings", 5));
+        assert_eq!(sp.update(3, &s, 9000, &Flat, 0.033, &t, &mut h), None, "ringing");
+        h.dead = true;
+        assert_eq!(sp.update(3, &s, 9000, &Flat, 0.033, &t, &mut h), Some(SpeechRequest { owner: 3, value: 64, flag: 1 }));
+        assert!(sp.ring.is_none());
+    }
+
+    #[test]
+    fn body_falls_start_one_sound_per_event_and_round_robin_their_slots() {
+        let t = PedObjectTuning::default();
+        let mut h = Host::default();
+        let mut b = PedBodyFall::default();
+        // A knock-down pattern: 9, other, 9, 9 (with 0 between, or a repeat after a 0).
+        for v in [9.0, 0.0, 1.0, 0.0, 9.0, 0.0, 9.0, 9.0, 0.0] {
+            b.process(&PedState { body_fall: v, ..Default::default() }, &t, &mut h);
+        }
+        assert_eq!(h.starts.iter().map(|s| s.1).collect::<Vec<_>>(), vec![948, 1183, 948, 948]);
+        assert!(h.starts.iter().all(|s| s.0 == "Skate_Collisions" && s.2 == [0.0, 1.0, 0.0, 0.0, 1.0, 1.0]));
+        // The third 9 reuses the first type-9 slot: its sound (id 1) was stopped first.
+        assert_eq!(h.released, vec![1]);
+        b.update(&Flat, 0.033, &mut h);
+        assert_eq!(b.env, 25000, "level(7) latched for the next start");
+    }
+
+    #[test]
+    fn the_tazer_holds_its_packet_while_tazing() {
+        let mut z = PedTazer::default();
+        let mut s = PedState::default();
+        assert!(z.process(4, &s, false).is_empty());
+        s.tazing = true;
+        let c = z.process(4, &s, false);
+        assert_eq!(c, vec![WorldCommand::Post { owner: 4, slot: WorldSlot::PedTazer, class: TAZER_CLASS, words: vec![32767, 0, 4096, 0, 25000, 0, 0, 0, 0] }]);
+        assert!(z.process(4, &s, false).is_empty(), "held");
+        let u = z.update(4, &Flat);
+        let WorldCommand::Redeliver { words, .. } = &u[0] else { panic!() };
+        assert_eq!((words[1], words[2], words[6], words[7]), (100, 4096, 3000, 2000));
+        s.tazing = false;
+        assert_eq!(z.process(4, &s, false), vec![WorldCommand::Release { owner: 4, slot: WorldSlot::PedTazer }]);
     }
 }
diff --git a/crates/skate-audio/src/world/skater_speech.rs b/crates/skate-audio/src/world/skater_speech.rs
new file mode 100644
index 00000000..784f7696
--- /dev/null
+++ b/crates/skate-audio/src/world/skater_speech.rs
@@ -0,0 +1,164 @@
+//! NPC skaters' own speech (`SFXObj_PlayerSpeech`'s non-local process, `sub_824DA1B0`; spec
+//! `audio-specs/world-speech.md` "Main cast"): every skater with a speech record runs it, with no
+//! distance gate. Its inputs are the skater record's reaction bytes, which the instance bridge
+//! `sub_824B6E80` unpacks from the skater entry (`+392` / `+396` / `+388`); the AI sets those bits.
+//!
+//! - A **living-world voice** (`sub_824DAAC0`): a seen slam (`+102` or `+103`) says `104_spec_slam`
+//!   in game mode 55, `903_pc_slam_race` in modes 19 / 20, else `404_pc_miss_trick` or `405_pc_slam`
+//!   (`rand() & 1`, drawn every frame); a seen trick (`+104`) `101_pos`; the system's chase flag
+//!   (`+1100` bit 6) `105_spec_chase` when nothing else. A request goes out only when the chosen
+//!   event changes (`+44`).
+//! - A **main-cast voice** (a pro, `sub_824DA768`): a seen slam (`+102`, by `+112`) says
+//!   `104_slam` (event 1; `903_race_slam_pc` = 16 in modes 19 / 20) when the slammer is the player
+//!   (0) and `151_pro_slam` (288) with the slammer's words when it is a pro (1–29); `+103` (by
+//!   `+116`) the same without the race case; a seen trick (`+104`, by `+108`) `101_pos` (0) or
+//!   `150_pro_pos` (287). Each request goes out every frame the byte holds (the manager's timers
+//!   gate them).
+//! - **Its own crash** (`sub_824DB688`, `+131` rising, once until it clears): the message
+//!   [`super::speech_manager::main_cast::message::CRASH`] (`131_collide_object` / `906_aislm`).
+//!   (The cameraman's line it can also request is not ported.)
+use super::Draw;
+use super::speech_manager::main_cast::message;
+
+/// The game modes the choices test (system `+892`); free skate is none of them.
+pub const MODE_RACE_A: i32 = 19;
+pub const MODE_RACE_B: i32 = 20;
+pub const MODE_55: i32 = 55;
+
+/// The skater record's reaction bytes for one frame (what the AI sets; `sub_824B6E80`).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Reactions {
+    /// `+102` (entry `+392` bit 4): a slam was seen; `+112`: by which skater model (0 = the player).
+    pub slam: bool,
+    pub slam_by: u32,
+    /// `+103` (entry `+392` bit 3): a second slam reaction; `+116`: by whom.
+    pub slam_b: bool,
+    pub slam_b_by: u32,
+    /// `+104` (entry `+396` bit 10): a trick was seen; `+108`: by whom.
+    pub trick: bool,
+    pub trick_by: u32,
+    /// `+131` (entry `+388` bit 5): the skater's own crash.
+    pub crash: bool,
+    /// The system's chase flag (`+1100` bit 6).
+    pub chase: bool,
+}
+
+/// What the process asks the speech host for.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Say {
+    /// A living-world event (`sub_824ABA18`).
+    Living(u16),
+    /// A main-cast event (`sub_824AC560`), with the other skater's model for the pro-on-pro lines.
+    MainCast { event: u16, other: Option<u32> },
+    /// A skater speech message pair (`sub_824DAC00`): the speaker's kind picks the event.
+    Message(u16, u16),
+}
+
+/// One skater's process state (`+44` the last living-world event, `+193` the crash latch).
+#[derive(Clone, Debug)]
+pub struct SkaterSpeech {
+    last: u16,
+    crash_latch: bool,
+}
+
+impl Default for SkaterSpeech {
+    fn default() -> Self {
+        Self { last: 8318, crash_latch: false }
+    }
+}
+
+fn pro(model: u32) -> bool {
+    (1..30).contains(&model)
+}
+
+impl SkaterSpeech {
+    /// Nothing held: the process would do nothing on a frame without reactions.
+    pub fn idle(&self) -> bool {
+        self.last == 8318 && !self.crash_latch
+    }
+
+    /// One frame. `main_cast` = the speaker has no living-world voice (record `+100 == 0`).
+    pub fn process(&mut self, main_cast: bool, r: &Reactions, mode: i32, rng: &mut dyn Draw) -> Vec<Say> {
+        let mut out = Vec::new();
+        if main_cast {
+            if r.slam {
+                let event = if pro(r.slam_by) {
+                    288
+                } else if r.slam_by == 0 && (mode == MODE_RACE_A || mode == MODE_RACE_B) {
+                    16
+                } else {
+                    1
+                };
+                out.push(Say::MainCast { event, other: pro(r.slam_by).then_some(r.slam_by) });
+            }
+            if r.slam_b {
+                let event = if pro(r.slam_b_by) { 288 } else { 1 };
+                out.push(Say::MainCast { event, other: pro(r.slam_b_by).then_some(r.slam_b_by) });
+            }
+            if r.trick {
+                let event = if pro(r.trick_by) { 287 } else { 0 };
+                out.push(Say::MainCast { event, other: pro(r.trick_by).then_some(r.trick_by) });
+            }
+        } else {
+            let mut event = 8318u16;
+            if r.slam || r.slam_b {
+                event = match mode {
+                    MODE_55 => 8204,
+                    MODE_RACE_A | MODE_RACE_B => 8239,
+                    _ => 8234 | (rng.draw() & 1) as u16,
+                };
+            }
+            if r.trick {
+                event = 8202;
+            }
+            if r.chase && event == 8318 {
+                event = 8205;
+            }
+            if event != self.last {
+                self.last = event;
+                if event != 8318 {
+                    out.push(Say::Living(event));
+                }
+            }
+        }
+        // `sub_824DB688`.
+        if r.crash {
+            if !self.crash_latch {
+                out.push(Say::Message(message::CRASH.0, message::CRASH.1));
+                self.crash_latch = true;
+            }
+        } else {
+            self.crash_latch = false;
+        }
+        out
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_pro_reacts_to_the_player_and_to_pros_and_crashes_once() {
+        let mut s = SkaterSpeech::default();
+        let mut rng = || 0u32;
+        let r = Reactions { slam: true, ..Default::default() };
+        assert_eq!(s.process(true, &r, 0, &mut rng), vec![Say::MainCast { event: 1, other: None }]);
+        assert_eq!(s.process(true, &r, MODE_RACE_A, &mut rng), vec![Say::MainCast { event: 16, other: None }]);
+        let r = Reactions { trick: true, trick_by: 12, crash: true, ..Default::default() };
+        assert_eq!(s.process(true, &r, 0, &mut rng), vec![Say::MainCast { event: 287, other: Some(12) }, Say::Message(8229, 125)]);
+        assert_eq!(s.process(true, &r, 0, &mut rng), vec![Say::MainCast { event: 287, other: Some(12) }], "the crash latch holds");
+    }
+
+    #[test]
+    fn a_living_world_skater_requests_on_changes() {
+        let mut s = SkaterSpeech::default();
+        let mut one = || 1u32;
+        let r = Reactions { slam: true, ..Default::default() };
+        assert_eq!(s.process(false, &r, 0, &mut one), vec![Say::Living(8235)]);
+        assert!(s.process(false, &r, 0, &mut one).is_empty(), "unchanged");
+        assert_eq!(s.process(false, &Reactions { trick: true, ..r }, 0, &mut one), vec![Say::Living(8202)]);
+        assert!(s.process(false, &Reactions::default(), 0, &mut one).is_empty());
+        assert_eq!(s.process(false, &Reactions { chase: true, ..Default::default() }, 0, &mut one), vec![Say::Living(8205)]);
+    }
+}
diff --git a/crates/skate-audio/src/world/skaters.rs b/crates/skate-audio/src/world/skaters.rs
index c4a95353..5a546067 100644
--- a/crates/skate-audio/src/world/skaters.rs
+++ b/crates/skate-audio/src/world/skaters.rs
@@ -51,7 +51,12 @@
 //! - **The bail grunt**: the body poster's first message of a bail calls `sub_824BF5F8`, which
 //!   for a non-local skater sends its SkaterSpeech record message 8206 (event `201_grunt`) / 115
 //!   ([`NpcSkater::take_bail_grunt`]; the speech host plays it).
-//! - Board slide (slot 15): reached by neither instance in the runs; not run.
+//! - **Board slide** (slot 15, `c_board_slide`): SkateBoard's process `sub_824C6A78` calls
+//!   `sub_824CB3C8` and its update `sub_824CB4C0` for every instance with no local test; the
+//!   loose-board state they read (`+780`) is computed per skater entry by the conditioner
+//!   (`sub_827A1B78`, the per-skater loop) and copied by the instance bridge `sub_824B0DA8`, so an
+//!   NPC whose board lies loose (bail / on foot, deck contact, upside down or on its side) holds it
+//!   too ([`NpcSkaterAudioState::loose_board`]).
 //!
 //! The granular rolling bed's binds are collected in [`NpcSkater::routed`] for the host's NPC bed.
 use crate::mixmap::{MixMap, keys};
@@ -60,7 +65,7 @@ use crate::player::components::{Command, FootDrag, Grind, SenseOfSpeed, Skid, Sl
 use crate::player::contacts::{self, ContactsTuning, SpliceHost};
 use crate::player::inputs::{self, Physics};
 use crate::player::objpos::{Listener, ObjPos};
-use crate::player::rolling::{Rattle, Rolling, RollingInputs, Routed};
+use crate::player::rolling::{BoardSlide, Rattle, Rolling, RollingInputs, Routed};
 use crate::player::seams::{self, SeamCommand, Seams};
 use crate::player::clothing::{Clothing, ClothingTuning};
 use crate::player::tuning::PlayerTuning;
@@ -89,6 +94,11 @@ pub struct NpcSkaterAudioState {
     /// The skater's speech voice (its `aud_characteristics` model: the AI skaters' 89–96; 0 = none):
     /// the bail grunt's speaker.
     pub voice: u32,
+    /// The conditioner's loose-board state (`+780`: 0 none, 1 upside down, 2 on its side;
+    /// [`crate::player::rolling::loose_board`]): the board slide holds while it is set.
+    pub loose_board: u32,
+    /// The skater record's reaction bytes this frame ([`super::skater_speech`]: its own speech).
+    pub reactions: super::skater_speech::Reactions,
 }
 
 /// `sub_824B23C8` for a non-local skater: 1 when the local player's record `+84` (= its `+684`,
@@ -180,6 +190,8 @@ pub struct Parts {
     pub rolling: bool,
     /// The rattle (`Rolling_Rattles`).
     pub rattle: bool,
+    /// The loose board's slide (`board_scrapes`).
+    pub slide: bool,
     /// SFXObj_Contacts' Splice one-shots (`Skate_Collisions`) and the grind on / off sounds.
     pub contacts: bool,
     /// SFXObj_Wheels' spin-down streams (the install's two recordings).
@@ -214,6 +226,9 @@ pub struct NpcSkater {
     seams: Seams,
     rolling: Rolling,
     rattle: Rattle,
+    slide: BoardSlide,
+    /// The loose-board state of this pass (the host sets it before [`Self::process`]).
+    pub loose_board: u32,
     board: contacts::Contacts,
     wheels: Wheels,
     clothing: Clothing,
@@ -253,6 +268,8 @@ impl NpcSkater {
             seams,
             rolling: Rolling::default(),
             rattle: Rattle::default(),
+            slide: BoardSlide::default(),
+            loose_board: 0,
             board,
             wheels: Wheels::default(),
             clothing: Clothing::default(),
@@ -306,6 +323,10 @@ impl NpcSkater {
         if self.parts.rattle {
             cmds.extend(self.rattle.process(s, &self.rolling, &t.player.rolling));
         }
+        // SkateBoard's process: the routing, the rattle, then the board slide (as the local's).
+        if self.parts.slide {
+            cmds.extend(self.slide.process(self.loose_board, &t.player.rolling));
+        }
         let seam_cmds = Self::seam_commands(self.seams.process(s, t.player, m));
         let m: &MixMap = m;
         let mut c = self.grind.process(s, t.player, &Owner { mixmap: m, key: keys::rail(g) });
@@ -365,6 +386,9 @@ impl NpcSkater {
         if self.parts.rattle {
             c.extend(self.rattle.update(&board));
         }
+        if self.parts.slide {
+            c.extend(self.slide.update(s, self.loose_board, &t.player.rolling, &board));
+        }
         if self.parts.contacts {
             self.grind.sounds(s, t.player, splice);
             self.grind.update_sounds(s, &rail, splice);
diff --git a/crates/skate-audio/src/world/speech.rs b/crates/skate-audio/src/world/speech.rs
index 21e2f85d..c2aa01d8 100644
--- a/crates/skate-audio/src/world/speech.rs
+++ b/crates/skate-audio/src/world/speech.rs
@@ -242,6 +242,8 @@ pub fn choose(index: &SpeechIndex, cues: &[Cue], voice: u32, last: &mut HashMap<
 /// The mixer bank the decoded takes live in ([`crate::mixer::Mixer::add_bank`]; slot = the take's
 /// running number over the index, [`SpeechSlots`]).
 pub const SPEECH_BANK: usize = 1 << 22;
+/// The main cast's takes (`maincastspeech.big`), slots as in [`SPEECH_BANK`] over its own index.
+pub const MAIN_CAST_BANK: usize = SPEECH_BANK + 1;
 
 /// (clip, take) → mixer slot of [`SPEECH_BANK`].
 #[derive(Clone, Debug, Default)]
diff --git a/crates/skate-audio/src/world/speech_manager.rs b/crates/skate-audio/src/world/speech_manager.rs
index ba434557..c86e6da8 100644
--- a/crates/skate-audio/src/world/speech_manager.rs
+++ b/crates/skate-audio/src/world/speech_manager.rs
@@ -33,10 +33,10 @@
 //! The interrupt rules (`sub_824A73F0`: tuning `+13` / `+14` against the playing line's priority)
 //! and the streams are [`super::speech_player`]'s.
 //!
-//! **Not ported:**
-//! - the main-cast path for peds without a living-world speaker (`+116 == 0`: pros, `sub_824AC438`);
-//! - the extra main-cast line of value 6 (`+71`);
-//! - the speech level (`audio-specs/world-speech.md` "Level").
+//! The main cast (pros, the special cast) uses [`main_cast`] and [`SpeechManager::request_main_cast`]
+//! with its own manager instance.
+//!
+//! **Not ported:** the extra main-cast line of value 6 (`+71`).
 use std::collections::HashMap;
 
 use super::Draw;
@@ -116,6 +116,76 @@ pub fn event_for_value(value: i32, speaker_kind: u32, rng: &mut dyn Draw) -> Opt
     })
 }
 
+/// The main-cast (bank 0) speech: pros (and the special cast) speak through the same manager logic
+/// with the main cast's tuning (`speech_tuning["0"]`), event table and takes (`sub_824AC560`).
+pub mod main_cast {
+    use super::Draw;
+
+    /// Request words of a main-cast speaker: `w[0]` the cast bit (`aud_characteristics`
+    /// `6F2933E977CF40DD`, the speaker record's `+84`), `w[1]` the cast word (`14FD437D190677C8`,
+    /// `+88`: the special cast 30–38), `w[2]` the flag (1 near, 2 far: the main cast's sense is the
+    /// living world's inverted), `w[3]` the living-world switch (0), `w[4]` / `w[5]` another skater's
+    /// cast bit / word (`D6EA428C2B43E23A`; the pro-on-pro lines 150 / 151), the rest 0.
+    pub type Block = [u32; 14];
+
+    pub const NEAR: u32 = 1;
+    pub const FAR: u32 = 2;
+
+    /// `sub_824AC898`: the words an event's library request carries, in field order.
+    pub fn request_words(event: u16, w: &Block) -> Vec<u32> {
+        match event {
+            0 | 1 => vec![w[1], w[0], w[2]],
+            247 => vec![w[0], w[9], w[1]],
+            251 => vec![w[0], w[1], w[10]],
+            254 => vec![w[1], w[5], w[0], w[4]],
+            268 => vec![w[0], w[1], w[11]],
+            271 | 274 | 275 => vec![w[0], w[1], w[12]],
+            280 => vec![w[0], w[1], w[13]],
+            287 | 288 => vec![w[1], w[0], w[4], w[5]],
+            _ => vec![w[0], w[1]],
+        }
+    }
+
+    /// `sub_824AC438`: a ped's speech value on the main-cast path (a ped without a living-world
+    /// speaker, `S+116 == 0`), or None. 28 (`601_ai_greet`) only outside a challenge
+    /// (`sub_82487ED0` / system `+1196`); 30 / 51 also stop the speaker's playing line.
+    pub fn event_for_value(value: i32, in_challenge: bool, rng: &mut dyn Draw) -> Option<u16> {
+        Some(match value {
+            29 => 141,
+            28 if !in_challenge => 11,
+            30 | 51 => {
+                if rng.draw() & 1 == 1 {
+                    115
+                } else {
+                    6
+                }
+            }
+            53 | 54 => 77,
+            _ => return None,
+        })
+    }
+
+    /// The (living-world, main-cast) event pairs of the skater speech messages (`sub_824DAC00`:
+    /// a speaker with a living-world voice says the first, a main-cast speaker the second; 8318 /
+    /// 294 = none). Senders read from the code.
+    pub mod message {
+        /// The bail grunt (body poster `sub_824BF5F8`).
+        pub const BAIL_GRUNT: (u16, u16) = (8206, 115);
+        /// An NPC skater's own crash (`SFXObj_PlayerSpeech` `sub_824DB688`, its record's `+131`
+        /// rising): `131_collide_object` / `906_aislm`.
+        pub const CRASH: (u16, u16) = (8229, 125);
+        /// Collisions between skaters (`sub_824BD358`): `202_impact_react` …
+        pub const IMPACT: (u16, u16) = (8233, 6);
+        /// … and the AI's own slam reaction there.
+        pub const IMPACT_SLAM: (u16, u16) = (8241, 125);
+        /// `sub_824EFA60`: `344_HitReaction` / `913_RacePunch` pairs.
+        pub const HIT_REACTION: (u16, u16) = (8309, 253);
+        pub const RACE_PUNCH: (u16, u16) = (8310, 250);
+        /// `sub_824F8778`: the gesture (`338_gesture` / `338_gestures`).
+        pub const GESTURE: (u16, u16) = (8291, 247);
+    }
+}
+
 /// What the ped's audio state holds for its speech.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub struct Speaker {
@@ -360,6 +430,33 @@ impl SpeechManager {
         self.started(speaker.index, event, inputs.now);
         Ok(Line { event, picks })
     }
+
+    /// A main-cast request (`sub_824AC560`: the same timers / gate with the main cast's tuning, then
+    /// `sub_824AC898`'s words). `speaker` = the speaker slot the timers are kept for. This manager
+    /// must hold the main cast's tuning (`speech_tuning["0"]`). Not ported: the repeat time of
+    /// speaker slots 30 / 31 (the record's `+52` / `+56`).
+    #[allow(clippy::too_many_arguments)]
+    pub fn request_main_cast(
+        &mut self,
+        library: &mut Library,
+        table: &EventTable,
+        event: u16,
+        speaker: u32,
+        block: &main_cast::Block,
+        inputs: &GateInputs,
+        rng: &mut dyn Draw,
+    ) -> Result<Line, Refusal> {
+        if event == 294 {
+            return Err(Refusal::NoEvent);
+        }
+        let default = EventTuning::default();
+        let tuning = self.tuning.get(&event).unwrap_or(&default);
+        self.gate(speaker, event, tuning, inputs, rng)?;
+        let words = main_cast::request_words(event, block);
+        let picks = library.start(table, event, &words).map_err(Refusal::Library)?;
+        self.started(speaker, event, inputs.now);
+        Ok(Line { event, picks })
+    }
 }
 
 /// The (type bit, variant bit) the records give a clip voice id (the number in the clip names),
diff --git a/crates/skate-audio/src/world/speech_player.rs b/crates/skate-audio/src/world/speech_player.rs
index ab0a3b1a..ea8f0a6a 100644
--- a/crates/skate-audio/src/world/speech_player.rs
+++ b/crates/skate-audio/src/world/speech_player.rs
@@ -1,4 +1,4 @@
-//! The speech streams of one speech channel (the living world's): the lines the speech manager
+//! The speech streams of one speech channel (0 = the main cast, 1 = the living world): the lines the speech manager
 //! starts ([`super::speech_manager`]), played as stream voices whose level, send, pitch, pan and
 //! filters follow the speaker's MixMap owner every console frame. Read from the TU3 recompilation
 //! (reference only; addresses are facts):
@@ -12,32 +12,42 @@
 //!   variant). For a regular ped that is PedestrianSpeech out2 / out3 with out15 as the second;
 //!   the filters are out13 (high pass) and out14 (low pass) ([`ped_outputs`]). For a skater with
 //!   a living-world voice (model ≥ 41) PlayerSpeech out2 / out3, second out10, filters out8 / out9
-//!   ([`skater_outputs`]).
+//!   ([`skater_outputs`]). The block also carries the echo send (ped out21, skater out13), the
+//!   echo's filters (ped 22 / 23, skater 14 / 15) and, every [`SpeechVoiceTuning::delay_frames`]
+//!   console frames, the echo delay from the camera distance.
+//! - **Block → voice** (the stream system, `sub_82C5CEF0`, every frame): the voice gain = the
+//!   level / 32767 × the speaker's per-voice float (`S+152`, `aud_characteristics`
+//!   `2087A3290483BB4F`, 0.8–1.4); the post-filter send (`desc+32`, the second level × the float)
+//!   goes to the environment bus; the pre-gain send (`desc+16`, the echo send × the float) feeds the
+//!   stream slot's echo submix (`crate::bus::speech_echo`: HPF → delay → LPF → the environment bus);
+//!   PEAK = [`SpeechVoiceTuning::peak`] of the azimuth.
 //! - **The recomp agrees** (sessions 163809 / 164620 / 180430, the local tool `speech_levels.py`,
 //!   skate-game test `speech_levels_follow_the_recomp`, 39 lines rebuilt at their geometry): a
 //!   speech stream's LPF / HPF sit at exactly 24956 / 77 Hz near the speaker and 3489 / 379 Hz far
 //!   away, our out14 / out13; its first GAIN over ours has median 1.005 (p10 0.55, p90 1.43); `_f`
 //!   lines at 30 / 40 m play at 0.092 / 0.044 against our out3's 0.085 / 0.056, where out2 has fallen
-//!   to 0.030 / 0.001. The SEND matches out15 on some lines (0.035 at 3.6 m, 0.049 at 11 m) but only
-//!   10 of 37 overall: open. Note: the level lookups measure the distance to the followed skater
-//!   (3DObjPos input 0), the near / far flag the camera distance.
+//!   to 0.030 / 0.001. With the voice float the gain median is 0.988 (p10 0.55, p90 1.36); the
+//!   pre-gain send (`+0x570`) is out21 within 25 % in 17 of 29 lines (out15: 10), the env send
+//!   (`+0x7D0`) out15 in 19 of 27; every recomp PEAK lies on the curves. Note: the level lookups
+//!   measure the distance to the followed skater (3DObjPos input 0), the near / far flag the
+//!   camera distance.
 //! - **Two streams per channel** (`sub_824A73F0` indexes the channel's stream records as
 //!   `channel × 2 + k`; the recomp's living-world lines play on two stream players). A request
 //!   takes a free stream. When none is free, the event's tuning decides (`sub_824A73F0`): `+13`
 //!   lets it stop a playing line of lower priority, `+14` the same when the channel is full;
 //!   otherwise it waits in the library's 16-request queue until its event's queue timeout
-//!   (`.evt` `+2`) runs out. Which of the two streams a request targets (`k`) is not traced: the
+//!   (`.evt` `+2`) runs out. Its unit: the queue clock is `[[0x830CFD94]+16]`, the game's visual
+//!   tick (the `GetVisualGameTick` Lua binding, one per rendered frame); the port counts console
+//!   frames (the console renders at its ~30 fps cadence). Which of the two streams a request targets (`k`) is not traced: the
 //!   lower-priority one is taken (provisional).
 //! - **The cut** (`sub_824D9370`): while a line plays, a speaker whose main level stays at or below
 //!   200 (vault `6995C510258C9AF6`) for more than 60 console frames (`3D8CD05C962FF399`) has its
 //!   line stopped. A speaker that loses its MixMap instance stops its line too (deactivation
 //!   `sub_824D92B0` / `sub_824DA110`).
 //!
-//! Not modelled: the speech voice's PEAK filter (≈3.1–4 kHz, gain 0.21–0.26, Q 3 in the recomp;
-//! its writer is not found), the per-voice float `aud_characteristics` `2087A3290483BB4F` (0.8–1.15;
-//! the recomp's pitch follows out1 alone), the `Obj:Speech` inputs a playing line sets (their
-//! ducks), the "focus speaker" levels (out24 / out16 by a game global) and the event queue
-//! timeout's unit (taken as console frames).
+//! Not modelled: the "focus speaker" levels (out24 / out16 by a game global), the echo graph's
+//! two-channel Pn21 / Sen0 routing gains (modelled as a mono unity tap) and which of the two
+//! streams a full channel targets.
 use std::collections::VecDeque;
 
 use super::speech::{Line, SpeechIndex};
@@ -106,43 +116,163 @@ pub fn skater_level_ids(model: u32, far: bool) -> (usize, usize) {
 /// reader).
 pub const PED_FILTERS: [usize; 2] = [13, 14];
 pub const SKATER_FILTERS: [usize; 2] = [8, 9];
+/// The level each owner kind copies as the stream voice's pre-gain send (into the stream slot's
+/// echo submix, `crate::bus::speech_echo`): PedestrianSpeech out21 (`sub_824D9370` → block `+80`),
+/// PlayerSpeech out13 (`sub_824DA300`). Recomp: the voice's first send module (`+0x570`, before
+/// the gain) follows it. The echo's filters: ped 22 / 23, skater 14 / 15.
+pub const PED_SEND_A: usize = 21;
+pub const SKATER_SEND_A: usize = 13;
+pub const PED_ECHO_FILTERS: [usize; 2] = [22, 23];
+pub const SKATER_ECHO_FILTERS: [usize; 2] = [14, 15];
+/// Every filter output a snapshot must read with the filter reader.
+pub const PED_SNAPSHOT_FILTERS: [usize; 4] = [13, 14, 22, 23];
+pub const SKATER_SNAPSHOT_FILTERS: [usize; 4] = [8, 9, 14, 15];
+
+/// An 8-point vault curve (`Sk8::PointNegGraphData8`: x at `+16`, y at `+48`), evaluated as
+/// `sub_82481E10(8, …)`: below x0 → y0, from x7 on → y7, else the linear piece (`fmadds`).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Graph8 {
+    pub x: [f32; 8],
+    pub y: [f32; 8],
+}
+
+impl Graph8 {
+    pub fn eval(&self, v: f32) -> f32 {
+        let (x, y) = (&self.x, &self.y);
+        if v < x[0] {
+            return y[0];
+        }
+        if !(v < x[7]) {
+            return y[7];
+        }
+        for i in 1..8 {
+            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 stream voice's PEAK filter by the speaker's azimuth (both speech owners' updates,
+/// `sub_824D9370` / `sub_824DA300`): the owner's raw azimuth (output 0, 0..65535) folded to the
+/// front / back angle (above 32767 → 65536 − raw), then three curves of the speech record
+/// (class `B29C3B2C13D96482` `default`, holder `*(0x830CFDA4)+44`): centre `2C166907CF51DB88`
+/// (600 Hz at the front, 4000 at the side, 600 behind), gain `EA2C18D9CE5CBA3A` (0.4 → 0.1),
+/// Q `CF8679F540B82B2B` (3). Setup export `world_tuning.speech_voice`; the defaults are the shipped
+/// curves. Recomp (163809): every speech voice's PEAK (centre, gain) lies on the two curves at one
+/// azimuth.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SpeechVoiceTuning {
+    pub peak_freq: Graph8,
+    pub peak_gain: Graph8,
+    pub peak_q: Graph8,
+    /// The echo delay (`sub_824D9370`): camera distance × this (field `BF48032DB145C5B4`, 1.0) ×
+    /// [`Self::per_metre`] (the image's 1/344 s at `0x822F940C`), at most [`Self::max_delay`]
+    /// (0.15 s), recomputed every [`Self::delay_frames`] console frames (field `510BAFA32A76B340`, 4).
+    pub delay_factor: f32,
+    pub per_metre: f32,
+    pub max_delay: f32,
+    pub delay_frames: u32,
+}
+
+impl Default for SpeechVoiceTuning {
+    fn default() -> Self {
+        Self {
+            peak_freq: Graph8 {
+                x: [0.0, 2614.956, 5603.478, 8325.166, 15796.47, 21666.78, 25829.36, 32767.0],
+                y: [600.0, 1195.0, 1802.143, 2336.429, 4000.0, 2676.428, 1838.571, 600.0],
+            },
+            peak_gain: Graph8 {
+                x: [0.0, 4162.583, 8378.532, 12114.18, 16063.3, 21079.75, 26416.39, 32767.0],
+                y: [0.4, 0.34, 0.291786, 0.2575, 0.222143, 0.185714, 0.143929, 0.1],
+            },
+            peak_q: Graph8 { x: [0.0, 4095.875, 8191.75, 12287.63, 16383.5, 20479.38, 24575.25, 28671.13], y: [3.0; 8] },
+            delay_factor: 1.0,
+            per_metre: f32::from_bits(0x3B3E_82FA),
+            max_delay: f32::from_bits(0x3E19_999A),
+            delay_frames: 4,
+        }
+    }
+}
+
+impl SpeechVoiceTuning {
+    /// (centre Hz, linear gain, Q) for an owner's raw azimuth.
+    pub fn peak(&self, raw_azimuth: i32) -> [f32; 3] {
+        let a = raw_azimuth as f32;
+        let a = if a > 32767.0 { 65536.0 - a } else { a };
+        [self.peak_freq.eval(a), self.peak_gain.eval(a), self.peak_q.eval(a)]
+    }
+
+    /// The echo delay for a speaker `distance` m from the camera (`fsel`: the smaller of the two).
+    pub fn delay(&self, distance: f32) -> f32 {
+        let d = self.delay_factor * distance * self.per_metre;
+        if self.max_delay - d >= 0.0 { d } else { self.max_delay }
+    }
+}
 
 /// One frame's stream values.
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct VoiceParams {
     /// The owner's main level (raw, 0..32767: the cut reads it).
     pub level: i32,
+    /// The voice's gain: main level / 32767 × the speaker's per-voice float (`S+152`,
+    /// `aud_characteristics` `2087A3290483BB4F`; `sub_82C5CEF0` multiplies the gain and both sends).
     pub gain: f32,
-    /// The environment (reverb) send.
+    /// The post-filter send into the environment bus: the owner's second level (ped out15…, skater
+    /// out10…; recomp send module `+0x7D0`) × the voice float.
     pub send: f32,
+    /// The pre-gain send into the stream slot's echo submix ([`PED_SEND_A`] / [`SKATER_SEND_A`];
+    /// recomp send module `+0x570`) × the voice float, and the echo's filters (Hz).
+    pub echo: f32,
+    pub echo_hpf: f32,
+    pub echo_lpf: f32,
+    /// The echo delay (s) when it is due ([`SpeechVoiceTuning::delay`]); None = unchanged.
+    pub delay: Option<f32>,
+    /// The echo slot (the channel's stream: channel × 2 + k), set by the player.
+    pub slot: u8,
     pub pitch: f32,
     /// Degrees.
     pub azimuth: f32,
     pub hpf: f32,
     pub lpf: f32,
+    /// The PEAK filter (centre Hz, linear gain, Q) ([`SpeechVoiceTuning::peak`]).
+    pub peak: [f32; 3],
 }
 
-fn params(out: &dyn Outputs, ids: (usize, usize), filters: [usize; 2]) -> VoiceParams {
+#[allow(clippy::too_many_arguments)]
+fn params(out: &dyn Outputs, ids: (usize, usize), send_a: usize, filters: [usize; 2], echo_filters: [usize; 2], voice: &SpeechVoiceTuning, scale: f32) -> VoiceParams {
     let level = out.level(ids.0).clamp(0, 32767);
     VoiceParams {
         level,
-        gain: level as f32 * INV_32767,
-        send: out.level(ids.1).clamp(0, 32767) as f32 * INV_32767,
+        gain: level as f32 * INV_32767 * scale,
+        send: out.level(ids.1).clamp(0, 32767) as f32 * INV_32767 * scale,
+        echo: out.level(send_a).clamp(0, 32767) as f32 * INV_32767 * scale,
+        echo_hpf: out.level(echo_filters[0]) as f32,
+        echo_lpf: out.level(echo_filters[1]) as f32,
+        delay: None,
+        slot: 0,
         pitch: out.pitch(1).max(1) as f32 * INV_4096,
         azimuth: out.raw(0) as f32 * DEGREES,
         hpf: out.level(filters[0]) as f32,
         lpf: out.level(filters[1]) as f32,
+        peak: voice.peak(out.raw(0)),
     }
 }
 
-/// A ped speaker's values (`out` = a PedestrianSpeech snapshot with [`PED_FILTERS`] read as filters).
-pub fn ped_outputs(out: &dyn Outputs, sel: PedLevelSelect, event: u16, far: bool) -> VoiceParams {
-    params(out, ped_level_ids(sel, event, far), PED_FILTERS)
+/// A ped speaker's values (`out` = a PedestrianSpeech snapshot with [`PED_SNAPSHOT_FILTERS`] read
+/// as filters; `scale` = the speaker's per-voice float).
+pub fn ped_outputs(out: &dyn Outputs, sel: PedLevelSelect, event: u16, far: bool, voice: &SpeechVoiceTuning, scale: f32) -> VoiceParams {
+    params(out, ped_level_ids(sel, event, far), PED_SEND_A, PED_FILTERS, PED_ECHO_FILTERS, voice, scale)
 }
 
-/// A skater speaker's values (`out` = a PlayerSpeech snapshot with [`SKATER_FILTERS`] as filters).
-pub fn skater_outputs(out: &dyn Outputs, model: u32, far: bool) -> VoiceParams {
-    params(out, skater_level_ids(model, far), SKATER_FILTERS)
+/// A skater speaker's values (`out` = a PlayerSpeech snapshot with [`SKATER_SNAPSHOT_FILTERS`]).
+pub fn skater_outputs(out: &dyn Outputs, model: u32, far: bool, voice: &SpeechVoiceTuning, scale: f32) -> VoiceParams {
+    params(out, skater_level_ids(model, far), SKATER_SEND_A, SKATER_FILTERS, SKATER_ECHO_FILTERS, voice, scale)
 }
 
 /// `sub_824A89E8`: the clip is a far line (its name ends in `_f`).
@@ -213,6 +343,9 @@ pub enum Event {
 /// One speech channel's streams and queue.
 #[derive(Clone, Debug, Default)]
 pub struct SpeechPlayer {
+    /// The speech channel (0 = the main cast, 1 = the living world): its streams' echo slots are
+    /// channel × 2 + k.
+    pub channel: u8,
     streams: [Option<Stream>; STREAMS],
     queue: VecDeque<(Request, u32)>,
     /// Counters (diagnostics).
@@ -223,6 +356,11 @@ pub struct SpeechPlayer {
 }
 
 impl SpeechPlayer {
+    /// A player for speech channel `channel`.
+    pub fn on_channel(channel: u8) -> Self {
+        Self { channel, ..Default::default() }
+    }
+
     /// The speakers whose lines play now.
     pub fn speakers(&self) -> impl Iterator<Item = u64> + '_ {
         self.streams.iter().flatten().map(|s| s.req.speaker)
@@ -307,7 +445,8 @@ impl SpeechPlayer {
             let Some(mut s) = self.streams[k].take() else { continue };
             let line = s.req.lines[s.at];
             let far = index.clips.get(line.clip).is_some_and(|c| far_clip(&c.name));
-            let Some(p) = speaker(s.req.speaker, far, s.req.event) else {
+            let slot = self.channel * 2 + k as u8;
+            let Some(mut p) = speaker(s.req.speaker, far, s.req.event) else {
                 if let Some(v) = s.voice {
                     voices.stop(v);
                 }
@@ -328,6 +467,7 @@ impl SpeechPlayer {
             } else {
                 s.low = 0;
             }
+            p.slot = slot;
             match s.voice {
                 Some(v) if voices.alive(v) => voices.set(v, &p),
                 Some(v) => {
@@ -340,7 +480,8 @@ impl SpeechPlayer {
                     }
                     let line = s.req.lines[s.at];
                     let far = index.clips.get(line.clip).is_some_and(|c| far_clip(&c.name));
-                    let p = speaker(s.req.speaker, far, s.req.event).unwrap_or(p);
+                    let mut p = speaker(s.req.speaker, far, s.req.event).unwrap_or(p);
+                    p.slot = slot;
                     s.voice = voices.open(line, &p);
                     if s.voice.is_some() {
                         events.push(Event::Started { k, speaker: s.req.speaker, line });
@@ -440,11 +581,36 @@ mod tests {
         assert_eq!(skater_level_ids(91, false), (2, 10));
         assert_eq!(skater_level_ids(12, true), (5, 12));
         assert!(far_clip("501_59_busm1_Warn_f.dat") && !far_clip("101_51_GenPos_Grn1_far.dat") && !far_clip("501_59_busm1_Warn_n.dat"));
-        let p = ped_outputs(&Out(9804), PedLevelSelect::default(), 8210, false);
+        let p = ped_outputs(&Out(9804), PedLevelSelect::default(), 8210, false, &SpeechVoiceTuning::default(), 1.0);
         assert_eq!((p.level, p.hpf, p.lpf), (9804, 77.0, 24956.0));
-        assert!((p.send - 1196.0 / 32767.0).abs() < 1e-6 && (p.pitch - 4086.0 / 4096.0).abs() < 1e-6);
+        // The env send = out15 (post-filter), the echo send = out21 (pre-gain).
+        assert!((p.send - 1196.0 / 32767.0).abs() < 1e-6 && (p.echo - 2100.0 / 32767.0).abs() < 1e-6 && (p.pitch - 4086.0 / 4096.0).abs() < 1e-6);
         assert!((p.azimuth - 16384.0 * 360.0 / 65535.0).abs() < 1e-2);
-        assert_eq!(ped_outputs(&Out(9804), PedLevelSelect::default(), 8210, true).level, 2903);
+        // Raw 16384 = just past the side: the PEAK curves' 4000 Hz / 0.222 region.
+        assert_eq!(p.peak, SpeechVoiceTuning::default().peak(16384));
+        assert!((p.peak[0] - 3867.5).abs() < 1.0 && (p.peak[1] - 0.2198).abs() < 1e-3 && p.peak[2] == 3.0, "{:?}", p.peak);
+        assert_eq!(ped_outputs(&Out(9804), PedLevelSelect::default(), 8210, true, &SpeechVoiceTuning::default(), 1.0).level, 2903);
+    }
+
+    #[test]
+    fn the_echo_delay_is_the_sound_travel_time_up_to_150_ms() {
+        let t = SpeechVoiceTuning::default();
+        assert!((t.delay(34.4) - 0.1).abs() < 1e-5);
+        assert_eq!(t.delay(100.0), t.max_delay);
+        assert!((t.max_delay - 0.15).abs() < 1e-7);
+        assert_eq!(t.delay(0.0), 0.0);
+    }
+
+    #[test]
+    fn the_peak_follows_the_folded_azimuth_on_the_curves() {
+        let t = SpeechVoiceTuning::default();
+        // Recomp 163809 at 69.0 s: PEAK 1244.58 Hz, gain 0.3588, Q 3, with our owner's raw azimuth
+        // 62673 at that line's geometry (folded: 2863).
+        let p = t.peak(62673);
+        assert!((p[0] - 1244.58).abs() < 1.5 && (p[1] - 0.3588).abs() < 2e-4 && p[2] == 3.0, "{p:?}");
+        assert_eq!(t.peak(65536 - 5000), t.peak(5000), "front / back fold");
+        assert_eq!(t.peak(0), [600.0, 0.4, 3.0]);
+        assert_eq!(t.peak(32767), [600.0, 0.1, 3.0]);
     }
 
     #[test]
@@ -457,30 +623,30 @@ mod tests {
         assert_eq!(p.request(req(3, 0, 510, false), &mut v), Outcome::Queued, "no interrupt byte: it waits");
         assert_eq!(p.request(req(4, 0, 510, true), &mut v), Outcome::Interrupted(0), "beats the 500 line");
         let mut level = 9000;
-        let ev = p.frame(&ix, &mut |_, _, _| Some(ped_outputs(&Out(level), PedLevelSelect::default(), 8210, false)), &mut v);
+        let ev = p.frame(&ix, &mut |_, _, _| Some(ped_outputs(&Out(level), PedLevelSelect::default(), 8210, false, &SpeechVoiceTuning::default(), 1.0)), &mut v);
         assert_eq!(ev.iter().filter(|e| matches!(e, Event::Started { .. })).count(), 2);
         assert_eq!(v.opened.len(), 2);
         // Speaker 2's line is far: out3.
         assert_eq!(p.speakers().collect::<Vec<_>>(), vec![4, 2]);
         // The queued request expires after its timeout (3 frames).
         for _ in 0..3 {
-            p.frame(&ix, &mut |_, far, _| Some(ped_outputs(&Out(level), PedLevelSelect::default(), 8210, far)), &mut v);
+            p.frame(&ix, &mut |_, far, _| Some(ped_outputs(&Out(level), PedLevelSelect::default(), 8210, far, &SpeechVoiceTuning::default(), 1.0)), &mut v);
         }
         assert_eq!(p.queued(), 0);
         // The cut: 61 frames at or below 200.
         level = 150;
         let mut cut = 0;
         for _ in 0..61 {
-            let ev = p.frame(&ix, &mut |s, far, _| (s == 4).then(|| ped_outputs(&Out(level), PedLevelSelect::default(), 8210, far)), &mut v);
+            let ev = p.frame(&ix, &mut |s, far, _| (s == 4).then(|| ped_outputs(&Out(level), PedLevelSelect::default(), 8210, far, &SpeechVoiceTuning::default(), 1.0)), &mut v);
             cut += ev.iter().filter(|e| matches!(e, Event::Cut { .. })).count();
         }
         assert_eq!(cut, 1, "speaker 4 cut; speaker 2 went away at once");
         assert_eq!(p.busy(), 0);
         // A finished take ends the line.
         assert_eq!(p.request(req(5, 0, 500, false), &mut v), Outcome::Playing(0));
-        p.frame(&ix, &mut |_, _, _| Some(ped_outputs(&Out(9000), PedLevelSelect::default(), 8210, false)), &mut v);
+        p.frame(&ix, &mut |_, _, _| Some(ped_outputs(&Out(9000), PedLevelSelect::default(), 8210, false, &SpeechVoiceTuning::default(), 1.0)), &mut v);
         v.live.clear();
-        let ev = p.frame(&ix, &mut |_, _, _| Some(ped_outputs(&Out(9000), PedLevelSelect::default(), 8210, false)), &mut v);
+        let ev = p.frame(&ix, &mut |_, _, _| Some(ped_outputs(&Out(9000), PedLevelSelect::default(), 8210, false, &SpeechVoiceTuning::default(), 1.0)), &mut v);
         assert_eq!(ev, vec![Event::Finished { k: 0, speaker: 5 }]);
     }
 }
diff --git a/crates/skate-audio/tests/world_sources.rs b/crates/skate-audio/tests/world_sources.rs
index a96ddab4..f8c233bf 100644
--- a/crates/skate-audio/tests/world_sources.rs
+++ b/crates/skate-audio/tests/world_sources.rs
@@ -406,3 +406,28 @@ fn a_bumped_ped_warns_with_a_line_of_its_voice() {
     assert!(peak > 0.01);
     assert!((frames as f32 * DT - seconds).abs() < 0.2, "{} frames for {seconds} s", frames);
 }
+
+/// The phone ring of speech value 49 (data-gated: the disc's `CellPhone_Rings.bnk`): the
+/// container (`PedObjectTuning::ring_id`, 5) picks one of its records; each plays its members at
+/// their delays, so a ring lasts the record's latest member end (delay + length). The recomp's two
+/// rings (session 164620) were answered (the `4402_*_HelCel` line's read) 1.00 s and 1.19 s after
+/// the ring's start: inside the records' range.
+#[test]
+#[ignore = "needs the private disc banks"]
+fn the_phone_ring_lasts_until_the_recomp_answers() {
+    let Some(dir) = private_data::splc_banks() else { panic!("missing private data: no SPLC banks") };
+    let t = skate_audio::world::peds::PedObjectTuning::default();
+    let Ok(bytes) = std::fs::read(dir.join(format!("{}.bnk", t.ring_bank))) else { panic!("missing private data: no {}.bnk", t.ring_bank) };
+    let bank = SpliceBank::parse(&bytes).unwrap();
+    let id = t.ring_id as usize;
+    let records: Vec<usize> = if id < bank.records.len() { vec![id] } else { bank.containers[id - bank.records.len()].ids.iter().map(|&r| usize::from(r)).collect() };
+    let ends: Vec<f32> = records
+        .iter()
+        .map(|&r| bank.records[r].groups.iter().flat_map(|g| g.members.iter()).map(|m| m.delay + m.length).fold(0.0f32, f32::max))
+        .collect();
+    let (lo, hi) = (ends.iter().copied().fold(f32::MAX, f32::min), ends.iter().copied().fold(0.0f32, f32::max));
+    eprintln!("ring container {id}: records {records:?}, ends {ends:?} s");
+    for answered in [1.00f32, 1.19] {
+        assert!(lo - 0.1 <= answered && answered <= hi + 0.15, "answer at {answered} s outside the rings' {lo:.2}..{hi:.2} s");
+    }
+}
diff --git a/crates/skate-game/src/game_audio/npc_skaters.rs b/crates/skate-game/src/game_audio/npc_skaters.rs
index b6458b19..6c460173 100644
--- a/crates/skate-game/src/game_audio/npc_skaters.rs
+++ b/crates/skate-game/src/game_audio/npc_skaters.rs
@@ -265,7 +265,7 @@ pub(crate) fn pre(host: &mut NpcHost, published: &NpcSkaters, native: &mut Nativ
         }
         info!("AUDIO_NPC release skater {id} (instance {g})");
     }
-    let parts = Parts { rolling: player.rolling_on, rattle: player.rattle_on, contacts: player.contacts_on, wheels: player.wheels_on, clothing: player.footsteps_on };
+    let parts = Parts { rolling: player.rolling_on, rattle: player.rattle_on, slide: player.slide_on, contacts: player.contacts_on, wheels: player.wheels_on, clothing: player.footsteps_on };
     for (id, g) in assignment.claimed {
         let npc = NpcSkater::new(g as u32, parts, true, true, true);
         host.objects.insert(id, npc);
@@ -280,7 +280,7 @@ pub(crate) fn pre(host: &mut NpcHost, published: &NpcSkaters, native: &mut Nativ
     let tuning = Tuning { player: &player.tuning, contacts: &player.contact_tuning, wheels: &player.wheels_tuning, clothing: &player.clothing_tuning };
     host.speakers.clear();
     for p in published.skaters.iter().filter(|p| p.voice != 0) {
-        host.speakers.push(super::world_speech::SkaterSpeaker { id: p.id, voice: p.voice, position: p.state.com_position, velocity: p.state.com_velocity });
+        host.speakers.push(super::world_speech::SkaterSpeaker { id: p.id, voice: p.voice, position: p.state.com_position, velocity: p.state.com_velocity, reactions: p.reactions });
     }
     let mut collisions = Vec::new();
     let held: Vec<(u32, u64)> = host.slots.holders().collect();
@@ -297,6 +297,7 @@ pub(crate) fn pre(host: &mut NpcHost, published: &NpcSkaters, native: &mut Nativ
         // The body / deck posters once per console evaluation, as the local player's.
         npc.set_body_calls(Some(evaluations));
         npc.set_deck_calls(Some(evaluations));
+        npc.loose_board = p.loose_board;
         let cmds = npc.process(m, &s, tuning, &mut rt.splice_host());
         host.apply(rt, id, cmds);
         // The routing's binds wait for the bed's step after the ticks (dropped without a bed).
@@ -329,6 +330,7 @@ pub(crate) fn post(host: &mut NpcHost, published: &NpcSkaters, native: &mut Nati
         let Some(mut npc) = host.objects.remove(&id) else { continue };
         let mut s = skaters::component_state(&p.state, local.soft_wheels);
         s.dt = dt;
+        npc.loose_board = p.loose_board;
         let cmds = npc.update(m, &s, tuning, &mut rt.splice_host());
         host.apply(rt, id, cmds);
         npc.update_wheels(m, &s, tuning.wheels, &mut rt.stream_host());
diff --git a/crates/skate-game/src/game_audio/npc_skaters/tests.rs b/crates/skate-game/src/game_audio/npc_skaters/tests.rs
index bbf6a82f..d62964f1 100644
--- a/crates/skate-game/src/game_audio/npc_skaters/tests.rs
+++ b/crates/skate-game/src/game_audio/npc_skaters/tests.rs
@@ -444,7 +444,7 @@ fn a_ghost_claims_instance_1_releases_and_survives_a_map_change() {
             for w in &mut s.wheel_position {
                 w[0] += shift;
             }
-            published.skaters = vec![skate_audio::world::skaters::NpcSkaterAudioState { id, state: s, voice: 0 }];
+            published.skaters = vec![skate_audio::world::skaters::NpcSkaterAudioState { id, state: s, voice: 0, loose_board: 0, reactions: Default::default() }];
             let m = native.mixmap.as_mut().unwrap();
             globals(m);
             // A pass (process, tick, update) on every other frame: the 30 Hz console cadence.
@@ -523,7 +523,7 @@ fn the_npc_instance_runs_wheels_clothing_and_the_bail_grunt() {
                 w[i] -= off[i];
             }
         }
-        published.skaters = vec![skate_audio::world::skaters::NpcSkaterAudioState { id, state: s, voice: 91 }];
+        published.skaters = vec![skate_audio::world::skaters::NpcSkaterAudioState { id, state: s, voice: 91, loose_board: 0, reactions: Default::default() }];
         let m = native.mixmap.as_mut().unwrap();
         globals(m);
         if f % 2 == 0 {
@@ -555,3 +555,121 @@ fn the_npc_instance_runs_wheels_clothing_and_the_bail_grunt() {
     assert_eq!(native.player.as_ref().map(|p| p.posts).unwrap_or(0), posts_before, "the local player's components posted nothing");
     assert_eq!(host.speakers.first().map(|s| (s.id, s.voice)), Some((id, 91)), "the speaking skater is published for the speech host");
 }
+
+#[derive(serde::Deserialize)]
+struct GrecRow {
+    turn: f32,
+    speed: f32,
+    wheels: u32,
+    air: u32,
+    material: u32,
+    #[serde(rename = "I")]
+    i: f32,
+    #[serde(rename = "Bk")]
+    bk: f32,
+    truck: GrecTruck,
+    distance: f32,
+}
+
+#[derive(serde::Deserialize)]
+struct GrecTruck {
+    a_gain: f32,
+    a_pitch: f32,
+    running: u32,
+}
+
+/// The NPC skater's grain bed against the recomp's own NPC bed (data-gated: the install, and
+/// `$SKATE_NPC_GREC/npc_rows_180430.json` from the local tool `npc_grec_rows.py`: session 180430's
+/// GREC rows of the NPC instance's SkateBoard object, filtered by owner, each joined with the NPC's
+/// board (SKATEB, matched by speed) and its distance to the camera). For the straight-roll rows
+/// (|turn| ≤ 0.02, turn intensity and brake slew ~0, wheels down, a truck running) our NPC bed rolls
+/// steadily at the row's speed, material and distance (2 s, the local player's wheels hard) and its
+/// truck 0 A record gain and pitch are compared with the recomp's, per distance band.
+#[test]
+#[ignore = "needs the private install data and the NPC GREC export"]
+fn npc_bed_follows_the_recomp_rows() {
+    let Some(dir) = std::env::var_os("SKATE_NPC_GREC").filter(|v| !v.is_empty()) else {
+        panic!("missing private data: SKATE_NPC_GREC (npc_grec_rows.py --json)");
+    };
+    let Ok(text) = std::fs::read_to_string(std::path::Path::new(&dir).join("npc_rows_180430.json")) else { panic!("missing private data: npc_rows_180430.json") };
+    let rows: Vec<GrecRow> = serde_json::from_str(&text).unwrap();
+    let straight: Vec<&GrecRow> = rows.iter().filter(|r| r.wheels > 0 && r.air == 0 && r.truck.running != 0 && r.turn.abs() <= 0.02 && r.i.abs() < 0.02 && r.bk < 0.02 && r.material != 143).collect();
+    assert!(straight.len() >= 100, "{} straight rows", straight.len());
+    let Some((library, mxb)) = install() else { panic!("missing private data: no install with a MixMap") };
+    let Some(local_bed) = super::super::grain_bed::Bed::new(&library) else { panic!("missing private data: no grain recordings / tuning") };
+    let tuning = library.player_tuning();
+    let contact_tuning = library.contacts_tuning();
+    let (wheels, clothing) = (Default::default(), Default::default());
+    let t = Tuning { player: &tuning, contacts: &contact_tuning, wheels: &wheels, clothing: &clothing };
+    // One run per (2 m distance, 1 m/s speed, material) bin.
+    let mut bins: BTreeMap<(i32, i32, u32), Vec<&GrecRow>> = BTreeMap::new();
+    for r in &straight {
+        bins.entry(((r.distance / 2.0) as i32, r.speed.round() as i32, r.material)).or_default().push(r);
+    }
+    let camera = [0.0, 1.8, 0.0];
+    let l = Listener { camera, view: [1.0, 0.0, 0.0], camera_velocity: [0.0; 3], followed: [0.0, 1.0, -3.0], facing: [1.0, 0.0, 0.0], followed_velocity: [0.0; 3] };
+    let mut by_band: BTreeMap<i32, (Vec<f32>, Vec<f32>, Vec<f32>, Vec<f32>)> = BTreeMap::new();
+    for (&(dbin, sbin, material), members) in &bins {
+        let d = dbin as f32 * 2.0 + 1.0;
+        let v = (sbin as f32).max(0.3);
+        let (mut rt, _, parts) = runtime(&library);
+        let mut m = MixMap::from_bytes(&mxb).unwrap();
+        let mut npc = NpcSkater::new(1, parts, true, true, true);
+        let mut bed = (local_bed.for_instance(1), 0u32);
+        let dt = 1.0 / 30.0;
+        let mut out = vec![0.0f32; 2 * 1600];
+        let (mut gain, mut pitch) = (0.0f32, 0.0f32);
+        for f in 0..60 {
+            // Rolling across the camera's view at distance d (along z, at x = d).
+            let z = -0.5 * v * 2.0 + v * f as f32 * dt;
+            let published = AudioState::rolling(&skate_audio::player::state::LiteSkater { position: [d, 0.1, z], velocity: [0.0, 0.0, v], heading: 0.0, material, dt, ..Default::default() });
+            let mut s = component_state(&published, false);
+            s.dt = dt;
+            globals(&mut m);
+            let _ = npc.update(&m, &s, t, &mut rt.splice_host());
+            bed.1 = bed.1.wrapping_add(u32::from(s.push_trigger));
+            let r = super::super::skate_events::Riding { speed: s.ground_speed, grinding: s.grinding, braking: s.brake, wheels: s.wheel_count, pushes: bed.1, audio: s, ..Default::default() };
+            let routed = Some((std::mem::take(&mut npc.routed.grains), npc.routed.primary));
+            super::super::grain_bed::step_with(&mut bed.0, &library, &m, &r, dt, &tuning, routed, |apply| apply(&mut rt));
+            bed.0.write_inputs(&mut m, &s, false);
+            npc.write_inputs(&mut m, &s, &l, [0.0; 3], &tuning);
+            let _ = npc.process(&mut m, &s, t, &mut rt.splice_host());
+            let _ = npc.take_collisions();
+            m.tick(dt);
+            rt.fill_stereo(&mut out);
+            if let Some(g) = rt.npc_grains.as_deref()
+                && f >= 45
+                && g.trucks[0].bound().is_some()
+            {
+                gain = g.trucks[0].players[0].record.gain;
+                pitch = g.trucks[0].players[0].record.pitch;
+            }
+        }
+        let band = (d / 10.0) as i32 * 10;
+        let e = by_band.entry(band).or_default();
+        for r in members {
+            e.0.push(r.truck.a_gain);
+            e.1.push(gain);
+            e.2.push(r.truck.a_pitch);
+            e.3.push(pitch);
+        }
+    }
+    let med = |v: &mut Vec<f32>| -> f32 {
+        v.sort_by(f32::total_cmp);
+        v.get(v.len() / 2).copied().unwrap_or(0.0)
+    };
+    eprintln!("NPC bed, straight roll ({} rows of session 180430's NPC GREC rows):", straight.len());
+    eprintln!("  distance   rows   A gain recomp / ours (median)   A pitch recomp / ours");
+    let mut ok = 0;
+    let mut n = 0;
+    for (band, (mut a, mut b, mut p, mut q)) in by_band {
+        let rows = a.len();
+        let (a, b, p, q) = (med(&mut a), med(&mut b), med(&mut p), med(&mut q));
+        eprintln!("  {band:2}-{:<2} m  {rows:5}   {a:.4} / {b:.4}                  {p:.3} / {q:.3}", band + 10);
+        if rows >= 20 {
+            n += 1;
+            ok += usize::from(b > 0.0 && (a / b) > 0.5 && (a / b) < 2.0);
+        }
+    }
+    assert!(n > 0 && ok * 2 >= n, "the NPC bed's level follows the recomp's in most distance bands");
+}
diff --git a/crates/skate-game/src/game_audio/state_replay.rs b/crates/skate-game/src/game_audio/state_replay.rs
index 8b51a82e..0cb6ed7b 100644
--- a/crates/skate-game/src/game_audio/state_replay.rs
+++ b/crates/skate-game/src/game_audio/state_replay.rs
@@ -285,7 +285,14 @@ impl Script {
 /// moved so the window's first board position lands on `anchor`, the velocities from the
 /// positions' change per row (the log keeps positions, not velocities). Requires every row to
 /// parse ([`try_read`]).
+#[cfg_attr(not(test), allow(dead_code))]
 pub(crate) fn ghost_states(text: &str, from: f32, seconds: f32, anchor: [f32; 3]) -> Result<Vec<AudioState>, String> {
+    ghost_window(text, from, seconds, anchor).map(|w| w.0)
+}
+
+/// [`ghost_states`] and, per row, the loose-board state (`+780`, the local host's own rule
+/// `PlayerAudio::loose_board` on the row's riding values): the NPC's board slide.
+pub(crate) fn ghost_window(text: &str, from: f32, seconds: f32, anchor: [f32; 3]) -> Result<(Vec<AudioState>, Vec<u8>), String> {
     let rows = try_read(text)?;
     let first = (from.max(0.0) * 60.0) as usize;
     let count = (seconds.max(1.0) * 60.0) as usize;
@@ -297,12 +304,15 @@ pub(crate) fn ghost_states(text: &str, from: f32, seconds: f32, anchor: [f32; 3]
     let origin = [rows[first].f("board_x"), rows[first].f("board_y"), rows[first].f("board_z")];
     let place = |p: [f32; 3]| -> [f32; 3] { std::array::from_fn(|i| p[i] - origin[i] + anchor[i]) };
     let mut out = Vec::with_capacity(end - first);
+    let mut loose = Vec::with_capacity(end - first);
     let mut last: Option<([f32; 3], [f32; 3])> = None;
     for (i, r) in rows[..end].iter().enumerate() {
-        let mut s = script.riding(r).audio;
+        let riding = script.riding(r);
+        let mut s = riding.audio;
         if i < first {
             continue;
         }
+        loose.push(super::player_audio::PlayerAudio::loose_board(&s, &riding) as u8);
         let board = place([r.f("board_x"), r.f("board_y"), r.f("board_z")]);
         let com = place([r.f("com_x"), r.f("com_y"), r.f("com_z")]);
         let rate = |now: [f32; 3], then: Option<[f32; 3]>| then.map_or([0.0; 3], |t| std::array::from_fn(|k| (now[k] - t[k]) * 60.0));
@@ -320,7 +330,7 @@ pub(crate) fn ghost_states(text: &str, from: f32, seconds: f32, anchor: [f32; 3]
         last = Some((board, com));
         out.push(s);
     }
-    Ok(out)
+    Ok((out, loose))
 }
 
 #[cfg(test)]
diff --git a/crates/skate-game/src/game_audio/world_bridge.rs b/crates/skate-game/src/game_audio/world_bridge.rs
index b1f3c905..3bf7b79a 100644
--- a/crates/skate-game/src/game_audio/world_bridge.rs
+++ b/crates/skate-game/src/game_audio/world_bridge.rs
@@ -45,6 +45,8 @@ pub(crate) struct WorldAudioPublish;
 #[derive(Component, Clone, Debug)]
 pub(crate) struct GhostSkater {
     pub(crate) states: Vec<AudioState>,
+    /// The loose-board state per row (the board slide).
+    pub(crate) loose: Vec<u8>,
     /// Rows played (fractional).
     pub(crate) at: f64,
 }
@@ -52,11 +54,11 @@ pub(crate) struct GhostSkater {
 impl GhostSkater {
     /// Load a state log's window as a ghost (see `ghost_states`).
     pub(crate) fn from_log(text: &str, from: f32, seconds: f32, anchor: [f32; 3]) -> Result<Self, String> {
-        let states = super::state_replay::ghost_states(text, from, seconds, anchor)?;
+        let (states, loose) = super::state_replay::ghost_window(text, from, seconds, anchor)?;
         if states.is_empty() {
             return Err("empty window".into());
         }
-        Ok(Self { states, at: 0.0 })
+        Ok(Self { states, loose, at: 0.0 })
     }
 }
 
@@ -76,6 +78,7 @@ fn ghost_step(time: Res<Time>, mut ghosts: Query<(&mut GhostSkater, &mut NpcSkat
         t.translation = Vec3::from_array(s.board_position);
         *g = GlobalTransform::from(*t);
         npc.state = Some(s);
+        npc.loose_board = ghost.loose.get(now % n).copied().unwrap_or(0);
     }
 }
 
@@ -84,6 +87,9 @@ pub(crate) fn register(app: &mut App) {
         .init_resource::<WorldAudioStats>()
         .init_resource::<Bridge>()
         .add_message::<PedSpeechEvent>()
+        .add_message::<PedTazerEvent>()
+        .add_message::<PedBodyFallEvent>()
+        .add_message::<NpcSkaterReactionEvent>()
         .add_message::<VehicleHorn>()
         .add_message::<VehicleAlarm>()
         .add_systems(Update, (tag_remote_players, ghost_step, publish.in_set(WorldAudioPublish)).chain().before(super::native::mixmap_frame).after(crate::app::FrameSet::Animation))
@@ -111,11 +117,37 @@ pub(crate) struct Bridge {
     unknown_models: HashSet<u32>,
     /// Speech values to set next frame (a repeated value goes through 0 first).
     speech_next: Vec<(Entity, i32)>,
+    /// Tazer holds from [`PedTazerEvent`]: seconds left.
+    tazers: HashMap<Entity, f32>,
+    /// Body-fall keys from [`PedBodyFallEvent`]: the queue, the key on now (0 = the gap) and the
+    /// seconds it has left.
+    falls: HashMap<Entity, (std::collections::VecDeque<f32>, f32, f32)>,
+    /// NPC skater reactions from [`NpcSkaterReactionEvent`]: the set and the seconds it has left.
+    reactions: HashMap<Entity, (SkaterReactions, f32)>,
+    /// The ped tuning's tazer hold (`world_tuning.ped_objects.tazer_seconds`), read once.
+    tazer_seconds: Option<f32>,
     /// The summary log: seconds since the last line, and the running counts then.
     log_timer: f32,
     log_counts: (u64, u64, u64),
 }
 
+/// The component's held reactions with an event's raised on top.
+fn merge_reactions(held: SkaterReactions, event: SkaterReactions) -> SkaterReactions {
+    let mut r = held;
+    if event.slam {
+        (r.slam, r.slam_by) = (true, event.slam_by);
+    }
+    if event.slam_b {
+        (r.slam_b, r.slam_b_by) = (true, event.slam_b_by);
+    }
+    if event.trick {
+        (r.trick, r.trick_by) = (true, event.trick_by);
+    }
+    r.crash |= event.crash;
+    r.chase |= event.chase;
+    r
+}
+
 /// The ground's audio material under a point (`material_of_tag` of the first surface a 1.5 m line
 /// down from 0.5 m above it hits; `NO_MATERIAL` when none): the same stock line query the wheel
 /// lines use.
@@ -174,12 +206,18 @@ fn publish(
     mut speech: MessageReader<PedSpeechEvent>,
     mut horns: MessageReader<VehicleHorn>,
     mut alarms: MessageReader<VehicleAlarm>,
+    mut zaps: MessageReader<PedTazerEvent>,
+    (mut falls, mut reacts): (MessageReader<PedBodyFallEvent>, MessageReader<NpcSkaterReactionEvent>),
 ) {
     let any = !vehicles.is_empty() || !peds.is_empty() || !npcs.is_empty();
     if owners.expected != living.expected {
         owners.expected = living.expected;
     }
-    if !any && !bridge.active && speech.is_empty() && horns.is_empty() && alarms.is_empty() && bridge.speech_next.is_empty() {
+    let photo = living.photo_flag || living.mod_photo_flag;
+    if owners.photo_flag != photo {
+        owners.photo_flag = photo;
+    }
+    if !any && !bridge.active && speech.is_empty() && horns.is_empty() && alarms.is_empty() && zaps.is_empty() && falls.is_empty() && reacts.is_empty() && bridge.speech_next.is_empty() && bridge.reactions.is_empty() {
         return;
     }
     let bridge = &mut *bridge;
@@ -207,6 +245,44 @@ fn publish(
     for a in alarms.read() {
         bridge.horns.insert(a.vehicle, (HornState::Alarm, ALARM_SECONDS));
     }
+    let tazer_seconds = *bridge.tazer_seconds.get_or_insert_with(|| library.as_deref().map_or_else(|| skate_audio::world::peds::PedObjectTuning::default().tazer_seconds, |l| l.world_tuning().ped_objects().tazer_seconds));
+    for z in zaps.read() {
+        bridge.tazers.insert(z.ped, z.seconds.unwrap_or(tazer_seconds).max(0.0));
+    }
+    for f in falls.read() {
+        if f.kind != 0.0 && f.kind.is_finite() {
+            bridge.falls.entry(f.ped).or_default().0.push_back(f.kind);
+        }
+    }
+    // Each key is on for one console frame, then 0 for one frame (so a repeated key is a change).
+    let step = skate_audio::mixmap::cadence::CONSOLE_DT;
+    for (queue, now, left) in bridge.falls.values_mut() {
+        *left -= dt;
+        if *left <= 0.0 {
+            if *now != 0.0 {
+                *now = 0.0;
+                *left = step;
+            } else if let Some(k) = queue.pop_front() {
+                *now = k;
+                *left = step;
+            }
+        }
+    }
+    bridge.falls.retain(|e, (q, now, left)| peds.contains(*e) && (!q.is_empty() || *now != 0.0 || *left > 0.0));
+    // A reaction is held for one console frame (the AI's bytes are per frame).
+    for (_, left) in bridge.reactions.values_mut() {
+        *left -= dt;
+    }
+    bridge.reactions.retain(|e, (_, left)| *left > 0.0 && npcs.contains(*e));
+    for r in reacts.read() {
+        let (set, left) = bridge.reactions.entry(r.skater).or_insert((SkaterReactions::default(), 0.0));
+        *set = r.reaction.raise(*set, r.by);
+        *left = step;
+    }
+    for left in bridge.tazers.values_mut() {
+        *left -= dt;
+    }
+    bridge.tazers.retain(|e, left| *left > 0.0 && peds.contains(*e));
     for (_, left) in bridge.horns.values_mut() {
         *left -= dt;
     }
@@ -276,6 +352,8 @@ fn publish(
                 voice: ped.voice.unwrap_or(0),
                 speaker,
                 level_select: skate_audio::world::speech_player::PedLevelSelect { security, ..Default::default() },
+                tazing: ped.tazing || bridge.tazers.contains_key(&e),
+                body_fall: bridge.falls.get(&e).map_or(ped.body_fall, |f| f.1),
             },
         );
         seen.push((e, at, 0.0));
@@ -283,7 +361,7 @@ fn publish(
 
     // NPC / remote skaters, in list order.
     skaters.skaters.clear();
-    let mut list: Vec<(bool, u32, u32, u64, AudioState, u32)> = Vec::new();
+    let mut list: Vec<(bool, u32, u32, u64, AudioState, u32, u8, SkaterReactions)> = Vec::new();
     for (e, t, mut npc, given) in &mut npcs {
         let at = t.translation().to_array();
         if npc.remote {
@@ -298,10 +376,11 @@ fn publish(
             bridge.next_order += 1;
             bridge.next_order
         });
-        list.push((!npc.remote, if npc.list_order == 0 { u32::MAX } else { npc.list_order }, spawn, e.to_bits(), state, npc.voice.unwrap_or(0)));
+        let reactions = bridge.reactions.get(&e).map_or(npc.reactions, |(set, _)| merge_reactions(npc.reactions, *set));
+        list.push((!npc.remote, if npc.list_order == 0 { u32::MAX } else { npc.list_order }, spawn, e.to_bits(), state, npc.voice.unwrap_or(0), npc.loose_board, reactions));
     }
     list.sort_by(|a, b| (a.0, a.1, a.2).cmp(&(b.0, b.1, b.2)));
-    skaters.skaters.extend(list.into_iter().map(|(_, _, _, id, state, voice)| skate_audio::world::skaters::NpcSkaterAudioState { id, state, voice }));
+    skaters.skaters.extend(list.into_iter().map(|(_, _, _, id, state, voice, loose_board, reactions)| skate_audio::world::skaters::NpcSkaterAudioState { id, state, voice, loose_board: u32::from(loose_board.min(2)), reactions }));
 
     bridge.last.clear();
     for (e, at, speed) in seen {
@@ -422,7 +501,7 @@ mod tests {
         app.add_plugins(MinimalPlugins);
         app.init_resource::<WorldOwners>().init_resource::<super::super::npc_skaters::NpcSkaters>().init_resource::<WorldHeld>();
         app.init_resource::<LivingWorldAudio>().init_resource::<WorldAudioStats>().init_resource::<Bridge>();
-        app.add_message::<PedSpeechEvent>().add_message::<VehicleHorn>().add_message::<VehicleAlarm>();
+        app.add_message::<PedSpeechEvent>().add_message::<VehicleHorn>().add_message::<VehicleAlarm>().add_message::<PedTazerEvent>().add_message::<PedBodyFallEvent>().add_message::<NpcSkaterReactionEvent>();
         app.add_systems(Update, (publish, read_back).chain());
         app.world_mut().spawn((super::super::GameAudioListener, Transform::default(), GlobalTransform::default()));
         app
diff --git a/crates/skate-game/src/game_audio/world_oneshot_tests.rs b/crates/skate-game/src/game_audio/world_oneshot_tests.rs
new file mode 100644
index 00000000..31722791
--- /dev/null
+++ b/crates/skate-game/src/game_audio/world_oneshot_tests.rs
@@ -0,0 +1,289 @@
+//! The peds' one-shot objects against the recomp (data-gated): SFXObj_Tazer's bursts and
+//! SFXObj_PedBodyFall's falls through the real runtime, rebuilt at the recomp's geometry. The
+//! recomp side is `$SKATE_WORLD_ONESHOTS/oneshots_<session>.json`, written by the local tool
+//! `world_oneshots.py <session> --json` (a local research tool, not published).
+use super::*;
+use skate_audio::world::peds::PedState;
+
+#[derive(Deserialize)]
+struct Row {
+    kind: String,
+    ms: f64,
+    #[serde(default)]
+    starts: Vec<TazerStart>,
+    #[serde(default)]
+    geometry: Option<Geometry>,
+    #[serde(default)]
+    fall_type: Option<i32>,
+    #[serde(default)]
+    container: Option<u32>,
+    #[serde(default)]
+    sample: Option<u32>,
+    #[serde(default)]
+    gain_first: Option<f32>,
+}
+
+#[derive(Deserialize)]
+struct TazerStart {
+    ms: f64,
+    sample: u32,
+    gain_first: Option<f32>,
+}
+
+#[derive(Deserialize, Clone, Copy)]
+struct Geometry {
+    ped: [f32; 3],
+    camera: [f32; 3],
+    player: [f32; 3],
+}
+
+fn rows(session: &str) -> Vec<Row> {
+    let Some(dir) = std::env::var_os("SKATE_WORLD_ONESHOTS").filter(|v| !v.is_empty()) else {
+        panic!("missing private data: SKATE_WORLD_ONESHOTS (the world_oneshots.py --json exports)");
+    };
+    let path = std::path::Path::new(&dir).join(format!("oneshots_{session}.json"));
+    let Ok(text) = std::fs::read_to_string(&path) else { panic!("missing private data: {}", path.display()) };
+    serde_json::from_str(&text).unwrap()
+}
+
+fn globals(native: &mut Native) {
+    let m = native.mixmap.as_mut().unwrap();
+    for id in 1..=4 {
+        m.set_input(skate_audio::mixmap::keys::MASTER, id, 32767);
+    }
+    for id in [1, 2, 5] {
+        m.set_input(skate_audio::mixmap::keys::MUSIC, id, 32767);
+    }
+    m.set_input(skate_audio::mixmap::keys::REVERB, 5, 32767);
+}
+
+/// The camera looking at the player (horizontally), as the speech level check does.
+fn view(g: &Geometry) -> [f32; 3] {
+    let d = [g.player[0] - g.camera[0], 0.0, g.player[2] - g.camera[2]];
+    let n = (d[0] * d[0] + d[2] * d[2]).sqrt().max(1e-3);
+    [d[0] / n, 0.0, d[2] / n]
+}
+
+/// A Tazer start of ours: (seconds after the post, sample, gain).
+type Start = (f64, u16, f32);
+
+/// One zap through the host at the recomp's geometry: the ped tazes for `hold` s; every new voice
+/// of the Tazer bank over `seconds` (the host at the console's 30 Hz, the render's blocks in step).
+fn zap(library: &Library, g: &Geometry, hold: f32, seconds: f32) -> Vec<Start> {
+    let Ok(mut native) = Native::start(library) else { panic!("missing private data: no AEMS install") };
+    let mut host = WorldHost::default();
+    let mut owners = WorldOwners::default();
+    let local = skate_audio::player::AudioState { com_position: g.player, ..Default::default() };
+    let camera = Some((g.camera, view(g)));
+    let block = BLOCK_SECONDS;
+    // Voice id → (index in `out`, blocks seen): a start's gain is its peak over its first 8 blocks
+    // (the program posts the level after the open).
+    let mut seen: HashMap<u32, (usize, u32)> = HashMap::new();
+    let mut out: Vec<Start> = Vec::new();
+    let mut blocks = 0u64;
+    let mut post_at: Option<u64> = None;
+    let frames = (seconds * 30.0) as usize;
+    for f in 0..frames {
+        let t = f as f32 / 30.0;
+        owners.peds.insert(9, PedState { position: g.ped, class: 2, tazing: t < hold, ..Default::default() });
+        globals(&mut native);
+        run(&mut host, &owners, &mut native, library, camera, &local);
+        if post_at.is_none() && host.nodes.contains_key(&(9, WorldSlot::PedTazer)) {
+            post_at = Some(blocks);
+        }
+        let due = (((f + 1) as f64 / 30.0) / block) as u64;
+        let bank = native.bank_id(skate_audio::world::peds::TAZER_BANK);
+        let mut rt = native.shared.lock().unwrap();
+        while blocks < due {
+            rt.render_block();
+            blocks += 1;
+            for v in rt.mixer.snapshot() {
+                if Some(v.bank) != bank {
+                    continue;
+                }
+                let entry = seen.entry(v.id).or_insert_with(|| {
+                    let at = (blocks - post_at.unwrap_or(blocks)) as f64 * block;
+                    out.push((at, v.slot, 0.0));
+                    (out.len() - 1, 0)
+                });
+                if entry.1 < 8 {
+                    entry.1 += 1;
+                    out[entry.0].2 = out[entry.0].2.max(v.gain);
+                }
+            }
+        }
+    }
+    out
+}
+
+const BLOCK_SECONDS: f64 = skate_audio::BLOCK as f64 / skate_audio::MIX_RATE as f64;
+
+/// The zap burst (session 164620: three zaps, 49 Tazer starts): per zap our starts while the ped
+/// tazes for the state graph's hold against the recomp's: the count, the sample order (8, 7, then
+/// shuffles of 0–6: no sample twice within seven), the first gaps (~190 / 190 / 130 ms, then
+/// 90–100) and the first start's gain at that geometry.
+#[test]
+#[ignore = "needs the private install data and the recomp one-shot export"]
+fn tazer_bursts_follow_the_recomp() {
+    let root = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets"));
+    let Ok(library) = Library::load(root) else { panic!("missing private data: no audio install") };
+    let hold = library.world_tuning().ped_objects().tazer_seconds;
+    let zaps: Vec<Row> = rows("164620").into_iter().filter(|r| r.kind == "tazer").collect();
+    assert_eq!(zaps.len(), 3);
+    assert_eq!(zaps.iter().map(|z| z.starts.len()).sum::<usize>(), 49, "the recomp's 49 Tazer starts");
+    let (mut count_ours, mut count_theirs, mut ratios) = (0usize, 0usize, Vec::new());
+    for z in &zaps {
+        let g = z.geometry.expect("geometry");
+        let ours = zap(&library, &g, hold, hold + 1.5);
+        let theirs: Vec<(f64, u32)> = z.starts.iter().map(|s| ((s.ms - z.ms) / 1000.0, s.sample)).collect();
+        let in_hold = ours.iter().filter(|s| s.0 <= f64::from(hold) + 0.15).count();
+        let after = ours.len() - in_hold;
+        let gaps = |t: &[f64]| t.windows(2).map(|w| ((w[1] - w[0]) * 1000.0).round() as i32).collect::<Vec<_>>();
+        let our_t: Vec<f64> = ours.iter().map(|s| s.0).collect();
+        let their_t: Vec<f64> = theirs.iter().map(|s| s.0).collect();
+        eprintln!("zap {:.3} s: recomp {} starts over {:.2} s, samples {:?}", z.ms / 1000.0, theirs.len(), their_t.last().copied().unwrap_or(0.0), theirs.iter().map(|s| s.1).collect::<Vec<_>>());
+        eprintln!("    recomp gaps {:?}", gaps(&their_t));
+        eprintln!("    ours   {} starts in the {hold} s hold (+{after} after), samples {:?}", in_hold, ours.iter().map(|s| s.1).collect::<Vec<_>>());
+        eprintln!("    ours   gaps {:?}", gaps(&our_t));
+        // The order: 8, 7, then shuffles of 0-6.
+        let samples: Vec<u16> = ours.iter().map(|s| s.1).collect();
+        assert!(samples.len() >= 3 && samples[0] == 8 && samples[1] == 7, "{samples:?}");
+        for chunk in samples[2..].chunks(7) {
+            let mut c = chunk.to_vec();
+            c.sort_unstable();
+            c.dedup();
+            assert_eq!(c.len(), chunk.len(), "no sample twice within a shuffle: {samples:?}");
+            assert!(chunk.iter().all(|s| *s <= 6));
+        }
+        // The first gaps (the program's walks): within 40 ms of the recomp's.
+        for (a, b) in gaps(&our_t).iter().zip(gaps(&their_t)).take(3) {
+            assert!((a - b).abs() <= 40, "first gaps {:?} vs {:?}", gaps(&our_t), gaps(&their_t));
+        }
+        if let (Some(first), Some(their)) = (ours.first(), z.starts.first().and_then(|s| s.gain_first)) {
+            eprintln!("    first start gain recomp {their:.3} ours {:.3}", first.2);
+            if first.2 > 1e-3 {
+                ratios.push(their / first.2);
+            }
+        }
+        count_ours += in_hold;
+        count_theirs += theirs.len();
+    }
+    ratios.sort_by(f32::total_cmp);
+    eprintln!("tazer: {count_ours} starts of ours in the holds vs the recomp's {count_theirs}; first-start gain recomp / ours {ratios:?}");
+    // The recomp's first zap ended after 1.3 s (its burst stops at the 10th start); the others ran
+    // the 2 s hold: the counts agree within the program's random tail.
+    assert!((count_ours as i32 - count_theirs as i32).abs() <= 12, "{count_ours} vs {count_theirs}");
+    assert!(ratios.len() == 3 && ratios.iter().all(|r| (0.7..=1.3).contains(r)), "first-start gains {ratios:?}");
+}
+
+//// PedBodyFall against the recomp's falls (sessions 163809 / 164620 / 214002 / 222155 and the audiox
+/// grind run 120315: 73 of the 75 recorded; audiox_ride has no sample resolution): per start, the fall
+/// type's container (9 → 948, 8 → 1184, other → 1183, from the export) and the Splice sample we
+/// start for it is one the container can play; where the recomp's sample is one of that container's,
+/// so is ours (the same container); our voice's gain (PedBodyFall through the runtime's Splice
+/// player, its type's volume output at the knocked-down ped's geometry) against the recomp's first
+/// gain. The knocked-down ped is not named by any hook: the ped nearest the player is taken.
+#[test]
+#[ignore = "needs the private install data and the recomp one-shot export"]
+fn body_falls_follow_the_recomp() {
+    let root = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets"));
+    let Ok(library) = Library::load(root) else { panic!("missing private data: no audio install") };
+    let tuning = library.world_tuning().ped_objects();
+    let Some((bank, _)) = library.splice_bank(&tuning.body_fall_bank) else { panic!("missing private data: no {} patch tree", tuning.body_fall_bank) };
+    let falls: Vec<(String, Row)> = ["163809", "164620", "214002", "222155", "120315"].iter().flat_map(|s| rows(s).into_iter().filter(|r| r.kind == "body_fall").map(move |r| (s.to_string(), r))).collect();
+    assert!(falls.len() >= 73, "{} falls", falls.len());
+    // The samples each container can play (its records' groups' members' sample ids).
+    let members = |id: u32| -> std::collections::BTreeSet<u32> {
+        let id = id as usize;
+        let records: Vec<usize> = if id < bank.records.len() {
+            vec![id]
+        } else {
+            bank.containers.get(id - bank.records.len()).map_or_else(Vec::new, |c| c.ids.iter().map(|&r| usize::from(r)).collect())
+        };
+        records.iter().filter_map(|&r| bank.records.get(r)).flat_map(|r| r.groups.iter()).flat_map(|g| g.members.iter()).map(|m| u32::from(m.sample)).collect()
+    };
+    let (mut ids_ok, mut member_n, mut member_ok, mut ratios) = (0usize, 0usize, 0usize, Vec::new());
+    let mut level_rows = 0;
+    let Ok(mut native) = Native::start(&library) else { panic!("missing private data: no AEMS install") };
+    let fall_bank = native.shared.lock().unwrap().splice.bank_index(&tuning.body_fall_bank).map(|i| skate_audio::splice::MIXER_BANK_BASE + i);
+    for (session, r) in &falls {
+        let kind = r.fall_type.unwrap();
+        let id = match kind {
+            8 => tuning.body_fall_ids[0],
+            9 => tuning.body_fall_ids[1],
+            _ => tuning.body_fall_ids[2],
+        };
+        ids_ok += usize::from(Some(id) == r.container);
+        if let Some(s) = r.sample {
+            let set = members(id);
+            // A recomp sample of another bank's family (the collision manager's sounds at the same
+            // moment) is not this fall's voice: only rows whose sample the container can play count.
+            if set.contains(&s) {
+                member_n += 1;
+                member_ok += 1;
+            }
+        }
+        // Our voice for it: PedBodyFall through the runtime's Splice player at the ped's geometry,
+        // its gain after the first update (the start block's level is 0, the update posts level(2)).
+        if let (Some(g), Some(gain), Some(sample)) = (r.geometry, r.gain_first, r.sample)
+            && members(id).contains(&sample)
+        {
+            let m = native.mixmap.as_mut().unwrap();
+            let l = skate_audio::player::objpos::Listener { camera: g.camera, view: view(&g), camera_velocity: [0.0; 3], followed: g.player, facing: view(&g), followed_velocity: [0.0; 3] };
+            let mut pos = skate_audio::player::objpos::ObjPos::default();
+            for _ in 0..40 {
+                pos.write(m, keys::ped_pos(0), &l, Some((g.ped, [0.0; 3])));
+                for id in 1..=4 {
+                    m.set_input(skate_audio::mixmap::keys::MASTER, id, 32767);
+                }
+                m.tick(CONSOLE_DT);
+            }
+            let out = OutputsSnapshot::take(m, keys::ped_body_fall(0), &[]);
+            let mut rt = native.shared.lock().unwrap();
+            let before: std::collections::BTreeSet<u32> = rt.mixer.snapshot().iter().map(|v| v.id).collect();
+            let mut fall = skate_audio::world::peds::PedBodyFall::default();
+            // The export's type 0 = "any other value" (the recomp's keys of that type are not logged).
+            let key = if kind == 0 { 1.0 } else { kind as f32 };
+            fall.process(&PedState { body_fall: key, ..Default::default() }, &tuning, &mut rt.splice_host());
+            // Its first voice's gain after the update (a member may start after a delay: watch 0.2 s).
+            let mut ours = 0.0f32;
+            for b in 0..38 {
+                if b % 6 == 0 {
+                    fall.update(&out, CONSOLE_DT, &mut rt.splice_host());
+                }
+                rt.render_block();
+                let g = rt.mixer.snapshot().iter().filter(|v| Some(v.bank) == fall_bank && !before.contains(&v.id)).map(|v| v.gain).fold(0.0f32, f32::max);
+                if g > 0.0 {
+                    ours = g;
+                    break;
+                }
+            }
+            assert!(fall.starts == 1, "{} type {kind} -> {id}: not started", r.ms);
+            fall.release(&mut rt.splice_host());
+            for _ in 0..4 {
+                rt.render_block();
+            }
+            level_rows += 1;
+            if ours > 1e-3 && gain > 1e-3 {
+                ratios.push(gain / ours);
+            }
+            if std::env::var_os("SKATE_VERIFY_VERBOSE").is_some() {
+                eprintln!("{session} {:8.3}s type {kind} -> {id} sample {sample}: recomp gain {gain:.3}, ours {ours:.3}", r.ms / 1000.0);
+            }
+        }
+    }
+    ratios.sort_by(f32::total_cmp);
+    let q = |p: f32| ratios.get(((ratios.len() as f32 - 1.0) * p) as usize).copied().unwrap_or(0.0);
+    eprintln!(
+        "body falls: {} recomp starts, container {ids_ok} / {} as the type says; the recomp's sample is one the container plays in {member_ok} rows; first gain recomp / ours p10 {:.3} p50 {:.3} p90 {:.3} (n {} of {level_rows} rows with geometry and the container's sample)",
+        falls.len(),
+        falls.len(),
+        q(0.1),
+        q(0.5),
+        q(0.9),
+        ratios.len()
+    );
+    assert_eq!(ids_ok, falls.len(), "every start's container follows its type");
+    assert!(member_n > 0 && ratios.len() >= 20);
+    assert!((0.5..=1.5).contains(&q(0.5)), "the fall voices' level follows the recomp (median {})", q(0.5));
+}
diff --git a/crates/skate-game/src/game_audio/world_sources.rs b/crates/skate-game/src/game_audio/world_sources.rs
index 4c11109f..fcaf234b 100644
--- a/crates/skate-game/src/game_audio/world_sources.rs
+++ b/crates/skate-game/src/game_audio/world_sources.rs
@@ -29,7 +29,8 @@ use skate_audio::eval::NodeId;
 use skate_audio::mixmap::cadence::CONSOLE_DT;
 use skate_audio::player::objpos::Listener;
 use skate_audio::world::owners::{Pool, Positions};
-use skate_audio::world::peds::{PedFootstepTuning, PedSfx, PedSpeech, PedState};
+use skate_audio::world::peds::{PedBodyFall, PedFootstepTuning, PedObjectTuning, PedSfx, PedSpeech, PedState, PedTazer};
+use skate_audio::player::Outputs as _;
 use skate_audio::world::traffic::{EngineRecord, OutputsSnapshot, Vehicle, VehicleState};
 use skate_audio::world::{Lcg, PED_BANKS, TRAFFIC_BANKS, WorldCommand, WorldSlot, keys};
 
@@ -44,6 +45,9 @@ pub(crate) struct WorldOwners {
     /// The living world will publish owners on this map: prefetch the world banks (decode only;
     /// see the module docs). Clearing it drops the prefetched banks no owner has used yet.
     pub(crate) expected: bool,
+    /// The game flag PedestrianSpeech's photographer repeat needs (system byte
+    /// `*(0x830CFDC4)+912`; meaning not traced): `LivingWorldAudio::photo_repeat`.
+    pub(crate) photo_flag: bool,
 }
 
 /// The install's world tuning (`audio_manifest.json` `world_tuning`, setup
@@ -61,6 +65,48 @@ pub(crate) struct WorldTuningJson {
     /// Traffic model (living-world entity name: `taxi01`, `sedan02`, …) → `aud_traffic_engine`
     /// record (spec §7.3 G1).
     traffic_models: HashMap<String, String>,
+    /// The ped one-shot objects (`skate_audio::world::peds::PedObjectTuning`): PedBodyFall's
+    /// containers and eEQChain bus, the phone ring, the tazer hold.
+    ped_objects: Option<PedObjectsJson>,
+    /// The speech stream voice's PEAK curves (`skate_audio::world::speech_player::SpeechVoiceTuning`).
+    speech_voice: Option<SpeechVoiceJson>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize)]
+#[serde(default)]
+struct PedObjectsJson {
+    body_fall_ids: Vec<u32>,
+    body_fall_bank: Option<String>,
+    body_fall_eq: Option<u8>,
+    ring_bank: Option<String>,
+    ring_id: Option<u32>,
+    ring_answer: Option<i32>,
+    photo_repeat: Option<f32>,
+    tazer_seconds: Option<f32>,
+}
+
+#[derive(Clone, Debug, Default, Deserialize)]
+#[serde(default)]
+struct GraphJson {
+    x: Vec<f32>,
+    y: Vec<f32>,
+}
+
+impl GraphJson {
+    fn graph8(&self) -> Option<skate_audio::world::speech_player::Graph8> {
+        Some(skate_audio::world::speech_player::Graph8 { x: self.x.as_slice().try_into().ok()?, y: self.y.as_slice().try_into().ok()? })
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize)]
+#[serde(default)]
+struct SpeechVoiceJson {
+    peak_freq: Option<GraphJson>,
+    peak_gain: Option<GraphJson>,
+    peak_q: Option<GraphJson>,
+    /// The echo delay's camera-distance factor and its refresh (console frames).
+    delay_factor: Option<f32>,
+    delay_frames: Option<u32>,
 }
 
 #[derive(Clone, Debug, Default, Deserialize)]
@@ -95,6 +141,23 @@ pub(crate) struct PedModelJson {
     pub(crate) shoe_class: u8,
     /// `S+156`: the far line threshold (m).
     pub(crate) far: f32,
+    /// `S+152`: the per-voice float (`2087A3290483BB4F`, 0.8–1.2): the speech stream's gain and
+    /// sends are multiplied by it (`sub_82C5CEF0`). 0 = absent (1.0).
+    pub(crate) pitch: f32,
+    /// The main cast's words (`S+84` / `+88`, the other-skater word `D6EA428C2B43E23A`): the cast bit
+    /// (`6F2933E977CF40DD`: the pros 1–29), the cast word (`14FD437D190677C8`: the special cast) and
+    /// the word another pro's line names this one by. A model with no type bit (`kind` 0) and a
+    /// cast bit or word speaks on the main-cast channel.
+    pub(crate) cast_bit: u32,
+    pub(crate) cast_word: u32,
+    pub(crate) cast_word2: u32,
+}
+
+impl PedModelJson {
+    /// The main-cast words (bit, word, other-skater word) when this model speaks on the main cast.
+    pub(crate) fn main_cast(&self) -> Option<(u32, u32, u32)> {
+        (self.kind == 0 && (self.cast_bit != 0 || self.cast_word != 0)).then_some((self.cast_bit, self.cast_word, self.cast_word2))
+    }
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize)]
@@ -157,7 +220,12 @@ impl WorldTuningJson {
 
     /// The living world's speech tuning (bank 1) by event id.
     pub(crate) fn speech_tuning(&self) -> HashMap<u16, skate_audio::world::speech_manager::EventTuning> {
-        let Some(bank) = self.speech_tuning.get("1") else { return HashMap::new() };
+        self.speech_tuning_bank(1)
+    }
+
+    /// One speech bank's tuning by event id (0 = the main cast, 1 = the living world).
+    pub(crate) fn speech_tuning_bank(&self, bank: u32) -> HashMap<u16, skate_audio::world::speech_manager::EventTuning> {
+        let Some(bank) = self.speech_tuning.get(&bank.to_string()) else { return HashMap::new() };
         bank.iter()
             .filter_map(|(id, t)| {
                 let flags = |i: usize| t.flags_12.get(i).is_some_and(|b| *b != 0);
@@ -185,6 +253,59 @@ impl WorldTuningJson {
             .collect()
     }
 
+    /// The ped one-shot objects' tuning (the retail defaults where the export lacks a field).
+    pub(crate) fn ped_objects(&self) -> PedObjectTuning {
+        let mut t = PedObjectTuning::default();
+        let Some(p) = &self.ped_objects else { return t };
+        if let [a, b, c] = p.body_fall_ids[..] {
+            t.body_fall_ids = [a, b, c];
+        }
+        if let Some(v) = &p.body_fall_bank {
+            t.body_fall_bank = v.clone();
+        }
+        if let Some(v) = p.body_fall_eq {
+            t.body_fall_eq = v.min(7);
+        }
+        if let Some(v) = &p.ring_bank {
+            t.ring_bank = v.clone();
+        }
+        if let Some(v) = p.ring_id {
+            t.ring_id = v;
+        }
+        if let Some(v) = p.ring_answer {
+            t.ring_answer = v;
+        }
+        if let Some(v) = p.photo_repeat.filter(|v| v.is_finite() && *v > 0.0) {
+            t.photo_repeat = v;
+        }
+        if let Some(v) = p.tazer_seconds.filter(|v| v.is_finite() && *v >= 0.0) {
+            t.tazer_seconds = v;
+        }
+        t
+    }
+
+    /// The speech stream voice's tuning (the shipped curves where the export lacks one).
+    pub(crate) fn speech_voice(&self) -> skate_audio::world::speech_player::SpeechVoiceTuning {
+        let mut t = skate_audio::world::speech_player::SpeechVoiceTuning::default();
+        let Some(v) = &self.speech_voice else { return t };
+        if let Some(g) = v.peak_freq.as_ref().and_then(GraphJson::graph8) {
+            t.peak_freq = g;
+        }
+        if let Some(g) = v.peak_gain.as_ref().and_then(GraphJson::graph8) {
+            t.peak_gain = g;
+        }
+        if let Some(g) = v.peak_q.as_ref().and_then(GraphJson::graph8) {
+            t.peak_q = g;
+        }
+        if let Some(f) = v.delay_factor.filter(|f| f.is_finite() && *f >= 0.0) {
+            t.delay_factor = f;
+        }
+        if let Some(n) = v.delay_frames.filter(|n| *n >= 1) {
+            t.delay_frames = n;
+        }
+        t
+    }
+
     pub(crate) fn ped_footsteps(&self) -> PedFootstepTuning {
         let mut t = PedFootstepTuning::default();
         let Some(p) = &self.ped_footsteps else { return t };
@@ -273,13 +394,18 @@ pub(crate) struct WorldHost {
     traffic: Pool,
     peds: Pool,
     vehicles: HashMap<u64, (Vehicle, Positions)>,
-    ped_objects: HashMap<u64, (PedSfx, PedSpeech, Positions)>,
+    ped_objects: HashMap<u64, PedObjects>,
     nodes: HashMap<(u64, WorldSlot), NodeId>,
     classes: HashMap<&'static str, usize>,
     /// This frame's pass between [`pre`] and [`post`]: the camera and the seconds it covers.
     pass: Option<([f32; 3], f32)>,
     rng: Lcg,
     ped_tuning: Option<PedFootstepTuning>,
+    /// The ped one-shot objects' tuning (`world_tuning.ped_objects`, read with the banks).
+    object_tuning: PedObjectTuning,
+    /// The phone ring's Splice bank is loaded (without it the answer follows the value at once:
+    /// a missing-data fallback, logged once).
+    ring_bank: Option<bool>,
     player_tuning: Option<skate_audio::player::tuning::PlayerTuning>,
     /// The camera at the last evaluation and the host's cut count then (`Native::cuts`: no
     /// velocity across a teleport / map change).
@@ -307,6 +433,8 @@ impl Default for WorldHost {
             pass: None,
             rng: Lcg(0x5EED),
             ped_tuning: None,
+            object_tuning: PedObjectTuning::default(),
+            ring_bank: None,
             player_tuning: None,
             last_camera: None,
             prefetch: WorldPrefetch::default(),
@@ -317,6 +445,40 @@ impl Default for WorldHost {
     }
 }
 
+//// A held ped's objects (the Pedestrian slot's four: Speech 5.0, SFX 5.1, BodyFall 5.2, Tazer 5.3)
+/// and its 3DObjPos block.
+pub(crate) struct PedObjects {
+    sfx: PedSfx,
+    speech: PedSpeech,
+    body_fall: PedBodyFall,
+    tazer: PedTazer,
+    pos: Positions,
+    /// The missing-ring fallback answered this value (once per value change).
+    ring_fallback: Option<i32>,
+}
+
+impl PedObjects {
+    fn new(g: u32) -> Self {
+        Self {
+            sfx: PedSfx::default(),
+            speech: PedSpeech::default(),
+            body_fall: PedBodyFall::default(),
+            tazer: PedTazer::default(),
+            pos: Positions::new(&[keys::ped_pos(g)]),
+            ring_fallback: None,
+        }
+    }
+
+    /// The ped lost its instance: every packet released, every Splice sound stopped.
+    fn release(&mut self, owner: u64, splice: &mut dyn skate_audio::player::contacts::SpliceHost) -> Vec<WorldCommand> {
+        let mut cmds = self.sfx.release(owner, splice);
+        cmds.extend(self.tazer.release(owner));
+        self.body_fall.release(splice);
+        self.speech.release(splice);
+        cmds
+    }
+}
+
 /// Which owners hold a MixMap instance after the last evaluation (the hosts write it; the
 /// engine-facing bridge turns it into `world_audio::WorldAudioInstance`).
 #[derive(Resource, Default, Debug, Clone, PartialEq)]
@@ -410,8 +572,8 @@ impl WorldHost {
         if !self.nodes.is_empty() || !self.ped_objects.is_empty() {
             if let Ok(mut runtime) = super::timing::lock(shared, &super::timing::GAME_LOCK) {
                 let rt = &mut *runtime;
-                for (owner, (mut sfx, _, _)) in std::mem::take(&mut self.ped_objects) {
-                    let _ = sfx.release(owner, &mut rt.splice_host());
+                for (owner, mut o) in std::mem::take(&mut self.ped_objects) {
+                    let _ = o.release(owner, &mut rt.splice_host());
                 }
                 for (_, node) in self.nodes.drain() {
                     rt.release(node);
@@ -473,6 +635,15 @@ pub(super) fn frame(
     if !host.speech_requests.is_empty() {
         speech.peds.append(&mut host.speech_requests);
     }
+    // The speaking peds' positions (the speech echo's delay reads the camera distance).
+    if !speech.ped_positions.is_empty() || !owners.peds.is_empty() {
+        speech.ped_positions.clear();
+        for (id, _) in host.peds.holders().map(|(g, o)| (o, g)) {
+            if let Some(p) = owners.peds.get(&id) {
+                speech.ped_positions.insert(id, p.position);
+            }
+        }
+    }
     let (traffic, peds) = host.held();
     if held.traffic != traffic || held.peds != peds {
         held.traffic = traffic;
@@ -521,10 +692,30 @@ pub(crate) fn pre(host: &mut WorldHost, owners: &WorldOwners, native: &mut Nativ
     }
     if host.banks.is_none() {
         host.ped_tuning = Some(library.world_tuning().ped_footsteps());
+        host.object_tuning = library.world_tuning().ped_objects();
         host.player_tuning = native.player.as_ref().map(|p| p.tuning.clone());
         info!("AUDIO_WORLD on: {} vehicles, {} peds published", owners.vehicles.len(), owners.peds.len());
     }
     host.banks = Some(!missing);
+    // The phone ring's Splice bank (once: Splice banks stay loaded across maps).
+    if host.ring_bank.is_none() && !owners.peds.is_empty() {
+        let stem = host.object_tuning.ring_bank.clone();
+        let loaded = match library.splice_bank(&stem) {
+            Some((bank, pcm)) => match super::timing::lock(&native.shared, &super::timing::GAME_LOCK) {
+                Ok(mut runtime) => {
+                    let rt = &mut *runtime;
+                    rt.splice.load_bank(&stem, bank, pcm, &mut rt.mixer);
+                    true
+                }
+                Err(_) => false,
+            },
+            None => {
+                warn!("AUDIO_WORLD {stem} has no patch tree in this install: phone calls answer without the ring (rerun setup)");
+                false
+            }
+        };
+        host.ring_bank = Some(loaded);
+    }
     let Some((cam, view)) = camera else { return };
     if calls == 0 {
         return;
@@ -562,9 +753,9 @@ pub(crate) fn pre(host: &mut WorldHost, owners: &WorldOwners, native: &mut Nativ
         }
     }
     for (owner, _) in peds.released {
-        if let Some((mut sfx, _, mut pos)) = host.ped_objects.remove(&owner) {
-            pos.deactivate(m, &l);
-            let cmds = sfx.release(owner, &mut rt.splice_host());
+        if let Some(mut o) = host.ped_objects.remove(&owner) {
+            o.pos.deactivate(m, &l);
+            let cmds = o.release(owner, &mut rt.splice_host());
             apply(host, rt, cmds);
         }
     }
@@ -573,7 +764,7 @@ pub(crate) fn pre(host: &mut WorldHost, owners: &WorldOwners, native: &mut Nativ
         host.vehicles.insert(owner, (Vehicle::default(), Positions::new(&[keys::traffic_pos(g, 1), keys::traffic_pos(g, 2), keys::traffic_pos(g, 3)])));
     }
     for (owner, g) in peds.claimed {
-        host.ped_objects.insert(owner, (PedSfx::default(), PedSpeech::default(), Positions::new(&[keys::ped_pos(g as u32)])));
+        host.ped_objects.insert(owner, PedObjects::new(g as u32));
     }
 
     // Process: the 3DObjPos blocks and inputs for this pass's evaluations, then the posts.
@@ -592,14 +783,27 @@ pub(crate) fn pre(host: &mut WorldHost, owners: &WorldOwners, native: &mut Nativ
     let holders: Vec<(usize, u64)> = host.peds.holders().collect();
     for (_, owner) in holders {
         let Some(p) = owners.peds.get(&owner) else { continue };
-        let Some((mut sfx, mut speech, mut pos)) = host.ped_objects.remove(&owner) else { continue };
-        pos.write(m, &l, &[Some((p.position, p.velocity))]);
-        let cmds = sfx.process(owner, p, &ped_tuning, &mut rt.splice_host(), dt);
-        if let Some(r) = speech.process(owner, p) {
+        let Some(mut o) = host.ped_objects.remove(&owner) else { continue };
+        o.pos.write(m, &l, &[Some((p.position, p.velocity))]);
+        // Retail's object order in the Pedestrian slot: Speech, SFX, BodyFall, Tazer.
+        let request = o.speech.process(owner, p, dt, owners.photo_flag, &host.object_tuning, &mut rt.splice_host());
+        if let Some(r) = request {
             host.speech_requests.push(super::world_speech::PedRequest { request: r, voice: p.voice, speaker: p.speaker, level: p.level_select });
+        } else if p.speech_value == 49 && o.speech.ring.is_none() && host.ring_bank == Some(false) && o.ring_fallback != Some(p.speech_value) {
+            // No ring bank in the install: answer at once (missing-data fallback).
+            host.speech_requests.push(super::world_speech::PedRequest {
+                request: skate_audio::world::peds::SpeechRequest { owner, value: host.object_tuning.ring_answer, flag: PedSpeech::flag(p) },
+                voice: p.voice,
+                speaker: p.speaker,
+                level: p.level_select,
+            });
         }
+        o.ring_fallback = (p.speech_value == 49).then_some(49);
+        let mut cmds = o.sfx.process(owner, p, &ped_tuning, &mut rt.splice_host(), dt);
+        o.body_fall.process(p, &host.object_tuning, &mut rt.splice_host());
+        cmds.extend(o.tazer.process(owner, p, local.global_224));
         apply(host, rt, cmds);
-        host.ped_objects.insert(owner, (sfx, speech, pos));
+        host.ped_objects.insert(owner, o);
     }
     host.ped_tuning = Some(ped_tuning);
 }
@@ -626,11 +830,27 @@ pub(crate) fn post(host: &mut WorldHost, owners: &WorldOwners, native: &mut Nati
     let holders: Vec<(usize, u64)> = host.peds.holders().collect();
     for (g, owner) in holders {
         let Some(p) = owners.peds.get(&owner) else { continue };
-        let Some((mut sfx, speech, pos)) = host.ped_objects.remove(&owner) else { continue };
-        let out = OutputsSnapshot::take(m, keys::ped_sfx(g as u32), &[7, 8]);
-        let cmds = sfx.update(owner, p, &ped_tuning, &player_tuning, &out, &mut rt.splice_host(), dt);
+        let Some(mut o) = host.ped_objects.remove(&owner) else { continue };
+        let g = g as u32;
+        if o.speech.ring.is_some() {
+            let out = OutputsSnapshot::take(m, keys::ped_speech(g), &skate_audio::world::speech_player::PED_FILTERS);
+            let main = out.level(skate_audio::world::speech_player::ped_level_ids(p.level_select, 0, false).0);
+            if let Some(r) = o.speech.update(owner, p, main, &out, dt, &host.object_tuning, &mut rt.splice_host()) {
+                host.speech_requests.push(super::world_speech::PedRequest { request: r, voice: p.voice, speaker: p.speaker, level: p.level_select });
+            }
+        }
+        let out = OutputsSnapshot::take(m, keys::ped_sfx(g), &[7, 8]);
+        let mut cmds = o.sfx.update(owner, p, &ped_tuning, &player_tuning, &out, &mut rt.splice_host(), dt);
+        if o.body_fall.sounding() {
+            o.body_fall.update(&OutputsSnapshot::take(m, keys::ped_body_fall(g), &[]), dt, &mut rt.splice_host());
+        } else {
+            o.body_fall.latch_env(m.level(keys::ped_body_fall(g), 7));
+        }
+        if o.tazer.packet.is_some() {
+            cmds.extend(o.tazer.update(owner, &OutputsSnapshot::take(m, keys::ped_tazer(g), &[])));
+        }
         apply(host, rt, cmds);
-        host.ped_objects.insert(owner, (sfx, speech, pos));
+        host.ped_objects.insert(owner, o);
     }
     host.ped_tuning = Some(ped_tuning);
     host.player_tuning = Some(player_tuning);
@@ -649,6 +869,10 @@ pub(crate) fn run(host: &mut WorldHost, owners: &WorldOwners, native: &mut Nativ
     post(host, owners, native);
 }
 
+#[cfg(test)]
+#[path = "world_oneshot_tests.rs"]
+mod oneshot_tests;
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/skate-game/src/game_audio/world_speech.rs b/crates/skate-game/src/game_audio/world_speech.rs
index 61684a0f..2de84c8d 100644
--- a/crates/skate-game/src/game_audio/world_speech.rs
+++ b/crates/skate-game/src/game_audio/world_speech.rs
@@ -20,14 +20,16 @@ use std::sync::Arc;
 
 use bevy::prelude::*;
 use serde::Deserialize;
+use skate_audio::bus::speech_echo::EchoParams;
 use skate_audio::formats::SampleHeader;
 use skate_audio::mixer::Mixer;
 use skate_audio::player::objpos::{Listener, ObjPos};
 use skate_audio::world::keys;
 use skate_audio::world::owners::Pool;
 use skate_audio::world::peds::SpeechRequest;
-use skate_audio::world::speech::{Clip, Line, SPEECH_BANK, SpeechIndex, SpeechSlots, Take};
-use skate_audio::world::speech_manager::{GateInputs, Speaker, SpeechManager, kind};
+use skate_audio::world::skater_speech::{Reactions, Say, SkaterSpeech};
+use skate_audio::world::speech::{Clip, Line, MAIN_CAST_BANK, SPEECH_BANK, SpeechIndex, SpeechSlots, Take};
+use skate_audio::world::speech_manager::{GateInputs, Speaker, SpeechManager, kind, main_cast};
 use skate_audio::world::speech_player::{self, Event, Outcome, PedLevelSelect, Request, SpeechPlayer, SpeechVoices, VoiceParams};
 use skate_audio::world::speech_rules::{ClipHeader, ClipRef, EventTable, Library as SpeechLibrary, Record};
 use skate_audio::world::traffic::OutputsSnapshot;
@@ -36,7 +38,8 @@ use skate_audio::world::Lcg;
 use super::native::Native;
 
 /// The NPC bail grunt's event (`201_grunt`, message 8206 / 115 of `sub_824BF5F8`).
-pub(crate) const BAIL_GRUNT_EVENT: u16 = 8206;
+#[cfg_attr(not(test), allow(dead_code))]
+pub(crate) const BAIL_GRUNT_EVENT: u16 = main_cast::message::BAIL_GRUNT.0;
 /// Decoded takes kept loaded after their line (the rest are read again when picked).
 const KEEP_TAKES: usize = 24;
 
@@ -56,6 +59,8 @@ pub(crate) struct SkaterSpeaker {
     pub(crate) voice: u32,
     pub(crate) position: [f32; 3],
     pub(crate) velocity: [f32; 3],
+    /// Its record's reaction bytes this frame (its own speech, `skater_speech`).
+    pub(crate) reactions: Reactions,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -64,6 +69,15 @@ enum Who {
     Skater(u32),
 }
 
+/// The main cast's channel (`maincastspeech.big`, speech manager bank 0, channel 0): the pros' and
+/// the special cast's lines, with its own tuning, timers, streams and decoded takes.
+struct MainCast {
+    data: Data,
+    manager: SpeechManager,
+    player: SpeechPlayer,
+    loaded: VecDeque<u16>,
+}
+
 /// The loaded speech export.
 struct Data {
     index: SpeechIndex,
@@ -84,6 +98,23 @@ pub(crate) struct WorldSpeech {
     data: Option<Data>,
     manager: SpeechManager,
     player: SpeechPlayer,
+    /// The stream voice's PEAK curves (`world_tuning.speech_voice`).
+    voice: skate_audio::world::speech_player::SpeechVoiceTuning,
+    /// Each speaker's voice id (the clip names' voice: SFXObj_Speech's inputs read it).
+    voices: HashMap<u64, u32>,
+    /// SFXObj_Speech's inputs as last written (in0..in4).
+    speech_inputs: [bool; 5],
+    /// The speaking peds' positions (`world_sources` fills it; the echo delay reads it).
+    pub(crate) ped_positions: HashMap<u64, [f32; 3]>,
+    /// Each speaker's echo delay countdown and value (`sub_824D9370`: recomputed when the count
+    /// reaches 0, then reloaded with `delay_frames`).
+    delay_clock: HashMap<u64, (i32, f32)>,
+    /// The delay last posted to each echo slot (retail posts Del0 only when it changed).
+    echo_delay: [Option<f32>; skate_audio::bus::speech_echo::SLOTS],
+    /// The main-cast channel (None: the install has no main-cast index).
+    cast: Option<MainCast>,
+    /// The NPC skaters' own speech processes (dropped while idle).
+    skater_speech: HashMap<u64, SkaterSpeech>,
     rng: Lcg,
     /// The manager clock (s): console time since the runtime started (`MixMap::ticks`).
     clock: f64,
@@ -109,7 +140,16 @@ impl Default for WorldSpeech {
             tried: false,
             data: None,
             manager: SpeechManager::default(),
-            player: SpeechPlayer::default(),
+            // The living world's speech channel is the second (streams 2 / 3; the main cast's first).
+            player: SpeechPlayer::on_channel(1),
+            voice: Default::default(),
+            voices: HashMap::new(),
+            speech_inputs: [false; 5],
+            ped_positions: HashMap::new(),
+            delay_clock: HashMap::new(),
+            echo_delay: [None; skate_audio::bus::speech_echo::SLOTS],
+            cast: None,
+            skater_speech: HashMap::new(),
             rng: Lcg(0x5EEC),
             clock: 0.0,
             last_tick: 0,
@@ -241,9 +281,12 @@ fn load(index_path: &std::path::Path, audio: Option<PathBuf>) -> Result<Data, St
 
 struct Voices<'a> {
     mixer: &'a mut Mixer,
+    /// The mixer bank of this channel's takes.
+    bank: usize,
     data: &'a Data,
     loaded: &'a mut VecDeque<u16>,
     missing: &'a mut bool,
+    echo_delay: &'a mut [Option<f32>; skate_audio::bus::speech_echo::SLOTS],
 }
 
 impl Voices<'_> {
@@ -268,28 +311,43 @@ impl Voices<'_> {
         };
         let frames = pcm.channels.first().map_or(0, Vec::len) as u32;
         let header = SampleHeader { codec: 0, channels: pcm.channels.len().clamp(1, 8) as u8, rate: pcm.rate, frames, loop_start: None };
-        self.mixer.set_bank_sample(SPEECH_BANK, slot, header, Arc::new(pcm));
+        self.mixer.set_bank_sample(self.bank, slot, header, Arc::new(pcm));
         self.loaded.push_back(slot);
         while self.loaded.len() > KEEP_TAKES {
             if let Some(old) = self.loaded.pop_front() {
                 // A playing voice keeps its own reference to the PCM.
-                self.mixer.clear_bank_sample(SPEECH_BANK, old);
+                self.mixer.clear_bank_sample(self.bank, old);
             }
         }
         Some(slot)
     }
+
+    /// The echo send and its slot's parameters; the delay goes out only when it changed.
+    fn echo(&mut self, voice: u32, p: &VoiceParams) {
+        let cached = self.echo_delay.get_mut(usize::from(p.slot));
+        let delay = match (p.delay, cached) {
+            (Some(d), Some(c)) if *c != Some(d) => {
+                *c = Some(d);
+                Some(d)
+            }
+            _ => None,
+        };
+        self.mixer.set_stream_echo(voice, p.slot, p.echo, &EchoParams { high_pass: p.echo_hpf, low_pass: p.echo_lpf, delay });
+    }
 }
 
 impl SpeechVoices for Voices<'_> {
     fn open(&mut self, line: Line, p: &VoiceParams) -> Option<u32> {
         let slot = self.ensure(line)?;
-        let v = self.mixer.open_direct(SPEECH_BANK, slot, 0.0, p.pitch, p.gain, Some(p.azimuth))?;
-        self.mixer.set_direct_dsp(v, p.hpf, p.lpf, p.send);
+        let v = self.mixer.open_direct(self.bank, slot, 0.0, p.pitch, p.gain, Some(p.azimuth))?;
+        self.mixer.set_stream_dsp(v, p.hpf, p.lpf, p.send, p.peak);
+        self.echo(v, p);
         Some(v)
     }
     fn set(&mut self, voice: u32, p: &VoiceParams) {
         self.mixer.set_direct(voice, p.pitch, p.gain, Some(p.azimuth));
-        self.mixer.set_direct_dsp(voice, p.hpf, p.lpf, p.send);
+        self.mixer.set_stream_dsp(voice, p.hpf, p.lpf, p.send, p.peak);
+        self.echo(voice, p);
     }
     fn alive(&self, voice: u32) -> bool {
         self.mixer.direct_alive(voice)
@@ -312,6 +370,26 @@ fn skater_speaker(library: &super::Library, data: &Data, voice: u32) -> Speaker
     }
 }
 
+/// A main-cast request block (`sub_824AC560`): the speaker's cast bit / word, the near / far flag
+/// (the main cast's sense: 1 near, 2 far) and, for the pro-on-pro lines, the other skater's cast bit
+/// and other-skater word.
+fn cast_block(cast: (u32, u32, u32), far: bool, other: Option<(u32, u32, u32)>) -> main_cast::Block {
+    let mut b = [0u32; 14];
+    b[0] = cast.0;
+    b[1] = cast.1;
+    b[2] = if far { main_cast::FAR } else { main_cast::NEAR };
+    if let Some(o) = other {
+        b[4] = o.0;
+        b[5] = o.2;
+    }
+    b
+}
+
+/// A speaker's main-cast words when its model speaks on the main cast.
+fn cast_of(library: &super::Library, voice: u32) -> Option<(u32, u32, u32)> {
+    library.world_tuning().ped_model(voice).and_then(|m| m.main_cast())
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(super) fn frame(
     native: Option<ResMut<Native>>,
@@ -322,7 +400,9 @@ pub(super) fn frame(
     listener: Query<&GlobalTransform, With<super::GameAudioListener>>,
 ) {
     let speech = &mut *speech;
-    if speech.peds.is_empty() && speech.grunts.is_empty() && speech.player.busy() == 0 && speech.player.queued() == 0 && speech.skater_slots.holders().next().is_none() {
+    let cast_idle = speech.cast.as_ref().is_none_or(|c| c.player.busy() == 0 && c.player.queued() == 0);
+    let reacting = !speech.skater_speech.is_empty() || speech.skaters.iter().any(|s| s.reactions != Reactions::default());
+    if speech.peds.is_empty() && speech.grunts.is_empty() && speech.player.busy() == 0 && speech.player.queued() == 0 && cast_idle && !reacting && speech.skater_slots.holders().next().is_none() && !speech.speech_inputs.contains(&true) {
         return;
     }
     let (Some(mut native), Some(library)) = (native, library) else {
@@ -346,10 +426,15 @@ pub(crate) fn run(speech: &mut WorldSpeech, peds: &[(u64, u32)], native: &mut Na
             && let Some(data) = speech.data.as_ref()
         {
             let mut missing = speech.missing_logged;
-            let mut v = Voices { mixer: &mut rt.mixer, data, loaded: &mut speech.loaded, missing: &mut missing };
+            let mut v = Voices { mixer: &mut rt.mixer, bank: SPEECH_BANK, data, loaded: &mut speech.loaded, missing: &mut missing, echo_delay: &mut speech.echo_delay };
             speech.player.clear(&mut v);
+            if let Some(c) = speech.cast.as_mut() {
+                let mut v = Voices { mixer: &mut rt.mixer, bank: MAIN_CAST_BANK, data: &c.data, loaded: &mut c.loaded, missing: &mut missing, echo_delay: &mut speech.echo_delay };
+                c.player.clear(&mut v);
+            }
             speech.missing_logged = missing;
         }
+        speech.skater_speech.clear();
         speech.who.clear();
         speech.skater_slots.clear();
         speech.skater_pos.clear();
@@ -358,6 +443,7 @@ pub(crate) fn run(speech: &mut WorldSpeech, peds: &[(u64, u32)], native: &mut Na
     if !speech.tried {
         speech.tried = true;
         speech.manager = SpeechManager::new(library.world_tuning().speech_tuning());
+        speech.voice = library.world_tuning().speech_voice();
         match library.speech("livingworld") {
             None => info!("AUDIO_WORLD speech off: the install has no speech index (rerun setup)"),
             Some((index, audio)) => match load(&index, audio.clone()) {
@@ -372,6 +458,16 @@ pub(crate) fn run(speech: &mut WorldSpeech, peds: &[(u64, u32)], native: &mut Na
                 Err(e) => warn!("AUDIO_WORLD speech off: {e}"),
             },
         }
+        // The main cast's channel (the pros and the special cast; opt-in decode as the living world's).
+        if let Some((index, audio)) = library.speech("maincast") {
+            match load(&index, audio.clone()) {
+                Ok(data) => {
+                    info!("AUDIO_WORLD main-cast speech {}: {} clips, {} events", if audio.is_some() { "on" } else { "chosen but silent (not decoded)" }, data.index.clips.len(), data.table.events.len());
+                    speech.cast = Some(MainCast { data, manager: SpeechManager::new(library.world_tuning().speech_tuning_bank(0)), player: SpeechPlayer::on_channel(0), loaded: VecDeque::new() });
+                }
+                Err(e) => warn!("AUDIO_WORLD main-cast speech off: {e}"),
+            }
+        }
     }
     let Some(data) = speech.data.as_mut() else {
         speech.peds.clear();
@@ -388,38 +484,85 @@ pub(crate) fn run(speech: &mut WorldSpeech, peds: &[(u64, u32)], native: &mut Na
     let inputs = GateInputs { now: speech.clock, player_speed: local.ground_speed.abs(), ..Default::default() };
     let mut missing = speech.missing_logged;
     // The requests.
-    let mut new: Vec<(u64, Who, Result<skate_audio::world::speech_manager::Line, skate_audio::world::speech_manager::Refusal>, i32)> = Vec::new();
+    // (speaker, who, result, value, on the main cast)
+    type Res = Result<skate_audio::world::speech_manager::Line, skate_audio::world::speech_manager::Refusal>;
+    let mut new: Vec<(u64, Who, Res, i32, bool)> = Vec::new();
     for r in std::mem::take(&mut speech.peds) {
         if r.voice == 0 {
             continue;
         }
+        speech.voices.insert(r.request.owner, r.voice);
+        // `sub_824AC438`: a ped without a living-world type (a pro) takes the main-cast path.
+        if let (Some(c), Some(words)) = (speech.cast.as_mut(), cast_of(library, r.voice)) {
+            let Some(event) = main_cast::event_for_value(r.request.value, false, &mut speech.rng) else { continue };
+            let block = cast_block(words, r.request.flag == skate_audio::world::speech_manager::FAR, None);
+            let res = c.manager.request_main_cast(&mut c.data.library, &c.data.table, event, r.voice, &block, &inputs, &mut speech.rng);
+            new.push((r.request.owner, Who::Ped(r.level), res, r.request.value, true));
+            continue;
+        }
         let res = speech.manager.request(&mut data.library, &data.table, r.request.value, r.request.flag, &r.speaker, &inputs, &mut speech.rng);
-        new.push((r.request.owner, Who::Ped(r.level), res, r.request.value));
+        new.push((r.request.owner, Who::Ped(r.level), res, r.request.value, false));
     }
     let camera_pos = camera.map(|c| c.0);
+    // Skater messages and reactions: (skater, living-world event, main-cast event, the other skater).
+    let mut says: Vec<(SkaterSpeaker, Option<u16>, Option<u16>, Option<u32>)> = Vec::new();
     for id in std::mem::take(&mut speech.grunts) {
         let Some(sk) = speech.skaters.iter().find(|s| s.id == id).copied() else { continue };
-        let words = skater_speaker(library, &*data, sk.voice);
-        let far = library.world_tuning().ped_model(sk.voice).map_or(20.0, |m| m.far);
-        let distance = camera_pos.map_or(0.0, |c| ((sk.position[0] - c[0]).powi(2) + (sk.position[1] - c[1]).powi(2) + (sk.position[2] - c[2]).powi(2)).sqrt());
-        // `sub_824DAC00`: flag 1 when the skater's distance exceeds the model's far threshold.
-        let flag = if distance > far { skate_audio::world::speech_manager::FAR } else { skate_audio::world::speech_manager::NEAR };
-        let res = speech.manager.request_event(&mut data.library, &data.table, BAIL_GRUNT_EVENT, flag, &words, &inputs, &mut speech.rng);
-        new.push((id, Who::Skater(sk.voice), res, -1));
+        let (lw, mc) = main_cast::message::BAIL_GRUNT;
+        says.push((sk, Some(lw), Some(mc), None));
     }
-    for (speaker, who, res, value) in new {
+    // `SFXObj_PlayerSpeech`'s non-local process, once per console frame (free skate: game mode 0).
+    if m.ticks != speech.last_tick {
+        for sk in speech.skaters.clone() {
+            let main = speech.cast.is_some() && cast_of(library, sk.voice).is_some();
+            let process = speech.skater_speech.entry(sk.id).or_default();
+            for say in process.process(main, &sk.reactions, 0, &mut speech.rng) {
+                says.push(match say {
+                    Say::Living(e) => (sk, Some(e), None, None),
+                    Say::MainCast { event, other } => (sk, None, Some(event), other),
+                    Say::Message(lw, mc) => (sk, Some(lw), Some(mc), None),
+                });
+            }
+        }
+        let skaters = &speech.skaters;
+        speech.skater_speech.retain(|id, p| !p.idle() && skaters.iter().any(|s| s.id == *id));
+    }
+    for (sk, lw, mc, other) in says {
+        let far_m = library.world_tuning().ped_model(sk.voice).map_or(20.0, |m| m.far);
+        let distance = camera_pos.map_or(0.0, |c| ((sk.position[0] - c[0]).powi(2) + (sk.position[1] - c[1]).powi(2) + (sk.position[2] - c[2]).powi(2)).sqrt());
+        // `sub_824DAC00`: far when the skater's distance exceeds the model's far threshold.
+        let far = distance > far_m;
+        speech.voices.insert(sk.id, sk.voice);
+        if let (Some(c), Some(words), Some(event)) = (speech.cast.as_mut(), cast_of(library, sk.voice), mc) {
+            let other = other.and_then(|o| cast_of(library, o));
+            let block = cast_block(words, far, other);
+            let res = c.manager.request_main_cast(&mut c.data.library, &c.data.table, event, sk.voice, &block, &inputs, &mut speech.rng);
+            new.push((sk.id, Who::Skater(sk.voice), res, -1, true));
+        } else if let Some(event) = lw {
+            let words = skater_speaker(library, &*data, sk.voice);
+            let flag = if far { skate_audio::world::speech_manager::FAR } else { skate_audio::world::speech_manager::NEAR };
+            let res = speech.manager.request_event(&mut data.library, &data.table, event, flag, &words, &inputs, &mut speech.rng);
+            new.push((sk.id, Who::Skater(sk.voice), res, -1, false));
+        }
+    }
+    for (speaker, who, res, value, on_cast) in new {
         match res {
             Ok(line) => {
-                let Some(lines) = data.index.picks_to_lines(&line.picks, u32::from(line.event)) else { continue };
-                let tuning = speech.manager.tuning.get(&line.event).cloned().unwrap_or_default();
-                let timeout = data.table.event(line.event).map_or(60, |e| u32::from(e.queue_timeout));
-                let names: Vec<&str> = lines.iter().filter_map(|l| data.index.clips.get(l.clip).map(|c| c.name.as_str())).collect();
+                let (d, manager, player, loaded, bank) = match (on_cast, speech.cast.as_mut()) {
+                    (true, Some(c)) => (&c.data, &c.manager, &mut c.player, &mut c.loaded, MAIN_CAST_BANK),
+                    _ => (&*data, &speech.manager, &mut speech.player, &mut speech.loaded, SPEECH_BANK),
+                };
+                let Some(lines) = d.index.picks_to_lines(&line.picks, u32::from(line.event)) else { continue };
+                let tuning = manager.tuning.get(&line.event).cloned().unwrap_or_default();
+                let timeout = d.table.event(line.event).map_or(60, |e| u32::from(e.queue_timeout));
+                let names: Vec<&str> = lines.iter().filter_map(|l| d.index.clips.get(l.clip).map(|c| c.name.as_str())).collect();
                 let req = Request { speaker, event: line.event, priority: tuning.priority, interrupt: tuning.interrupt, interrupt_when_full: tuning.interrupt_when_full, lines, timeout };
-                let mut v = Voices { mixer: &mut rt.mixer, data: &*data, loaded: &mut speech.loaded, missing: &mut missing };
-                let outcome = speech.player.request(req, &mut v);
-                info!("AUDIO_WORLD speech owner={speaker} value={value} event={} line={} -> {outcome:?}", line.event, names.join("+"));
+                let mut v = Voices { mixer: &mut rt.mixer, bank, data: d, loaded, missing: &mut missing, echo_delay: &mut speech.echo_delay };
+                let outcome = player.request(req, &mut v);
+                let channel = if on_cast { "main cast" } else { "living world" };
+                info!("AUDIO_WORLD speech ({channel}) owner={speaker} value={value} event={} line={} -> {outcome:?}", line.event, names.join("+"));
                 #[cfg(test)]
-                eprintln!("AUDIO_WORLD speech owner={speaker} value={value} event={} line={} -> {outcome:?}", line.event, names.join("+"));
+                eprintln!("AUDIO_WORLD speech ({channel}) owner={speaker} value={value} event={} line={} -> {outcome:?}", line.event, names.join("+"));
                 if !matches!(outcome, Outcome::Dropped) {
                     speech.who.insert(speaker, who);
                 }
@@ -455,40 +598,89 @@ pub(crate) fn run(speech: &mut WorldSpeech, peds: &[(u64, u32)], native: &mut Na
     }
     let who = &speech.who;
     let skater_slots = &speech.skater_slots;
+    let voice_tuning = speech.voice;
+    let voices_of = &speech.voices;
+    let ped_positions = &speech.ped_positions;
+    let skaters = &speech.skaters;
+    let delay_clock = &mut speech.delay_clock;
+    let world = library.world_tuning();
     let m_ref: &skate_audio::mixmap::MixMap = m;
     let mut params = |speaker: u64, far: bool, event: u16| -> Option<VoiceParams> {
-        match *who.get(&speaker)? {
+        // `S+152`, the per-voice float (0 = absent: 1.0).
+        let scale = voices_of.get(&speaker).and_then(|v| world.ped_model(*v)).map_or(1.0, |m| if m.pitch > 0.0 { m.pitch } else { 1.0 });
+        let mut p = match *who.get(&speaker)? {
             Who::Ped(sel) => {
                 let g = peds.iter().find(|(o, _)| *o == speaker)?.1;
-                let out = OutputsSnapshot::take(m_ref, keys::ped_speech(g), &speech_player::PED_FILTERS);
-                Some(speech_player::ped_outputs(&out, sel, event, far))
+                let out = OutputsSnapshot::take(m_ref, keys::ped_speech(g), &speech_player::PED_SNAPSHOT_FILTERS);
+                speech_player::ped_outputs(&out, sel, event, far, &voice_tuning, scale)
             }
             Who::Skater(voice) => {
                 let g = skater_slots.instance(speaker)? as u32 + 1;
-                let out = OutputsSnapshot::take(m_ref, keys::player_speech(g), &speech_player::SKATER_FILTERS);
-                Some(speech_player::skater_outputs(&out, voice, far))
+                let out = OutputsSnapshot::take(m_ref, keys::player_speech(g), &speech_player::SKATER_SNAPSHOT_FILTERS);
+                speech_player::skater_outputs(&out, voice, far, &voice_tuning, scale)
+            }
+        };
+        // The echo delay: every `delay_frames` console frames from the camera distance.
+        let pos = ped_positions.get(&speaker).copied().or_else(|| skaters.iter().find(|s| s.id == speaker).map(|s| s.position));
+        let clock = delay_clock.entry(speaker).or_insert((0, 0.0));
+        clock.0 -= 1;
+        if clock.0 <= 0 {
+            clock.0 = voice_tuning.delay_frames.max(1) as i32;
+            if let Some(pos) = pos {
+                let d = ((pos[0] - cam[0]).powi(2) + (pos[1] - cam[1]).powi(2) + (pos[2] - cam[2]).powi(2)).sqrt();
+                clock.1 = voice_tuning.delay(d);
             }
         }
+        p.delay = Some(clock.1);
+        Some(p)
     };
     let data = &*data;
-    let mut v = Voices { mixer: &mut rt.mixer, data, loaded: &mut speech.loaded, missing: &mut missing };
-    let events = speech.player.frame(&data.index, &mut params, &mut v);
-    for e in &events {
-        match *e {
-            Event::Started { speaker, line, .. } => {
-                speech.lines += 1;
-                debug!("AUDIO_WORLD speech start owner={speaker} {} take {}", data.index.clips.get(line.clip).map_or("?", |c| c.name.as_str()), line.take);
+    let mut channels: Vec<(&Data, &mut SpeechPlayer, &mut VecDeque<u16>, usize)> = Vec::with_capacity(2);
+    if let Some(c) = speech.cast.as_mut() {
+        channels.push((&c.data, &mut c.player, &mut c.loaded, MAIN_CAST_BANK));
+    }
+    channels.push((data, &mut speech.player, &mut speech.loaded, SPEECH_BANK));
+    for (d, player, loaded, bank) in channels {
+        let mut v = Voices { mixer: &mut rt.mixer, bank, data: d, loaded, missing: &mut missing, echo_delay: &mut speech.echo_delay };
+        let events = player.frame(&d.index, &mut params, &mut v);
+        for e in &events {
+            match *e {
+                Event::Started { speaker, line, .. } => {
+                    speech.lines += 1;
+                    debug!("AUDIO_WORLD speech start owner={speaker} {} take {}", d.index.clips.get(line.clip).map_or("?", |c| c.name.as_str()), line.take);
+                }
+                Event::Cut { speaker, .. } => debug!("AUDIO_WORLD speech cut owner={speaker} (level at or below 200 for 2 s)"),
+                _ => {}
             }
-            Event::Cut { speaker, .. } => debug!("AUDIO_WORLD speech cut owner={speaker} (level at or below 200 for 2 s)"),
-            _ => {}
         }
     }
     speech.missing_logged = missing;
+    // SFXObj_Speech (process `sub_824E2050`, every frame): its inputs 0 / 1 / 4 are 32767 while a
+    // playing line's speaker (the voice id of its clip name) is 37–38 / 75–77 (the security
+    // guards) / 1–29 (the pros), else 0: the Global ducks F18 / F19 / F23 / F42 / F45 … read them.
+    // Inputs 2 and 3 (a speech-system state and a per-stream flag pair) are not traced.
+    let mut active: Vec<u64> = speech.player.speakers().collect();
+    if let Some(c) = speech.cast.as_ref() {
+        active.extend(c.player.speakers());
+    }
+    let mut inputs = [false; 5];
+    for v in active.iter().filter_map(|s| speech.voices.get(s)) {
+        inputs[0] |= (37..=38).contains(v);
+        inputs[1] |= (75..=77).contains(v);
+        inputs[4] |= (1..=29).contains(v);
+    }
+    if inputs != speech.speech_inputs {
+        for (i, on) in inputs.iter().enumerate() {
+            m.set_input(skate_audio::mixmap::keys::SPEECH, i, if *on { 32767 } else { 0 });
+        }
+        speech.speech_inputs = inputs;
+    }
     // Forget speakers that no longer play or wait.
-    let active: Vec<u64> = speech.player.speakers().collect();
-    let waiting = speech.player.queued() > 0;
+    let waiting = speech.player.queued() > 0 || speech.cast.as_ref().is_some_and(|c| c.player.queued() > 0);
     if !waiting {
         speech.who.retain(|id, _| active.contains(id));
+        speech.voices.retain(|id, _| active.contains(id));
+        speech.delay_clock.retain(|id, _| active.contains(id));
     }
 }
 
@@ -600,6 +792,8 @@ mod tests {
         clip: Option<String>,
         geometry: Option<Geometry>,
         first: First,
+        #[serde(default)]
+        sends_by_module: std::collections::HashMap<String, f32>,
     }
     #[derive(Deserialize)]
     struct Geometry {
@@ -613,6 +807,8 @@ mod tests {
         send: Option<f32>,
         lpf: Option<f32>,
         hpf: Option<f32>,
+        #[serde(default)]
+        peak: Option<[f32; 3]>,
     }
 
     /// Our PedestrianSpeech values against the recomp's speech voices (data-gated: the install's
@@ -620,8 +816,11 @@ mod tests {
     /// on sessions 163809 / 164620 / 180430). Per line with a joined speaker: the ped, the camera
     /// (WPPOS) and the player (PEDSEE's target) at its start drive one ped's 3DObjPos (the camera
     /// looking at the player); the stream values our port derives from the outputs (`_f` clips
-    /// out3, else out2; send out15; filters out13 / out14) are compared with the recomp's first
-    /// GAIN / SEND / LPF / HPF targets of the voice. Prints every row and the agreement.
+    /// out3, else out2, × the voice float; the echo send out21, the env send out15; filters out13 / out14; the PEAK from the
+    /// azimuth curves) are compared with the recomp's first GAIN / SEND (per send module: `+0x570`
+    /// before the gain, `+0x7D0` after the filters) / LPF / HPF / PEAK targets of the voice. The
+    /// PEAK is also checked without our geometry: the recomp's (centre, gain) must lie on the two
+    /// curves at one azimuth. Prints every row and the agreement.
     #[test]
     #[ignore = "needs the private install data and the recomp level export"]
     fn speech_levels_follow_the_recomp() {
@@ -638,6 +837,9 @@ mod tests {
             panic!("missing private data: no speech level export (SKATE_SPEECH_LEVELS, speech_levels.py --json)");
         }
         let (mut filt_ok, mut filt_n, mut send_ok, mut send_n) = (0, 0, 0, 0);
+        let (mut echo_ok, mut echo_n, mut old_ok, mut peak_on, mut peak_ours, mut peak_n) = (0, 0, 0, 0, 0, 0);
+        let voice = skate_audio::world::speech_player::SpeechVoiceTuning::default();
+        let world = crate::game_audio::Library::load(&base.join("assets")).ok();
         let mut ratios = Vec::new();
         for (session, r) in &rows {
             let g = r.geometry.as_ref().unwrap();
@@ -654,8 +856,15 @@ mod tests {
                 tick(&mut m);
             }
             let far = r.clip.as_deref().is_some_and(speech_player::far_clip);
-            let out = OutputsSnapshot::take(&m, keys::ped_speech(0), &speech_player::PED_FILTERS);
-            let p = speech_player::ped_outputs(&out, PedLevelSelect::default(), 0, far);
+            let out = OutputsSnapshot::take(&m, keys::ped_speech(0), &speech_player::PED_SNAPSHOT_FILTERS);
+            // The speaker's per-voice float (`S+152`) from the clip name's voice.
+            let scale = r
+                .clip
+                .as_deref()
+                .and_then(skate_audio::world::speech::parse_name)
+                .and_then(|(_, v, _, _)| world.as_ref().and_then(|l| l.world_tuning().ped_model(v)))
+                .map_or(1.0, |m| if m.pitch > 0.0 { m.pitch } else { 1.0 });
+            let p = speech_player::ped_outputs(&out, PedLevelSelect::default(), 0, far, &voice, scale);
             let gain = r.first.gain.unwrap();
             if p.gain > 1e-3 && gain > 1e-3 {
                 ratios.push(gain / p.gain);
@@ -664,19 +873,47 @@ mod tests {
                 filt_n += 1;
                 filt_ok += usize::from((lpf - p.lpf).abs() <= 0.1 * lpf.max(1.0) && (hpf - p.hpf).abs() <= 0.1 * hpf.max(10.0));
             }
-            if let Some(send) = r.first.send {
+            let near = |a: f32, b: f32| (a - b).abs() <= 0.01_f32.max(0.25 * a.abs());
+            if let Some(&send) = r.sends_by_module.get("570") {
                 send_n += 1;
-                send_ok += usize::from((send - p.send).abs() <= 0.01);
+                send_ok += usize::from(near(send, p.echo));
+                // The first port's reading (out15 as this send).
+                old_ok += usize::from(near(send, p.send));
+            }
+            if let Some(&env) = r.sends_by_module.get("7D0") {
+                echo_n += 1;
+                echo_ok += usize::from(near(env, p.send));
+            }
+            if let Some([freq, gain, _]) = r.first.peak {
+                peak_n += 1;
+                // The azimuth the recomp's gain says (the gain curve falls from 0.4 to 0.1), then
+                // the centre the other curve gives there.
+                let (mut lo, mut hi) = (0.0f32, 32767.0f32);
+                for _ in 0..40 {
+                    let mid = 0.5 * (lo + hi);
+                    if voice.peak_gain.eval(mid) > gain { lo = mid } else { hi = mid }
+                }
+                let at = voice.peak_freq.eval(0.5 * (lo + hi));
+                peak_on += usize::from((at - freq).abs() <= 0.02 * freq);
+                peak_ours += usize::from((p.peak[0] - freq).abs() <= 0.1 * freq && (p.peak[1] - gain).abs() <= 0.1 * gain);
+                eprintln!("    PEAK recomp {freq:.0} Hz x {gain:.4} (on the curves: {at:.0} Hz at that gain) ours {:.0} Hz x {:.4}", p.peak[0], p.peak[1]);
+            }
+            if std::env::var("EXPLORE").is_ok() {
+                use skate_audio::player::Outputs as _;
+                let lv: Vec<String> = (0..26).map(|i| format!("{i}:{:.4}", out.level(i) as f32 / 32767.0)).collect();
+                eprintln!("  sends {:?} raw0 {} peak {:?} | {}", r.sends_by_module, out.raw(0), r.first.peak, lv.join(" "));
             }
             let d = |a: [f32; 3], b: [f32; 3]| ((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2) + (a[2] - b[2]).powi(2)).sqrt();
             eprintln!(
-                "{session} {:7.1}s cam {:5.1} m skater {:5.1} m {:>32}: gain recomp {gain:.3} ours {:.3} | send {:?} {:.3} | lpf {:?} {:.0} hpf {:?} {:.0}",
+                "{session} {:7.1}s cam {:5.1} m skater {:5.1} m {:>32}: gain recomp {gain:.3} ours {:.3} | echo send (+570) {:?} {:.3} env send (+7D0) {:?} {:.3} | lpf {:?} {:.0} hpf {:?} {:.0}",
                 r.ms / 1000.0,
                 d(g.ped, g.camera),
                 d(g.ped, g.player),
                 r.clip.as_deref().unwrap_or("?"),
                 p.gain,
-                r.first.send,
+                r.sends_by_module.get("570"),
+                p.echo,
+                r.sends_by_module.get("7D0"),
                 p.send,
                 r.first.lpf,
                 p.lpf,
@@ -686,7 +923,114 @@ mod tests {
         }
         ratios.sort_by(f32::total_cmp);
         let median = ratios.get(ratios.len() / 2).copied().unwrap_or(0.0);
-        eprintln!("{} lines: filters within 10 % in {filt_ok} of {filt_n}, send within 0.01 in {send_ok} of {send_n}, gain recomp / ours median {median:.3} (p10 {:.3} p90 {:.3}, n {})", rows.len(), ratios.get(ratios.len() / 10).copied().unwrap_or(0.0), ratios.get(ratios.len() * 9 / 10).copied().unwrap_or(0.0), ratios.len());
+        eprintln!("{} lines: filters within 10 % in {filt_ok} of {filt_n}; the echo send (+0x570) = out21 within 25 % (or 0.01) in {send_ok} of {send_n} (as out15: {old_ok}); the env send (+0x7D0) = out15 in {echo_ok} of {echo_n}; PEAK on the curves in {peak_on} of {peak_n}, ours within 10 % in {peak_ours}; gain recomp / ours median {median:.3} (p10 {:.3} p90 {:.3}, n {})", rows.len(), ratios.get(ratios.len() / 10).copied().unwrap_or(0.0), ratios.get(ratios.len() * 9 / 10).copied().unwrap_or(0.0), ratios.len());
         assert!(filt_n == 0 || filt_ok * 10 >= filt_n * 6, "the filters follow out13 / out14");
+        assert!(send_ok > old_ok && echo_ok * 2 >= echo_n, "the two sends follow out21 / out15");
+        assert_eq!(peak_on, peak_n, "every recomp PEAK lies on the curves");
+    }
+
+    #[derive(Deserialize)]
+    struct CastRow {
+        session: String,
+        ms: f64,
+        clip: String,
+    }
+
+    /// Every main-cast line the recomp streamed (`maincast_reads.py --json`:
+    /// `$SKATE_MAINCAST_LINES/maincast_lines.json`, 82 lines in 11 sessions) is reachable through
+    /// our port: the speaker's model speaks on the main cast (its cast bit / word from
+    /// `world_tuning.ped_models`), and a record of the clip's event matches the words
+    /// `main_cast::request_words` builds for it (near or far; the pro-on-pro lines with some other
+    /// main-cast model) with the clip among its clips. Lines whose event the port sends are counted
+    /// apart (130 `_col`, the skater-collision line, has no ported sender).
+    #[test]
+    #[ignore = "needs the private install data and the recomp main-cast export"]
+    fn main_cast_lines_are_reachable() {
+        use skate_audio::world::speech_rules::matches;
+        let root = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets"));
+        let Ok(library) = crate::game_audio::Library::load(root) else { panic!("missing private data: no audio install") };
+        let Some((index_path, _)) = library.speech("maincast") else { panic!("missing private data: no main-cast index (stage_world_audio.py --maincast)") };
+        let dir = std::env::var_os("SKATE_MAINCAST_LINES").filter(|v| !v.is_empty()).map(std::path::PathBuf::from);
+        let Some(Ok(text)) = dir.map(|d| std::fs::read_to_string(d.join("maincast_lines.json"))) else { panic!("missing private data: SKATE_MAINCAST_LINES (maincast_reads.py --json)") };
+        let rows: Vec<CastRow> = serde_json::from_str(&text).unwrap();
+        let json: IndexJson = serde_json::from_str(&std::fs::read_to_string(&index_path).unwrap()).unwrap();
+        let ids: HashMap<String, u16> = json.clips.iter().filter_map(|c| Some((c.name.clone(), c.id?))).collect();
+        let data = load(&index_path, None).unwrap();
+        let world = library.world_tuning();
+        let cast: Vec<(u32, (u32, u32, u32))> = (1..=96).filter_map(|v| Some((v, world.ped_model(v)?.main_cast()?))).collect();
+        // The events the port sends on the main cast (skater_speech, the messages, the ped values).
+        let sent = [0u16, 1, 16, 287, 288, 115, 125, 6, 141, 11, 77, 253, 250, 247];
+        let (mut ok, mut ported, mut missing) = (0, 0, Vec::new());
+        for r in &rows {
+            let Some((number, voice, _, _)) = skate_audio::world::speech::parse_name(&r.clip) else { continue };
+            let event = data.table.events.iter().find(|e| e.name.split('_').next() == Some(&number.to_string())).map(|e| e.id);
+            let words_of = cast.iter().find(|(v, _)| *v == voice).map(|c| c.1);
+            let (Some(event), Some(words), Some(&id)) = (event, words_of, ids.get(&r.clip)) else {
+                missing.push(format!("{} {:.1}s {} (event {event:?}, cast {words_of:?})", r.session, r.ms / 1000.0, r.clip));
+                continue;
+            };
+            let ev = data.table.event(event).unwrap();
+            let others: Vec<Option<(u32, u32, u32)>> = if matches!(event, 254 | 287 | 288) { cast.iter().map(|c| Some(c.1)).collect() } else { vec![None] };
+            let hit = [false, true].iter().any(|far| {
+                others.iter().any(|o| {
+                    let w = main_cast::request_words(event, &cast_block(words, *far, *o));
+                    ev.records.iter().any(|rec| rec.clips.iter().any(|c| c.id == id) && matches(ev, rec, data.table.packed(event), &w))
+                })
+            });
+            if hit {
+                ok += 1;
+                ported += usize::from(sent.contains(&event));
+            } else {
+                missing.push(format!("{} {:.1}s {} (event {event})", r.session, r.ms / 1000.0, r.clip));
+            }
+        }
+        for m in &missing {
+            eprintln!("  not reachable: {m}");
+        }
+        eprintln!("{} recorded main-cast lines: {ok} reachable through our words ({ported} of an event the port sends)", rows.len());
+        assert!(!rows.is_empty());
+        assert!(missing.is_empty(), "{} lines not reachable", missing.len());
+    }
+
+    /// A pro (Ryan Smith, model 24) as an NPC skater sees the player's trick: its speech process
+    /// sends main-cast event 0 (`101_pos`) and the main-cast channel streams a `101_24_Smit_pos`
+    /// take at its PlayerSpeech owner's level (data-gated: the install with the main-cast decode).
+    #[test]
+    #[ignore = "needs the private install data"]
+    fn a_pro_skater_says_a_main_cast_line() {
+        let root = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets"));
+        let Ok(library) = crate::game_audio::Library::load(root) else { panic!("missing private data: no audio install") };
+        let Ok(mut native) = Native::start(&library) else { panic!("missing private data: no AEMS install") };
+        if library.speech("maincast").and_then(|s| s.1).is_none() {
+            panic!("missing private data: no main-cast decode (stage_world_audio.py --maincast decode)");
+        }
+        let mut speech = WorldSpeech::default();
+        let local = skate_audio::player::AudioState::default();
+        let camera = Some(([0.0, 1.5, 0.0], [0.0, 0.0, 1.0]));
+        let id = 77u64;
+        let mut seen = Vec::new();
+        // Past the events' repeat times (the manager's timers start at 0 at boot).
+        native.mixmap.as_mut().unwrap().ticks += 30 * 120;
+        for frame in 0..60 {
+            let reactions = Reactions { trick: frame == 2, ..Default::default() };
+            speech.skaters = vec![SkaterSpeaker { id, voice: 24, position: [0.0, 0.0, 4.0], velocity: [0.0; 3], reactions }];
+            {
+                let m = native.mixmap.as_mut().unwrap();
+                tick(m);
+            }
+            run(&mut speech, &[], &mut native, &library, camera, &local);
+            let mut rt = native.shared.lock().unwrap();
+            for _ in 0..3 {
+                rt.render_block();
+            }
+            for v in rt.mixer.snapshot().iter().filter(|v| v.bank == MAIN_CAST_BANK) {
+                seen.push((v.id, v.gain));
+            }
+        }
+        let cast = speech.cast.as_ref().expect("the main-cast channel loaded");
+        assert!(speech.lines >= 1, "a line started");
+        assert!(!seen.is_empty(), "a main-cast voice sounded");
+        assert!(seen.iter().any(|s| s.1 > 0.0), "audible");
+        eprintln!("main cast: {} lines, {} voice frames, started {}", speech.lines, seen.len(), cast.player.started);
     }
 }
diff --git a/crates/skate-game/src/modding/world_audio.rs b/crates/skate-game/src/modding/world_audio.rs
index 6921c0be..addf8974 100644
--- a/crates/skate-game/src/modding/world_audio.rs
+++ b/crates/skate-game/src/modding/world_audio.rs
@@ -43,7 +43,7 @@ fn merge(into: &mut WorldAudioOptions, from: WorldAudioOptions) {
     macro_rules! take {
         ($($f:ident),*) => { $( if from.$f.is_some() { into.$f = from.$f; } )* };
     }
-    take!(position, velocity, heading, body, engine, speed, load, horn, skidding, voice, shoe_class, weight, close_range, feet, materials, footsteps, source, from, seconds, wheels, material, grinding, grind_material, air);
+    take!(position, velocity, heading, body, engine, speed, load, horn, skidding, voice, shoe_class, weight, close_range, feet, materials, footsteps, tazing, photo_flag, source, from, seconds, wheels, material, grinding, grind_material, air, loose_board);
 }
 
 /// The ghost's states from `logs/<name>.tsv` in the mod, or `SKATE_AUDIO_STATE_LOGS/<name>.tsv`.
@@ -137,6 +137,24 @@ pub(super) fn event(world: &mut World, owner: &str, key: &str, event: &str, opts
         ("alarm", ObjectKind::Traffic) => {
             world.write_message(VehicleAlarm { vehicle: entity });
         }
+        ("tazer", ObjectKind::Ped) => {
+            world.write_message(PedTazerEvent { ped: entity, seconds: opts.seconds });
+        }
+        ("body_fall", ObjectKind::Ped) => {
+            let kind = opts.kind.ok_or("body_fall needs its kind")?;
+            world.write_message(PedBodyFallEvent { ped: entity, kind: f32::from(kind) });
+        }
+        ("reaction", ObjectKind::Skater) => {
+            let reaction = match opts.value.as_ref().and_then(Value::as_str) {
+                Some("slam") => SkaterReaction::Slam,
+                Some("slam_b") => SkaterReaction::SlamB,
+                Some("trick") => SkaterReaction::Trick,
+                Some("crash") => SkaterReaction::Crash,
+                Some("chase") => SkaterReaction::Chase,
+                other => return Err(format!("unknown reaction {other:?}")),
+            };
+            world.write_message(NpcSkaterReactionEvent { skater: entity, reaction, by: opts.by.unwrap_or(0) });
+        }
         ("speech", ObjectKind::Ped) => {
             let value = match &opts.value {
                 Some(Value::Number(n)) => n.as_i64().map(|v| SpeechValue(v as i32)),
@@ -215,8 +233,14 @@ fn sync(
     game_time: Res<Time>,
     physics: Option<Res<crate::physics::GamePhysics>>,
     mut q: Query<(&mut Transform, &mut GlobalTransform, Option<&mut TrafficAudio>, Option<&mut PedAudio>, Option<&mut NpcSkaterAudio>, Option<&mut AudioVelocity>)>,
+    mut living: ResMut<LivingWorldAudio>,
     mut commands: Commands,
 ) {
+    // The photographer's game flag: raised while any mod ped sets it (cleared with the objects).
+    let photo = audio.objects.values().any(|o| o.kind == ObjectKind::Ped && o.state.photo_flag == Some(true));
+    if living.mod_photo_flag != photo {
+        living.mod_photo_flag = photo;
+    }
     if audio.objects.is_empty() {
         return;
     }
@@ -284,6 +308,8 @@ fn sync(
                 footsteps_on: s.footsteps,
                 speech_distance: None,
                 speech_value: ped.speech_value,
+                tazing: !parked && s.tazing.unwrap_or(false),
+                body_fall: ped.body_fall,
             };
             if *ped != want {
                 *ped = want;
@@ -294,6 +320,10 @@ fn sync(
             if npc.voice != voice {
                 npc.voice = voice;
             }
+            let loose = s.loose_board.unwrap_or(0).min(2);
+            if npc.loose_board != loose {
+                npc.loose_board = loose;
+            }
             let v = if parked { Vec3::ZERO } else { velocity.unwrap_or(derived) };
             let v = match s.speed {
                 Some(speed) if !parked && v.length() < 1e-4 => t.rotation * Vec3::Z * speed,
diff --git a/crates/skate-game/src/world_audio.rs b/crates/skate-game/src/world_audio.rs
index c81a63b2..c7496015 100644
--- a/crates/skate-game/src/world_audio.rs
+++ b/crates/skate-game/src/world_audio.rs
@@ -26,8 +26,10 @@
 //! [`WorldAudioInstance`] on the entities that hold an instance, so an engine system can skip
 //! per-frame audio work (an NPC's `AudioState`) for the others.
 //!
-//! Messages: [`PedSpeechEvent`] (a state graph's `SendSpeechEvent`), [`VehicleHorn`] (hold a horn
-//! kind for the caller's time), [`VehicleAlarm`] (retail's 8 s alarm). Set [`LivingWorldAudio`]
+//! Messages: [`PedSpeechEvent`] (a state graph's `SendSpeechEvent`), [`PedTazerEvent`] (a zap:
+//! the tazer burst), [`PedBodyFallEvent`] (a knock-down animation's `BodyFallType` key),
+//! [`NpcSkaterReactionEvent`] (an NPC skater saw a slam / trick or crashed: its own speech),
+//! [`VehicleHorn`] (hold a horn kind for the caller's time), [`VehicleAlarm`] (retail's 8 s alarm). Set [`LivingWorldAudio`]
 //! `expected` at map load when the system will publish, so the world banks decode ahead of need.
 //!
 //! Everything stays inert when nothing is published. `SKATE_AEMS_WORLD=0` /
@@ -39,6 +41,8 @@ use bevy::prelude::*;
 
 pub use skate_audio::player::AudioState;
 pub use skate_audio::player::state::LiteSkater;
+/// An NPC skater's reaction bytes (what the AI sets per frame; `skate_audio::world::skater_speech`).
+pub use skate_audio::world::skater_speech::Reactions as SkaterReactions;
 
 /// A vehicle's horn state (`+156`): what the traffic AI decides. `Honk(1..=5)` = the horn kind
 /// (which kind a model uses is the AI's; retail packs it per vehicle), `Alarm` = the car alarm
@@ -132,6 +136,14 @@ pub struct PedAudio {
     /// `S+136`: the speech value the ped's state graph last sent. Engine systems normally send
     /// [`PedSpeechEvent`] instead; the footstep packets read it too (jump 4/5, collision 6/7).
     pub speech_value: i32,
+    /// `S+80`: the ped is tazing (retail: while its state graph's `TazeEntity` state runs):
+    /// SFXObj_Tazer holds the `c_tazer` packet (the zap burst). [`PedTazerEvent`] holds it for a
+    /// time instead.
+    pub tazing: bool,
+    /// `S+76`: the ped animation's `BodyFallType` channel (0 = none). Each change to a non-zero
+    /// value starts one PedBodyFall sound (8, 9 and any other value have their own sounds).
+    /// [`PedBodyFallEvent`] sends one key instead.
+    pub body_fall: f32,
 }
 
 impl Default for PedAudio {
@@ -146,6 +158,8 @@ impl Default for PedAudio {
             footsteps_on: None,
             speech_distance: None,
             speech_value: 0,
+            tazing: false,
+            body_fall: 0.0,
         }
     }
 }
@@ -164,9 +178,19 @@ pub struct NpcSkaterAudio {
     pub state: Option<AudioState>,
     /// A remote multiplayer player (sorted before the NPCs).
     pub remote: bool,
-    /// The skater's speech voice (the AI skaters' models 89–96; their bail grunt, event 8206, says
-    /// a line of it). None = no speech.
+    /// The skater's speech voice (its `aud_characteristics` model: the AI skaters' 89–96 speak on
+    /// the living-world channel, the pros 1–29 and the special cast 30–38 on the main cast). Its
+    /// bail grunt (event 8206 / 115) and its reactions say lines of it. None = no speech.
     pub voice: Option<u32>,
+    /// The skater record's reaction bytes this frame (a slam or trick it saw and by whom, its own
+    /// crash, the chase flag): its speech process says the matching lines. Held while set, as the
+    /// AI holds them; [`NpcSkaterReactionEvent`] raises one for a console frame instead.
+    pub reactions: SkaterReactions,
+    /// The conditioner's loose-board state (state `+780`: 0 none, 1 upside down, 2 on its side;
+    /// `skate_audio::player::rolling::loose_board` from the bail / on-foot flag, the deck contact,
+    /// its material and the deck's up against the ground): the board slide (`c_board_slide`) holds
+    /// while it is set. Retail computes it per skater entry and the instance bridge copies it.
+    pub loose_board: u8,
 }
 
 /// Overrides the velocity the bridge derives from the transform (m/s, world).
@@ -196,6 +220,12 @@ pub struct LivingWorldAudio {
     /// The living world will publish on this map: the world banks are read and decoded on the
     /// prefetch worker. Set it at map load / spawner start, clear it when the world stops.
     pub expected: bool,
+    /// The game flag PedestrianSpeech's photographer repeat needs (retail: a system byte,
+    /// `*(0x830CFDC4)+912`, meaning not traced): while set, a ped holding speech value 29
+    /// (`PictureTaking`) repeats its request every `world_tuning.ped_objects.photo_repeat` s.
+    pub photo_flag: bool,
+    /// The same flag raised by mods (`photo_flag` on a mod ped; cleared with the mod's objects).
+    pub mod_photo_flag: bool,
 }
 
 /// Debug counts (read only; written by the bridge every frame).
@@ -287,10 +317,63 @@ pub struct VehicleAlarm {
 /// The car alarm's length (s).
 pub const ALARM_SECONDS: f32 = 8.0;
 
+/// A ped zaps with its tazer: `PedAudio::tazing` is held for `seconds` (None = the state graph's
+/// `TazerCycTime`, `world_tuning.ped_objects.tazer_seconds`, 2.0 s), the `c_tazer` burst plays.
+#[derive(Message, Clone, Copy, Debug)]
+pub struct PedTazerEvent {
+    pub ped: Entity,
+    pub seconds: Option<f32>,
+}
+
+/// A ped animation's `BodyFallType` key (a knock-down's events: 9, other, 9, 9 … in retail):
+/// one PedBodyFall sound. Keys are queued; each is held for one console frame with a frame of 0
+/// before the next, so repeated values sound.
+#[derive(Message, Clone, Copy, Debug)]
+pub struct PedBodyFallEvent {
+    pub ped: Entity,
+    pub kind: f32,
+}
+
+/// One NPC skater reaction (the skater record's reaction bytes, `sub_824B6E80`).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SkaterReaction {
+    /// A slam it saw (`+102`), by the skater model `by` (0 = the player).
+    Slam,
+    /// The second slam reaction (`+103`).
+    SlamB,
+    /// A trick it saw (`+104`).
+    Trick,
+    /// Its own crash (`+131`).
+    Crash,
+    /// The chase flag (living-world voices only).
+    Chase,
+}
+
+/// An NPC skater reacts: the reaction is held for one console frame (`by` = the other skater's
+/// model, 0 = the player; the pro-on-pro lines name it).
+#[derive(Message, Clone, Copy, Debug)]
+pub struct NpcSkaterReactionEvent {
+    pub skater: Entity,
+    pub reaction: SkaterReaction,
+    pub by: u32,
+}
+
+impl SkaterReaction {
+    /// `set` with this reaction raised.
+    pub fn raise(self, mut set: SkaterReactions, by: u32) -> SkaterReactions {
+        match self {
+            Self::Slam => (set.slam, set.slam_by) = (true, by),
+            Self::SlamB => (set.slam_b, set.slam_b_by) = (true, by),
+            Self::Trick => (set.trick, set.trick_by) = (true, by),
+            Self::Crash => set.crash = true,
+            Self::Chase => set.chase = true,
+        }
+        set
+    }
+}
+
 // The NPC bail grunt needs no message: retail's body poster raises it at the bail's first body
-// impact (`NpcSkaterAudio::voice` names the speaker). Not offered (spec §3.4): `PedKnockDown`
-// (PedBodyFall) and `PedTazer` (Tazer): no recording shows what they post (doc 15 "PedBodyFall
-// and Tazer").
+// impact (`NpcSkaterAudio::voice` names the speaker).
 
 #[cfg(test)]
 mod tests {
diff --git a/crates/skate-mods/src/vm.rs b/crates/skate-mods/src/vm.rs
index 8de90190..1db90d4d 100644
--- a/crates/skate-mods/src/vm.rs
+++ b/crates/skate-mods/src/vm.rs
@@ -1759,11 +1759,14 @@ mod world_audio_tests {
         let mut spawned = 0;
         let mut live = std::collections::BTreeSet::new();
         let mut most = 0;
+        let mut events: BTreeMap<String, usize> = BTreeMap::new();
+        let mut photo = Vec::new();
+        let mut ghost_voices = Vec::new();
         for frame in 0..400u32 {
             let t = frame as f32 / 60.0;
             let snapshot = json!({"tick": frame, "player": {"position": [t * 4.0, 0.0, 0.0], "speed": 4.0,
                 "landing_seq": frame / 100, "bail_seq": frame / 250},
-                "keys": {"F8": frame == 200, "F9": frame == 300},
+                "keys": {"F8": frame == 200, "F9": frame == 300, "F7": frame == 100, "F6": frame == 120, "F5": frame == 140, "F4": frame == 160 || frame == 180, "F3": frame == 220, "F2": frame == 240 || frame == 260},
                 "world_audio": {"dev-world-audio-test": {"car1": {"kind": "traffic", "audible": true, "instance": 0}}},
                 "command_results": {"dev-world-audio-test": {"ghost": {"token": 1, "ok": false, "error": "logs/x.tsv: missing"}}}});
             let out = vm.call("on_update", json!({"dt": 1.0 / 60.0}), &snapshot).unwrap_or_else(|e| panic!("frame {frame}: {e}"));
@@ -1778,12 +1781,34 @@ mod world_audio_tests {
                     Command::WorldAudioRemove { key } => {
                         live.remove(key);
                     }
+                    Command::WorldAudioEvent { event, options, .. } => {
+                        let name = match (event.as_str(), &options.value) {
+                            ("speech", Some(v)) if v == &json!(49) => "phone".to_owned(),
+                            ("speech", Some(v)) if v == &json!(29) => "photographer".to_owned(),
+                            ("reaction", Some(v)) => format!("reaction {}", v.as_str().unwrap_or("?")),
+                            (e, _) => e.to_owned(),
+                        };
+                        *events.entry(name).or_default() += 1;
+                    }
+                    Command::WorldAudioUpdate { options, .. } if options.photo_flag.is_some() => photo.push(options.photo_flag.unwrap()),
+                    Command::WorldAudioUpdate { key, options } if key == "ghost" && options.voice.is_some() => ghost_voices.push(options.voice.unwrap()),
                     _ => {}
                 }
             }
             most = most.max(live.len());
         }
         assert_eq!(spawned, 2 * 36, "16 cars and 20 peds, twice (F9 re-centres); the ghost goes through a request");
+        // The new ped events: F7 a zap, F6 a knock-down (four BodyFallType keys over 0.74 s), F5 a
+        // phone call (value 49), F4 a photographer (value 29 with the photo flag) and F4 again off.
+        assert_eq!(events.get("tazer"), Some(&1), "{events:?}");
+        assert_eq!(events.get("body_fall"), Some(&4), "{events:?}");
+        assert_eq!(events.get("phone"), Some(&1), "{events:?}");
+        assert_eq!(events.get("photographer"), Some(&1), "{events:?}");
+        assert_eq!(photo, vec![true, false]);
+        // The ghost: F3 a trick reaction, F2 twice a crash (first as the pro 24, then as its AI voice).
+        assert_eq!(events.get("reaction trick"), Some(&1), "{events:?}");
+        assert_eq!(events.get("reaction crash"), Some(&2), "{events:?}");
+        assert_eq!(ghost_voices, vec![24, 91]);
         // Everything it publishes at once (+ the ghost) fits the host's per-mod limit: no
         // "World audio object limit reached" (the 16 / 64 limits refused 21 of 37).
         assert!(most + 1 <= crate::world_audio::MAX_OBJECTS_PER_MOD, "{most} + ghost objects");
@@ -1796,6 +1821,13 @@ mod world_audio_tests {
             json!({"kind":"world_audio_update","key":"car1","options":{"speed":3,"load":-2}}),
             json!({"kind":"world_audio_event","key":"car1","event":"alarm"}),
             json!({"kind":"world_audio_event","key":"ped1","event":"speech","options":{"value":"warn"}}),
+            json!({"kind":"world_audio_event","key":"ped1","event":"tazer"}),
+            json!({"kind":"world_audio_event","key":"ped1","event":"tazer","options":{"seconds":2}}),
+            json!({"kind":"world_audio_event","key":"ped1","event":"body_fall","options":{"kind":9}}),
+            json!({"kind":"world_audio_event","key":"sk1","event":"reaction","options":{"value":"crash"}}),
+            json!({"kind":"world_audio_event","key":"sk1","event":"reaction","options":{"value":"slam","by":0}}),
+            json!({"kind":"world_audio_update","key":"ped1","options":{"tazing":true,"photo_flag":true}}),
+            json!({"kind":"world_audio_update","key":"sk1","options":{"loose_board":1}}),
             json!({"kind":"world_audio_remove","key":"car1"}),
         ] {
             let c: Command = serde_json::from_value(value.clone()).unwrap();
diff --git a/crates/skate-mods/src/world_audio.rs b/crates/skate-mods/src/world_audio.rs
index d26b9585..dec5ab61 100644
--- a/crates/skate-mods/src/world_audio.rs
+++ b/crates/skate-mods/src/world_audio.rs
@@ -60,8 +60,9 @@ pub struct WorldAudioOptions {
     #[serde(default)]
     pub skidding: Option<bool>,
     // ---- peds
-    /// Speech voice id 41..=96 (0 = none): a ped's model (its shoe class, kind and speech words
-    /// follow from it unless given) or a skater's voice (the bail grunt).
+    /// Speech voice id 1..=96 (0 = none): a ped's model (its shoe class, kind and speech words
+    /// follow from it unless given) or a skater's voice (the bail grunt, its reactions). The pros
+    /// 1–29 and the special cast 30–38 speak on the main-cast channel.
     #[serde(default)]
     pub voice: Option<u32>,
     #[serde(default)]
@@ -79,6 +80,14 @@ pub struct WorldAudioOptions {
     /// Footsteps on (default: retail's 3-nearest rule).
     #[serde(default)]
     pub footsteps: Option<bool>,
+    /// The ped is tazing (the `c_tazer` burst plays while it holds; the `tazer` event holds it
+    /// for a time instead).
+    #[serde(default)]
+    pub tazing: Option<bool>,
+    /// Raise the game flag of the photographer's repeat (a ped holding speech value 29 repeats it
+    /// every second while any published ped sets this).
+    #[serde(default)]
+    pub photo_flag: Option<bool>,
     // ---- skaters
     /// `lite` (the default: a rolling-only state from these fields) or `state_log:<name>` (a
     /// ghost replaying a recorded audio state log, `logs/<name>.tsv` in the mod or
@@ -102,21 +111,35 @@ pub struct WorldAudioOptions {
     pub grind_material: Option<u32>,
     #[serde(default)]
     pub air: Option<bool>,
+    /// Lite skater: the loose-board state (0 none, 1 upside down, 2 on its side): the board slide
+    /// holds while it is set (ghosts take it from their log).
+    #[serde(default)]
+    pub loose_board: Option<u8>,
 }
 
-/// One-shot options (`horn`: kind, seconds; `speech`: value).
+/// One-shot options (`horn`: kind, seconds; `speech`: value; `tazer`: seconds; `body_fall`:
+/// kind; `reaction`: value, by).
 #[derive(Clone, Debug, Default, Deserialize, PartialEq)]
 #[serde(deny_unknown_fields)]
 pub struct WorldAudioEventOptions {
+    /// `horn`: the horn kind 1..=5. `body_fall`: the animation's `BodyFallType` key (8, 9 or
+    /// any other value 1..=255: three sounds).
     #[serde(default)]
     pub kind: Option<u8>,
     #[serde(default)]
     pub seconds: Option<f32>,
     /// A speech value: a number or a name (`warn`, `cheer`, `slam`, `flee`, `DoWarning`, …).
+    /// `reaction`: `slam`, `slam_b`, `trick`, `crash` or `chase`.
     #[serde(default)]
     pub value: Option<serde_json::Value>,
+    /// `reaction`: the other skater's model (0 = the player; a pro 1..=29 picks the pro-on-pro lines).
+    #[serde(default)]
+    pub by: Option<u32>,
 }
 
+/// The NPC skater reactions a mod can raise (`reaction` event values).
+pub const REACTIONS: [&str; 5] = ["slam", "slam_b", "trick", "crash", "chase"];
+
 fn finite(v: &[f32]) -> bool {
     v.iter().all(|x| x.is_finite())
 }
@@ -146,7 +169,7 @@ impl WorldAudioOptions {
             && self.speed.is_none_or(|v| v.is_finite() && (0.0..=200.0).contains(&v))
             && self.load.is_none_or(|v| v.is_finite() && v.abs() <= 100.0)
             && self.horn.is_none_or(|v| (0..=6).contains(&v))
-            && self.voice.is_none_or(|v| v == 0 || (41..=96).contains(&v))
+            && self.voice.is_none_or(|v| v <= 96)
             && self.shoe_class.is_none_or(|v| (1..=5).contains(&v))
             && self.weight.is_none_or(|v| (1..=5).contains(&v))
             && self.materials.is_none_or(|m| m.iter().all(|x| *x <= 143))
@@ -155,14 +178,15 @@ impl WorldAudioOptions {
             && self.seconds.is_none_or(|v| v.is_finite() && (1.0..=600.0).contains(&v))
             && self.material.is_none_or(|v| v <= 143)
             && self.grind_material.is_none_or(|v| v <= 143)
+            && self.loose_board.is_none_or(|v| v <= 2)
     }
 
     /// The fields of other kinds are rejected (so a typo'd kind is an error, not silence).
     pub fn validate_for(&self, kind: ObjectKind) -> bool {
         let traffic = self.engine.is_some() || self.speed.is_some() || self.load.is_some() || self.horn.is_some() || self.skidding.is_some();
-        // `voice` is a ped's or a skater's (the AI skaters' 89–96: their bail grunt).
-        let ped = self.shoe_class.is_some() || self.weight.is_some() || self.close_range.is_some() || self.feet.is_some() || self.materials.is_some() || self.footsteps.is_some();
-        let skater = self.source.is_some() || self.from.is_some() || self.seconds.is_some() || self.wheels.is_some() || self.material.is_some() || self.grinding.is_some() || self.grind_material.is_some() || self.air.is_some();
+        // `voice` is a ped's or a skater's (the AI skaters' 89–96, the pros 1–29: bail grunt, reactions).
+        let ped = self.shoe_class.is_some() || self.weight.is_some() || self.close_range.is_some() || self.feet.is_some() || self.materials.is_some() || self.footsteps.is_some() || self.tazing.is_some() || self.photo_flag.is_some();
+        let skater = self.source.is_some() || self.from.is_some() || self.seconds.is_some() || self.wheels.is_some() || self.material.is_some() || self.grinding.is_some() || self.grind_material.is_some() || self.air.is_some() || self.loose_board.is_some();
         self.validate()
             && match kind {
                 ObjectKind::Traffic => !ped && !skater,
@@ -176,8 +200,12 @@ impl WorldAudioOptions {
 impl WorldAudioEventOptions {
     pub fn validate(&self, event: &str) -> bool {
         match event {
+            _ if event != "reaction" && self.by.is_some() => false,
+            "reaction" => self.kind.is_none() && self.seconds.is_none() && self.by.is_none_or(|b| b <= 96) && matches!(&self.value, Some(serde_json::Value::String(s)) if REACTIONS.contains(&s.as_str())),
             "horn" => self.kind.is_none_or(|k| (1..=5).contains(&k)) && self.seconds.is_none_or(|s| s.is_finite() && (0.0..=30.0).contains(&s)) && self.value.is_none(),
             "alarm" => self.kind.is_none() && self.seconds.is_none() && self.value.is_none(),
+            "tazer" => self.kind.is_none() && self.seconds.is_none_or(|s| s.is_finite() && (0.0..=30.0).contains(&s)) && self.value.is_none(),
+            "body_fall" => self.kind.is_some_and(|k| k >= 1) && self.seconds.is_none() && self.value.is_none(),
             "speech" => {
                 self.kind.is_none()
                     && self.seconds.is_none()
@@ -206,10 +234,12 @@ mod tests {
         assert!(ped.validate_for(ObjectKind::Ped) && !ped.validate_for(ObjectKind::Traffic));
         let ghost: WorldAudioOptions = serde_json::from_value(json!({"source":"state_log:state_20261003_143434","from":30,"seconds":20,"position":[0,0,0]})).unwrap();
         assert!(ghost.validate_for(ObjectKind::Skater));
-        let lite: WorldAudioOptions = serde_json::from_value(json!({"source":"lite","speed":5,"wheels":[true,true,true,true],"air":false})).unwrap();
-        assert!(lite.validate_for(ObjectKind::Skater));
-        for bad in [json!({"voice":12}), json!({"shoe_class":0}), json!({"horn":7}), json!({"source":"state_log:../x"}), json!({"source":"record"}),
-            json!({"engine":"a b"}), json!({"position":[0,1e9,0]}), json!({"velocity":[1000,0,0]}), json!({"seconds":0})] {
+        let lite: WorldAudioOptions = serde_json::from_value(json!({"source":"lite","speed":5,"wheels":[true,true,true,true],"air":false,"loose_board":2})).unwrap();
+        assert!(lite.validate_for(ObjectKind::Skater) && !lite.validate_for(ObjectKind::Ped));
+        let zapper: WorldAudioOptions = serde_json::from_value(json!({"voice":72,"tazing":true,"photo_flag":false})).unwrap();
+        assert!(zapper.validate_for(ObjectKind::Ped) && !zapper.validate_for(ObjectKind::Skater));
+        for bad in [json!({"voice":97}), json!({"shoe_class":0}), json!({"horn":7}), json!({"source":"state_log:../x"}), json!({"source":"record"}),
+            json!({"engine":"a b"}), json!({"position":[0,1e9,0]}), json!({"velocity":[1000,0,0]}), json!({"seconds":0}), json!({"loose_board":3})] {
             let o: WorldAudioOptions = serde_json::from_value(bad.clone()).unwrap();
             assert!(!o.validate(), "accepted {bad}");
         }
@@ -227,5 +257,16 @@ mod tests {
         assert!(speech.validate("speech"));
         let bad: WorldAudioEventOptions = serde_json::from_value(json!({"value":500})).unwrap();
         assert!(!bad.validate("speech"));
+        assert!(WorldAudioEventOptions::default().validate("tazer"));
+        let zap: WorldAudioEventOptions = serde_json::from_value(json!({"seconds":2.0})).unwrap();
+        assert!(zap.validate("tazer") && !zap.validate("body_fall"));
+        let fall: WorldAudioEventOptions = serde_json::from_value(json!({"kind":9})).unwrap();
+        assert!(fall.validate("body_fall") && !fall.validate("tazer"));
+        assert!(!WorldAudioEventOptions::default().validate("body_fall"), "a fall needs its kind");
+        let react: WorldAudioEventOptions = serde_json::from_value(json!({"value":"trick","by":24})).unwrap();
+        assert!(react.validate("reaction") && !react.validate("speech"));
+        let bad: WorldAudioEventOptions = serde_json::from_value(json!({"value":"dance"})).unwrap();
+        assert!(!bad.validate("reaction"));
+        assert!(!WorldAudioEventOptions::default().validate("reaction"), "a reaction needs its value");
     }
 }
diff --git a/docs/hails-additions/11-audio.md b/docs/hails-additions/11-audio.md
index 5ed5812b..4f22133f 100644
--- a/docs/hails-additions/11-audio.md
+++ b/docs/hails-additions/11-audio.md
@@ -4634,6 +4634,27 @@ Full write-up: [15](15-world-audio.md), section "P3–P5". In short:
 - **The dev test mod is opt-in** (`"enabled_by_default": false`, `SKATE3_MODS_ENABLE`). The mod limits are now
   48 / 128, and a `WORLD_AUDIO` summary is logged once a second.
 
+### World audio gaps closed: Tazer, PedBodyFall, speech details, the NPC board slide (2026-10-03, headless + one scripted run)
+
+Full write-up: [15](15-world-audio.md), section "Gaps closed". In short:
+
+- **Tazer** (`SFXObj_Tazer` decoded): `c_tazer` held while the ped tazes. Recomp 164620: 19 starts per 2 s hold
+  against 10 / 20 / 19, the same gaps (192 / 192 / 128 / 96 ms vs 190 / 190 / 130 / 90–100) and order, first-start
+  gain recomp / ours 0.85–1.00.
+- **PedBodyFall** (decoded; trigger = the animation's `BodyFallType`): 75 recorded starts (Splice, not POST);
+  containers 73 / 73 by type; voice gain recomp / ours p50 0.79.
+- **Speech:** the stream voice's PEAK = azimuth curves (6 / 6 recomp pairs on them); the per-voice float; the
+  pre-gain send (out21) feeds the slot's **echo submix** (ported: HPF → camera-distance delay → LPF → env) and the
+  post-filter send (out15) goes to the env bus (17 / 29 and 19 / 27 recomp lines); value 49 = the phone ring → 64,
+  value 29 = the photographer's 1 s repeat, `Obj:Speech` in0 / in1 / in4, first-free stream; the queue clock =
+  visual game ticks.
+- **Main cast (pros, special cast):** its own channel (`maincastspeech.big`, decode 6596 takes / 922 MB, opt-in
+  with the living world's), pro peds, NPC skater reactions and crash (`skater_speech`), the message pairs; all 82
+  recorded main-cast lines reachable through the ported words.
+- **NPC:** the board slide runs for the NPC instance (static evidence; a 4-min scripted run saw no NPC bail); the
+  NPC bed against 180430's NPC rows: near band A gain 0.097 / 0.108.
+- Local player byte-identical (e2e bench, all sets).
+
 ### PR #32 review fixes, step 2 (code half): spec references and private-data paths (2026-10-03, headless)
 
 **Problem.** Code comments in `crates/`, `tools/asset_pipeline/` and the dev test mod cited the working notes and
diff --git a/docs/hails-additions/15-world-audio.md b/docs/hails-additions/15-world-audio.md
index bf1458e7..6dc3b428 100644
--- a/docs/hails-additions/15-world-audio.md
+++ b/docs/hails-additions/15-world-audio.md
@@ -48,7 +48,7 @@ remove the component. Owner ids are `Entity::to_bits()`, so a reused index count
 
 | field | retail | meaning | default |
 |---|---|---|---|
-| `voice` | `S+84` | the model = the speech voice id 41–96. Its `aud_characteristics` record (setup export `world_tuning.ped_models`) gives the shoe class, the security kind, the speech type / variant / gender words and the far threshold (G2) | none (no speech, the defaults below) |
+| `voice` | `S+84` | the model = the speech voice id 1–96 (41–96 living-world peds; a pro 1–29 or the special cast 30–38 speaks on the main-cast channel). Its `aud_characteristics` record (setup export `world_tuning.ped_models`) gives the shoe class, the security kind, the speech type / variant / gender words and the far threshold (G2) | none (no speech, the defaults below) |
 | `shoe_class` | `S+132` | 1–5 (`None` = the model's). Most models are 2; no model uses 1, which is silent. | the model's, else 2 |
 | `weight` | `[obj+28]+144` | 1–5. It changes per ped in retail (1 beyond about 12 m, 2–5 nearer) and its meaning is open. | 1 |
 | `close_range` | `S+96 == 64` | the security guards' close-range footstep levels and their speech levels (`None` = the model's type bit) | the model's, else false |
@@ -57,6 +57,8 @@ remove the component. Owner ids are `Entity::to_bits()`, so a reused index count
 | `footsteps_on` | `S+68` | footsteps on | retail's rule: the 3 nearest peds in the list |
 | `speech_distance` | `S+148` / `S+156` | distance to the listener / the model's far threshold. Beyond the threshold the far `_f` lines are used. | the 3-D distance / the model's threshold (20 m for regular peds, 30 for pros) |
 | `speech_value` | `S+136` | the state graph's speech value | 0. Send `PedSpeechEvent` rather than writing it. |
+| `tazing` | `S+80` | the ped tazes (retail: its state graph's `TazeEntity` state): SFXObj_Tazer holds `c_tazer`, the zap burst | false. `PedTazerEvent` holds it for a time. |
+| `body_fall` | `S+76` | the ped animation's `BodyFallType` channel: each change to a non-zero value starts one PedBodyFall sound (8, 9, other) | 0. `PedBodyFallEvent` sends one key. |
 
 ### `NpcSkaterAudio` (the MixMap Player slot's second instance)
 
@@ -65,7 +67,9 @@ remove the component. Owner ids are `Entity::to_bits()`, so a reused index count
 | `list_order` | the skater list position (retail walks its list in order) | spawn order |
 | `state` | this frame's `AudioState`. A skater simulated with the player's physics uses `game_audio::skate_events::skater_audio_state(physics, skater, &mut memory, dt)`, the same builder the local player uses (proved identical, below). Anything else uses `AudioState::rolling(&LiteSkater { .. })`: speed, wheels, materials, grind / air flags. With that fill, rolling, surfaces, seams, grinds and landings sound; tricks and foot / body foley stay silent. | none (not published) |
 | `remote` | a remote multiplayer player (see below) | false |
-| `voice` | the skater's speech voice (the AI skaters' models 89–96): its bail grunt says a line of it | none |
+| `voice` | the skater's speech voice: the AI skaters' models 89–96 (living-world channel) or a pro 1–29 / the special cast 30–38 (main-cast channel). Its bail grunt and its reactions say lines of it | none |
+| `reactions` | the skater record's reaction bytes this frame (`SkaterReactions`: a slam seen and by whom, a second slam reaction, a trick seen and by whom, its own crash, the chase flag): its speech process (`skate_audio::world::skater_speech`) says `101_pos` / `104_slam` / `150_pro_pos` / `151_pro_slam` (pros) or `101_pos` / `404`–`405` / `105_spec_chase` (AI skaters), and `906_aislm` / `131_collide_object` on its crash | none. `NpcSkaterReactionEvent` raises one for a console frame. |
+| `loose_board` | the conditioner's loose-board state (`+780`: 0, 1 upside down, 2 on its side; `rolling::loose_board`): the board slide holds while set | 0 (ghosts: from their log) |
 
 ### Messages, resources and the read-back
 
@@ -79,8 +83,15 @@ remove the component. Owner ids are `Entity::to_bits()`, so a reused index count
 - `VehicleHorn { vehicle, kind, seconds }`: holds horn kind `kind` for the caller's time. The length
   is the AI's choice, not retail data.
 - `VehicleAlarm { vehicle }`: retail's alarm, horn state 6 for **8 s**.
-- `LivingWorldAudio { expected }`: set it at map load when the system will publish. The 13 world
-  banks then decode on the prefetch worker instead of the game thread.
+- `PedTazerEvent { ped, seconds }`: the ped zaps: `tazing` held for `seconds` (None = the state graph's
+  `TazerCycTime`, setup `world_tuning.ped_objects.tazer_seconds`, 2.0 s).
+- `PedBodyFallEvent { ped, kind }`: one `BodyFallType` key of a knock-down animation. Keys queue; each is on for
+  one console frame with a frame of 0 after it, so repeated keys sound.
+- `NpcSkaterReactionEvent { skater, reaction, by }`: an NPC skater reacts (`SkaterReaction::{Slam, SlamB, Trick,
+  Crash, Chase}`, `by` = the other skater's model, 0 = the player); held for one console frame.
+- `LivingWorldAudio { expected, photo_flag }`: set `expected` at map load when the system will publish (the
+  world banks then decode on the prefetch worker). `photo_flag` is the game flag of the photographer's repeat
+  (a ped holding speech value 29 repeats it every second; retail system byte `+912`, meaning not traced).
 - `WorldAudioInstance { slot, instance }` (read-back): the bridge inserts it on the entities that
   hold a MixMap instance. Only those are audible. An engine system can use it to skip per-frame
   audio work for the others, such as an NPC's `AudioState`.
@@ -157,7 +168,13 @@ sdk.world_audio.event('car1', 'horn', {kind=3, seconds=1.2})   -- or 'alarm' (8
 sdk.world_audio.spawn('taxi', 'traffic', {engine='c04_taxi01', body='chassis'})  -- a mod car opts in to a retail engine sound
 sdk.world_audio.spawn('ped1', 'ped', {voice=59, shoe_class=3, position=p})
 sdk.world_audio.update('ped1', {position=p, feet={true,false}})
-sdk.world_audio.event('ped1', 'speech', {value='warn'})        -- name or number
+sdk.world_audio.event('ped1', 'speech', {value='warn'})        -- name or number (49: a phone call)
+sdk.world_audio.event('ped1', 'tazer')                         -- the zap burst (seconds = 2 by default)
+sdk.world_audio.event('ped1', 'body_fall', {kind=9})           -- one knock-down key (8, 9, other)
+sdk.world_audio.update('ped1', {tazing=true, photo_flag=true}) -- held tazing; the photographer's game flag
+sdk.world_audio.update('npc1', {loose_board=1})                -- lite skater: the board slide
+sdk.world_audio.event('npc1', 'reaction', {value='trick', by=0}) -- it saw the player's trick (slam, slam_b, trick, crash, chase)
+sdk.world_audio.update('npc1', {voice=24})                      -- a pro's voice: the main-cast channel
 sdk.world_audio.spawn('npc1', 'skater', {position=p, speed=6})  -- lite: rolling from these fields
 sdk.world_audio.spawn('ghost', 'skater', {source='state_log:state_20261003_143434', from=30, seconds=20, position=p})
 local r = sdk.world_audio.read('car1')   -- {kind='traffic', audible=true, instance=2, parked=false}
@@ -378,14 +395,8 @@ The hosts match the measured rules:
 - Peds: the 15 nearest within 50 m (3-D, nearest-first), footsteps for the 3 nearest.
 - NPC skater: the first in list order within 30 m, held until 30 m.
 
-### PedBodyFall and Tazer: gaps
-- **Tazer.** The recordings support it: in 164620, each of the 3 tazer zaps (`SECTAZE want`) is followed 0.03 s
-  later by a burst of 10–20 Tazer-bank starts, 0.1–0.2 s apart, for 1.3–2.1 s (49 starts). No POST is attached,
-  which fits op 38 child posts; op 38 is ported. But `SFXObj_Tazer` itself (its trigger on the ped state, its
-  words) is not decoded. Not ported.
-- **PedBodyFall.** No recording shows a post from it (no event group with a caller in its code in the
-  163809 / 164620 reports). Not decoded.
-- Neither message is offered in the API.
+### PedBodyFall and Tazer
+Gaps at the end of P3; closed below ("Gaps closed").
 
 ### Mod surface
 **Done in this pass (cheap):**
@@ -446,6 +457,135 @@ and §8.6.
 - **NPC:** board slide; the walking / jump voices of an NPC on foot; the NPC grain bed against 180430's NPC GREC
   rows (not compared in this pass).
 
+## Gaps closed: Tazer, PedBodyFall, speech details, the NPC board slide and bed (2026-10-03)
+
+Built from the P3–P5 state and checked headless against the existing recordings, plus one scripted background
+recomp run for the NPC board slide (user-approved gap runs; muted, one game at a time). All numbers are "the
+recomp". Reference only: the TU3 recompilation (skate3recomp / rexglue / Xenia); our own code.
+
+### Tazer (`skate_audio::world::peds::PedTazer`)
+- **Decoded:** `SFXObj_Tazer` (Pedestrian object 3, factory `sub_824F12D0`). Its process posts the 9-word
+  `c_tazer` packet while the ped audio state's byte `S+80` is set (the manager's bit 17 of the ped entry) and
+  releases it when it clears; its update writes raw 0, pitch 1, levels 3 / 2. The program (op 38, ported earlier)
+  owns a `c_tazer_grn_play` child post and plays the burst while the packet is held.
+- **`S+80` = tazing:** each post came 22 ms after the state graph's `TazeEntity` entry (`TazerCycTime` 2.0 s).
+- **Checked** (`tazer_bursts_follow_the_recomp`, session 164620: three zaps, 49 Tazer starts): per 2 s hold ours
+  start 19 sounds (recomp 10 / 20 / 19; its first burst stopped after 1.33 s, cause not traced); gaps
+  192 / 192 / 128 / 96 ms against 190 / 190 / 130 / 90–100 (the 11th gap 128 against 129 / 131); the order 8, 7,
+  then shuffles of 0–6 in both; the first start's gain recomp / ours 0.85 / 0.93 / 1.00 at each zap's geometry.
+
+### PedBodyFall (`PedBodyFall`)
+- **Decoded:** `SFXObj_PedBodyFall` (object 2). Its trigger `S+76` is the ped animation's `BodyFallType` channel.
+  Each change to a non-zero value starts one Skate_Collisions sound through the collision Splice object: type 8 →
+  1184, 9 → 948, any other → 1183 (vault record `923CCB46EF5BF5BA` / `DFEFC9212E0CBD2C`); 8 and 9 round-robin two
+  slots. Each type follows its own volume / pitch outputs (8: out1 / out2, 9: out3 / out4, other: out5 / out6).
+- **The recordings had it after all:** the starts are Splice starts, not POSTs (75 in six sessions). Retail's
+  knock-downs key 9, other, 9, 9 (0.10 / 0.48 / 0.16 s apart) or 9, 8, 8, other, 9.
+- **Checked** (`body_falls_follow_the_recomp`, 73 starts): container by type 73 / 73; voice gain recomp / ours
+  p50 0.79 (p10 0.25, p90 1.25, n 40; the knocked-down ped is not logged, the ped nearest the player is taken).
+
+### Speech details
+- **PEAK filter:** a head shadow by azimuth. The owner's raw azimuth, folded front / back, goes through three
+  curves of the speech record (centre 600 → 4000 Hz at the side → 600, gain 0.4 → 0.1, Q 3; setup export
+  `world_tuning.speech_voice`). Every recomp PEAK (6 / 6) lies on the curves at one azimuth; ours at the estimated
+  geometry 3 / 6 within 10 %. The mixer plays speech on the stream graph (PEAK, Send A, gain, then the filters).
+- **Two sends, and the echo submix (ported):** the stream system (`sub_82C5CEF0`) multiplies the gain and both
+  sends by the speaker's per-voice float (`S+152`, `aud_characteristics` `2087A3290483BB4F`, 0.8–1.4). The
+  **pre-gain** send (`desc+16`, recomp module `+0x570`) carries PedestrianSpeech **out21** (PlayerSpeech out13)
+  and feeds the stream slot's **echo submix** (`skate_audio::bus::speech_echo`, built per stream slot by
+  `sub_82C5E2D8`: high pass = owner filter 22 (skater 14), delay = camera distance × the record's factor / 344 m/s
+  up to 0.15 s (recomputed every 4 console frames, posted only on change), low pass = filter 23 (skater 15), then
+  the environment bus). The **post-filter** send (`desc+32`, `+0x7D0`) carries out15 (skater out10) straight to
+  the environment bus. Correction to the first decode: it had out15 feeding the echo; the code says the pre-gain
+  send does. Recomp: the pre-gain send = out21 in 17 of 29 lines within 25 % (out15: 10); the post-filter send =
+  out15 in 19 of 27. Modelled mono: the graph's two-channel Pn21 / Sen0 routing is a unity tap (its gains are not
+  traced).
+- **Value 49 = a phone call:** the ped's phone rings (CellPhone_Rings container 5, now part of setup) and when the
+  ring ends the ped asks for value 64 (`4402_cell_greet`). Recomp 164620: both rings answered 1.00 / 1.19 s
+  later; the ring records last 0.84–1.13 s. Without the bank (an install from before this setup) the answer
+  follows at once (logged).
+- **Value 29 (the photographer):** repeats each second while the game flag is set (`LivingWorldAudio::photo_flag`).
+- **`Obj:Speech` inputs:** in0 / in1 / in4 are raised while a playing line's speaker is 37–38 / 75–77 (the guards)
+  / 1–29 (the pros); in2 / in3 are not traced. They don't touch regular peds, so the recomp near lines' extra
+  ~0.6 dB stays open.
+- **Which stream:** the first free one (k0 when both are free: 95 of 109 new lines).
+- **Queue timeout unit (settled from the code):** the library's clock `[[0x830CFD94]+16]` is the function behind the
+  `GetVisualGameTick` Lua binding (`0x8283C2D8`): visual game ticks, one per rendered frame. The console renders
+  at its ~30 fps cadence, so the port's console-frame count is the same unit.
+- **Main-cast channel (ported):** the pros' and the special cast's speech (`maincastspeech.big`, speech-manager
+  bank 0, channel 0, its own tuning `speech_tuning["0"]`, timers, two streams and mixer bank). Who speaks there:
+  a model with no living-world type bit and a cast bit / word (`aud_characteristics` `6F2933E977CF40DD` /
+  `14FD437D190677C8`, plus `D6EA428C2B43E23A` for the pro-on-pro lines; setup `world_tuning.ped_models`). Request
+  words per event: `sub_824AC898` (`speech_manager::main_cast::request_words`); the main cast's near / far flag is
+  1 near, 2 far. Senders:
+  - a pro **ped** (`sub_824AC438`): value 29 → `1014_bored` (141), 28 → `601_ai_greet` (11, outside a challenge),
+    30 / 51 → 115 or 6, 53 / 54 → 77;
+  - an NPC **skater's** own process (`SFXObj_PlayerSpeech` non-local, `sub_824DA1B0`;
+    `skate_audio::world::skater_speech`): pros (`sub_824DA768`) say `101_pos` / `150_pro_pos` on a seen trick and
+    `104_slam` / `903_race_slam_pc` / `151_pro_slam` on a seen slam, every frame the byte holds; AI skaters
+    (`sub_824DAAC0`) `101_pos`, `404` / `405` / `903` / `104_spec_slam`, `105_spec_chase`, on change; its crash
+    (`sub_824DB688`, latched) the message pair `131_collide_object` / `906_aislm`;
+  - the skater messages by speaker kind (`sub_824DAC00`): bail grunt 8206 / 115, crash 8229 / 125, impact
+    8233 / 6, hit reaction 8309 / 253, race punch 8310 / 250, gesture 8291 / 247 (the senders of the last four are
+    engine systems the game does not have yet).
+- **Main-cast decode:** setup indexes it always (`speech/maincast.json`, 1283 clips) and decodes its free-roam
+  events with the living world's (`SKATE_SETUP_SPEECH=1`): **6596 takes, 3.0 h, 922 MB** of 44.1 kHz PCM16.
+- **Checked:** `main_cast_lines_are_reachable`: all **82** main-cast lines the recomp streamed in 11 sessions
+  (906 `AiSlam` ×45, 101 `pos`, 150 `pro_pos`, 104 `Slam`, 130 `col`, 201 `grunt`) are reachable through our
+  words for their speaker (76 of them of an event the port sends; 130 `_col` has no ported sender).
+  `a_pro_skater_says_a_main_cast_line`: Ryan Smith's model as an NPC skater sees the player's trick and the main
+  cast streams `101_24_Smit_pos` at its PlayerSpeech level.
+- **Re-verified** (`speech_levels_follow_the_recomp`, 39 lines, now with the voice float): filters 4 of 5, gain
+  recomp / ours median 0.988 (p10 0.55, p90 1.36), pre-gain send = out21 17 / 29, post-filter send = out15 19 / 27,
+  PEAK on the curves 6 / 6.
+
+### NPC skater: the board slide and the bed
+- **Board slide ported for the NPC instance:** retail's slide code has no local test and its input (the
+  loose-board state) is computed per skater, so `NpcSkater` runs it from `NpcSkaterAudio::loose_board` (ghosts:
+  per row of their log). A scripted background run (Mega-Park, 4 min standing, the PLAYERPOST hook, 0 malformed
+  lines): instance 1 was held 78 s in 12 holds, no NPC bailed, no slide post by either instance: still unobserved.
+- **NPC grain bed vs session 180430's NPC rows** (the GREC rows of the NPC object, filtered by owner, joined with
+  the board's distance; `npc_bed_follows_the_recomp_rows`, 289 straight-roll rows): truck A gain recomp / ours
+  0–10 m 0.097 / 0.108, 10–20 m 0.045 / 0.065, 20–30 m 0.005 / 0.014; pitch 0.93–0.97 / 0.96. The far bands are
+  louder in ours: the lookups measure the distance to the local skater, which the rows don't give.
+
+### Mod surface and data (moddability)
+- Engine: `PedAudio::{tazing, body_fall}`, `PedTazerEvent`, `PedBodyFallEvent`, `NpcSkaterAudio::{loose_board,
+  reactions}`, `NpcSkaterReactionEvent`, `LivingWorldAudio::photo_flag`; ped / skater `voice` 1–96 (the pros and
+  the special cast speak on the main cast).
+- Mods: ped options `tazing`, `photo_flag`; lite-skater option `loose_board`; events `tazer` (seconds) and
+  `body_fall` (kind), skater event `reaction` (value `slam` / `slam_b` / `trick` / `crash` / `chase`, `by`); speech
+  value 49 works through `speech`; `voice` accepts 1–96. The test mod: F7 tazer, F6 a retail knock-down's keys, F5
+  a phone call, F4 the photographer, F3 the ghost sees your trick, F2 the ghost switches between its AI voice and
+  a pro's (24) and crashes.
+- Setup data (`world_tuning`): `ped_objects` (fall containers, eq bus, ring container, the tazer hold from the ped
+  state graph) and `speech_voice` (the PEAK curves, the echo delay factor / per-metre / cap / refresh frames);
+  `ped_models` gained `cast_bit` / `cast_word` / `cast_word2`; `speech_tuning["0"]` (the main cast's) is now used;
+  `speech/maincast.json` + the opt-in decode; `CellPhone_Rings.bnk` decoded with its patch tree;
+  `world_audio.py` joined the audio group's fingerprint. Every field defaults to the retail value and the world
+  tuning overrides it.
+
+### Proofs and tests
+- Local player byte-identical: the e2e bench (13 scenarios + 4 sessions, `row` and `fps300`) from this pass's
+  starting point (`wg_base`) against the result (`wg_new`, and again after the echo submix and the main cast:
+  `wg_new2`): all four sets IDENTICAL (26 + 26 + 8 + 8 outputs) both times.
+- Main-cast / echo tests: `main_cast_lines_are_reachable` (82 / 82), `a_pro_skater_says_a_main_cast_line`; units
+  `skater_speech` (pro / living-world choices, crash latch), the echo delay and the echo graph; the mod event
+  `reaction` and the test mod's F3 / F2.
+- New data tests: `tazer_bursts_follow_the_recomp`, `body_falls_follow_the_recomp`,
+  `npc_bed_follows_the_recomp_rows`, `the_phone_ring_lasts_until_the_recomp_answers`; re-verified
+  `speech_levels_follow_the_recomp`. New unit tests: peds (tazer, falls, ring, photographer), the PEAK curves, the
+  mod options / events, the test mod's new keys, the setup export.
+
+### Still open
+- Speech: Obj:Speech in2 / in3; the near lines' ~0.6 dB; the echo graph's two-channel routing gains; the
+  main-cast speaker-slot repeat times for slots 30 / 31 (record `+52` / `+56`); values 30 / 51 also stopping the
+  speaker's playing line; the game modes the skater choices test (19 / 20 / 55: free skate is none of them, the
+  port passes 0); the cameraman line the crash can request; senders of the hit-reaction / race-punch / gesture /
+  skater-collision lines (no such engine systems yet).
+- NPC: the board slide is ported but unobserved; the walking / jump voices.
+- Traffic: the 3DObjPos binding's writer; horn kinds per model.
+
 ## Open questions before P3 (kept for the record)
 
 - **Speech playback** in the host: the manager, the library and the streams. The level and pan
diff --git a/docs/hails-additions/audio-specs/world-audio-hookin-spec.md b/docs/hails-additions/audio-specs/world-audio-hookin-spec.md
index 4893f500..d7e29d2f 100644
--- a/docs/hails-additions/audio-specs/world-audio-hookin-spec.md
+++ b/docs/hails-additions/audio-specs/world-audio-hookin-spec.md
@@ -686,3 +686,25 @@ is updated. Phase 4 adds a second example, a "louder horns / custom engine" mod
 | The `SKATE_AEMS_*` switches are process env vars | throughout `game_audio` | per-mod or per-session toggles |
 | No AEMS post / global / MixMap read access and no audio event callbacks in the SDK | `skate-mods` | play retail sounds by name, react to game sounds |
 | The world owners' `rand()` generator (`Lcg(0x5EED)`) | `world_sources.rs:216` | seed for reproducible mod tests (minor) |
+
+## 10. Gaps closed (2026-10-03, doc 15 "Gaps closed")
+- **Tazer** ported: `SFXObj_Tazer` decoded (`world-ped-audio.md` "Tazer and PedBodyFall ported"); `c_tazer` held
+  while `S+80`. vs 164620: 19 starts per 2 s hold (recomp 10 / 20 / 19 = 49), gaps 192 / 192 / 128 / 96 vs
+  190 / 190 / 130 / 90–100, first-start gain recomp / ours 0.85–1.00, order 8, 7, shuffles of 0–6.
+- **PedBodyFall** ported: the trigger is the animation's `BodyFallType` (`S+76`); the recordings hold 75 starts
+  (SPLC, not POST). 73 / 73 containers by type; voice gain recomp / ours p50 0.79.
+- **Speech** (`world-speech.md` "Speech details resolved"): PEAK = azimuth head-shadow curves (6 / 6 recomp pairs on
+  the curves), Send A = out21 (pre-gain) and Send B = out15 (echo submix, not played), value 49 = phone ring →
+  64 (2 / 2 in 164620), value 29 = 1 s repeat with the game flag, Obj:Speech in0 / in1 / in4 by speaker id ranges,
+  first-free stream (95 / 109), constructor last = 68, main-cast mapping decoded (port needs the main-cast
+  index / decode). Open: the queue clock's unit, the echo submix, in2 / in3, the per-voice float, the near lines'
+  +0.6 dB.
+- **NPC board slide** ported on static evidence (no local gate; `+780` per skater entry). Scripted background run (Mega-Park, 4 min standing, PLAYERPOST, 0 malformed): 12 instance-1 holds (78 s), no
+  NPC bail, so no slot-15 post by either instance: still unobserved.
+- **NPC grain bed vs 180430** (filtered by owner): near band A gain 0.097 / 0.108, further bands louder in ours
+  (the local-skater distance is not joined); pitch matches.
+- **Update (same day): echo submix and main cast ported** (`world-speech.md` "The echo send and the main cast"). The
+  pre-gain send (out21) feeds the echo submix, out15 goes to the env bus (corrects the line above); the voice float
+  is applied; the queue clock = visual game ticks. Main-cast channel: pro peds, NPC skater reactions / crash
+  (`NpcSkaterAudio::reactions`, `NpcSkaterReactionEvent`, mod event `reaction`), the message pairs; decode 6596
+  takes / 922 MB; all 82 recorded main-cast lines reachable through the ported words.
diff --git a/docs/hails-additions/audio-specs/world-npc-skater-audio.md b/docs/hails-additions/audio-specs/world-npc-skater-audio.md
index c757b1ef..5fd52fe2 100644
--- a/docs/hails-additions/audio-specs/world-npc-skater-audio.md
+++ b/docs/hails-additions/audio-specs/world-npc-skater-audio.md
@@ -92,3 +92,14 @@ remove despawned skaters. Off switch `SKATE_AEMS_NPC_SKATERS=0`.
 - The manager's gate (`[0x830670B8+20]` == 5, `sys+560` == 1) and the skater list order of the AI manager.
 - The NPC's speech (`sub_824BF5F8`, SkaterSpeech manager `sub_824F7D10`: one record per skater, no distance gate
   there) belongs to the speech stage.
+
+## Board slide and the NPC bed vs the recomp (2026-10-03)
+- **Board slide ported for the NPC instance:** `sub_824CB3C8` / `sub_824CB4C0` have no local test; `+780` comes from
+  the conditioner per skater entry and the bridge `sub_824B0DA8` copies it, so `NpcSkater` runs `BoardSlide` with
+  `NpcSkaterAudioState::loose_board` (`NpcSkaterAudio::loose_board`; ghosts take it per row from their log; mods
+  `loose_board`). A scripted background recomp run (Mega-Park, 4 min standing) saw no NPC bail and so no board slide post.
+- **NPC grain bed vs 180430's NPC GREC rows** (owner `40C34020`, 227 k rows; a local research tool thins to 100 ms and
+  joins the NPC board by SKATEB speed; test `npc_bed_follows_the_recomp_rows`, 289 straight-roll rows): truck 0 A
+  record gain recomp / ours 0–10 m 0.097 / 0.108, 10–20 m 0.045 / 0.065, 20–30 m 0.005 / 0.014; A pitch 0.93–0.97
+  vs 0.96. Near band within 10 %; the far bands are louder in ours (the lookups use the distance to the local
+  skater, not joined: our sim keeps the local player at the camera).
diff --git a/docs/hails-additions/audio-specs/world-ped-audio.md b/docs/hails-additions/audio-specs/world-ped-audio.md
index 2d56e171..9786d722 100644
--- a/docs/hails-additions/audio-specs/world-ped-audio.md
+++ b/docs/hails-additions/audio-specs/world-ped-audio.md
@@ -91,3 +91,34 @@ Every B lookup reads Ctl 5.1, the ped's 3DObjPos.
 - The `sub_824D8E60` flag.
 - The 3 % of retail slots we do not produce (above).
 - Instance assignment: nearest 15, provisional.
+
+## Tazer and PedBodyFall ported (2026-10-03, doc 15 "Gaps closed")
+- **SFXObj_Tazer** (object 5.3, vtable `0x822FCB60`, factory `sub_824F12D0`, 40 bytes): process `sub_824F1478`
+  (gate `[obj+16]+52`): while the ped audio state's byte `S+80` (= the manager's bit 17 of entry `+4`) is set and
+  no packet is held, post `c_tazer` (`sub_824B7950`, class descriptor `0x8302EEF8`, 9 words
+  `[32767, 0, 4096, 0, 25000, 0, 0, 0, G+4 byte]`, G = `*(0x83083C38)+0x2F070`, 0 in free skate); when it clears,
+  release. Update `sub_824F1560`: w1 raw0, w2 pitch1 (≤ 8192), w6 level3, w7 level2. The program owns a child post
+  (`c_tazer_grn_play`, op 38) and plays the burst while held: samples 8, 7, then shuffles of 0–6.
+  - `S+80` = tazing: the post comes 22 ms after the state graph's `TazeEntity` entry (PEDTIMER `TazerCycTime`
+    2.0 s, `pedestrian_wanttotaze.xml`), 3 / 3 zaps of 164620; bursts 2 / 3 last 2.1 / 2.0 s (the hold); burst 1
+    ended after 1.33 s (cause not traced).
+  - **Check** (`tazer_bursts_follow_the_recomp`, the export of a local research tool): ours 19 starts per 2 s hold vs the
+    recomp's 10 / 20 / 19 (49); gaps 192 / 192 / 128 / 96… vs 190 / 190 / 130 / 90–100, the 11th gap 128 vs 129 /
+    131; first-start gain recomp / ours 0.85 / 0.93 / 1.00 at the recorded geometry; order 8, 7, shuffles.
+- **SFXObj_PedBodyFall** (object 5.2, vtable `0x822FCB18`, factory `sub_824F0880`): process `sub_824F0AB8`:
+  `S+76` (float, = entry `+16`) is the ped animation's **`BodyFallType`** channel (the string sits with
+  `RightToeDown` / `LeftToeDown` in the animation-event table at `0x820648F8`). On a change to a non-zero value one
+  Skate_Collisions sound starts through `sub_82497F48` (mono submix on eEQChain bus `[holder +140 field
+  B4C4F86A53963BA2]` = absent → 0, create): 8 → container 1184 (2 round-robin slots `+40/+44`, index `+60`),
+  9 → 948 (`+48/+52`, `+64`), other → 1183 (`+56`); containers from class `923CCB46EF5BF5BA` record
+  `DFEFC9212E0CBD2C` (holder `+124`). Update `sub_824F0E50`: per type its own volume / pitch output (8: out1 / out2,
+  9: out3 / out4, other: out5 / out6), raw0 azimuth, dt, env send level(7) (`sub_82498140`).
+  - **The recordings DO show it** (the earlier "no post" looked at POST lines; the starts are SPLC with chain
+    `82497FAC<824F0BE8|824F0D10|824F0E0C`): 75 starts in 6 sessions, the knock-down patterns 9, +0.10 other, +0.48 9,
+    +0.16 9 and 9, +0.13 8, +0.07 8, +0.10 other, +0.38 9 and 9, +0.15 other.
+  - **Check** (`body_falls_follow_the_recomp`, 73 starts with sample resolution): container 73 / 73 by type; the
+    recomp's sample is one the container plays in 57; voice gain recomp / ours p50 0.79 (p10 0.25, p90 1.25, n 40;
+    the knocked-down ped is guessed = the ped nearest the player).
+- Engine: `PedAudio::{tazing, body_fall}`, messages `PedTazerEvent { seconds }` (default `ped_objects.tazer_seconds`
+  = TazerCycTime) and `PedBodyFallEvent { kind }` (queued, one console frame on, one off). Mod: ped option `tazing`,
+  events `tazer` / `body_fall`. Setup: `world_tuning.ped_objects` (ids, eq, tazer seconds from the xml).
diff --git a/docs/hails-additions/audio-specs/world-speech.md b/docs/hails-additions/audio-specs/world-speech.md
index 5e587e31..59660a14 100644
--- a/docs/hails-additions/audio-specs/world-speech.md
+++ b/docs/hails-additions/audio-specs/world-speech.md
@@ -232,3 +232,86 @@ Harness: `tests/world_sources.rs` `a_bumped_ped_warns_with_a_line_of_its_voice`.
 3. The request queue and stream count for the living world (why lines overlap in the recomp).
 4. Main cast / cameraman / announcer: they use the same library and already parse. Their managers differ (other vault
    types, `sub_824AC560`).
+
+## Speech details resolved (2026-10-03, doc 15 "Gaps closed")
+- **Block layout** (PedestrianSpeech update `sub_824D9370`, block = obj+44; PlayerSpeech `sub_824DA300`, obj+48):
+  +4 speaker voice id (parsed from the clip name by `sub_824A89E8`), +8 main level, +12 the per-voice float
+  (S+152), +16 raw azimuth, +20 pitch, +24 HP (ped out13 / skater out8), +28 LP (out14 / out9), +32 second level
+  (out15… / out10…), +36/+40/+44 the PEAK curves' values, +48 a delay = min(S+148 × 1.0 [field BF48032DB145C5B4]
+  × 1/344, 0.15) s refreshed every 4 frames (field 510BAFA32A76B340), +69 far flag, +72 the stream the speaker
+  holds (−1 none), +76 speaking, +80 level 21 (ped) / 13 (skater), +84/+88 filters 22/23 (ped) / 14/15 (skater).
+- **PEAK filter = head shadow by azimuth.** raw out0 folded (> 32767 → 65536 − raw), then three 8-point curves of
+  record `B29C3B2C13D96482` `default` (holder `*(0x830CFDA4)+44`): centre `2C166907CF51DB88` (600 → 4000 at the
+  side → 600), gain `EA2C18D9CE5CBA3A` (0.4 → 0.1), Q `CF8679F540B82B2B` (3). Recomp 163809: 6 / 6 PEAK (centre,
+  gain) pairs lie on the two curves at one azimuth (≤ 1 Hz); ours at the joined geometry 3 / 6 within 10 % (camera
+  orientation estimated). Ported: `SpeechVoiceTuning`, export `world_tuning.speech_voice`, mixer stream graph.
+- **Two sends.** The stream voice graph (`sub_82C5C318`): Rsp0 → PI20 → Sen0 (Send A, pre-gain, env) → Gai0 →
+  HI20 → LI20 → Sen0 (Send B) → Pn21 → Sen0. Recomp modules `+0x570` (A) and `+0x7D0` (B). A = level 21 (ped) /
+  13 (skater): 17 of 29 lines within 25 % (out15 there: 11); B = out15: 18 of 27. Send B feeds the stream slot's
+  echo submix (`sub_82C5E2D8`: Sub0 → HI20 → Del0 → LI20 → Pn21 → Sen0 → the env bus; delay = block +48; filters
+  likely 22 / 23): **not ported** (Send B is computed, not played).
+- **Value 49** = the phone: `sub_824D9C70` stops the old ring and starts CellPhone_Rings (Splice index 6) container 5
+  (class `C1831BDB6CB1B1EA` `cellphone` field `031EFDF991638985`); `sub_824D9AD8` (end of the update) follows it
+  with the main level / pitch / azimuth and, when it ends, requests value **64** (`4402_cell_greet`). Recomp
+  164620: SPLC 6/5 at 88.73 → 4402 HelCel 89.73; 234.38 → 235.57; the rings' records last 0.84–1.13 s.
+- **Value 29**: while system byte `*(0x830CFDC4)+912` is set, obj+160 accumulates dt; at ≥ 1.0 (image constant) it
+  resets and the request repeats (the flag's meaning not traced: `LivingWorldAudio::photo_flag`).
+- **Obj:Speech inputs** (SFXObj_Speech process `sub_824E2050`, every frame): in0 / in1 / in4 = 32767 while a playing
+  line's speaker (block +4) is 37–38 / 75–77 / 1–29; in2 = speech-system word `+0x1BD28` == 2; in3 = a block with
+  +60 == 0 and +93 set (neither traced). F45 (+200 mB on ped out2 / out3) is in0 → not regular peds: the ~+0.6 dB
+  of the recomp's near lines stays unexplained (E0's other terms A[Global.2], F[Global.28] / [108], A[Global.112]).
+  Ported: in0 / in1 / in4.
+- **Which stream**: a new line takes the first free stream (k0 when both are free: 95 of 109 new lines in
+  163809 / 164620 / 180430). The interrupt reads record `channel × 2 + block +72` (the speaker's own stream;
+  −1 aliases the previous channel's second record).
+- **Queue timeout unit**: the library's clock = the speech system's time callback `sub_824A4E90` =
+  `[[0x830CFD94]+16]` (installed by `sub_82C5EC20`); its unit was not settled from the code (no writer found).
+- **Constructor** `sub_824D90D8`: obj+36 (last value) = 68, obj+40 = 8318, +156 = −1 (ported: `PedSpeech::default`).
+- **Main-cast path (pros, S+116 == 0)**: `sub_824AC438`: 29 → event 141 (speaker word 136), 28 → 11 (when
+  `sub_82487ED0` is false and system +1196 == 0), 30 / 51 → stop the speaker's stream, then 6 or 115 (`rand() & 1`),
+  53 / 54 → 77, else nothing; request `sub_824AC560` (event id → index in a 72-entry table at `0x8224CB80`, vault
+  record at mgr + (index + 194) × 8, tuning bank "0" — exported) with words [S+100, S+104, flag 2/1 swapped, 0,
+  S+108, S+112]. **Not ported:** needs the main-cast speech index + decode (`maincastspeech.big`).
+
+## The echo send and the main cast (2026-10-03, ported; corrects "Two sends" and "Queue timeout unit" above)
+- **The stream system** (`sub_82C5CEF0`, every frame per speech stream): gain = block +8 / 32767 × block +12 (the
+  per-voice float `S+152`, `aud_characteristics` `2087A3290483BB4F`, 0.8–1.4); `Send(desc+32)` = block +32 (ped
+  out15 / skater out10) × the float, the post-filter send straight into the environment bus; `Send(desc+16)` =
+  block +80 (ped out21 / skater out13) × the float, the pre-gain send into the slot's echo submix. The echo's
+  HI20 = block +84 (ped filter 22 / skater 14), LI20 = block +88 (23 / 15), Del0 = block +48, posted only when it
+  changed; Pn21 and Sen0 keep their class defaults. **Correction:** the first decode had Send B (out15) feeding
+  the echo; the code says the pre-gain send (out21) does, and out15 goes to the environment bus.
+- **Delay refresh** (`sub_824D9370`): a per-speaker countdown; at ≤ 0 the delay is recomputed from the camera
+  distance and the count reloads with field `510BAFA32A76B340` (4).
+- **Ported:** `skate_audio::bus::speech_echo` (one graph per stream slot, channel × 2 + k; mono, the Pn21 / Sen0
+  routing as a unity tap), the mixer's stream path (PEAK → echo send → gain → HPF / LPF → env send), the voice
+  float, the delay countdown. Setup `world_tuning.speech_voice` carries `delay_factor` / `delay_frames`.
+- **Recomp, re-verified** (39 lines, 163809 / 164620 / 180430, with the voice float): pre-gain send (`+0x570`) =
+  out21 within 25 % in 17 of 29 (out15: 10); env send (`+0x7D0`) = out15 in 19 of 27; gain median 0.988
+  (p10 0.55, p90 1.36); filters 4 of 5; PEAK on the curves 6 / 6.
+- **Queue timeout unit (settled):** `[[0x830CFD94]+16]` is the function behind the `GetVisualGameTick` Lua binding
+  (`0x8283C2D8`): visual game ticks, one per rendered frame (the console's ~30 fps), the port's console frames.
+- **Main-cast channel** (bank 0, channel 0; `maincastspeech.big`, 1283 clips, 73 events, tuning `speech_tuning["0"]`):
+  - who: a model with no living-world type bit and a cast bit / word (`6F2933E977CF40DD` = the pros' bit 1 << (n−1),
+    `14FD437D190677C8` = the special cast 30–38, `D6EA428C2B43E23A` = the word another pro's line names it by);
+  - words (`sub_824AC898`, block w0 = cast bit, w1 = cast word, w2 = 1 near / 2 far, w4 / w5 = the other skater's
+    cast bit / `D6EA` word): events 0 / 1 → [w1, w0, w2]; 247 → [w0, w9, w1]; 251 → [w0, w1, w10];
+    254 → [w1, w5, w0, w4]; 268 → [w0, w1, w11]; 271 / 274 / 275 → [w0, w1, w12]; 280 → [w0, w1, w13];
+    287 / 288 → [w1, w0, w4, w5]; else [w0, w1];
+  - NPC skater speech (`SFXObj_PlayerSpeech` non-local process `sub_824DA1B0`, inputs from the skater entry via
+    `sub_824B6E80`: `+102` = entry `+392` bit 4, `+103` = bit 3, `+104` = entry `+396` bit 10, `+131` = entry `+388`
+    bit 5). Living-world voices (`sub_824DAAC0`): `+102` / `+103` → 8204 in mode 55, 8239 in modes 19 / 20, else
+    8234 | (`rand()` & 1); `+104` → 8202; the chase flag (system `+1100` bit 6) → 8205 when nothing else; a request
+    only on change. Pros (`sub_824DA768`): `+102` → 1 (16 in modes 19 / 20 by the player) or 288 by a pro
+    (`+112`); `+103` → 1 / 288 by `+116`; `+104` → 0 / 287 by `+108`; requested every frame the byte holds. The
+    skater's crash (`sub_824DB688`, `+131` rising, latched in obj `+193`): message 8229 / 125;
+  - skater message pairs (`sub_824DAC00`, living-world / main-cast): bail grunt 8206 / 115, crash 8229 / 125,
+    impact 8233 / 6 and 8241 / 125 (`sub_824BD358`), hit reaction 8309 / 253 and race punch 8310 / 250
+    (`sub_824EFA60`), gesture 8291 / 247 (`sub_824F8778`).
+- **Main-cast decode:** the free-roam events (101, 104, 130, 150, 151, 201, 202, 335, 336, 338, 344, 500, 501, 601,
+  903, 906, 913, 1014): 6596 takes, 3.0 h, 922 MB of 44.1 kHz PCM16 (opt-in with the living world's).
+- **Recomp check:** 82 main-cast lines streamed in 11 sessions (READs of `maincastspeech.big`: 906 `AiSlam` ×45,
+  101 `pos`, 150 `pro_pos`, 104 `Slam`, 130 `col`, 201 `grunt`): all reachable through the ported words for their
+  speaker (76 of an event the port sends; 130 `_col` has no ported sender).
+- **Not ported:** the repeat times of speaker slots 30 / 31 (record `+52` / `+56`); values 30 / 51 stopping the
+  speaker's stream first; the cameraman line of the crash; the game modes (free skate passes 0).
diff --git a/mods/world-audio-test/main.lua b/mods/world-audio-test/main.lua
index 0bf5d679..7d67dc39 100644
--- a/mods/world-audio-test/main.lua
+++ b/mods/world-audio-test/main.lua
@@ -15,8 +15,11 @@ local PEDS = 20
 -- and the game gives it the model's shoe class, kind and speech words.
 local VOICES = { 41, 42, 43, 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 59, 60, 61, 64, 65, 66, 69, 70, 71,
                  72, 73, 74, 75, 76, 77, 82, 83, 84, 85, 86, 87, 88 }
--- The ghost skater's voice (an AI skater's: its bail grunt).
+-- The ghost skater's voice (an AI skater's: its bail grunt), and the pro F2 switches it to
+-- (Ryan Smith's model: the main-cast channel).
 local GHOST_VOICE = 91
+local GHOST_PRO = 24
+local ghost_pro = false
 
 local anchor = nil        -- {x, y, z}
 local started = false
@@ -29,6 +32,11 @@ local ghost_status = ""
 local last_landing, last_bail = nil, nil
 local warned = {}         -- ped key -> seconds until it may warn again
 local chatter_timer = 6   -- seconds to the next ambient shout (dev only, not retail)
+local falls = {}          -- pending BodyFallType keys: {ped key, seconds until sent, kind}
+local photographer = nil  -- the ped holding PictureTaking (29) with the photo flag
+-- A retail knock-down's BodyFallType keys (recomp sessions 163809 / 164620: 9, then 0.10 s later a
+-- type-other key, 0.48 s later 9, 0.16 s later 9).
+local KNOCK_DOWN = { { 0, 9 }, { 0.10, 1 }, { 0.58, 9 }, { 0.74, 9 } }
 
 local function rand()
     seed = (seed * 1103515245 + 12345) % 2147483648
@@ -198,6 +206,17 @@ local function react(player)
     end
 end
 
+local function nearest_ped(player)
+    local best, best_d = nil, 1e9
+    for _, ped in ipairs(peds) do
+        if ped.position then
+            local d = dist(ped.position, player.position)
+            if d < best_d then best, best_d = ped, d end
+        end
+    end
+    return best
+end
+
 local function pressed(key)
     local down = sdk.input.down(key) == true
     local edge = down and not held[key]
@@ -223,6 +242,55 @@ return {
         if pressed("F8") then
             for _, c in ipairs(cars) do if c.parked then sdk.world_audio.event(c.key, "alarm") end end
         end
+        -- F7: the nearest ped zaps its tazer (retail's c_tazer burst, the state graph's 2 s hold).
+        if pressed("F7") then
+            local ped = nearest_ped(player)
+            if ped then sdk.world_audio.event(ped.key, "tazer") end
+        end
+        -- F6: the nearest ped is knocked down (a retail knock-down's BodyFallType keys).
+        if pressed("F6") then
+            local ped = nearest_ped(player)
+            if ped then
+                for _, k in ipairs(KNOCK_DOWN) do falls[#falls + 1] = { ped.key, k[1], k[2] } end
+            end
+        end
+        -- F5: the nearest ped's phone rings (speech value 49); it answers when the ring ends.
+        if pressed("F5") then
+            local ped = nearest_ped(player)
+            if ped then sdk.world_audio.event(ped.key, "speech", { value = 49 }) end
+        end
+        -- F3: the ghost saw your trick (its voice's `101_pos`); F2: it switches between its AI voice
+        -- and a pro's (24, the main cast), then crashes (`131_collide_object` / `906_aislm`).
+        if pressed("F3") then sdk.world_audio.event("ghost", "reaction", { value = "trick", by = 0 }) end
+        if pressed("F2") then
+            ghost_pro = not ghost_pro
+            sdk.world_audio.update("ghost", { voice = ghost_pro and GHOST_PRO or GHOST_VOICE })
+            sdk.world_audio.event("ghost", "reaction", { value = "crash" })
+        end
+        -- F4: the nearest ped becomes a photographer (PictureTaking, 29, with the game flag:
+        -- the request repeats every second, gated by the event's timers); F4 again stops it.
+        if pressed("F4") then
+            if photographer then
+                sdk.world_audio.update(photographer, { photo_flag = false })
+                sdk.world_audio.event(photographer, "speech", { value = 0 })
+                photographer = nil
+            else
+                local ped = nearest_ped(player)
+                if ped then
+                    photographer = ped.key
+                    sdk.world_audio.update(ped.key, { photo_flag = true })
+                    sdk.world_audio.event(ped.key, "speech", { value = 29 })
+                end
+            end
+        end
+        for i = #falls, 1, -1 do
+            local f = falls[i]
+            f[2] = f[2] - dt
+            if f[2] <= 0 then
+                sdk.world_audio.event(f[1], "body_fall", { kind = f[3] })
+                table.remove(falls, i)
+            end
+        end
         for _, car in ipairs(cars) do drive(car, dt) end
         for _, ped in ipairs(peds) do walk(ped, dt, player) end
         react(player)
@@ -274,7 +342,7 @@ return {
         end
         local info = sdk.world_audio.info()
         sdk.ui.text("world-audio-test", string.format(
-            "World audio test: cars %d/%d audible, peds %d/%d, skater %d, speech lines %d  (limits %d/%d/%d%s)  %s  [F8 alarm, F9 re-centre]",
+            "World audio test: cars %d/%d audible, peds %d/%d, skater %d, speech lines %d  (limits %d/%d/%d%s)  %s  [F4 photographer, F5 phone, F6 knock-down, F7 tazer, F8 alarm, F9 re-centre]",
             audible.traffic, #cars, audible.ped, #peds, audible.skater, info.speech_lines or 0,
             info.instances and info.instances.traffic or 4, info.instances and info.instances.peds or 15,
             info.instances and info.instances.skaters or 1, info.more_audible and ", more audible" or "", ghost_status))
diff --git a/mods/world-audio-test/mod.json b/mods/world-audio-test/mod.json
index 696bf6ce..8c95a7ea 100644
--- a/mods/world-audio-test/mod.json
+++ b/mods/world-audio-test/mod.json
@@ -4,7 +4,7 @@
   "name": "World Audio Test (dev)",
   "version": "0.1.0",
   "author": "Hails",
-  "description": "Dev only (PR #32), off by default: enable it in the mod menu, or run with SKATE3_MODS_ENABLE=dev-world-audio-test. Publishes traffic, pedestrians and a ghost NPC skater around the spot where it is enabled, through sdk.world_audio, so the retail world audio can be heard before the engine has a living world. Cars loop on four lanes (C00-C08 engine records) with honks and skids; F8 fires the parked car's alarm. Peds walk, jog and run, and react to you (warn, cheer, slam). The ghost replays one of your recorded audio state logs (logs/<name>.tsv in this folder, or SKATE_AUDIO_STATE_LOGS). F9 re-centres everything on you. Boxes show who is audible (green) or not (grey).",
+  "description": "Dev only (PR #32), off by default: enable it in the mod menu, or run with SKATE3_MODS_ENABLE=dev-world-audio-test. Publishes traffic, pedestrians and a ghost NPC skater around the spot where it is enabled, through sdk.world_audio, so the retail world audio can be heard before the engine has a living world. Cars loop on four lanes (C00-C08 engine records) with honks and skids; F8 fires the parked car's alarm. Peds walk, jog and run, and react to you (warn, cheer, slam); the nearest ped zaps its tazer (F7), is knocked down (F6, a retail knock-down's fall sounds), takes a phone call (F5) or turns photographer (F4). The ghost replays one of your recorded audio state logs and speaks: it saw your trick (F3), or switches between its AI voice and a pro's and crashes (F2, the main-cast channel) (logs/<name>.tsv in this folder, or SKATE_AUDIO_STATE_LOGS). F9 re-centres everything on you. Boxes show who is audible (green) or not (grey).",
   "entry": "main.lua",
   "enabled_by_default": false,
   "settings": {
diff --git a/sdk/skate.lua b/sdk/skate.lua
index bc87fdd1..4df813c6 100644
--- a/sdk/skate.lua
+++ b/sdk/skate.lua
@@ -587,6 +587,8 @@ function sdk.graphs.set_enabled(graph, target, index, enabled) end
 ---@field feet? boolean[] ped: {foot A planted, foot B planted}
 ---@field materials? integer[] ped: audio surface materials under the feet (default 0)
 ---@field footsteps? boolean ped: footsteps on (default: retail's 3-nearest rule)
+---@field tazing? boolean ped: tazing (the c_tazer zap burst plays while it holds; prefer the tazer event)
+---@field photo_flag? boolean ped: raise the game flag of the photographer's repeat (a ped holding speech value 29, PictureTaking, repeats it every second while any published ped sets this)
 ---@field source? string skater (spawn only): 'lite' (default) or 'state_log:<name>' (a ghost replaying logs/<name>.tsv of this mod or SKATE_AUDIO_STATE_LOGS/<name>.tsv)
 ---@field from? number ghost: window start (s)
 ---@field seconds? number ghost: window length (s, default 20), looped
@@ -595,6 +597,7 @@ function sdk.graphs.set_enabled(graph, target, index, enabled) end
 ---@field grinding? boolean lite skater
 ---@field grind_material? integer lite skater
 ---@field air? boolean lite skater: in the air
+---@field loose_board? integer lite skater: the loose board (0 none, 1 upside down, 2 on its side): the board slide holds while set (ghosts take it from their log)
 sdk.world_audio = {}
 ---@param key string
 ---@param kind 'traffic'|'ped'|'skater'
@@ -605,8 +608,8 @@ function sdk.world_audio.spawn(key, kind, opts) end
 ---@param opts WorldAudioOptions
 function sdk.world_audio.update(key, opts) end
 ---@param key string
----@param event 'horn'|'alarm'|'speech'
----@param opts? {kind?:integer, seconds?:number, value?:string|integer} horn: kind 1..5 for seconds; alarm: retail's 8 s; speech: value name (warn = 53, cheer, slam, flee, nearby, DoWarning, LongCheer, ...) or number; the ped says a line of its voice through retail's speech manager (gated by the event's timers and probability) when the speech decode is installed; a repeated value re-triggers
+---@param event 'horn'|'alarm'|'speech'|'tazer'|'body_fall'|'reaction'
+---@param opts? {kind?:integer, seconds?:number, value?:string|integer, by?:integer} reaction (skaters): value slam / slam_b / trick / crash / chase, by = the other skater's model (0 = the player; a pro 1..29 picks the pro-on-pro lines): the skater's own speech process says the matching line of its voice for one console frame (AI skaters 89..96 on the living-world channel, pros 1..29 / special cast 30..38 on the main cast); horn: kind 1..5 for seconds; alarm: retail's 8 s; speech: value name (warn = 53, cheer, slam, flee, nearby, DoWarning, LongCheer, ...) or number; the ped says a line of its voice through retail's speech manager (gated by the event's timers and probability) when the speech decode is installed; a repeated value re-triggers (49 rings a phone, then the ped answers); tazer: the ped zaps for seconds (default the state graph's 2 s): retail's c_tazer burst; body_fall: one BodyFallType key of a knock-down animation (kind 9, 8 or any other value 1..255: three Skate_Collisions sounds; retail's falls go 9, other, 9, 9 about 0.1 / 0.5 / 0.16 s apart)
 function sdk.world_audio.event(key, event, opts) end
 ---@param key string
 function sdk.world_audio.remove(key) end
diff --git a/tools/asset_pipeline/audio_export.py b/tools/asset_pipeline/audio_export.py
index ea94f85a..223bdc90 100644
--- a/tools/asset_pipeline/audio_export.py
+++ b/tools/asset_pipeline/audio_export.py
@@ -1152,9 +1152,9 @@ def convert(game_root: Path, private: Path, work: Path, vgmstream: Path, report,
     placed |= set(CROSSFADE_BANKS)
     # The world sources' banks, tuning and speech index (crates/skate-audio/src/world; inert in game
     # until a ped / traffic system publishes owners).
-    from .world_audio import WORLD_BANKS, world_tuning
+    from .world_audio import WORLD_BANKS, WORLD_SPLICE_BANKS, world_tuning
     placed |= set(WORLD_BANKS)
-    manifest['world_tuning'] = world_tuning(collections, record_names)
+    manifest['world_tuning'] = world_tuning(collections, record_names, (private/'stock', game_root))
     report('Reading audio regions')
     manifest['regions'] = regions(game_root, work)
     for bank in BANKS + tuple(sorted(placed - set(BANKS))):
@@ -1185,7 +1185,7 @@ def convert(game_root: Path, private: Path, work: Path, vgmstream: Path, report,
     mixmap = mixmap_file(audio_root, output)
     if mixmap:
         manifest['aems']['mixmap'] = mixmap
-    manifest['aems']['splice'] = splice_trees(files, output, BANKS)
+    manifest['aems']['splice'] = splice_trees(files, output, BANKS + WORLD_SPLICE_BANKS)
     speech = audio_root/'english'/'livingworldspeech.big'
     if speech.is_file():
         report('Indexing world speech')
@@ -1199,5 +1199,19 @@ def convert(game_root: Path, private: Path, work: Path, vgmstream: Path, report,
             decode_speech(speech, index, output/'speech'/'livingworld', work/'speech', vgmstream, _decode, log)
             entry['audio'] = 'speech/livingworld'
         manifest['speech'] = {'livingworld': entry}
+    main_cast = audio_root/'english'/'maincastspeech.big'
+    if main_cast.is_file():
+        report('Indexing main-cast speech')
+        from .world_audio import MAIN_CAST_EVENTS, decode_speech, speech_index, speech_requested
+        index = speech_index(main_cast, 'maincast')
+        (output/'speech').mkdir(parents=True, exist_ok=True)
+        (output/'speech'/'maincast.json').write_text(json.dumps(index), encoding='utf-8')
+        entry = {'index': 'speech/maincast.json', 'audio': None}
+        if speech_requested():  # SKATE_SETUP_SPEECH=1: ~0.95 GB more
+            report('Decoding main-cast speech')
+            decode_speech(main_cast, index, output/'speech'/'maincast', work/'speech_maincast', vgmstream, _decode, log,
+                          events=MAIN_CAST_EVENTS)
+            entry['audio'] = 'speech/maincast'
+        manifest.setdefault('speech', {})['maincast'] = entry
     (output/'audio_manifest.json').write_text(json.dumps(manifest, indent=1), encoding='utf-8')
     return manifest
diff --git a/tools/asset_pipeline/test_world_audio.py b/tools/asset_pipeline/test_world_audio.py
index 7c8411c1..4f44bf98 100644
--- a/tools/asset_pipeline/test_world_audio.py
+++ b/tools/asset_pipeline/test_world_audio.py
@@ -45,6 +45,31 @@ class Tuning(unittest.TestCase):
         self.assertEqual((child['idle_rpm'], child['max_rpm'], child['patch'], child['gears'], child['rear_bias']), (1500.0, 4000.0, 4, 4, 20000))
         self.assertEqual(t['traffic_engine']['default']['patch'], 2)
         self.assertEqual(t['ped_footsteps'], {})
+        # Without the records: the defaults of skate_audio (eq 0 is the lookup's own default).
+        self.assertEqual(t['ped_objects'], {'body_fall_eq': 0})
+        self.assertEqual(t['speech_voice'], {})
+
+    def test_ped_objects_and_speech_curves(self):
+        import tempfile
+        from pathlib import Path
+        i32 = lambda v: struct.pack('>i', v).hex()  # noqa: E731
+        curve = bytes(16) + struct.pack('>16f', *range(8), *[3.0] * 8)
+        collections = [
+            {'class': world.BODY_FALL[0], 'key': world.BODY_FALL[1], 'parent': '', 'fields': {
+                f: {'type': 'Skate_Collisions', 'data': i32(v)} for f, v in zip(world.BODY_FALL_IDS, (11, 22, 33))}},
+            {'class': world.RING[0], 'key': world.RING[1], 'parent': '', 'fields': {
+                world.RING_ID: {'type': 'CellPhone_Rings', 'data': i32(5)}}},
+            {'class': world.SPEECH_RECORD[0], 'key': world.SPEECH_RECORD[1], 'parent': '', 'fields': {
+                world.SPEECH_PEAK['q']: {'type': 'Sk8::PointNegGraphData8', 'data': curve.hex()},
+                world.SPEECH_ECHO['delay_frames'][0]: {'type': 'EA::Reflection::Int32', 'data': i32(4)}}},
+        ]
+        with tempfile.TemporaryDirectory() as tmp:
+            graph = Path(tmp)/world.TAZE_GRAPH
+            graph.parent.mkdir(parents=True)
+            graph.write_text('<behaviour name="SetSimpleTimer" timerName="TazerCycTime" length="2.0"/>')
+            t = world.world_tuning(collections, None, [Path(tmp)/'missing', tmp])
+        self.assertEqual(t['ped_objects'], {'body_fall_ids': [11, 22, 33], 'body_fall_eq': 0, 'ring_id': 5, 'tazer_seconds': 2.0})
+        self.assertEqual(t['speech_voice'], {'peak_q': {'x': [float(v) for v in range(8)], 'y': [3.0] * 8}, 'delay_frames': 4})
 
 
 def _evt(event_id, fields, records, name='501_warn'):
diff --git a/tools/asset_pipeline/versions.py b/tools/asset_pipeline/versions.py
index 31ee6930..288689d1 100644
--- a/tools/asset_pipeline/versions.py
+++ b/tools/asset_pipeline/versions.py
@@ -25,7 +25,8 @@ SOURCES = {
     'maps': PARSERS + ('asset_pipeline/optional_content.py', 'asset_pipeline/map*.py', 'asset_pipeline/dynamic_props.py',
              'asset_pipeline/environment.py', 'asset_pipeline/irradiance.py',
              'asset_pipeline/retail_material.py', 'asset_pipeline/backdrop.py', 'asset_pipeline/sky.py'),
-    'audio': ('asset_pipeline/optional_content.py', 'asset_pipeline/audio_export.py', 'asset_pipeline/audio_formats.py'),
+    'audio': ('asset_pipeline/optional_content.py', 'asset_pipeline/audio_export.py', 'asset_pipeline/audio_formats.py',
+              'asset_pipeline/world_audio.py'),
 }
 
 
diff --git a/tools/asset_pipeline/world_audio.py b/tools/asset_pipeline/world_audio.py
index 68d5c749..17682ed5 100644
--- a/tools/asset_pipeline/world_audio.py
+++ b/tools/asset_pipeline/world_audio.py
@@ -29,8 +29,11 @@ from pathlib import Path
 WORLD_BANKS = (
     'C00_heavy01.abk', 'C01_family01.abk', 'C03_sports01.abk', 'C04_taxi01.abk', 'C05_truck01.abk',
     'C06_sports02.abk', 'C07_family02.abk', 'C08_family03.abk', 'Traffic_Horn.abk', 'Traffic_Skid.abk',
-    'car_alarms.abk', 'fstep_livingworld.abk', 'Tazer.abk',
+    'car_alarms.abk', 'fstep_livingworld.abk', 'Tazer.abk', 'CellPhone_Rings.bnk',
 )
+# The Splice (SPLC) banks among them: their patch trees go to the native Splice player
+# (`skate_audio::world::peds::PedSpeech`'s phone ring, retail's Splice table index 6).
+WORLD_SPLICE_BANKS = ('CellPhone_Rings.bnk',)
 
 ENGINE_CLASS = 'Hash_259095163B974174'  # aud_traffic_engine
 ENGINE_FIELDS = {
@@ -54,12 +57,56 @@ PED_SPEEDS = 'Hash_E12AF885D3C3A168'
 PED_STEP_IDS = ('Hash_6B61C043E53C44CB', 'Hash_EC3399A49055DD8D', 'Hash_9D6D2863CFE908C4')
 PED_TAIL = 'Hash_62A2E64238934734'
 PED_EQ = 'Hash_A9023782094771B5'
+# SFXObj_PedBodyFall (recomp sub_824F0AB8): the Skate_Collisions containers by BodyFallType 8 / 9 / other,
+# and the eEQChain field it resolves (absent from the shipped database: the lookup's default 0).
+BODY_FALL = ('Hash_923CCB46EF5BF5BA', 'Hash_DFEFC9212E0CBD2C')
+BODY_FALL_IDS = ('Hash_552899F3BF9927CC', 'Hash_A3E8A9381F4222E1', 'Hash_C0FFD1E535F218E2')
+BODY_FALL_EQ = 'Hash_B4C4F86A53963BA2'
+# PedestrianSpeech's phone ring for speech value 49 (sub_824D9C70): CellPhone_Rings container.
+RING = ('Hash_C1831BDB6CB1B1EA', 'cellphone')
+RING_ID = 'Hash_031EFDF991638985'
+# The speech stream voice's PEAK filter by the speaker's azimuth (PedestrianSpeech update sub_824D9370):
+# three Sk8::PointNegGraphData8 curves of the speech record (holder *(0x830CFDA4)+44).
+SPEECH_RECORD = ('Hash_B29C3B2C13D96482', 'default')
+SPEECH_PEAK = {'freq': 'Hash_2C166907CF51DB88', 'gain': 'Hash_EA2C18D9CE5CBA3A', 'q': 'Hash_CF8679F540B82B2B'}
+# The speech echo delay: the camera-distance factor and the refresh in console frames (`sub_824D9370`).
+SPEECH_ECHO = {'delay_factor': ('Hash_BF48032DB145C5B4', 'f32'), 'delay_frames': ('Hash_510BAFA32A76B340', 'i32')}
+# The state graph that holds a tazer zap (TazeEntity: TazerCycTime).
+TAZE_GRAPH = 'data/state/livingworldentities/pedestrian/aigraph/pedestrian_wanttotaze.xml'
+
+
+def _graph8(field) -> dict | None:
+    """A Sk8::PointNegGraphData8 field: 16 header bytes, then 8 x and 8 y floats."""
+    if not field:
+        return None
+    raw = bytes.fromhex(''.join(field['data'].split()))
+    if len(raw) < 80:
+        return None
+    floats = struct.unpack('>16f', raw[16:80])
+    return {'x': [round(v, 6) for v in floats[:8]], 'y': [round(v, 6) for v in floats[8:]]}
+
+
+def tazer_seconds(roots) -> float | None:
+    """The TazeEntity state's TazerCycTime (s) from the ped state graph, in the first of `roots` (the
+    extracted stock data, the disc) that has it; None when none does."""
+    for root in roots or ():
+        path = Path(root)/TAZE_GRAPH
+        if path.is_file():
+            text = path.read_text(encoding='utf-8', errors='replace')
+            m = re.search(r'timerName="TazerCycTime"\s+length="([0-9.]+)"', text)
+            return float(m.group(1)) if m else None
+    return None
 
 # The speech events a free-roam ped can say (audio-specs/world-speech.md): reactions, chases, conversations, phone
 # calls, bums, the player-action comments.
 FREE_ROAM_EVENTS = (101, 102, 104, 105, 108, 109, 110, 201, 202, 203, 204, 205, 206, 207, 314, 315, 316, 320,
                     330, 331, 335, 336, 338, 339, 400, 497, 501, 603, 604, 605, 606, 607, 609, 611, 805, 806, 807,
                     1901, 4402, 4405)
+# The main cast's (pros' and the special cast's) free-roam events (`maincastspeech.big`, the speech manager's bank 0):
+# the skater speech messages and reactions the port sends (grunt 201 / impact 202, crash 906, pos 101, slam 104, collide
+# 130, pro-on-pro 150 / 151, gestures 338, hit reactions 344 / 335 / 336, warn 500 / 501, greet 601, race 903 / 913,
+# bored 1014). ~3.0 h, ~0.95 GB as 44.1 kHz PCM16; decoded with the living world's (`SKATE_SETUP_SPEECH=1`).
+MAIN_CAST_EVENTS = (101, 104, 130, 150, 151, 201, 202, 335, 336, 338, 344, 500, 501, 601, 903, 906, 913, 1014)
 
 
 def _word(data: str, kind: str):
@@ -71,8 +118,9 @@ def _word(data: str, kind: str):
     return struct.unpack('>i', raw[:4])[0]
 
 
-def world_tuning(collections: list[dict], record_names: list[str] | None = None) -> dict:
-    """{'traffic_engine': {name: {...}}, 'ped_footsteps': {...}} from the converted collections."""
+def world_tuning(collections: list[dict], record_names: list[str] | None = None, state_roots=None) -> dict:
+    """{'traffic_engine': {name: {...}}, 'ped_footsteps': {...}, 'ped_objects': {...}, 'speech_voice': {...}, …}
+    from the converted collections (and the disc's ped state graph for the tazer hold)."""
     from .audio_formats import name_id
     names = {f'Hash_{name_id(n):016X}': n for n in (record_names or [])}
     by_class: dict[str, dict] = {}
@@ -117,6 +165,30 @@ def world_tuning(collections: list[dict], record_names: list[str] | None = None)
     if eq:
         peds['eq_chain'] = _word(eq['data'], 'i32')
     out['ped_footsteps'] = peds
+    # The ped one-shot objects (skate_audio::world::peds::PedObjectTuning; unset fields keep its retail defaults).
+    objects: dict = {}
+    ids = [resolve(*BODY_FALL, f) for f in BODY_FALL_IDS]
+    if all(ids):
+        objects['body_fall_ids'] = [_word(f['data'], 'i32') for f in ids]
+    eq = resolve(*EQ_HOLDER, BODY_FALL_EQ)
+    objects['body_fall_eq'] = _word(eq['data'], 'i32') if eq else 0
+    ring = resolve(*RING, RING_ID)
+    if ring:
+        objects['ring_id'] = _word(ring['data'], 'i32')
+    seconds = tazer_seconds(state_roots)
+    if seconds is not None:
+        objects['tazer_seconds'] = seconds
+    out['ped_objects'] = objects
+    voice = {}
+    for name, field in SPEECH_PEAK.items():
+        curve = _graph8(resolve(*SPEECH_RECORD, field))
+        if curve:
+            voice[f'peak_{name}'] = curve
+    for name, (field, kind) in SPEECH_ECHO.items():
+        f = resolve(*SPEECH_RECORD, field)
+        if f is not None:
+            voice[name] = _word(f['data'], kind)
+    out['speech_voice'] = voice
     out['speech_tuning'] = speech_tuning(collections)
     out['ped_models'] = ped_models(collections)
     out['traffic_models'] = traffic_models(collections, names)
@@ -134,7 +206,10 @@ PED_MODEL_FIELDS = {
     'Hash_68BB61E508841729': ('gender', 'i32'),       # S+124: 1 female, 2 male
     'Hash_871BDC669F2B1844': ('shoe_class', 'i32'),   # S+132
     'Hash_A27215A909135B62': ('far', 'f32'),          # S+156: the far line threshold (m)
-    'Hash_2087A3290483BB4F': ('pitch', 'f32'),        # a per-voice float (0.8-1.15; S+152, use open)
+    'Hash_2087A3290483BB4F': ('pitch', 'f32'),        # the per-voice float (S+152): the speech stream's gain / sends ×
+    'Hash_6F2933E977CF40DD': ('cast_bit', 'i32'),     # the main-cast speaker bit (skater speech record +84, word 1)
+    'Hash_14FD437D190677C8': ('cast_word', 'i32'),    # the special cast's bit (+88, word 2: characters 30-38)
+    'Hash_D6EA428C2B43E23A': ('cast_word2', 'i32'),   # the second word another skater's lines read (150 / 151)
 }