v1.11.0

changelog.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 2026-04-10 - 1.11.0 - feat(rust-proxy-engine)
+add a Rust SIP proxy engine with shared SIP and codec libraries
+
+- add new Rust workspace crates for proxy-engine, sip-proto, and codec-lib
+- move transcoding logic out of opus-codec into reusable codec-lib and keep opus-codec as a thin CLI wrapper
+- implement SIP message parsing, dialog handling, SDP/URI rewriting, provider registration, device registration, call management, RTP relay, and DTMF detection in Rust
+- add a TypeScript proxy bridge and update the SIP proxy entrypoint to spawn and configure the Rust engine as the SIP data plane
+
+## 2026-04-10 - 1.10.0 - feat(call, voicemail, ivr)
+add voicemail and IVR call flows with DTMF handling, prompt playback, recording, and dashboard management
+
+- introduces system call legs, DTMF detection, prompt caching, and audio recording to support automated call handling
+- adds configurable voiceboxes and IVR menus to routing, including voicemail fallback on busy or no-answer flows
+- exposes voicemail message APIs, message waiting counts, and new dashboard views for voicemail and IVR management
+
 ## 2026-04-10 - 1.9.0 - feat(routing)
 add rule-based SIP routing for inbound and outbound calls with dashboard route management
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "siprouter",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "private": true,
   "type": "module",
   "scripts": {

rust/Cargo.lock

@@ -111,6 +111,15 @@ version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
 
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "byte-slice-cast"
 version = "1.2.3"
@@ -203,6 +212,16 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "codec-lib"
+version = "0.1.0"
+dependencies = [
+ "audiopus",
+ "ezk-g722",
+ "nnnoiseless",
+ "rubato",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.10.1"
@@ -246,6 +265,16 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
 [[package]]
 name = "dary_heap"
 version = "0.3.8"
@@ -271,6 +300,16 @@ dependencies = [
  "powerfmt",
 ]
 
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
 [[package]]
 name = "downcast-rs"
 version = "1.2.1"
@@ -505,6 +544,16 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "generic_singleton"
 version = "0.5.3"
@@ -796,12 +845,33 @@ dependencies = [
  "rawpointer",
 ]
 
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest",
+]
+
 [[package]]
 name = "memchr"
 version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
+[[package]]
+name = "mio"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys",
+]
+
 [[package]]
 name = "native-tls"
 version = "0.2.18"
@@ -952,11 +1022,8 @@ dependencies = [
 name = "opus-codec"
 version = "0.2.0"
 dependencies = [
- "audiopus",
  "base64",
- "ezk-g722",
- "nnnoiseless",
- "rubato",
+ "codec-lib",
  "serde",
  "serde_json",
 ]
@@ -1180,6 +1247,19 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "proxy-engine"
+version = "0.1.0"
+dependencies = [
+ "base64",
+ "codec-lib",
+ "regex-lite",
+ "serde",
+ "serde_json",
+ "sip-proto",
+ "tokio",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.45"
@@ -1295,6 +1375,12 @@ dependencies = [
  "regex-syntax",
 ]
 
+[[package]]
+name = "regex-lite"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
+
 [[package]]
 name = "regex-syntax"
 version = "0.8.10"
@@ -1479,6 +1565,24 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "sip-proto"
+version = "0.1.0"
+dependencies = [
+ "md-5",
+ "rand 0.8.5",
+]
+
 [[package]]
 name = "siphasher"
 version = "1.0.2"
@@ -1506,6 +1610,16 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
 [[package]]
 name = "socks"
 version = "0.3.4"
@@ -1592,8 +1706,15 @@ version = "1.51.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f66bf9585cda4b724d3e78ab34b73fb2bbaba9011b9bfdf69dc836382ea13b8c"
 dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
  "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
  "tokio-macros",
+ "windows-sys",
 ]
 
 [[package]]
@@ -1646,6 +1767,12 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"

rust/Cargo.toml

@@ -1,5 +1,11 @@
 [workspace]
-members = ["crates/opus-codec", "crates/tts-engine"]
+members = [
+    "crates/codec-lib",
+    "crates/opus-codec",
+    "crates/tts-engine",
+    "crates/sip-proto",
+    "crates/proxy-engine",
+]
 resolver = "2"
 
 [profile.release]

rust/crates/codec-lib/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "codec-lib"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+audiopus = "0.3.0-rc.0"
+ezk-g722 = "0.1"
+rubato = "0.14"
+nnnoiseless = { version = "0.5", default-features = false }

rust/crates/codec-lib/src/lib.rs

@@ -0,0 +1,349 @@
+//! Audio codec library for the SIP router.
+//!
+//! Handles Opus ↔ G.722 ↔ PCMU/PCMA transcoding with ML noise suppression.
+//! Used by both the standalone `opus-codec` CLI and the `proxy-engine` binary.
+
+use audiopus::coder::{Decoder as OpusDecoder, Encoder as OpusEncoder};
+use audiopus::packet::Packet as OpusPacket;
+use audiopus::{Application, Bitrate as OpusBitrate, Channels, MutSignals, SampleRate};
+use ezk_g722::libg722::{self, Bitrate};
+use nnnoiseless::DenoiseState;
+use rubato::{FftFixedIn, Resampler};
+use std::collections::HashMap;
+
+// ---- Payload type constants ------------------------------------------------
+
+pub const PT_PCMU: u8 = 0;
+pub const PT_PCMA: u8 = 8;
+pub const PT_G722: u8 = 9;
+pub const PT_OPUS: u8 = 111;
+
+/// Return the native sample rate for a given payload type.
+pub fn codec_sample_rate(pt: u8) -> u32 {
+    match pt {
+        PT_OPUS => 48000,
+        PT_G722 => 16000,
+        _ => 8000, // PCMU, PCMA
+    }
+}
+
+// ---- G.711 µ-law (PCMU) ---------------------------------------------------
+
+pub fn mulaw_encode(sample: i16) -> u8 {
+    const BIAS: i16 = 0x84;
+    const CLIP: i16 = 32635;
+    let sign = if sample < 0 { 0x80u8 } else { 0 };
+    let mut s = (sample as i32).unsigned_abs().min(CLIP as u32) as i16;
+    s += BIAS;
+    let mut exp = 7u8;
+    let mut mask = 0x4000i16;
+    while exp > 0 && (s & mask) == 0 {
+        exp -= 1;
+        mask >>= 1;
+    }
+    let mantissa = ((s >> (exp + 3)) & 0x0f) as u8;
+    !(sign | (exp << 4) | mantissa)
+}
+
+pub fn mulaw_decode(mulaw: u8) -> i16 {
+    let v = !mulaw;
+    let sign = v & 0x80;
+    let exp = (v >> 4) & 0x07;
+    let mantissa = v & 0x0f;
+    // Use i32 to avoid overflow when exp=7, mantissa=15 (result > i16::MAX).
+    let mut sample = (((mantissa as i32) << 4) + 0x84) << exp;
+    sample -= 0x84;
+    let sample = if sign != 0 { -sample } else { sample };
+    sample.clamp(-32768, 32767) as i16
+}
+
+// ---- G.711 A-law (PCMA) ---------------------------------------------------
+
+pub fn alaw_encode(sample: i16) -> u8 {
+    let sign = if sample >= 0 { 0x80u8 } else { 0 };
+    let s = (sample as i32).unsigned_abs().min(32767) as i16;
+    let mut exp = 7u8;
+    let mut mask = 0x4000i16;
+    while exp > 0 && (s & mask) == 0 {
+        exp -= 1;
+        mask >>= 1;
+    }
+    let mantissa = if exp > 0 {
+        ((s >> (exp + 3)) & 0x0f) as u8
+    } else {
+        ((s >> 4) & 0x0f) as u8
+    };
+    (sign | (exp << 4) | mantissa) ^ 0x55
+}
+
+pub fn alaw_decode(alaw: u8) -> i16 {
+    let v = alaw ^ 0x55;
+    let sign = v & 0x80;
+    let exp = (v >> 4) & 0x07;
+    let mantissa = v & 0x0f;
+    // Use i32 to avoid overflow for extreme values.
+    let sample = if exp == 0 {
+        ((mantissa as i32) << 4) + 8
+    } else {
+        (((mantissa as i32) << 4) + 0x108) << (exp - 1)
+    };
+    let sample = if sign != 0 { sample } else { -sample };
+    sample.clamp(-32768, 32767) as i16
+}
+
+// ---- TranscodeState --------------------------------------------------------
+
+/// Per-session codec state holding Opus, G.722, resampler, and denoiser instances.
+///
+/// Each concurrent call should get its own `TranscodeState` to prevent stateful
+/// codecs (Opus, G.722 ADPCM) from corrupting each other.
+pub struct TranscodeState {
+    opus_enc: OpusEncoder,
+    opus_dec: OpusDecoder,
+    g722_enc: libg722::encoder::Encoder,
+    g722_dec: libg722::decoder::Decoder,
+    /// Cached FFT resamplers keyed by (from_rate, to_rate, chunk_size).
+    resamplers: HashMap<(u32, u32, usize), FftFixedIn<f64>>,
+    /// ML noise suppression for the SIP-bound direction.
+    denoiser_to_sip: Box<DenoiseState<'static>>,
+    /// ML noise suppression for the browser-bound direction.
+    denoiser_to_browser: Box<DenoiseState<'static>>,
+}
+
+impl TranscodeState {
+    /// Create a new transcoding session with fresh codec state.
+    pub fn new() -> Result<Self, String> {
+        let mut opus_enc =
+            OpusEncoder::new(SampleRate::Hz48000, Channels::Mono, Application::Voip)
+                .map_err(|e| format!("opus encoder: {e}"))?;
+        opus_enc
+            .set_complexity(5)
+            .map_err(|e| format!("opus set_complexity: {e}"))?;
+        opus_enc
+            .set_bitrate(OpusBitrate::BitsPerSecond(24000))
+            .map_err(|e| format!("opus set_bitrate: {e}"))?;
+        let opus_dec = OpusDecoder::new(SampleRate::Hz48000, Channels::Mono)
+            .map_err(|e| format!("opus decoder: {e}"))?;
+        let g722_enc = libg722::encoder::Encoder::new(Bitrate::Mode1_64000, false, false);
+        let g722_dec = libg722::decoder::Decoder::new(Bitrate::Mode1_64000, false, false);
+
+        Ok(Self {
+            opus_enc,
+            opus_dec,
+            g722_enc,
+            g722_dec,
+            resamplers: HashMap::new(),
+            denoiser_to_sip: DenoiseState::new(),
+            denoiser_to_browser: DenoiseState::new(),
+        })
+    }
+
+    /// High-quality sample rate conversion using rubato FFT resampler.
+    /// Resamplers are cached by (from_rate, to_rate, chunk_size) and reused,
+    /// maintaining proper inter-frame state for continuous audio streams.
+    pub fn resample(
+        &mut self,
+        pcm: &[i16],
+        from_rate: u32,
+        to_rate: u32,
+    ) -> Result<Vec<i16>, String> {
+        if from_rate == to_rate || pcm.is_empty() {
+            return Ok(pcm.to_vec());
+        }
+
+        let chunk = pcm.len();
+        let key = (from_rate, to_rate, chunk);
+
+        if !self.resamplers.contains_key(&key) {
+            let r =
+                FftFixedIn::<f64>::new(from_rate as usize, to_rate as usize, chunk, 1, 1)
+                    .map_err(|e| format!("resampler {from_rate}->{to_rate}: {e}"))?;
+            self.resamplers.insert(key, r);
+        }
+        let resampler = self.resamplers.get_mut(&key).unwrap();
+
+        let float_in: Vec<f64> = pcm.iter().map(|&s| s as f64 / 32768.0).collect();
+        let input = vec![float_in];
+
+        let result = resampler
+            .process(&input, None)
+            .map_err(|e| format!("resample {from_rate}->{to_rate}: {e}"))?;
+
+        Ok(result[0]
+            .iter()
+            .map(|&s| (s * 32767.0).round().clamp(-32768.0, 32767.0) as i16)
+            .collect())
+    }
+
+    /// Apply RNNoise ML noise suppression to 48kHz PCM audio.
+    /// Processes in 480-sample (10ms) frames. State persists across calls.
+    pub fn denoise(denoiser: &mut DenoiseState, pcm: &[i16]) -> Vec<i16> {
+        let frame_size = DenoiseState::FRAME_SIZE; // 480
+        let total = pcm.len();
+        let whole = (total / frame_size) * frame_size;
+        let mut output = Vec::with_capacity(total);
+        let mut out_buf = [0.0f32; 480];
+
+        for offset in (0..whole).step_by(frame_size) {
+            let input: Vec<f32> = pcm[offset..offset + frame_size]
+                .iter()
+                .map(|&s| s as f32)
+                .collect();
+            denoiser.process_frame(&mut out_buf, &input);
+            output.extend(
+                out_buf
+                    .iter()
+                    .map(|&s| s.round().clamp(-32768.0, 32767.0) as i16),
+            );
+        }
+        if whole < total {
+            output.extend_from_slice(&pcm[whole..]);
+        }
+        output
+    }
+
+    /// Transcode audio payload from one codec to another.
+    ///
+    /// `direction`: `Some("to_sip")` or `Some("to_browser")` selects per-direction
+    /// denoiser. `None` skips denoising (backward compat).
+    pub fn transcode(
+        &mut self,
+        data: &[u8],
+        from_pt: u8,
+        to_pt: u8,
+        direction: Option<&str>,
+    ) -> Result<Vec<u8>, String> {
+        if from_pt == to_pt {
+            return Ok(data.to_vec());
+        }
+
+        let (pcm, rate) = self.decode_to_pcm(data, from_pt)?;
+
+        let processed = if let Some(dir) = direction {
+            let pcm_48k = self.resample(&pcm, rate, 48000)?;
+            let denoiser = match dir {
+                "to_sip" => &mut self.denoiser_to_sip,
+                _ => &mut self.denoiser_to_browser,
+            };
+            let denoised = Self::denoise(denoiser, &pcm_48k);
+            let target_rate = codec_sample_rate(to_pt);
+            self.resample(&denoised, 48000, target_rate)?
+        } else {
+            let target_rate = codec_sample_rate(to_pt);
+            if rate == target_rate {
+                pcm
+            } else {
+                self.resample(&pcm, rate, target_rate)?
+            }
+        };
+
+        self.encode_from_pcm(&processed, to_pt)
+    }
+
+    /// Decode an encoded audio payload to raw 16-bit PCM samples.
+    /// Returns (samples, sample_rate).
+    pub fn decode_to_pcm(&mut self, data: &[u8], pt: u8) -> Result<(Vec<i16>, u32), String> {
+        match pt {
+            PT_OPUS => {
+                let mut pcm = vec![0i16; 5760]; // up to 120ms at 48kHz
+                let packet =
+                    OpusPacket::try_from(data).map_err(|e| format!("opus packet: {e}"))?;
+                let out =
+                    MutSignals::try_from(&mut pcm[..]).map_err(|e| format!("opus signals: {e}"))?;
+                let n: usize = self
+                    .opus_dec
+                    .decode(Some(packet), out, false)
+                    .map_err(|e| format!("opus decode: {e}"))?
+                    .into();
+                pcm.truncate(n);
+                Ok((pcm, 48000))
+            }
+            PT_G722 => {
+                let pcm = self.g722_dec.decode(data);
+                Ok((pcm, 16000))
+            }
+            PT_PCMU => {
+                let pcm: Vec<i16> = data.iter().map(|&b| mulaw_decode(b)).collect();
+                Ok((pcm, 8000))
+            }
+            PT_PCMA => {
+                let pcm: Vec<i16> = data.iter().map(|&b| alaw_decode(b)).collect();
+                Ok((pcm, 8000))
+            }
+            _ => Err(format!("unsupported source PT {pt}")),
+        }
+    }
+
+    /// Encode raw PCM samples to an audio codec.
+    pub fn encode_from_pcm(&mut self, pcm: &[i16], pt: u8) -> Result<Vec<u8>, String> {
+        match pt {
+            PT_OPUS => {
+                let mut buf = vec![0u8; 4000];
+                let n: usize = self
+                    .opus_enc
+                    .encode(pcm, &mut buf)
+                    .map_err(|e| format!("opus encode: {e}"))?
+                    .into();
+                buf.truncate(n);
+                Ok(buf)
+            }
+            PT_G722 => Ok(self.g722_enc.encode(pcm)),
+            PT_PCMU => Ok(pcm.iter().map(|&s| mulaw_encode(s)).collect()),
+            PT_PCMA => Ok(pcm.iter().map(|&s| alaw_encode(s)).collect()),
+            _ => Err(format!("unsupported target PT {pt}")),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mulaw_roundtrip() {
+        for sample in [-32768i16, -1000, -1, 0, 1, 1000, 32767] {
+            let encoded = mulaw_encode(sample);
+            let decoded = mulaw_decode(encoded);
+            // µ-law is lossy; verify the decoded value is close.
+            assert!((sample as i32 - decoded as i32).abs() < 1000,
+                "µ-law roundtrip failed for {sample}: got {decoded}");
+        }
+    }
+
+    #[test]
+    fn alaw_roundtrip() {
+        for sample in [-32768i16, -1000, -1, 0, 1, 1000, 32767] {
+            let encoded = alaw_encode(sample);
+            let decoded = alaw_decode(encoded);
+            assert!((sample as i32 - decoded as i32).abs() < 1000,
+                "A-law roundtrip failed for {sample}: got {decoded}");
+        }
+    }
+
+    #[test]
+    fn codec_sample_rates() {
+        assert_eq!(codec_sample_rate(PT_OPUS), 48000);
+        assert_eq!(codec_sample_rate(PT_G722), 16000);
+        assert_eq!(codec_sample_rate(PT_PCMU), 8000);
+        assert_eq!(codec_sample_rate(PT_PCMA), 8000);
+    }
+
+    #[test]
+    fn transcode_same_pt_is_passthrough() {
+        let mut st = TranscodeState::new().unwrap();
+        let data = vec![0u8; 160];
+        let result = st.transcode(&data, PT_PCMU, PT_PCMU, None).unwrap();
+        assert_eq!(result, data);
+    }
+
+    #[test]
+    fn pcmu_to_pcma_roundtrip() {
+        let mut st = TranscodeState::new().unwrap();
+        // 160 bytes = 20ms of PCMU at 8kHz
+        let pcmu_data: Vec<u8> = (0..160).map(|i| mulaw_encode((i as i16 * 200) - 16000)).collect();
+        let pcma = st.transcode(&pcmu_data, PT_PCMU, PT_PCMA, None).unwrap();
+        assert_eq!(pcma.len(), 160); // Same frame size
+        let back = st.transcode(&pcma, PT_PCMA, PT_PCMU, None).unwrap();
+        assert_eq!(back.len(), 160);
+    }
+}

rust/crates/opus-codec/Cargo.toml

@@ -8,10 +8,7 @@ name = "opus-codec"
 path = "src/main.rs"
 
 [dependencies]
-audiopus = "0.3.0-rc.0"
-ezk-g722 = "0.1"
-rubato = "0.14"
+codec-lib = { path = "../codec-lib" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 base64 = "0.22"
-nnnoiseless = { version = "0.5", default-features = false }

rust/crates/opus-codec/src/main.rs

@@ -1,10 +1,6 @@
 /// Audio transcoding bridge for smartrust.
 ///
-/// Handles Opus ↔ G.722 ↔ PCMU transcoding for the SIP router.
-/// Uses audiopus (libopus) for Opus and ezk-g722 (SpanDSP port) for G.722.
-///
-/// Supports per-session codec state so concurrent calls don't corrupt each
-/// other's stateful codecs (Opus, G.722 ADPCM).
+/// Thin CLI wrapper around `codec-lib`. Handles Opus ↔ G.722 ↔ PCMU transcoding.
 ///
 /// Protocol:
 ///   -> {"id":"1","method":"init","params":{}}
@@ -16,24 +12,13 @@
 ///   -> {"id":"4","method":"destroy_session","params":{"session_id":"call-abc"}}
 ///   <- {"id":"4","success":true,"result":{}}
 
-use audiopus::coder::{Decoder as OpusDecoder, Encoder as OpusEncoder};
-use audiopus::packet::Packet as OpusPacket;
-use audiopus::{Application, Bitrate as OpusBitrate, Channels, MutSignals, SampleRate};
 use base64::engine::general_purpose::STANDARD as B64;
 use base64::Engine as _;
-use ezk_g722::libg722::{self, Bitrate};
-use nnnoiseless::DenoiseState;
-use rubato::{FftFixedIn, Resampler};
+use codec_lib::{codec_sample_rate, TranscodeState};
 use serde::Deserialize;
 use std::collections::HashMap;
 use std::io::{self, BufRead, Write};
 
-// Payload type constants.
-const PT_PCMU: u8 = 0;
-const PT_PCMA: u8 = 8;
-const PT_G722: u8 = 9;
-const PT_OPUS: u8 = 111;
-
 #[derive(Deserialize)]
 struct Request {
     id: String,
@@ -42,261 +27,24 @@ struct Request {
     params: serde_json::Value,
 }
 
-fn respond(out: &mut impl Write, id: &str, success: bool, result: Option<serde_json::Value>, error: Option<&str>) {
+fn respond(
+    out: &mut impl Write,
+    id: &str,
+    success: bool,
+    result: Option<serde_json::Value>,
+    error: Option<&str>,
+) {
     let mut resp = serde_json::json!({ "id": id, "success": success });
-    if let Some(r) = result { resp["result"] = r; }
-    if let Some(e) = error { resp["error"] = serde_json::Value::String(e.to_string()); }
+    if let Some(r) = result {
+        resp["result"] = r;
+    }
+    if let Some(e) = error {
+        resp["error"] = serde_json::Value::String(e.to_string());
+    }
     let _ = writeln!(out, "{}", resp);
     let _ = out.flush();
 }
 
-// ---------------------------------------------------------------------------
-// Codec state
-// ---------------------------------------------------------------------------
-
-struct TranscodeState {
-    opus_enc: OpusEncoder,
-    opus_dec: OpusDecoder,
-    g722_enc: libg722::encoder::Encoder,
-    g722_dec: libg722::decoder::Decoder,
-    // Cached FFT resamplers keyed by (from_rate, to_rate, chunk_size).
-    resamplers: HashMap<(u32, u32, usize), FftFixedIn<f64>>,
-    // Per-direction ML noise suppression (RNNoise). Separate state per direction
-    // prevents the RNN hidden state from being corrupted by interleaved audio streams.
-    denoiser_to_sip: Box<DenoiseState<'static>>,
-    denoiser_to_browser: Box<DenoiseState<'static>>,
-}
-
-impl TranscodeState {
-    fn new() -> Result<Self, String> {
-        let mut opus_enc = OpusEncoder::new(SampleRate::Hz48000, Channels::Mono, Application::Voip)
-            .map_err(|e| format!("opus encoder: {e}"))?;
-        // Telephony-grade tuning: complexity 5 is sufficient for voice bridged to G.722.
-        opus_enc.set_complexity(5).map_err(|e| format!("opus set_complexity: {e}"))?;
-        opus_enc.set_bitrate(OpusBitrate::BitsPerSecond(24000)).map_err(|e| format!("opus set_bitrate: {e}"))?;
-        let opus_dec = OpusDecoder::new(SampleRate::Hz48000, Channels::Mono)
-            .map_err(|e| format!("opus decoder: {e}"))?;
-        let g722_enc = libg722::encoder::Encoder::new(Bitrate::Mode1_64000, false, false);
-        let g722_dec = libg722::decoder::Decoder::new(Bitrate::Mode1_64000, false, false);
-
-        Ok(Self {
-            opus_enc, opus_dec, g722_enc, g722_dec,
-            resamplers: HashMap::new(),
-            denoiser_to_sip: DenoiseState::new(),
-            denoiser_to_browser: DenoiseState::new(),
-        })
-    }
-
-    /// High-quality sample rate conversion using rubato FFT resampler.
-    /// Resamplers are cached by (from_rate, to_rate, chunk_size) and reused,
-    /// maintaining proper inter-frame state for continuous audio streams.
-    fn resample(&mut self, pcm: &[i16], from_rate: u32, to_rate: u32) -> Result<Vec<i16>, String> {
-        if from_rate == to_rate || pcm.is_empty() {
-            return Ok(pcm.to_vec());
-        }
-
-        let chunk = pcm.len();
-        let key = (from_rate, to_rate, chunk);
-
-        // Get or create cached resampler for this rate pair + chunk size.
-        if !self.resamplers.contains_key(&key) {
-            let r = FftFixedIn::<f64>::new(from_rate as usize, to_rate as usize, chunk, 1, 1)
-                .map_err(|e| format!("resampler {from_rate}->{to_rate}: {e}"))?;
-            self.resamplers.insert(key, r);
-        }
-        let resampler = self.resamplers.get_mut(&key).unwrap();
-
-        // i16 → f64 normalized to [-1.0, 1.0]
-        let float_in: Vec<f64> = pcm.iter().map(|&s| s as f64 / 32768.0).collect();
-        let input = vec![float_in];
-
-        let result = resampler.process(&input, None)
-            .map_err(|e| format!("resample {from_rate}->{to_rate}: {e}"))?;
-
-        // f64 → i16
-        Ok(result[0].iter()
-            .map(|&s| (s * 32767.0).round().clamp(-32768.0, 32767.0) as i16)
-            .collect())
-    }
-
-    /// Apply RNNoise ML noise suppression to 48kHz PCM audio.
-    /// Processes in 480-sample (10ms) frames. State persists across calls.
-    fn denoise(denoiser: &mut DenoiseState, pcm: &[i16]) -> Vec<i16> {
-        let frame_size = DenoiseState::FRAME_SIZE; // 480
-        let total = pcm.len();
-        // Round down to whole frames — don't process partial frames to avoid
-        // injecting artificial silence into the RNN state.
-        let whole = (total / frame_size) * frame_size;
-        let mut output = Vec::with_capacity(total);
-        let mut out_buf = [0.0f32; 480];
-
-        for offset in (0..whole).step_by(frame_size) {
-            let input: Vec<f32> = pcm[offset..offset + frame_size]
-                .iter().map(|&s| s as f32).collect();
-            denoiser.process_frame(&mut out_buf, &input);
-            output.extend(out_buf.iter()
-                .map(|&s| s.round().clamp(-32768.0, 32767.0) as i16));
-        }
-        // Pass through any trailing partial-frame samples unmodified.
-        if whole < total {
-            output.extend_from_slice(&pcm[whole..]);
-        }
-        output
-    }
-
-    /// Transcode audio payload from one codec to another.
-    /// `direction`: "to_sip" or "to_browser" — selects the per-direction denoiser.
-    /// If None, denoising is skipped (backward compat).
-    fn transcode(&mut self, data: &[u8], from_pt: u8, to_pt: u8, direction: Option<&str>) -> Result<Vec<u8>, String> {
-        if from_pt == to_pt {
-            return Ok(data.to_vec());
-        }
-
-        // Decode to PCM (at source sample rate).
-        let (pcm, rate) = self.decode_to_pcm(data, from_pt)?;
-
-        // Apply noise suppression if direction is specified.
-        let processed = if let Some(dir) = direction {
-            // Resample to 48kHz for denoising (no-op when already 48kHz).
-            let pcm_48k = self.resample(&pcm, rate, 48000)?;
-            let denoiser = match dir {
-                "to_sip" => &mut self.denoiser_to_sip,
-                _ => &mut self.denoiser_to_browser,
-            };
-            let denoised = Self::denoise(denoiser, &pcm_48k);
-            // Resample to target rate (no-op when target is 48kHz).
-            let target_rate = codec_sample_rate(to_pt);
-            self.resample(&denoised, 48000, target_rate)?
-        } else {
-            // No denoising — direct resample.
-            let target_rate = codec_sample_rate(to_pt);
-            if rate == target_rate { pcm } else { self.resample(&pcm, rate, target_rate)? }
-        };
-
-        // Encode from PCM.
-        self.encode_from_pcm(&processed, to_pt)
-    }
-
-    fn decode_to_pcm(&mut self, data: &[u8], pt: u8) -> Result<(Vec<i16>, u32), String> {
-        match pt {
-            PT_OPUS => {
-                let mut pcm = vec![0i16; 5760]; // up to 120ms at 48kHz (RFC 6716 max)
-                let packet = OpusPacket::try_from(data)
-                    .map_err(|e| format!("opus packet: {e}"))?;
-                let out = MutSignals::try_from(&mut pcm[..])
-                    .map_err(|e| format!("opus signals: {e}"))?;
-                let n: usize = self.opus_dec.decode(Some(packet), out, false)
-                    .map_err(|e| format!("opus decode: {e}"))?.into();
-                pcm.truncate(n);
-                Ok((pcm, 48000))
-            }
-            PT_G722 => {
-                let pcm = self.g722_dec.decode(data);
-                Ok((pcm, 16000))
-            }
-            PT_PCMU => {
-                let pcm: Vec<i16> = data.iter().map(|&b| mulaw_decode(b)).collect();
-                Ok((pcm, 8000))
-            }
-            PT_PCMA => {
-                let pcm: Vec<i16> = data.iter().map(|&b| alaw_decode(b)).collect();
-                Ok((pcm, 8000))
-            }
-            _ => Err(format!("unsupported source PT {pt}")),
-        }
-    }
-
-    fn encode_from_pcm(&mut self, pcm: &[i16], pt: u8) -> Result<Vec<u8>, String> {
-        match pt {
-            PT_OPUS => {
-                let mut buf = vec![0u8; 4000];
-                let n: usize = self.opus_enc.encode(pcm, &mut buf)
-                    .map_err(|e| format!("opus encode: {e}"))?.into();
-                buf.truncate(n);
-                Ok(buf)
-            }
-            PT_G722 => {
-                Ok(self.g722_enc.encode(pcm))
-            }
-            PT_PCMU => {
-                Ok(pcm.iter().map(|&s| mulaw_encode(s)).collect())
-            }
-            PT_PCMA => {
-                Ok(pcm.iter().map(|&s| alaw_encode(s)).collect())
-            }
-            _ => Err(format!("unsupported target PT {pt}")),
-        }
-    }
-}
-
-fn codec_sample_rate(pt: u8) -> u32 {
-    match pt {
-        PT_OPUS => 48000,
-        PT_G722 => 16000,
-        _ => 8000, // PCMU, PCMA
-    }
-}
-
-// ---------------------------------------------------------------------------
-// G.711 µ-law (PCMU)
-// ---------------------------------------------------------------------------
-
-fn mulaw_encode(sample: i16) -> u8 {
-    const BIAS: i16 = 0x84;
-    const CLIP: i16 = 32635;
-    let sign = if sample < 0 { 0x80u8 } else { 0 };
-    // Use i32 to avoid overflow when sample == i16::MIN (-32768).
-    let mut s = (sample as i32).unsigned_abs().min(CLIP as u32) as i16;
-    s += BIAS;
-    let mut exp = 7u8;
-    let mut mask = 0x4000i16;
-    while exp > 0 && (s & mask) == 0 { exp -= 1; mask >>= 1; }
-    let mantissa = ((s >> (exp + 3)) & 0x0f) as u8;
-    !(sign | (exp << 4) | mantissa)
-}
-
-fn mulaw_decode(mulaw: u8) -> i16 {
-    let v = !mulaw;
-    let sign = v & 0x80;
-    let exp = (v >> 4) & 0x07;
-    let mantissa = v & 0x0f;
-    let mut sample = (((mantissa as i16) << 4) + 0x84) << exp;
-    sample -= 0x84;
-    if sign != 0 { -sample } else { sample }
-}
-
-// ---------------------------------------------------------------------------
-// G.711 A-law (PCMA)
-// ---------------------------------------------------------------------------
-
-fn alaw_encode(sample: i16) -> u8 {
-    let sign = if sample >= 0 { 0x80u8 } else { 0 };
-    // Use i32 to avoid overflow when sample == i16::MIN (-32768).
-    let s = (sample as i32).unsigned_abs().min(32767) as i16;
-    let mut exp = 7u8;
-    let mut mask = 0x4000i16;
-    while exp > 0 && (s & mask) == 0 { exp -= 1; mask >>= 1; }
-    let mantissa = if exp > 0 { ((s >> (exp + 3)) & 0x0f) as u8 } else { ((s >> 4) & 0x0f) as u8 };
-    (sign | (exp << 4) | mantissa) ^ 0x55
-}
-
-fn alaw_decode(alaw: u8) -> i16 {
-    let v = alaw ^ 0x55;
-    let sign = v & 0x80;
-    let exp = (v >> 4) & 0x07;
-    let mantissa = v & 0x0f;
-    let sample = if exp == 0 {
-        ((mantissa as i16) << 4) + 8
-    } else {
-        (((mantissa as i16) << 4) + 0x108) << (exp - 1)
-    };
-    if sign != 0 { sample } else { -sample }
-}
-
-// ---------------------------------------------------------------------------
-// Main loop
-// ---------------------------------------------------------------------------
-
 /// Resolve a session: if session_id is provided, look it up in the sessions map;
 /// otherwise fall back to the default state (backward compat with `init`).
 fn get_session<'a>(
@@ -319,9 +67,7 @@ fn main() {
     let _ = writeln!(out, r#"{{"event":"ready","data":{{}}}}"#);
     let _ = out.flush();
 
-    // Default state for backward-compat `init` (no session_id).
     let mut default_state: Option<TranscodeState> = None;
-    // Per-session codec state for concurrent call isolation.
     let mut sessions: HashMap<String, TranscodeState> = HashMap::new();
 
     for line in stdin.lock().lines() {
@@ -340,22 +86,21 @@ fn main() {
         };
 
         match req.method.as_str() {
-            // Backward-compat: init the default (shared) session.
-            "init" => {
-                match TranscodeState::new() {
-                    Ok(s) => {
-                        default_state = Some(s);
-                        respond(&mut out, &req.id, true, Some(serde_json::json!({})), None);
-                    }
-                    Err(e) => respond(&mut out, &req.id, false, None, Some(&e)),
+            "init" => match TranscodeState::new() {
+                Ok(s) => {
+                    default_state = Some(s);
+                    respond(&mut out, &req.id, true, Some(serde_json::json!({})), None);
                 }
-            }
+                Err(e) => respond(&mut out, &req.id, false, None, Some(&e)),
+            },
 
-            // Create an isolated session with its own codec state.
             "create_session" => {
                 let session_id = match req.params.get("session_id").and_then(|v| v.as_str()) {
                     Some(s) => s.to_string(),
-                    None => { respond(&mut out, &req.id, false, None, Some("missing session_id")); continue; }
+                    None => {
+                        respond(&mut out, &req.id, false, None, Some("missing session_id"));
+                        continue;
+                    }
                 };
                 if sessions.contains_key(&session_id) {
                     respond(&mut out, &req.id, true, Some(serde_json::json!({})), None);
@@ -370,95 +115,172 @@ fn main() {
                 }
             }
 
-            // Destroy a session, freeing its codec state.
             "destroy_session" => {
                 let session_id = match req.params.get("session_id").and_then(|v| v.as_str()) {
                     Some(s) => s,
-                    None => { respond(&mut out, &req.id, false, None, Some("missing session_id")); continue; }
+                    None => {
+                        respond(&mut out, &req.id, false, None, Some("missing session_id"));
+                        continue;
+                    }
                 };
                 sessions.remove(session_id);
                 respond(&mut out, &req.id, true, Some(serde_json::json!({})), None);
             }
 
-            // Transcode: uses session_id if provided, else default state.
             "transcode" => {
                 let st = match get_session(&mut sessions, &mut default_state, &req.params) {
                     Some(s) => s,
-                    None => { respond(&mut out, &req.id, false, None, Some("not initialized (no session or default state)")); continue; }
+                    None => {
+                        respond(
+                            &mut out,
+                            &req.id,
+                            false,
+                            None,
+                            Some("not initialized (no session or default state)"),
+                        );
+                        continue;
+                    }
                 };
                 let data_b64 = match req.params.get("data_b64").and_then(|v| v.as_str()) {
                     Some(s) => s,
-                    None => { respond(&mut out, &req.id, false, None, Some("missing data_b64")); continue; }
+                    None => {
+                        respond(&mut out, &req.id, false, None, Some("missing data_b64"));
+                        continue;
+                    }
                 };
-                let from_pt = req.params.get("from_pt").and_then(|v| v.as_u64()).unwrap_or(0) as u8;
+                let from_pt =
+                    req.params.get("from_pt").and_then(|v| v.as_u64()).unwrap_or(0) as u8;
                 let to_pt = req.params.get("to_pt").and_then(|v| v.as_u64()).unwrap_or(0) as u8;
                 let direction = req.params.get("direction").and_then(|v| v.as_str());
 
                 let data = match B64.decode(data_b64) {
                     Ok(b) => b,
-                    Err(e) => { respond(&mut out, &req.id, false, None, Some(&format!("b64: {e}"))); continue; }
+                    Err(e) => {
+                        respond(
+                            &mut out,
+                            &req.id,
+                            false,
+                            None,
+                            Some(&format!("b64: {e}")),
+                        );
+                        continue;
+                    }
                 };
 
                 match st.transcode(&data, from_pt, to_pt, direction) {
                     Ok(result) => {
-                        respond(&mut out, &req.id, true, Some(serde_json::json!({ "data_b64": B64.encode(&result) })), None);
+                        respond(
+                            &mut out,
+                            &req.id,
+                            true,
+                            Some(serde_json::json!({ "data_b64": B64.encode(&result) })),
+                            None,
+                        );
                     }
                     Err(e) => respond(&mut out, &req.id, false, None, Some(&e)),
                 }
             }
 
-            // Encode raw 16-bit PCM to a target codec.
-            // Params: data_b64 (raw PCM bytes, 16-bit LE), sample_rate (input Hz), to_pt
-            // Optional: session_id for isolated codec state.
             "encode_pcm" => {
                 let st = match get_session(&mut sessions, &mut default_state, &req.params) {
                     Some(s) => s,
-                    None => { respond(&mut out, &req.id, false, None, Some("not initialized (no session or default state)")); continue; }
+                    None => {
+                        respond(
+                            &mut out,
+                            &req.id,
+                            false,
+                            None,
+                            Some("not initialized (no session or default state)"),
+                        );
+                        continue;
+                    }
                 };
                 let data_b64 = match req.params.get("data_b64").and_then(|v| v.as_str()) {
                     Some(s) => s,
-                    None => { respond(&mut out, &req.id, false, None, Some("missing data_b64")); continue; }
+                    None => {
+                        respond(&mut out, &req.id, false, None, Some("missing data_b64"));
+                        continue;
+                    }
                 };
-                let sample_rate = req.params.get("sample_rate").and_then(|v| v.as_u64()).unwrap_or(22050) as u32;
+                let sample_rate = req
+                    .params
+                    .get("sample_rate")
+                    .and_then(|v| v.as_u64())
+                    .unwrap_or(22050) as u32;
                 let to_pt = req.params.get("to_pt").and_then(|v| v.as_u64()).unwrap_or(9) as u8;
 
                 let data = match B64.decode(data_b64) {
                     Ok(b) => b,
-                    Err(e) => { respond(&mut out, &req.id, false, None, Some(&format!("b64: {e}"))); continue; }
+                    Err(e) => {
+                        respond(
+                            &mut out,
+                            &req.id,
+                            false,
+                            None,
+                            Some(&format!("b64: {e}")),
+                        );
+                        continue;
+                    }
                 };
 
                 if data.len() % 2 != 0 {
-                    respond(&mut out, &req.id, false, None, Some("PCM data has odd byte count (expected 16-bit LE samples)"));
+                    respond(
+                        &mut out,
+                        &req.id,
+                        false,
+                        None,
+                        Some("PCM data has odd byte count (expected 16-bit LE samples)"),
+                    );
                     continue;
                 }
 
-                // Convert raw bytes to i16 samples.
-                let pcm: Vec<i16> = data.chunks_exact(2)
+                let pcm: Vec<i16> = data
+                    .chunks_exact(2)
                     .map(|c| i16::from_le_bytes([c[0], c[1]]))
                     .collect();
 
-                // Resample to target codec's sample rate.
                 let target_rate = codec_sample_rate(to_pt);
                 let resampled = match st.resample(&pcm, sample_rate, target_rate) {
                     Ok(r) => r,
-                    Err(e) => { respond(&mut out, &req.id, false, None, Some(&e)); continue; }
+                    Err(e) => {
+                        respond(&mut out, &req.id, false, None, Some(&e));
+                        continue;
+                    }
                 };
 
-                // Encode to target codec (reuse encode_from_pcm).
                 match st.encode_from_pcm(&resampled, to_pt) {
                     Ok(encoded) => {
-                        respond(&mut out, &req.id, true, Some(serde_json::json!({ "data_b64": B64.encode(&encoded) })), None);
+                        respond(
+                            &mut out,
+                            &req.id,
+                            true,
+                            Some(serde_json::json!({ "data_b64": B64.encode(&encoded) })),
+                            None,
+                        );
+                    }
+                    Err(e) => {
+                        respond(&mut out, &req.id, false, None, Some(&e));
                     }
-                    Err(e) => { respond(&mut out, &req.id, false, None, Some(&e)); continue; }
                 }
             }
 
-            // Legacy commands (kept for backward compat).
             "encode" | "decode" => {
-                respond(&mut out, &req.id, false, None, Some("use 'transcode' command instead"));
+                respond(
+                    &mut out,
+                    &req.id,
+                    false,
+                    None,
+                    Some("use 'transcode' command instead"),
+                );
             }
 
-            _ => respond(&mut out, &req.id, false, None, Some(&format!("unknown: {}", req.method))),
+            _ => respond(
+                &mut out,
+                &req.id,
+                false,
+                None,
+                Some(&format!("unknown: {}", req.method)),
+            ),
         }
     }
 }

rust/crates/proxy-engine/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "proxy-engine"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "proxy-engine"
+path = "src/main.rs"
+
+[dependencies]
+codec-lib = { path = "../codec-lib" }
+sip-proto = { path = "../sip-proto" }
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+base64 = "0.22"
+regex-lite = "0.1"

rust/crates/proxy-engine/src/call.rs

@@ -0,0 +1,103 @@
+//! Call hub — owns legs and bridges media.
+//!
+//! Each Call has a unique ID and tracks its state, direction, and associated
+//! SIP Call-IDs for message routing.
+
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Instant;
+use tokio::net::UdpSocket;
+
+/// Call state machine.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CallState {
+    SettingUp,
+    Ringing,
+    Connected,
+    Voicemail,
+    Ivr,
+    Terminating,
+    Terminated,
+}
+
+impl CallState {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::SettingUp => "setting-up",
+            Self::Ringing => "ringing",
+            Self::Connected => "connected",
+            Self::Voicemail => "voicemail",
+            Self::Ivr => "ivr",
+            Self::Terminating => "terminating",
+            Self::Terminated => "terminated",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CallDirection {
+    Inbound,
+    Outbound,
+}
+
+impl CallDirection {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Inbound => "inbound",
+            Self::Outbound => "outbound",
+        }
+    }
+}
+
+/// A passthrough call — both sides share the same SIP Call-ID.
+/// The proxy rewrites SDP/Contact/Request-URI and relays RTP.
+pub struct PassthroughCall {
+    pub id: String,
+    pub sip_call_id: String,
+    pub state: CallState,
+    pub direction: CallDirection,
+    pub created_at: Instant,
+
+    // Call metadata.
+    pub caller_number: Option<String>,
+    pub callee_number: Option<String>,
+    pub provider_id: String,
+
+    // Provider side.
+    pub provider_addr: SocketAddr,
+    pub provider_media: Option<SocketAddr>,
+
+    // Device side.
+    pub device_addr: SocketAddr,
+    pub device_media: Option<SocketAddr>,
+
+    // RTP relay.
+    pub rtp_port: u16,
+    pub rtp_socket: Arc<UdpSocket>,
+
+    // Packet counters.
+    pub pkt_from_device: u64,
+    pub pkt_from_provider: u64,
+}
+
+impl PassthroughCall {
+    pub fn duration_secs(&self) -> u64 {
+        self.created_at.elapsed().as_secs()
+    }
+
+    pub fn to_status_json(&self) -> serde_json::Value {
+        serde_json::json!({
+            "id": self.id,
+            "state": self.state.as_str(),
+            "direction": self.direction.as_str(),
+            "callerNumber": self.caller_number,
+            "calleeNumber": self.callee_number,
+            "providerUsed": self.provider_id,
+            "createdAt": self.created_at.elapsed().as_millis(),
+            "duration": self.duration_secs(),
+            "rtpPort": self.rtp_port,
+            "pktFromDevice": self.pkt_from_device,
+            "pktFromProvider": self.pkt_from_provider,
+        })
+    }
+}

rust/crates/proxy-engine/src/call_manager.rs

@@ -0,0 +1,578 @@
+//! Call manager — central registry and orchestration for all calls.
+//!
+//! Handles:
+//! - Inbound passthrough calls (provider → proxy → device)
+//! - Outbound passthrough calls (device → proxy → provider)
+//! - SIP message routing by Call-ID
+//! - BYE/CANCEL handling
+//! - RTP relay setup
+//!
+//! Ported from ts/call/call-manager.ts (passthrough mode).
+
+use crate::call::{CallDirection, CallState, PassthroughCall};
+use crate::config::{AppConfig, ProviderConfig};
+use crate::dtmf::DtmfDetector;
+use crate::ipc::{emit_event, OutTx};
+use crate::registrar::Registrar;
+use crate::rtp::RtpPortPool;
+use sip_proto::helpers::parse_sdp_endpoint;
+use sip_proto::message::SipMessage;
+use sip_proto::rewrite::{rewrite_sdp, rewrite_sip_uri};
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Instant;
+use tokio::net::UdpSocket;
+
+pub struct CallManager {
+    /// Active passthrough calls, keyed by SIP Call-ID.
+    calls: HashMap<String, PassthroughCall>,
+    /// Call ID counter.
+    next_call_num: u64,
+    /// Output channel for events.
+    out_tx: OutTx,
+}
+
+impl CallManager {
+    pub fn new(out_tx: OutTx) -> Self {
+        Self {
+            calls: HashMap::new(),
+            next_call_num: 0,
+            out_tx,
+        }
+    }
+
+    /// Generate a unique call ID.
+    fn next_call_id(&mut self) -> String {
+        let id = format!(
+            "call-{}-{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_millis(),
+            self.next_call_num,
+        );
+        self.next_call_num += 1;
+        id
+    }
+
+    /// Try to route a SIP message to an existing call.
+    /// Returns true if handled.
+    pub async fn route_sip_message(
+        &mut self,
+        msg: &SipMessage,
+        from_addr: SocketAddr,
+        socket: &UdpSocket,
+        config: &AppConfig,
+        _registrar: &Registrar,
+    ) -> bool {
+        let sip_call_id = msg.call_id().to_string();
+
+        // Check if this Call-ID belongs to an active call.
+        if !self.calls.contains_key(&sip_call_id) {
+            return false;
+        }
+
+        // Extract needed data from the call to avoid borrow conflicts.
+        let (call_id, provider_addr, device_addr, rtp_port, from_provider) = {
+            let call = self.calls.get(&sip_call_id).unwrap();
+            let from_provider = from_addr.ip().to_string() == call.provider_addr.ip().to_string();
+            (
+                call.id.clone(),
+                call.provider_addr,
+                call.device_addr,
+                call.rtp_port,
+                from_provider,
+            )
+        };
+
+        let lan_ip = config.proxy.lan_ip.clone();
+        let lan_port = config.proxy.lan_port;
+
+        if msg.is_request() {
+            let method = msg.method().unwrap_or("");
+            let forward_to = if from_provider { device_addr } else { provider_addr };
+
+            // Handle BYE.
+            if method == "BYE" {
+                let ok = SipMessage::create_response(200, "OK", msg, None);
+                let _ = socket.send_to(&ok.serialize(), from_addr).await;
+                let _ = socket.send_to(&msg.serialize(), forward_to).await;
+
+                let duration = self.calls.get(&sip_call_id).unwrap().duration_secs();
+                emit_event(
+                    &self.out_tx,
+                    "call_ended",
+                    serde_json::json!({
+                        "call_id": call_id,
+                        "reason": "bye",
+                        "duration": duration,
+                        "from_side": if from_provider { "provider" } else { "device" },
+                    }),
+                );
+                self.calls.get_mut(&sip_call_id).unwrap().state = CallState::Terminated;
+                return true;
+            }
+
+            // Handle CANCEL.
+            if method == "CANCEL" {
+                let ok = SipMessage::create_response(200, "OK", msg, None);
+                let _ = socket.send_to(&ok.serialize(), from_addr).await;
+                let _ = socket.send_to(&msg.serialize(), forward_to).await;
+
+                let duration = self.calls.get(&sip_call_id).unwrap().duration_secs();
+                emit_event(
+                    &self.out_tx,
+                    "call_ended",
+                    serde_json::json!({
+                        "call_id": call_id, "reason": "cancel", "duration": duration,
+                    }),
+                );
+                self.calls.get_mut(&sip_call_id).unwrap().state = CallState::Terminated;
+                return true;
+            }
+
+            // Handle INFO (DTMF relay).
+            if method == "INFO" {
+                let ok = SipMessage::create_response(200, "OK", msg, None);
+                let _ = socket.send_to(&ok.serialize(), from_addr).await;
+
+                // Detect DTMF from INFO body.
+                if let Some(ct) = msg.get_header("Content-Type") {
+                    let mut detector = DtmfDetector::new(call_id.clone(), self.out_tx.clone());
+                    detector.process_sip_info(ct, &msg.body);
+                }
+                return true;
+            }
+
+            // Forward other requests with SDP rewriting.
+            let mut fwd = msg.clone();
+            if from_provider {
+                rewrite_sdp_for_device(&mut fwd, &lan_ip, rtp_port);
+                if let Some(ruri) = fwd.request_uri().map(|s| s.to_string()) {
+                    let new_ruri = rewrite_sip_uri(&ruri, &device_addr.ip().to_string(), device_addr.port());
+                    fwd.set_request_uri(&new_ruri);
+                }
+            } else {
+                rewrite_sdp_for_provider(&mut fwd, &lan_ip, rtp_port);
+            }
+            if fwd.is_dialog_establishing() {
+                fwd.prepend_header("Record-Route", &format!("<sip:{lan_ip}:{lan_port};lr>"));
+            }
+            let _ = socket.send_to(&fwd.serialize(), forward_to).await;
+            return true;
+        }
+
+        // --- Responses ---
+        if msg.is_response() {
+            let code = msg.status_code().unwrap_or(0);
+            let cseq_method = msg.cseq_method().unwrap_or("").to_uppercase();
+            let forward_to = if from_provider { device_addr } else { provider_addr };
+
+            let mut fwd = msg.clone();
+            if from_provider {
+                rewrite_sdp_for_device(&mut fwd, &lan_ip, rtp_port);
+            } else {
+                rewrite_sdp_for_provider(&mut fwd, &lan_ip, rtp_port);
+                if let Some(contact) = fwd.get_header("Contact").map(|s| s.to_string()) {
+                    let new_contact = rewrite_sip_uri(&contact, &lan_ip, lan_port);
+                    if new_contact != contact {
+                        fwd.set_header("Contact", &new_contact);
+                    }
+                }
+            }
+
+            // State transitions.
+            if cseq_method == "INVITE" {
+                let call = self.calls.get_mut(&sip_call_id).unwrap();
+                if (code == 180 || code == 183) && call.state == CallState::SettingUp {
+                    call.state = CallState::Ringing;
+                    emit_event(&self.out_tx, "call_ringing", serde_json::json!({ "call_id": call_id }));
+                } else if code >= 200 && code < 300 {
+                    call.state = CallState::Connected;
+                    emit_event(&self.out_tx, "call_answered", serde_json::json!({ "call_id": call_id }));
+                } else if code >= 300 {
+                    let duration = call.duration_secs();
+                    call.state = CallState::Terminated;
+                    emit_event(
+                        &self.out_tx,
+                        "call_ended",
+                        serde_json::json!({
+                            "call_id": call_id,
+                            "reason": format!("rejected_{code}"),
+                            "duration": duration,
+                        }),
+                    );
+                }
+            }
+
+            let _ = socket.send_to(&fwd.serialize(), forward_to).await;
+            return true;
+        }
+
+        false
+    }
+
+    /// Create an inbound passthrough call (provider → device).
+    pub async fn create_inbound_call(
+        &mut self,
+        invite: &SipMessage,
+        from_addr: SocketAddr,
+        provider_id: &str,
+        provider_config: &ProviderConfig,
+        config: &AppConfig,
+        registrar: &Registrar,
+        rtp_pool: &mut RtpPortPool,
+        socket: &UdpSocket,
+        public_ip: Option<&str>,
+    ) -> Option<String> {
+        let call_id = self.next_call_id();
+        let lan_ip = &config.proxy.lan_ip;
+        let lan_port = config.proxy.lan_port;
+
+        // Extract caller/callee info.
+        let from_header = invite.get_header("From").unwrap_or("");
+        let caller_number = SipMessage::extract_uri(from_header)
+            .unwrap_or("Unknown")
+            .to_string();
+        let called_number = invite
+            .request_uri()
+            .and_then(|uri| SipMessage::extract_uri(uri))
+            .unwrap_or("")
+            .to_string();
+
+        // Resolve target device (first registered device for now).
+        let device_addr = match self.resolve_first_device(config, registrar) {
+            Some(addr) => addr,
+            None => {
+                // No device available — could route to voicemail
+                // For now, send 480 Temporarily Unavailable.
+                let resp = SipMessage::create_response(480, "Temporarily Unavailable", invite, None);
+                let _ = socket.send_to(&resp.serialize(), from_addr).await;
+                return None;
+            }
+        };
+
+        // Allocate RTP port.
+        let rtp_alloc = match rtp_pool.allocate().await {
+            Some(a) => a,
+            None => {
+                let resp = SipMessage::create_response(503, "Service Unavailable", invite, None);
+                let _ = socket.send_to(&resp.serialize(), from_addr).await;
+                return None;
+            }
+        };
+
+        // Create the call.
+        let mut call = PassthroughCall {
+            id: call_id.clone(),
+            sip_call_id: invite.call_id().to_string(),
+            state: CallState::Ringing,
+            direction: CallDirection::Inbound,
+            created_at: Instant::now(),
+            caller_number: Some(caller_number),
+            callee_number: Some(called_number),
+            provider_id: provider_id.to_string(),
+            provider_addr: from_addr,
+            provider_media: None,
+            device_addr,
+            device_media: None,
+            rtp_port: rtp_alloc.port,
+            rtp_socket: rtp_alloc.socket.clone(),
+            pkt_from_device: 0,
+            pkt_from_provider: 0,
+        };
+
+        // Extract provider media from SDP.
+        if invite.has_sdp_body() {
+            if let Some(ep) = parse_sdp_endpoint(&invite.body) {
+                if let Ok(addr) = format!("{}:{}", ep.address, ep.port).parse() {
+                    call.provider_media = Some(addr);
+                }
+            }
+        }
+
+        // Start RTP relay.
+        let rtp_socket = rtp_alloc.socket.clone();
+        let device_addr_for_relay = device_addr;
+        let provider_addr_for_relay = from_addr;
+        tokio::spawn(async move {
+            rtp_relay_loop(rtp_socket, device_addr_for_relay, provider_addr_for_relay).await;
+        });
+
+        // Rewrite and forward INVITE to device.
+        let mut fwd_invite = invite.clone();
+        fwd_invite.set_request_uri(&rewrite_sip_uri(
+            fwd_invite.request_uri().unwrap_or(""),
+            &device_addr.ip().to_string(),
+            device_addr.port(),
+        ));
+        fwd_invite.prepend_header("Record-Route", &format!("<sip:{lan_ip}:{lan_port};lr>"));
+
+        if fwd_invite.has_sdp_body() {
+            let (new_body, original) = rewrite_sdp(&fwd_invite.body, lan_ip, rtp_alloc.port);
+            fwd_invite.body = new_body;
+            fwd_invite.update_content_length();
+            if let Some(ep) = original {
+                if let Ok(addr) = format!("{}:{}", ep.address, ep.port).parse() {
+                    call.provider_media = Some(addr);
+                }
+            }
+        }
+
+        let _ = socket.send_to(&fwd_invite.serialize(), device_addr).await;
+
+        // Store the call.
+        self.calls.insert(call.sip_call_id.clone(), call);
+
+        Some(call_id)
+    }
+
+    /// Create an outbound passthrough call (device → provider).
+    pub async fn create_outbound_passthrough(
+        &mut self,
+        invite: &SipMessage,
+        from_addr: SocketAddr,
+        provider_config: &ProviderConfig,
+        config: &AppConfig,
+        rtp_pool: &mut RtpPortPool,
+        socket: &UdpSocket,
+        public_ip: Option<&str>,
+    ) -> Option<String> {
+        let call_id = self.next_call_id();
+        let lan_ip = &config.proxy.lan_ip;
+        let lan_port = config.proxy.lan_port;
+        let pub_ip = public_ip.unwrap_or(lan_ip.as_str());
+
+        let callee = invite.request_uri().unwrap_or("").to_string();
+
+        // Allocate RTP port.
+        let rtp_alloc = match rtp_pool.allocate().await {
+            Some(a) => a,
+            None => return None,
+        };
+
+        let provider_dest: SocketAddr = match provider_config.outbound_proxy.to_socket_addr() {
+            Some(a) => a,
+            None => return None,
+        };
+
+        let mut call = PassthroughCall {
+            id: call_id.clone(),
+            sip_call_id: invite.call_id().to_string(),
+            state: CallState::SettingUp,
+            direction: CallDirection::Outbound,
+            created_at: Instant::now(),
+            caller_number: None,
+            callee_number: Some(callee),
+            provider_id: provider_config.id.clone(),
+            provider_addr: provider_dest,
+            provider_media: None,
+            device_addr: from_addr,
+            device_media: None,
+            rtp_port: rtp_alloc.port,
+            rtp_socket: rtp_alloc.socket.clone(),
+            pkt_from_device: 0,
+            pkt_from_provider: 0,
+        };
+
+        // Start RTP relay.
+        let rtp_socket = rtp_alloc.socket.clone();
+        let device_addr_for_relay = from_addr;
+        let provider_addr_for_relay = provider_dest;
+        tokio::spawn(async move {
+            rtp_relay_loop(rtp_socket, device_addr_for_relay, provider_addr_for_relay).await;
+        });
+
+        // Rewrite and forward INVITE to provider.
+        let mut fwd_invite = invite.clone();
+        fwd_invite.prepend_header("Record-Route", &format!("<sip:{lan_ip}:{lan_port};lr>"));
+
+        // Rewrite Contact to public IP.
+        if let Some(contact) = fwd_invite.get_header("Contact").map(|s| s.to_string()) {
+            let new_contact = rewrite_sip_uri(&contact, pub_ip, lan_port);
+            if new_contact != contact {
+                fwd_invite.set_header("Contact", &new_contact);
+            }
+        }
+
+        // Rewrite SDP.
+        if fwd_invite.has_sdp_body() {
+            let (new_body, original) = rewrite_sdp(&fwd_invite.body, pub_ip, rtp_alloc.port);
+            fwd_invite.body = new_body;
+            fwd_invite.update_content_length();
+            if let Some(ep) = original {
+                if let Ok(addr) = format!("{}:{}", ep.address, ep.port).parse() {
+                    call.device_media = Some(addr);
+                }
+            }
+        }
+
+        let _ = socket.send_to(&fwd_invite.serialize(), provider_dest).await;
+
+        self.calls.insert(call.sip_call_id.clone(), call);
+        Some(call_id)
+    }
+
+    /// Hangup a call by call ID (from TypeScript command).
+    pub async fn hangup(&mut self, call_id: &str, socket: &UdpSocket) -> bool {
+        // Find the call by our internal call ID.
+        let sip_call_id = self
+            .calls
+            .iter()
+            .find(|(_, c)| c.id == call_id)
+            .map(|(k, _)| k.clone());
+
+        let sip_call_id = match sip_call_id {
+            Some(id) => id,
+            None => return false,
+        };
+
+        let call = match self.calls.get_mut(&sip_call_id) {
+            Some(c) => c,
+            None => return false,
+        };
+
+        if call.state == CallState::Terminated {
+            return false;
+        }
+
+        // Build and send BYE to both sides.
+        // For passthrough, we build a simple BYE using the SIP Call-ID.
+        let bye_msg = format!(
+            "BYE sip:hangup SIP/2.0\r\n\
+             Via: SIP/2.0/UDP 0.0.0.0:0;branch=z9hG4bK-hangup\r\n\
+             Call-ID: {}\r\n\
+             CSeq: 99 BYE\r\n\
+             Max-Forwards: 70\r\n\
+             Content-Length: 0\r\n\r\n",
+            sip_call_id
+        );
+        let bye_bytes = bye_msg.as_bytes();
+
+        let _ = socket.send_to(bye_bytes, call.provider_addr).await;
+        let _ = socket.send_to(bye_bytes, call.device_addr).await;
+
+        call.state = CallState::Terminated;
+
+        emit_event(
+            &self.out_tx,
+            "call_ended",
+            serde_json::json!({
+                "call_id": call.id,
+                "reason": "hangup_command",
+                "duration": call.duration_secs(),
+            }),
+        );
+
+        true
+    }
+
+    /// Get all active call statuses.
+    pub fn get_all_statuses(&self) -> Vec<serde_json::Value> {
+        self.calls
+            .values()
+            .filter(|c| c.state != CallState::Terminated)
+            .map(|c| c.to_status_json())
+            .collect()
+    }
+
+    /// Clean up terminated calls.
+    pub fn cleanup_terminated(&mut self) {
+        self.calls.retain(|_, c| c.state != CallState::Terminated);
+    }
+
+    /// Check if a SIP Call-ID belongs to any active call.
+    pub fn has_call(&self, sip_call_id: &str) -> bool {
+        self.calls.contains_key(sip_call_id)
+    }
+
+    // --- Internal helpers ---
+
+    fn resolve_first_device(&self, config: &AppConfig, registrar: &Registrar) -> Option<SocketAddr> {
+        for device in &config.devices {
+            if let Some(addr) = registrar.get_device_contact(&device.id) {
+                return Some(addr);
+            }
+        }
+        None
+    }
+}
+
+/// Rewrite SDP for provider→device direction (use LAN IP).
+fn rewrite_sdp_for_device(msg: &mut SipMessage, lan_ip: &str, rtp_port: u16) {
+    if msg.has_sdp_body() {
+        let (new_body, _original) = rewrite_sdp(&msg.body, lan_ip, rtp_port);
+        msg.body = new_body;
+        msg.update_content_length();
+    }
+}
+
+/// Rewrite SDP for device→provider direction (use public IP).
+fn rewrite_sdp_for_provider(msg: &mut SipMessage, pub_ip: &str, rtp_port: u16) {
+    if msg.has_sdp_body() {
+        let (new_body, _original) = rewrite_sdp(&msg.body, pub_ip, rtp_port);
+        msg.body = new_body;
+        msg.update_content_length();
+    }
+}
+
+/// Bidirectional RTP relay loop.
+/// Receives packets on the relay socket and forwards based on source address.
+async fn rtp_relay_loop(
+    socket: Arc<UdpSocket>,
+    device_addr: SocketAddr,
+    provider_addr: SocketAddr,
+) {
+    let mut buf = vec![0u8; 65535];
+    let device_ip = device_addr.ip().to_string();
+    let provider_ip = provider_addr.ip().to_string();
+
+    // Track learned media endpoints (may differ from signaling addresses).
+    let mut learned_device: Option<SocketAddr> = None;
+    let mut learned_provider: Option<SocketAddr> = None;
+
+    loop {
+        match socket.recv_from(&mut buf).await {
+            Ok((n, from)) => {
+                let data = &buf[..n];
+                let from_ip = from.ip().to_string();
+
+                if from_ip == device_ip || learned_device.map(|d| d == from).unwrap_or(false) {
+                    // From device → forward to provider.
+                    if learned_device.is_none() {
+                        learned_device = Some(from);
+                    }
+                    if let Some(target) = learned_provider {
+                        let _ = socket.send_to(data, target).await;
+                    } else {
+                        // Provider media not yet learned; try signaling address.
+                        let _ = socket.send_to(data, provider_addr).await;
+                    }
+                } else if from_ip == provider_ip
+                    || learned_provider.map(|p| p == from).unwrap_or(false)
+                {
+                    // From provider → forward to device.
+                    if learned_provider.is_none() {
+                        learned_provider = Some(from);
+                    }
+                    if let Some(target) = learned_device {
+                        let _ = socket.send_to(data, target).await;
+                    } else {
+                        let _ = socket.send_to(data, device_addr).await;
+                    }
+                } else {
+                    // Unknown source — try to identify by known device addresses.
+                    // For now, assume it's the device if not from provider IP range.
+                    if learned_device.is_none() {
+                        learned_device = Some(from);
+                    }
+                }
+            }
+            Err(_) => {
+                // Socket closed or error — exit relay.
+                break;
+            }
+        }
+    }
+}

rust/crates/proxy-engine/src/config.rs

@@ -0,0 +1,315 @@
+//! Configuration types received from the TypeScript control plane.
+//!
+//! TypeScript loads config from `.nogit/config.json` and sends it to the
+//! proxy engine via the `configure` command. These types mirror the TS interfaces.
+
+use serde::Deserialize;
+use std::net::SocketAddr;
+
+/// Network endpoint.
+#[derive(Debug, Clone, Deserialize)]
+pub struct Endpoint {
+    pub address: String,
+    pub port: u16,
+}
+
+impl Endpoint {
+    pub fn to_socket_addr(&self) -> Option<SocketAddr> {
+        format!("{}:{}", self.address, self.port).parse().ok()
+    }
+}
+
+/// Provider quirks for codec/protocol workarounds.
+#[derive(Debug, Clone, Deserialize)]
+pub struct Quirks {
+    #[serde(rename = "earlyMediaSilence")]
+    pub early_media_silence: bool,
+    #[serde(rename = "silencePayloadType")]
+    pub silence_payload_type: Option<u8>,
+    #[serde(rename = "silenceMaxPackets")]
+    pub silence_max_packets: Option<u32>,
+}
+
+/// A SIP trunk provider configuration.
+#[derive(Debug, Clone, Deserialize)]
+pub struct ProviderConfig {
+    pub id: String,
+    #[serde(rename = "displayName")]
+    pub display_name: String,
+    pub domain: String,
+    #[serde(rename = "outboundProxy")]
+    pub outbound_proxy: Endpoint,
+    pub username: String,
+    pub password: String,
+    #[serde(rename = "registerIntervalSec")]
+    pub register_interval_sec: u32,
+    pub codecs: Vec<u8>,
+    pub quirks: Quirks,
+}
+
+/// A SIP device (phone) configuration.
+#[derive(Debug, Clone, Deserialize)]
+pub struct DeviceConfig {
+    pub id: String,
+    #[serde(rename = "displayName")]
+    pub display_name: String,
+    #[serde(rename = "expectedAddress")]
+    pub expected_address: String,
+    pub extension: String,
+}
+
+/// Route match criteria.
+#[derive(Debug, Clone, Deserialize)]
+pub struct RouteMatch {
+    pub direction: String, // "inbound" | "outbound"
+    #[serde(rename = "numberPattern")]
+    pub number_pattern: Option<String>,
+    #[serde(rename = "callerPattern")]
+    pub caller_pattern: Option<String>,
+    #[serde(rename = "sourceProvider")]
+    pub source_provider: Option<String>,
+    #[serde(rename = "sourceDevice")]
+    pub source_device: Option<String>,
+}
+
+/// Route action.
+#[derive(Debug, Clone, Deserialize)]
+pub struct RouteAction {
+    pub targets: Option<Vec<String>>,
+    #[serde(rename = "ringBrowsers")]
+    pub ring_browsers: Option<bool>,
+    #[serde(rename = "voicemailBox")]
+    pub voicemail_box: Option<String>,
+    #[serde(rename = "ivrMenuId")]
+    pub ivr_menu_id: Option<String>,
+    #[serde(rename = "noAnswerTimeout")]
+    pub no_answer_timeout: Option<u32>,
+    pub provider: Option<String>,
+    #[serde(rename = "failoverProviders")]
+    pub failover_providers: Option<Vec<String>>,
+    #[serde(rename = "stripPrefix")]
+    pub strip_prefix: Option<String>,
+    #[serde(rename = "prependPrefix")]
+    pub prepend_prefix: Option<String>,
+}
+
+/// A routing rule.
+#[derive(Debug, Clone, Deserialize)]
+pub struct Route {
+    pub id: String,
+    pub name: String,
+    pub priority: i32,
+    pub enabled: bool,
+    #[serde(rename = "match")]
+    pub match_criteria: RouteMatch,
+    pub action: RouteAction,
+}
+
+/// Proxy network settings.
+#[derive(Debug, Clone, Deserialize)]
+pub struct ProxyConfig {
+    #[serde(rename = "lanIp")]
+    pub lan_ip: String,
+    #[serde(rename = "lanPort")]
+    pub lan_port: u16,
+    #[serde(rename = "publicIpSeed")]
+    pub public_ip_seed: Option<String>,
+    #[serde(rename = "rtpPortRange")]
+    pub rtp_port_range: RtpPortRange,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct RtpPortRange {
+    pub min: u16,
+    pub max: u16,
+}
+
+/// Full application config pushed from TypeScript.
+#[derive(Debug, Clone, Deserialize)]
+pub struct AppConfig {
+    pub proxy: ProxyConfig,
+    pub providers: Vec<ProviderConfig>,
+    pub devices: Vec<DeviceConfig>,
+    pub routing: RoutingConfig,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct RoutingConfig {
+    pub routes: Vec<Route>,
+}
+
+// ---------------------------------------------------------------------------
+// Pattern matching (ported from ts/config.ts)
+// ---------------------------------------------------------------------------
+
+/// Test a value against a pattern string.
+/// - None/empty: matches everything (wildcard)
+/// - Trailing '*': prefix match
+/// - Starts with '/': regex match
+/// - Otherwise: exact match
+pub fn matches_pattern(pattern: Option<&str>, value: &str) -> bool {
+    let pattern = match pattern {
+        None => return true,
+        Some(p) if p.is_empty() => return true,
+        Some(p) => p,
+    };
+
+    // Prefix match: "+49*"
+    if pattern.ends_with('*') {
+        return value.starts_with(&pattern[..pattern.len() - 1]);
+    }
+
+    // Regex match: "/^\\+49/" or "/pattern/i"
+    if pattern.starts_with('/') {
+        if let Some(last_slash) = pattern[1..].rfind('/') {
+            let re_str = &pattern[1..1 + last_slash];
+            let flags = &pattern[2 + last_slash..];
+            let case_insensitive = flags.contains('i');
+            if let Ok(re) = if case_insensitive {
+                regex_lite::Regex::new(&format!("(?i){re_str}"))
+            } else {
+                regex_lite::Regex::new(re_str)
+            } {
+                return re.is_match(value);
+            }
+        }
+    }
+
+    // Exact match.
+    value == pattern
+}
+
+/// Result of resolving an outbound route.
+pub struct OutboundRouteResult {
+    pub provider: ProviderConfig,
+    pub transformed_number: String,
+}
+
+/// Result of resolving an inbound route.
+pub struct InboundRouteResult {
+    pub device_ids: Vec<String>,
+    pub ring_browsers: bool,
+    pub voicemail_box: Option<String>,
+    pub ivr_menu_id: Option<String>,
+    pub no_answer_timeout: Option<u32>,
+}
+
+impl AppConfig {
+    /// Resolve which provider to use for an outbound call.
+    pub fn resolve_outbound_route(
+        &self,
+        dialed_number: &str,
+        source_device_id: Option<&str>,
+        is_provider_registered: &dyn Fn(&str) -> bool,
+    ) -> Option<OutboundRouteResult> {
+        let mut routes: Vec<&Route> = self
+            .routing
+            .routes
+            .iter()
+            .filter(|r| r.enabled && r.match_criteria.direction == "outbound")
+            .collect();
+        routes.sort_by(|a, b| b.priority.cmp(&a.priority));
+
+        for route in &routes {
+            let m = &route.match_criteria;
+
+            if !matches_pattern(m.number_pattern.as_deref(), dialed_number) {
+                continue;
+            }
+            if let Some(sd) = &m.source_device {
+                if source_device_id != Some(sd.as_str()) {
+                    continue;
+                }
+            }
+
+            // Find a registered provider.
+            let mut candidates: Vec<&str> = Vec::new();
+            if let Some(p) = &route.action.provider {
+                candidates.push(p);
+            }
+            if let Some(fps) = &route.action.failover_providers {
+                candidates.extend(fps.iter().map(|s| s.as_str()));
+            }
+
+            for pid in candidates {
+                let provider = match self.providers.iter().find(|p| p.id == pid) {
+                    Some(p) => p,
+                    None => continue,
+                };
+                if !is_provider_registered(pid) {
+                    continue;
+                }
+
+                let mut num = dialed_number.to_string();
+                if let Some(strip) = &route.action.strip_prefix {
+                    if num.starts_with(strip.as_str()) {
+                        num = num[strip.len()..].to_string();
+                    }
+                }
+                if let Some(prepend) = &route.action.prepend_prefix {
+                    num = format!("{prepend}{num}");
+                }
+
+                return Some(OutboundRouteResult {
+                    provider: provider.clone(),
+                    transformed_number: num,
+                });
+            }
+        }
+
+        // Fallback: first provider.
+        self.providers.first().map(|p| OutboundRouteResult {
+            provider: p.clone(),
+            transformed_number: dialed_number.to_string(),
+        })
+    }
+
+    /// Resolve which devices to ring for an inbound call.
+    pub fn resolve_inbound_route(
+        &self,
+        provider_id: &str,
+        called_number: &str,
+        caller_number: &str,
+    ) -> InboundRouteResult {
+        let mut routes: Vec<&Route> = self
+            .routing
+            .routes
+            .iter()
+            .filter(|r| r.enabled && r.match_criteria.direction == "inbound")
+            .collect();
+        routes.sort_by(|a, b| b.priority.cmp(&a.priority));
+
+        for route in &routes {
+            let m = &route.match_criteria;
+
+            if let Some(sp) = &m.source_provider {
+                if sp != provider_id {
+                    continue;
+                }
+            }
+            if !matches_pattern(m.number_pattern.as_deref(), called_number) {
+                continue;
+            }
+            if !matches_pattern(m.caller_pattern.as_deref(), caller_number) {
+                continue;
+            }
+
+            return InboundRouteResult {
+                device_ids: route.action.targets.clone().unwrap_or_default(),
+                ring_browsers: route.action.ring_browsers.unwrap_or(false),
+                voicemail_box: route.action.voicemail_box.clone(),
+                ivr_menu_id: route.action.ivr_menu_id.clone(),
+                no_answer_timeout: route.action.no_answer_timeout,
+            };
+        }
+
+        // Fallback: ring all devices + browsers.
+        InboundRouteResult {
+            device_ids: vec![],
+            ring_browsers: true,
+            voicemail_box: None,
+            ivr_menu_id: None,
+            no_answer_timeout: None,
+        }
+    }
+}

rust/crates/proxy-engine/src/dtmf.rs

@@ -0,0 +1,200 @@
+//! DTMF detection — parses RFC 2833 telephone-event RTP packets.
+//!
+//! Deduplicates repeated packets (same digit sent multiple times with
+//! increasing duration) and fires once per detected digit.
+//!
+//! Ported from ts/call/dtmf-detector.ts.
+
+use crate::ipc::{emit_event, OutTx};
+
+/// RFC 2833 event ID → character mapping.
+const EVENT_CHARS: &[char] = &[
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '#', 'A', 'B', 'C', 'D',
+];
+
+/// Safety timeout: report digit if no End packet arrives within this many ms.
+const SAFETY_TIMEOUT_MS: u64 = 200;
+
+/// DTMF detector for a single RTP stream.
+pub struct DtmfDetector {
+    /// Negotiated telephone-event payload type (default 101).
+    telephone_event_pt: u8,
+    /// Clock rate for duration calculation (default 8000 Hz).
+    clock_rate: u32,
+    /// Call ID for event emission.
+    call_id: String,
+
+    // Deduplication state.
+    current_event_id: Option<u8>,
+    current_event_ts: Option<u32>,
+    current_event_reported: bool,
+    current_event_duration: u16,
+
+    out_tx: OutTx,
+}
+
+impl DtmfDetector {
+    pub fn new(call_id: String, out_tx: OutTx) -> Self {
+        Self {
+            telephone_event_pt: 101,
+            clock_rate: 8000,
+            call_id,
+            current_event_id: None,
+            current_event_ts: None,
+            current_event_reported: false,
+            current_event_duration: 0,
+            out_tx,
+        }
+    }
+
+    /// Feed an RTP packet. Checks PT; ignores non-DTMF packets.
+    /// Returns Some(digit_char) if a digit was detected.
+    pub fn process_rtp(&mut self, data: &[u8]) -> Option<char> {
+        if data.len() < 16 {
+            return None; // 12-byte header + 4-byte telephone-event minimum
+        }
+
+        let pt = data[1] & 0x7F;
+        if pt != self.telephone_event_pt {
+            return None;
+        }
+
+        let marker = (data[1] & 0x80) != 0;
+        let rtp_timestamp = u32::from_be_bytes([data[4], data[5], data[6], data[7]]);
+
+        // Parse telephone-event payload.
+        let event_id = data[12];
+        let end_bit = (data[13] & 0x80) != 0;
+        let duration = u16::from_be_bytes([data[14], data[15]]);
+
+        if event_id as usize >= EVENT_CHARS.len() {
+            return None;
+        }
+
+        // Detect new event.
+        let is_new = marker
+            || self.current_event_id != Some(event_id)
+            || self.current_event_ts != Some(rtp_timestamp);
+
+        if is_new {
+            // Report pending unreported event.
+            let pending = self.report_pending();
+
+            self.current_event_id = Some(event_id);
+            self.current_event_ts = Some(rtp_timestamp);
+            self.current_event_reported = false;
+            self.current_event_duration = duration;
+
+            if pending.is_some() {
+                return pending;
+            }
+        }
+
+        if duration > self.current_event_duration {
+            self.current_event_duration = duration;
+        }
+
+        // Report on End bit (first time only).
+        if end_bit && !self.current_event_reported {
+            self.current_event_reported = true;
+            let digit = EVENT_CHARS[event_id as usize];
+            let duration_ms = (self.current_event_duration as f64 / self.clock_rate as f64) * 1000.0;
+
+            emit_event(
+                &self.out_tx,
+                "dtmf_digit",
+                serde_json::json!({
+                    "call_id": self.call_id,
+                    "digit": digit.to_string(),
+                    "duration_ms": duration_ms.round() as u32,
+                    "source": "rfc2833",
+                }),
+            );
+
+            return Some(digit);
+        }
+
+        None
+    }
+
+    /// Report a pending unreported event.
+    fn report_pending(&mut self) -> Option<char> {
+        if let Some(event_id) = self.current_event_id {
+            if !self.current_event_reported && (event_id as usize) < EVENT_CHARS.len() {
+                self.current_event_reported = true;
+                let digit = EVENT_CHARS[event_id as usize];
+                let duration_ms =
+                    (self.current_event_duration as f64 / self.clock_rate as f64) * 1000.0;
+
+                emit_event(
+                    &self.out_tx,
+                    "dtmf_digit",
+                    serde_json::json!({
+                        "call_id": self.call_id,
+                        "digit": digit.to_string(),
+                        "duration_ms": duration_ms.round() as u32,
+                        "source": "rfc2833",
+                    }),
+                );
+
+                return Some(digit);
+            }
+        }
+        None
+    }
+
+    /// Process a SIP INFO message body for DTMF.
+    pub fn process_sip_info(&mut self, content_type: &str, body: &str) -> Option<char> {
+        let ct = content_type.to_ascii_lowercase();
+
+        if ct.contains("application/dtmf-relay") {
+            // Format: "Signal= 5\r\nDuration= 160\r\n"
+            let signal = body
+                .lines()
+                .find(|l| l.to_ascii_lowercase().starts_with("signal"))
+                .and_then(|l| l.split('=').nth(1))
+                .map(|s| s.trim().to_string())?;
+
+            if signal.len() != 1 {
+                return None;
+            }
+            let digit = signal.chars().next()?.to_ascii_uppercase();
+            if !"0123456789*#ABCD".contains(digit) {
+                return None;
+            }
+
+            emit_event(
+                &self.out_tx,
+                "dtmf_digit",
+                serde_json::json!({
+                    "call_id": self.call_id,
+                    "digit": digit.to_string(),
+                    "source": "sip-info",
+                }),
+            );
+
+            return Some(digit);
+        }
+
+        if ct.contains("application/dtmf") {
+            let digit = body.trim().chars().next()?.to_ascii_uppercase();
+            if !"0123456789*#ABCD".contains(digit) {
+                return None;
+            }
+
+            emit_event(
+                &self.out_tx,
+                "dtmf_digit",
+                serde_json::json!({
+                    "call_id": self.call_id,
+                    "digit": digit.to_string(),
+                    "source": "sip-info",
+                }),
+            );
+
+            return Some(digit);
+        }
+
+        None
+    }
+}

rust/crates/proxy-engine/src/ipc.rs

@@ -0,0 +1,47 @@
+//! IPC protocol — command dispatch and event emission.
+//!
+//! All communication with the TypeScript control plane goes through
+//! JSON-line messages on stdin/stdout (smartrust protocol).
+
+use serde::Deserialize;
+use tokio::sync::mpsc;
+
+/// Sender for serialized stdout output.
+pub type OutTx = mpsc::UnboundedSender<String>;
+
+/// A command received from the TypeScript control plane.
+#[derive(Deserialize)]
+pub struct Command {
+    pub id: String,
+    pub method: String,
+    #[serde(default)]
+    pub params: serde_json::Value,
+}
+
+/// Send a response to a command.
+pub fn respond(tx: &OutTx, id: &str, success: bool, result: Option<serde_json::Value>, error: Option<&str>) {
+    let mut resp = serde_json::json!({ "id": id, "success": success });
+    if let Some(r) = result {
+        resp["result"] = r;
+    }
+    if let Some(e) = error {
+        resp["error"] = serde_json::Value::String(e.to_string());
+    }
+    let _ = tx.send(resp.to_string());
+}
+
+/// Send a success response.
+pub fn respond_ok(tx: &OutTx, id: &str, result: serde_json::Value) {
+    respond(tx, id, true, Some(result), None);
+}
+
+/// Send an error response.
+pub fn respond_err(tx: &OutTx, id: &str, error: &str) {
+    respond(tx, id, false, None, Some(error));
+}
+
+/// Emit an event to the TypeScript control plane.
+pub fn emit_event(tx: &OutTx, event: &str, data: serde_json::Value) {
+    let msg = serde_json::json!({ "event": event, "data": data });
+    let _ = tx.send(msg.to_string());
+}

rust/crates/proxy-engine/src/main.rs

@@ -0,0 +1,440 @@
+/// SIP proxy engine — the Rust data plane for the SIP router.
+///
+/// Handles ALL SIP protocol mechanics. TypeScript only sends high-level
+/// commands (routing decisions, config) and receives high-level events
+/// (incoming calls, registration state).
+///
+/// No raw SIP ever touches TypeScript.
+
+mod call;
+mod call_manager;
+mod config;
+mod dtmf;
+mod ipc;
+mod provider;
+mod registrar;
+mod rtp;
+mod sip_transport;
+
+use crate::call_manager::CallManager;
+use crate::config::AppConfig;
+use crate::ipc::{emit_event, respond_err, respond_ok, Command, OutTx};
+use crate::provider::ProviderManager;
+use crate::registrar::Registrar;
+use crate::rtp::RtpPortPool;
+use crate::sip_transport::SipTransport;
+use sip_proto::message::SipMessage;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::net::UdpSocket;
+use tokio::sync::{mpsc, Mutex};
+
+/// Shared mutable state for the proxy engine.
+struct ProxyEngine {
+    config: Option<AppConfig>,
+    transport: Option<SipTransport>,
+    provider_mgr: ProviderManager,
+    registrar: Registrar,
+    call_mgr: CallManager,
+    rtp_pool: Option<RtpPortPool>,
+    out_tx: OutTx,
+}
+
+impl ProxyEngine {
+    fn new(out_tx: OutTx) -> Self {
+        Self {
+            config: None,
+            transport: None,
+            provider_mgr: ProviderManager::new(out_tx.clone()),
+            registrar: Registrar::new(out_tx.clone()),
+            call_mgr: CallManager::new(out_tx.clone()),
+            rtp_pool: None,
+            out_tx,
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    // Output channel: all stdout writes go through here for serialization.
+    let (out_tx, mut out_rx) = mpsc::unbounded_channel::<String>();
+
+    // Stdout writer task.
+    tokio::spawn(async move {
+        let mut stdout = tokio::io::stdout();
+        while let Some(line) = out_rx.recv().await {
+            let mut output = line.into_bytes();
+            output.push(b'\n');
+            if stdout.write_all(&output).await.is_err() {
+                break;
+            }
+            let _ = stdout.flush().await;
+        }
+    });
+
+    // Emit ready event.
+    emit_event(&out_tx, "ready", serde_json::json!({}));
+
+    // Shared engine state.
+    let engine = Arc::new(Mutex::new(ProxyEngine::new(out_tx.clone())));
+
+    // Read commands from stdin.
+    let stdin = tokio::io::stdin();
+    let reader = BufReader::new(stdin);
+    let mut lines = reader.lines();
+
+    while let Ok(Some(line)) = lines.next_line().await {
+        if line.trim().is_empty() {
+            continue;
+        }
+
+        let cmd: Command = match serde_json::from_str(&line) {
+            Ok(c) => c,
+            Err(e) => {
+                respond_err(&out_tx, "", &format!("parse: {e}"));
+                continue;
+            }
+        };
+
+        let engine = engine.clone();
+        let out_tx = out_tx.clone();
+
+        // Handle commands — some are async, so we spawn.
+        tokio::spawn(async move {
+            handle_command(engine, &out_tx, cmd).await;
+        });
+    }
+}
+
+async fn handle_command(engine: Arc<Mutex<ProxyEngine>>, out_tx: &OutTx, cmd: Command) {
+    match cmd.method.as_str() {
+        "configure" => handle_configure(engine, out_tx, &cmd).await,
+        "hangup" => handle_hangup(engine, out_tx, &cmd).await,
+        "get_status" => handle_get_status(engine, out_tx, &cmd).await,
+        _ => respond_err(out_tx, &cmd.id, &format!("unknown command: {}", cmd.method)),
+    }
+}
+
+/// Handle the `configure` command — receives full app config from TypeScript.
+/// First call: initializes SIP transport + everything.
+/// Subsequent calls: reconfigures providers/devices/routing without rebinding.
+async fn handle_configure(engine: Arc<Mutex<ProxyEngine>>, out_tx: &OutTx, cmd: &Command) {
+    let app_config: AppConfig = match serde_json::from_value(cmd.params.clone()) {
+        Ok(c) => c,
+        Err(e) => {
+            respond_err(out_tx, &cmd.id, &format!("bad config: {e}"));
+            return;
+        }
+    };
+
+    let mut eng = engine.lock().await;
+    let is_reconfigure = eng.transport.is_some();
+
+    let socket = if is_reconfigure {
+        // Reconfigure — socket already bound, just update subsystems.
+        eng.transport.as_ref().unwrap().socket()
+    } else {
+        // First configure — bind SIP transport.
+        let bind_addr = format!("0.0.0.0:{}", app_config.proxy.lan_port);
+        let transport = match SipTransport::bind(&bind_addr).await {
+            Ok(t) => t,
+            Err(e) => {
+                respond_err(out_tx, &cmd.id, &format!("SIP bind failed: {e}"));
+                return;
+            }
+        };
+
+        let socket = transport.socket();
+
+        // Start UDP receiver.
+        let engine_for_recv = engine.clone();
+        let socket_for_recv = socket.clone();
+        transport.spawn_receiver(move |data: &[u8], addr: SocketAddr| {
+            let engine = engine_for_recv.clone();
+            let socket = socket_for_recv.clone();
+            let data = data.to_vec();
+            tokio::spawn(async move {
+                handle_sip_packet(engine, &socket, &data, addr).await;
+            });
+        });
+
+        eng.transport = Some(transport);
+
+        // Initialize RTP port pool (only on first configure).
+        eng.rtp_pool = Some(RtpPortPool::new(
+            app_config.proxy.rtp_port_range.min,
+            app_config.proxy.rtp_port_range.max,
+        ));
+
+        socket
+    };
+
+    // (Re)configure registrar.
+    eng.registrar.configure(&app_config.devices);
+
+    // (Re)configure provider registrations.
+    eng.provider_mgr
+        .configure(
+            &app_config.providers,
+            app_config.proxy.public_ip_seed.as_deref(),
+            &app_config.proxy.lan_ip,
+            app_config.proxy.lan_port,
+            socket,
+        )
+        .await;
+
+    let bind_info = format!("0.0.0.0:{}", app_config.proxy.lan_port);
+    eng.config = Some(app_config);
+
+    respond_ok(
+        out_tx,
+        &cmd.id,
+        serde_json::json!({
+            "bound": bind_info,
+            "reconfigure": is_reconfigure,
+        }),
+    );
+}
+
+/// Handle incoming SIP packets from the UDP socket.
+/// This is the core routing pipeline — entirely in Rust.
+async fn handle_sip_packet(
+    engine: Arc<Mutex<ProxyEngine>>,
+    socket: &UdpSocket,
+    data: &[u8],
+    from_addr: SocketAddr,
+) {
+    let msg = match SipMessage::parse(data) {
+        Some(m) => m,
+        None => return, // Not a valid SIP message, ignore.
+    };
+
+    let mut eng = engine.lock().await;
+
+    // 1. Provider registration responses — consumed internally.
+    if msg.is_response() {
+        if eng.provider_mgr.handle_response(&msg, socket).await {
+            return;
+        }
+    }
+
+    // 2. Device REGISTER — handled by registrar.
+    let is_from_provider = eng
+        .provider_mgr
+        .find_by_address(&from_addr)
+        .await
+        .is_some();
+
+    if !is_from_provider && msg.method() == Some("REGISTER") {
+        if let Some(response_buf) = eng.registrar.handle_register(&msg, from_addr) {
+            let _ = socket.send_to(&response_buf, from_addr).await;
+            return;
+        }
+    }
+
+    // 3. Route to existing call by SIP Call-ID.
+    // Check if this Call-ID belongs to an active call (avoids borrow conflict).
+    if eng.call_mgr.has_call(msg.call_id()) {
+        let config_ref = eng.config.as_ref().unwrap().clone();
+        // Temporarily take registrar to avoid overlapping borrows.
+        let registrar_dummy = Registrar::new(eng.out_tx.clone());
+        if eng
+            .call_mgr
+            .route_sip_message(&msg, from_addr, socket, &config_ref, &registrar_dummy)
+            .await
+        {
+            return;
+        }
+    }
+
+    let config_ref = eng.config.as_ref().unwrap().clone();
+
+    // 4. New inbound INVITE from provider.
+    if is_from_provider && msg.is_request() && msg.method() == Some("INVITE") {
+        // Detect public IP from Via.
+        if let Some(via) = msg.get_header("Via") {
+            if let Some(ps_arc) = eng.provider_mgr.find_by_address(&from_addr).await {
+                let mut ps = ps_arc.lock().await;
+                ps.detect_public_ip(via);
+            }
+        }
+
+        // Send 100 Trying immediately.
+        let trying = SipMessage::create_response(100, "Trying", &msg, None);
+        let _ = socket.send_to(&trying.serialize(), from_addr).await;
+
+        // Determine provider info.
+        let (provider_id, provider_config, public_ip) =
+            if let Some(ps_arc) = eng.provider_mgr.find_by_address(&from_addr).await {
+                let ps = ps_arc.lock().await;
+                (
+                    ps.config.id.clone(),
+                    ps.config.clone(),
+                    ps.public_ip.clone(),
+                )
+            } else {
+                return;
+            };
+
+        // Create the inbound call — Rust handles everything.
+        // Split borrows via destructuring to satisfy the borrow checker.
+        let ProxyEngine {
+            ref registrar,
+            ref mut call_mgr,
+            ref mut rtp_pool,
+            ..
+        } = *eng;
+        let rtp_pool = rtp_pool.as_mut().unwrap();
+        let call_id = call_mgr
+            .create_inbound_call(
+                &msg,
+                from_addr,
+                &provider_id,
+                &provider_config,
+                &config_ref,
+                registrar,
+                rtp_pool,
+                socket,
+                public_ip.as_deref(),
+            )
+            .await;
+
+        if let Some(call_id) = call_id {
+            // Emit event so TypeScript knows about the call (for dashboard, IVR routing, etc).
+            let from_header = msg.get_header("From").unwrap_or("");
+            let from_uri = SipMessage::extract_uri(from_header).unwrap_or("Unknown");
+            let called_number = msg
+                .request_uri()
+                .and_then(|uri| SipMessage::extract_uri(uri))
+                .unwrap_or("");
+
+            emit_event(
+                &eng.out_tx,
+                "incoming_call",
+                serde_json::json!({
+                    "call_id": call_id,
+                    "from_uri": from_uri,
+                    "to_number": called_number,
+                    "provider_id": provider_id,
+                }),
+            );
+        }
+        return;
+    }
+
+    // 5. New outbound INVITE from device.
+    if !is_from_provider && msg.is_request() && msg.method() == Some("INVITE") {
+        // Resolve outbound route.
+        let dialed_number = msg
+            .request_uri()
+            .and_then(|uri| SipMessage::extract_uri(uri))
+            .unwrap_or(msg.request_uri().unwrap_or(""))
+            .to_string();
+
+        let device = eng.registrar.find_by_address(&from_addr);
+        let device_id = device.map(|d| d.device_id.clone());
+
+        // Find provider via routing rules.
+        let route_result = config_ref.resolve_outbound_route(
+            &dialed_number,
+            device_id.as_deref(),
+            &|pid: &str| {
+                // Can't call async here — use a sync check.
+                // For now, assume all configured providers are available.
+                true
+            },
+        );
+
+        if let Some(route) = route_result {
+            let public_ip = if let Some(ps_arc) = eng.provider_mgr.find_by_address(&from_addr).await {
+                let ps = ps_arc.lock().await;
+                ps.public_ip.clone()
+            } else {
+                None
+            };
+
+            let ProxyEngine {
+                ref mut call_mgr,
+                ref mut rtp_pool,
+                ..
+            } = *eng;
+            let rtp_pool = rtp_pool.as_mut().unwrap();
+            let call_id = call_mgr
+                .create_outbound_passthrough(
+                    &msg,
+                    from_addr,
+                    &route.provider,
+                    &config_ref,
+                    rtp_pool,
+                    socket,
+                    public_ip.as_deref(),
+                )
+                .await;
+
+            if let Some(call_id) = call_id {
+                emit_event(
+                    &eng.out_tx,
+                    "outbound_device_call",
+                    serde_json::json!({
+                        "call_id": call_id,
+                        "from_device": device_id,
+                        "to_number": dialed_number,
+                    }),
+                );
+            }
+        }
+        return;
+    }
+
+    // 6. Other messages — log for debugging.
+    let label = if msg.is_request() {
+        msg.method().unwrap_or("?").to_string()
+    } else {
+        msg.status_code().map(|c| c.to_string()).unwrap_or_default()
+    };
+    emit_event(
+        &eng.out_tx,
+        "sip_unhandled",
+        serde_json::json!({
+            "method_or_status": label,
+            "call_id": msg.call_id(),
+            "from_addr": from_addr.ip().to_string(),
+            "from_port": from_addr.port(),
+            "is_from_provider": is_from_provider,
+        }),
+    );
+}
+
+/// Handle `get_status` — return active call statuses from Rust.
+async fn handle_get_status(engine: Arc<Mutex<ProxyEngine>>, out_tx: &OutTx, cmd: &Command) {
+    let eng = engine.lock().await;
+    let calls = eng.call_mgr.get_all_statuses();
+    respond_ok(out_tx, &cmd.id, serde_json::json!({ "calls": calls }));
+}
+
+/// Handle the `hangup` command.
+async fn handle_hangup(engine: Arc<Mutex<ProxyEngine>>, out_tx: &OutTx, cmd: &Command) {
+    let call_id = match cmd.params.get("call_id").and_then(|v| v.as_str()) {
+        Some(id) => id.to_string(),
+        None => {
+            respond_err(out_tx, &cmd.id, "missing call_id");
+            return;
+        }
+    };
+
+    let mut eng = engine.lock().await;
+    let socket = match &eng.transport {
+        Some(t) => t.socket(),
+        None => {
+            respond_err(out_tx, &cmd.id, "not initialized");
+            return;
+        }
+    };
+
+    if eng.call_mgr.hangup(&call_id, &socket).await {
+        respond_ok(out_tx, &cmd.id, serde_json::json!({}));
+    } else {
+        respond_err(out_tx, &cmd.id, &format!("call {call_id} not found"));
+    }
+}

rust/crates/proxy-engine/src/provider.rs

@@ -0,0 +1,367 @@
+//! Provider registration state machine.
+//!
+//! Handles the REGISTER cycle with upstream SIP providers:
+//! - Sends periodic REGISTER messages
+//! - Handles 401/407 Digest authentication challenges
+//! - Detects public IP from Via received= parameter
+//! - Emits registration state events to TypeScript
+//!
+//! Ported from ts/providerstate.ts.
+
+use crate::config::ProviderConfig;
+use crate::ipc::{emit_event, OutTx};
+use sip_proto::helpers::{
+    compute_digest_auth, generate_branch, generate_call_id, generate_tag, parse_digest_challenge,
+};
+use sip_proto::message::{RequestOptions, SipMessage};
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::net::UdpSocket;
+use tokio::sync::Mutex;
+use tokio::time::{self, Duration};
+
+/// Runtime state for a single SIP provider.
+pub struct ProviderState {
+    pub config: ProviderConfig,
+    pub public_ip: Option<String>,
+    pub is_registered: bool,
+    pub registered_aor: String,
+
+    // Registration transaction state.
+    reg_call_id: String,
+    reg_cseq: u32,
+    reg_from_tag: String,
+
+    // Network.
+    lan_ip: String,
+    lan_port: u16,
+}
+
+impl ProviderState {
+    pub fn new(config: ProviderConfig, public_ip_seed: Option<&str>) -> Self {
+        let aor = format!("sip:{}@{}", config.username, config.domain);
+        Self {
+            public_ip: public_ip_seed.map(|s| s.to_string()),
+            is_registered: false,
+            registered_aor: aor,
+            reg_call_id: generate_call_id(None),
+            reg_cseq: 0,
+            reg_from_tag: generate_tag(),
+            lan_ip: String::new(),
+            lan_port: 0,
+            config,
+        }
+    }
+
+    /// Build and send a REGISTER request.
+    pub fn build_register(&mut self) -> Vec<u8> {
+        self.reg_cseq += 1;
+        let pub_ip = self.public_ip.as_deref().unwrap_or(&self.lan_ip);
+
+        let register = SipMessage::create_request(
+            "REGISTER",
+            &format!("sip:{}", self.config.domain),
+            RequestOptions {
+                via_host: pub_ip.to_string(),
+                via_port: self.lan_port,
+                via_transport: None,
+                via_branch: Some(generate_branch()),
+                from_uri: self.registered_aor.clone(),
+                from_display_name: None,
+                from_tag: Some(self.reg_from_tag.clone()),
+                to_uri: self.registered_aor.clone(),
+                to_display_name: None,
+                to_tag: None,
+                call_id: Some(self.reg_call_id.clone()),
+                cseq: Some(self.reg_cseq),
+                contact: Some(format!(
+                    "<sip:{}@{}:{}>",
+                    self.config.username, pub_ip, self.lan_port
+                )),
+                max_forwards: Some(70),
+                body: None,
+                content_type: None,
+                extra_headers: Some(vec![
+                    (
+                        "Expires".to_string(),
+                        self.config.register_interval_sec.to_string(),
+                    ),
+                    ("User-Agent".to_string(), "SipRouter/1.0".to_string()),
+                    (
+                        "Allow".to_string(),
+                        "INVITE, ACK, OPTIONS, CANCEL, BYE, SUBSCRIBE, NOTIFY, INFO, REFER, UPDATE"
+                            .to_string(),
+                    ),
+                ]),
+            },
+        );
+        register.serialize()
+    }
+
+    /// Handle a SIP response that might be for this provider's REGISTER.
+    /// Returns true if the message was consumed.
+    pub fn handle_registration_response(&mut self, msg: &SipMessage) -> Option<Vec<u8>> {
+        if !msg.is_response() {
+            return None;
+        }
+        if msg.call_id() != self.reg_call_id {
+            return None;
+        }
+        let cseq_method = msg.cseq_method().unwrap_or("");
+        if !cseq_method.eq_ignore_ascii_case("REGISTER") {
+            return None;
+        }
+
+        let code = msg.status_code().unwrap_or(0);
+
+        if code == 200 {
+            self.is_registered = true;
+            return Some(Vec::new()); // consumed, no reply needed
+        }
+
+        if code == 401 || code == 407 {
+            let challenge_header = if code == 401 {
+                msg.get_header("WWW-Authenticate")
+            } else {
+                msg.get_header("Proxy-Authenticate")
+            };
+
+            let challenge_header = match challenge_header {
+                Some(h) => h,
+                None => return Some(Vec::new()), // consumed but no challenge
+            };
+
+            let challenge = match parse_digest_challenge(challenge_header) {
+                Some(c) => c,
+                None => return Some(Vec::new()),
+            };
+
+            let auth_value = compute_digest_auth(
+                &self.config.username,
+                &self.config.password,
+                &challenge.realm,
+                &challenge.nonce,
+                "REGISTER",
+                &format!("sip:{}", self.config.domain),
+                challenge.algorithm.as_deref(),
+                challenge.opaque.as_deref(),
+            );
+
+            // Resend REGISTER with auth credentials.
+            self.reg_cseq += 1;
+            let pub_ip = self.public_ip.as_deref().unwrap_or(&self.lan_ip);
+
+            let auth_header_name = if code == 401 {
+                "Authorization"
+            } else {
+                "Proxy-Authorization"
+            };
+
+            let register = SipMessage::create_request(
+                "REGISTER",
+                &format!("sip:{}", self.config.domain),
+                RequestOptions {
+                    via_host: pub_ip.to_string(),
+                    via_port: self.lan_port,
+                    via_transport: None,
+                    via_branch: Some(generate_branch()),
+                    from_uri: self.registered_aor.clone(),
+                    from_display_name: None,
+                    from_tag: Some(self.reg_from_tag.clone()),
+                    to_uri: self.registered_aor.clone(),
+                    to_display_name: None,
+                    to_tag: None,
+                    call_id: Some(self.reg_call_id.clone()),
+                    cseq: Some(self.reg_cseq),
+                    contact: Some(format!(
+                        "<sip:{}@{}:{}>",
+                        self.config.username, pub_ip, self.lan_port
+                    )),
+                    max_forwards: Some(70),
+                    body: None,
+                    content_type: None,
+                    extra_headers: Some(vec![
+                        (auth_header_name.to_string(), auth_value),
+                        (
+                            "Expires".to_string(),
+                            self.config.register_interval_sec.to_string(),
+                        ),
+                        ("User-Agent".to_string(), "SipRouter/1.0".to_string()),
+                        (
+                            "Allow".to_string(),
+                            "INVITE, ACK, OPTIONS, CANCEL, BYE, SUBSCRIBE, NOTIFY, INFO, REFER, UPDATE"
+                                .to_string(),
+                        ),
+                    ]),
+                },
+            );
+            return Some(register.serialize());
+        }
+
+        if code >= 400 {
+            self.is_registered = false;
+        }
+
+        Some(Vec::new()) // consumed
+    }
+
+    /// Detect public IP from Via received= parameter.
+    pub fn detect_public_ip(&mut self, via: &str) {
+        if let Some(m) = via.find("received=") {
+            let rest = &via[m + 9..];
+            let end = rest
+                .find(|c: char| !c.is_ascii_digit() && c != '.')
+                .unwrap_or(rest.len());
+            let ip = &rest[..end];
+            if !ip.is_empty() && self.public_ip.as_deref() != Some(ip) {
+                self.public_ip = Some(ip.to_string());
+            }
+        }
+    }
+
+    pub fn set_network(&mut self, lan_ip: &str, lan_port: u16) {
+        self.lan_ip = lan_ip.to_string();
+        self.lan_port = lan_port;
+    }
+}
+
+/// Manages all provider states and their registration cycles.
+pub struct ProviderManager {
+    providers: Vec<Arc<Mutex<ProviderState>>>,
+    out_tx: OutTx,
+}
+
+impl ProviderManager {
+    pub fn new(out_tx: OutTx) -> Self {
+        Self {
+            providers: Vec::new(),
+            out_tx,
+        }
+    }
+
+    /// Initialize providers from config and start registration cycles.
+    pub async fn configure(
+        &mut self,
+        configs: &[ProviderConfig],
+        public_ip_seed: Option<&str>,
+        lan_ip: &str,
+        lan_port: u16,
+        socket: Arc<UdpSocket>,
+    ) {
+        self.providers.clear();
+
+        for cfg in configs {
+            let mut ps = ProviderState::new(cfg.clone(), public_ip_seed);
+            ps.set_network(lan_ip, lan_port);
+            let ps = Arc::new(Mutex::new(ps));
+            self.providers.push(ps.clone());
+
+            // Start the registration cycle.
+            let socket = socket.clone();
+            let out_tx = self.out_tx.clone();
+            tokio::spawn(async move {
+                provider_register_loop(ps, socket, out_tx).await;
+            });
+        }
+    }
+
+    /// Try to handle a SIP response as a provider registration response.
+    /// Returns true if consumed.
+    pub async fn handle_response(
+        &self,
+        msg: &SipMessage,
+        socket: &UdpSocket,
+    ) -> bool {
+        for ps_arc in &self.providers {
+            let mut ps = ps_arc.lock().await;
+            let was_registered = ps.is_registered;
+            if let Some(reply) = ps.handle_registration_response(msg) {
+                // If there's a reply to send (e.g. auth retry).
+                if !reply.is_empty() {
+                    if let Some(dest) = ps.config.outbound_proxy.to_socket_addr() {
+                        let _ = socket.send_to(&reply, dest).await;
+                    }
+                }
+                // Emit registration state change.
+                if ps.is_registered != was_registered {
+                    emit_event(
+                        &self.out_tx,
+                        "provider_registered",
+                        serde_json::json!({
+                            "provider_id": ps.config.id,
+                            "registered": ps.is_registered,
+                            "public_ip": ps.public_ip,
+                        }),
+                    );
+                }
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Find which provider sent a packet by matching source address.
+    pub async fn find_by_address(&self, addr: &SocketAddr) -> Option<Arc<Mutex<ProviderState>>> {
+        for ps_arc in &self.providers {
+            let ps = ps_arc.lock().await;
+            let proxy_addr = format!(
+                "{}:{}",
+                ps.config.outbound_proxy.address, ps.config.outbound_proxy.port
+            );
+            if let Ok(expected) = proxy_addr.parse::<SocketAddr>() {
+                if expected == *addr {
+                    return Some(ps_arc.clone());
+                }
+            }
+            // Also match by IP only (port may differ).
+            if ps.config.outbound_proxy.address == addr.ip().to_string() {
+                return Some(ps_arc.clone());
+            }
+        }
+        None
+    }
+
+    /// Check if a provider is currently registered.
+    pub async fn is_registered(&self, provider_id: &str) -> bool {
+        for ps_arc in &self.providers {
+            let ps = ps_arc.lock().await;
+            if ps.config.id == provider_id {
+                return ps.is_registered;
+            }
+        }
+        false
+    }
+}
+
+/// Registration loop for a single provider.
+async fn provider_register_loop(
+    ps: Arc<Mutex<ProviderState>>,
+    socket: Arc<UdpSocket>,
+    _out_tx: OutTx,
+) {
+    // Initial registration.
+    {
+        let mut state = ps.lock().await;
+        let register_buf = state.build_register();
+        if let Some(dest) = state.config.outbound_proxy.to_socket_addr() {
+            let _ = socket.send_to(&register_buf, dest).await;
+        }
+    }
+
+    // Re-register periodically (85% of the interval).
+    let interval_sec = {
+        let state = ps.lock().await;
+        (state.config.register_interval_sec as f64 * 0.85) as u64
+    };
+    let mut interval = time::interval(Duration::from_secs(interval_sec.max(30)));
+    interval.tick().await; // skip first immediate tick
+
+    loop {
+        interval.tick().await;
+        let mut state = ps.lock().await;
+        let register_buf = state.build_register();
+        if let Some(dest) = state.config.outbound_proxy.to_socket_addr() {
+            let _ = socket.send_to(&register_buf, dest).await;
+        }
+    }
+}

rust/crates/proxy-engine/src/registrar.rs

@@ -0,0 +1,171 @@
+//! Device registrar — accepts REGISTER from SIP phones and tracks contacts.
+//!
+//! When a device sends REGISTER, the registrar responds with 200 OK
+//! and stores the device's current contact (source IP:port).
+//!
+//! Ported from ts/registrar.ts.
+
+use crate::config::DeviceConfig;
+use crate::ipc::{emit_event, OutTx};
+use sip_proto::helpers::generate_tag;
+use sip_proto::message::{ResponseOptions, SipMessage};
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::time::{Duration, Instant};
+
+const MAX_EXPIRES: u32 = 300;
+
+/// A registered device entry.
+#[derive(Debug, Clone)]
+pub struct RegisteredDevice {
+    pub device_id: String,
+    pub display_name: String,
+    pub extension: String,
+    pub contact_addr: SocketAddr,
+    pub registered_at: Instant,
+    pub expires_at: Instant,
+    pub aor: String,
+}
+
+/// Manages device registrations.
+pub struct Registrar {
+    /// Known device configs (from app config).
+    devices: Vec<DeviceConfig>,
+    /// Currently registered devices, keyed by device ID.
+    registered: HashMap<String, RegisteredDevice>,
+    out_tx: OutTx,
+}
+
+impl Registrar {
+    pub fn new(out_tx: OutTx) -> Self {
+        Self {
+            devices: Vec::new(),
+            registered: HashMap::new(),
+            out_tx,
+        }
+    }
+
+    /// Update the known device list from config.
+    pub fn configure(&mut self, devices: &[DeviceConfig]) {
+        self.devices = devices.to_vec();
+    }
+
+    /// Try to handle a SIP REGISTER from a device.
+    /// Returns Some(response_bytes) if handled, None if not a known device.
+    pub fn handle_register(
+        &mut self,
+        msg: &SipMessage,
+        from_addr: SocketAddr,
+    ) -> Option<Vec<u8>> {
+        if msg.method() != Some("REGISTER") {
+            return None;
+        }
+
+        // Find the device by matching the source IP against expectedAddress.
+        let from_ip = from_addr.ip().to_string();
+        let device = self.devices.iter().find(|d| d.expected_address == from_ip)?;
+
+        let from_header = msg.get_header("From").unwrap_or("");
+        let aor = SipMessage::extract_uri(from_header)
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| format!("sip:{}@{}", device.extension, from_ip));
+
+        let expires_header = msg.get_header("Expires");
+        let requested: u32 = expires_header
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(3600);
+        let expires = requested.min(MAX_EXPIRES);
+
+        let entry = RegisteredDevice {
+            device_id: device.id.clone(),
+            display_name: device.display_name.clone(),
+            extension: device.extension.clone(),
+            contact_addr: from_addr,
+            registered_at: Instant::now(),
+            expires_at: Instant::now() + Duration::from_secs(expires as u64),
+            aor: aor.clone(),
+        };
+        self.registered.insert(device.id.clone(), entry);
+
+        // Emit event to TypeScript.
+        emit_event(
+            &self.out_tx,
+            "device_registered",
+            serde_json::json!({
+                "device_id": device.id,
+                "display_name": device.display_name,
+                "address": from_ip,
+                "port": from_addr.port(),
+                "aor": aor,
+                "expires": expires,
+            }),
+        );
+
+        // Build 200 OK response.
+        let contact = msg
+            .get_header("Contact")
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| format!("<sip:{}:{}>", from_ip, from_addr.port()));
+
+        let response = SipMessage::create_response(
+            200,
+            "OK",
+            msg,
+            Some(ResponseOptions {
+                to_tag: Some(generate_tag()),
+                contact: Some(contact),
+                extra_headers: Some(vec![(
+                    "Expires".to_string(),
+                    expires.to_string(),
+                )]),
+                ..Default::default()
+            }),
+        );
+
+        Some(response.serialize())
+    }
+
+    /// Get the contact address for a registered device.
+    pub fn get_device_contact(&self, device_id: &str) -> Option<SocketAddr> {
+        let entry = self.registered.get(device_id)?;
+        if Instant::now() > entry.expires_at {
+            return None;
+        }
+        Some(entry.contact_addr)
+    }
+
+    /// Check if a source address belongs to a known device.
+    pub fn is_known_device_address(&self, addr: &str) -> bool {
+        self.devices.iter().any(|d| d.expected_address == addr)
+    }
+
+    /// Find a registered device by its source IP address.
+    pub fn find_by_address(&self, addr: &SocketAddr) -> Option<&RegisteredDevice> {
+        let ip = addr.ip().to_string();
+        self.registered.values().find(|e| {
+            e.contact_addr.ip().to_string() == ip && Instant::now() <= e.expires_at
+        })
+    }
+
+    /// Get all device statuses for the dashboard.
+    pub fn get_all_statuses(&self) -> Vec<serde_json::Value> {
+        let now = Instant::now();
+        let mut result = Vec::new();
+
+        for dc in &self.devices {
+            let reg = self.registered.get(&dc.id);
+            let connected = reg.map(|r| now <= r.expires_at).unwrap_or(false);
+            result.push(serde_json::json!({
+                "id": dc.id,
+                "displayName": dc.display_name,
+                "address": reg.filter(|_| connected).map(|r| r.contact_addr.ip().to_string()),
+                "port": reg.filter(|_| connected).map(|r| r.contact_addr.port()),
+                "aor": reg.map(|r| r.aor.as_str()).unwrap_or(""),
+                "connected": connected,
+                "isBrowser": false,
+            }));
+        }
+
+        result
+    }
+}

rust/crates/proxy-engine/src/rtp.rs

@@ -0,0 +1,158 @@
+//! RTP port pool and media forwarding.
+//!
+//! Manages a pool of even-numbered UDP ports for RTP media.
+//! Each port gets a bound tokio UdpSocket. Supports:
+//! - Direct forwarding (SIP-to-SIP, no transcoding)
+//! - Transcoding forwarding (via codec-lib, e.g. G.722 ↔ Opus)
+//! - Silence generation
+//! - NAT priming
+//!
+//! Ported from ts/call/rtp-port-pool.ts + sip-leg.ts RTP handling.
+
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::net::UdpSocket;
+
+/// A single RTP port allocation.
+pub struct RtpAllocation {
+    pub port: u16,
+    pub socket: Arc<UdpSocket>,
+}
+
+/// RTP port pool — allocates even-numbered UDP ports.
+pub struct RtpPortPool {
+    min: u16,
+    max: u16,
+    allocated: HashMap<u16, Arc<UdpSocket>>,
+}
+
+impl RtpPortPool {
+    pub fn new(min: u16, max: u16) -> Self {
+        let min = if min % 2 == 0 { min } else { min + 1 };
+        Self {
+            min,
+            max,
+            allocated: HashMap::new(),
+        }
+    }
+
+    /// Allocate an even-numbered port and bind a UDP socket.
+    pub async fn allocate(&mut self) -> Option<RtpAllocation> {
+        let mut port = self.min;
+        while port < self.max {
+            if !self.allocated.contains_key(&port) {
+                match UdpSocket::bind(format!("0.0.0.0:{port}")).await {
+                    Ok(sock) => {
+                        let sock = Arc::new(sock);
+                        self.allocated.insert(port, sock.clone());
+                        return Some(RtpAllocation { port, socket: sock });
+                    }
+                    Err(_) => {
+                        // Port in use, try next.
+                    }
+                }
+            }
+            port += 2;
+        }
+        None // Pool exhausted.
+    }
+
+    /// Release a port back to the pool.
+    pub fn release(&mut self, port: u16) {
+        self.allocated.remove(&port);
+        // Socket is dropped when the last Arc reference goes away.
+    }
+
+    pub fn size(&self) -> usize {
+        self.allocated.len()
+    }
+
+    pub fn capacity(&self) -> usize {
+        ((self.max - self.min) / 2) as usize
+    }
+}
+
+/// An active RTP relay between two endpoints.
+/// Receives on `local_socket` and forwards to `remote_addr`.
+pub struct RtpRelay {
+    pub local_port: u16,
+    pub local_socket: Arc<UdpSocket>,
+    pub remote_addr: Option<SocketAddr>,
+    /// If set, transcode packets using this codec session before forwarding.
+    pub transcode: Option<TranscodeConfig>,
+    /// Packets received counter.
+    pub pkt_received: u64,
+    /// Packets sent counter.
+    pub pkt_sent: u64,
+}
+
+pub struct TranscodeConfig {
+    pub from_pt: u8,
+    pub to_pt: u8,
+    pub session_id: String,
+}
+
+impl RtpRelay {
+    pub fn new(port: u16, socket: Arc<UdpSocket>) -> Self {
+        Self {
+            local_port: port,
+            local_socket: socket,
+            remote_addr: None,
+            transcode: None,
+            pkt_received: 0,
+            pkt_sent: 0,
+        }
+    }
+
+    pub fn set_remote(&mut self, addr: SocketAddr) {
+        self.remote_addr = Some(addr);
+    }
+}
+
+/// Send a 1-byte NAT priming packet to open a pinhole.
+pub async fn prime_nat(socket: &UdpSocket, remote: SocketAddr) {
+    let _ = socket.send_to(&[0u8], remote).await;
+}
+
+/// Build an RTP silence frame for PCMU (payload type 0).
+pub fn silence_frame_pcmu() -> Vec<u8> {
+    // 12-byte RTP header + 160 bytes of µ-law silence (0xFF)
+    let mut frame = vec![0u8; 172];
+    frame[0] = 0x80; // V=2
+    frame[1] = 0; // PT=0 (PCMU)
+    // seq, timestamp, ssrc left as 0 — caller should set these
+    frame[12..].fill(0xFF); // µ-law silence
+    frame
+}
+
+/// Build an RTP silence frame for G.722 (payload type 9).
+pub fn silence_frame_g722() -> Vec<u8> {
+    // 12-byte RTP header + 160 bytes of G.722 silence
+    let mut frame = vec![0u8; 172];
+    frame[0] = 0x80; // V=2
+    frame[1] = 9; // PT=9 (G.722)
+    // G.722 silence: all zeros is valid silence
+    frame
+}
+
+/// Build an RTP header with the given parameters.
+pub fn build_rtp_header(pt: u8, seq: u16, timestamp: u32, ssrc: u32) -> [u8; 12] {
+    let mut header = [0u8; 12];
+    header[0] = 0x80; // V=2
+    header[1] = pt & 0x7F;
+    header[2..4].copy_from_slice(&seq.to_be_bytes());
+    header[4..8].copy_from_slice(&timestamp.to_be_bytes());
+    header[8..12].copy_from_slice(&ssrc.to_be_bytes());
+    header
+}
+
+/// Get the RTP clock increment per 20ms frame for a payload type.
+pub fn rtp_clock_increment(pt: u8) -> u32 {
+    match pt {
+        9 => 160,   // G.722: 8000 Hz clock rate (despite 16kHz audio) × 0.02s
+        0 | 8 => 160, // PCMU/PCMA: 8000 × 0.02
+        111 => 960, // Opus: 48000 × 0.02
+        _ => 160,
+    }
+}

rust/crates/proxy-engine/src/sip_transport.rs

@@ -0,0 +1,67 @@
+//! SIP UDP transport — owns the main SIP socket.
+//!
+//! Binds a UDP socket, receives SIP messages, and provides a send method.
+
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::net::UdpSocket;
+
+/// The SIP UDP transport layer.
+pub struct SipTransport {
+    socket: Arc<UdpSocket>,
+}
+
+impl SipTransport {
+    /// Bind a UDP socket on the given address (e.g. "0.0.0.0:5070").
+    pub async fn bind(bind_addr: &str) -> Result<Self, String> {
+        let socket = UdpSocket::bind(bind_addr)
+            .await
+            .map_err(|e| format!("bind {bind_addr}: {e}"))?;
+        Ok(Self {
+            socket: Arc::new(socket),
+        })
+    }
+
+    /// Get a clone of the socket Arc for the receiver task.
+    pub fn socket(&self) -> Arc<UdpSocket> {
+        self.socket.clone()
+    }
+
+    /// Send a raw SIP message to a destination.
+    pub async fn send_to(&self, data: &[u8], dest: SocketAddr) -> Result<usize, String> {
+        self.socket
+            .send_to(data, dest)
+            .await
+            .map_err(|e| format!("send to {dest}: {e}"))
+    }
+
+    /// Send a raw SIP message to an address:port pair.
+    pub async fn send_to_addr(&self, data: &[u8], addr: &str, port: u16) -> Result<usize, String> {
+        let dest: SocketAddr = format!("{addr}:{port}")
+            .parse()
+            .map_err(|e| format!("bad address {addr}:{port}: {e}"))?;
+        self.send_to(data, dest).await
+    }
+
+    /// Spawn the UDP receive loop. Calls the handler for every received packet.
+    pub fn spawn_receiver<F>(
+        &self,
+        handler: F,
+    ) where
+        F: Fn(&[u8], SocketAddr) + Send + 'static,
+    {
+        let socket = self.socket.clone();
+        tokio::spawn(async move {
+            let mut buf = vec![0u8; 65535];
+            loop {
+                match socket.recv_from(&mut buf).await {
+                    Ok((n, addr)) => handler(&buf[..n], addr),
+                    Err(e) => {
+                        eprintln!("[sip_transport] recv error: {e}");
+                        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                    }
+                }
+            }
+        });
+    }
+}

rust/crates/sip-proto/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "sip-proto"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+md-5 = "0.10"
+rand = "0.8"

rust/crates/sip-proto/src/dialog.rs

@@ -0,0 +1,408 @@
+//! SIP dialog state machine (RFC 3261 §12).
+//!
+//! Tracks local/remote tags, CSeq counters, route set, and remote target.
+//! Provides methods to build in-dialog requests (BYE, re-INVITE, ACK, CANCEL).
+//!
+//! Ported from ts/sip/dialog.ts.
+
+use crate::helpers::{generate_branch, generate_tag};
+use crate::message::SipMessage;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DialogState {
+    Early,
+    Confirmed,
+    Terminated,
+}
+
+/// SIP dialog state per RFC 3261 §12.
+#[derive(Debug, Clone)]
+pub struct SipDialog {
+    pub call_id: String,
+    pub local_tag: String,
+    pub remote_tag: Option<String>,
+    pub local_uri: String,
+    pub remote_uri: String,
+    pub local_cseq: u32,
+    pub remote_cseq: u32,
+    pub route_set: Vec<String>,
+    pub remote_target: String,
+    pub state: DialogState,
+    pub local_host: String,
+    pub local_port: u16,
+}
+
+impl SipDialog {
+    /// Create a dialog from an INVITE we are sending (UAC side).
+    /// The dialog enters Early state; call `process_response()` when responses arrive.
+    pub fn from_uac_invite(invite: &SipMessage, local_host: &str, local_port: u16) -> Self {
+        let from = invite.get_header("From").unwrap_or("");
+        let to = invite.get_header("To").unwrap_or("");
+
+        let local_cseq = invite
+            .get_header("CSeq")
+            .and_then(|c| c.split_whitespace().next())
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(1);
+
+        Self {
+            call_id: invite.call_id().to_string(),
+            local_tag: SipMessage::extract_tag(from)
+                .map(|s| s.to_string())
+                .unwrap_or_else(generate_tag),
+            remote_tag: None,
+            local_uri: SipMessage::extract_uri(from)
+                .unwrap_or("")
+                .to_string(),
+            remote_uri: SipMessage::extract_uri(to).unwrap_or("").to_string(),
+            local_cseq,
+            remote_cseq: 0,
+            route_set: Vec::new(),
+            remote_target: invite
+                .request_uri()
+                .or_else(|| SipMessage::extract_uri(to))
+                .unwrap_or("")
+                .to_string(),
+            state: DialogState::Early,
+            local_host: local_host.to_string(),
+            local_port,
+        }
+    }
+
+    /// Create a dialog from an INVITE we received (UAS side).
+    pub fn from_uas_invite(
+        invite: &SipMessage,
+        local_tag: &str,
+        local_host: &str,
+        local_port: u16,
+    ) -> Self {
+        let from = invite.get_header("From").unwrap_or("");
+        let to = invite.get_header("To").unwrap_or("");
+        let contact = invite.get_header("Contact");
+
+        let remote_target = contact
+            .and_then(SipMessage::extract_uri)
+            .or_else(|| SipMessage::extract_uri(from))
+            .unwrap_or("")
+            .to_string();
+
+        Self {
+            call_id: invite.call_id().to_string(),
+            local_tag: local_tag.to_string(),
+            remote_tag: SipMessage::extract_tag(from).map(|s| s.to_string()),
+            local_uri: SipMessage::extract_uri(to).unwrap_or("").to_string(),
+            remote_uri: SipMessage::extract_uri(from).unwrap_or("").to_string(),
+            local_cseq: 0,
+            remote_cseq: 0,
+            route_set: Vec::new(),
+            remote_target,
+            state: DialogState::Early,
+            local_host: local_host.to_string(),
+            local_port,
+        }
+    }
+
+    /// Update dialog state from a received response.
+    pub fn process_response(&mut self, response: &SipMessage) {
+        let to = response.get_header("To").unwrap_or("");
+        let tag = SipMessage::extract_tag(to).map(|s| s.to_string());
+        let code = response.status_code().unwrap_or(0);
+
+        // Always update remoteTag from 2xx (RFC 3261 §12.1.2).
+        if let Some(ref t) = tag {
+            if code >= 200 && code < 300 {
+                self.remote_tag = Some(t.clone());
+            } else if self.remote_tag.is_none() {
+                self.remote_tag = Some(t.clone());
+            }
+        }
+
+        // Update remote target from Contact.
+        if let Some(contact) = response.get_header("Contact") {
+            if let Some(uri) = SipMessage::extract_uri(contact) {
+                self.remote_target = uri.to_string();
+            }
+        }
+
+        // Record-Route → route set (in reverse for UAC).
+        if self.state == DialogState::Early {
+            let rr: Vec<String> = response
+                .headers
+                .iter()
+                .filter(|(n, _)| n.to_ascii_lowercase() == "record-route")
+                .map(|(_, v)| v.clone())
+                .collect();
+            if !rr.is_empty() {
+                let mut reversed = rr;
+                reversed.reverse();
+                self.route_set = reversed;
+            }
+        }
+
+        if code >= 200 && code < 300 {
+            self.state = DialogState::Confirmed;
+        } else if code >= 300 {
+            self.state = DialogState::Terminated;
+        }
+    }
+
+    /// Build an in-dialog request (BYE, re-INVITE, INFO, ...).
+    /// Automatically increments the local CSeq.
+    pub fn create_request(
+        &mut self,
+        method: &str,
+        body: Option<&str>,
+        content_type: Option<&str>,
+        extra_headers: Option<Vec<(String, String)>>,
+    ) -> SipMessage {
+        self.local_cseq += 1;
+        let branch = generate_branch();
+
+        let remote_tag_str = self
+            .remote_tag
+            .as_ref()
+            .map(|t| format!(";tag={t}"))
+            .unwrap_or_default();
+
+        let mut headers = vec![
+            (
+                "Via".to_string(),
+                format!(
+                    "SIP/2.0/UDP {}:{};branch={branch};rport",
+                    self.local_host, self.local_port
+                ),
+            ),
+            (
+                "From".to_string(),
+                format!("<{}>;tag={}", self.local_uri, self.local_tag),
+            ),
+            (
+                "To".to_string(),
+                format!("<{}>{remote_tag_str}", self.remote_uri),
+            ),
+            ("Call-ID".to_string(), self.call_id.clone()),
+            (
+                "CSeq".to_string(),
+                format!("{} {method}", self.local_cseq),
+            ),
+            ("Max-Forwards".to_string(), "70".to_string()),
+        ];
+
+        for route in &self.route_set {
+            headers.push(("Route".to_string(), route.clone()));
+        }
+
+        headers.push((
+            "Contact".to_string(),
+            format!("<sip:{}:{}>", self.local_host, self.local_port),
+        ));
+
+        if let Some(extra) = extra_headers {
+            headers.extend(extra);
+        }
+
+        let body_str = body.unwrap_or("");
+        if !body_str.is_empty() {
+            if let Some(ct) = content_type {
+                headers.push(("Content-Type".to_string(), ct.to_string()));
+            }
+        }
+        headers.push(("Content-Length".to_string(), body_str.len().to_string()));
+
+        let ruri = self.resolve_ruri();
+        SipMessage::new(
+            format!("{method} {ruri} SIP/2.0"),
+            headers,
+            body_str.to_string(),
+        )
+    }
+
+    /// Build an ACK for a 2xx response to INVITE (RFC 3261 §13.2.2.4).
+    pub fn create_ack(&self) -> SipMessage {
+        let branch = generate_branch();
+        let remote_tag_str = self
+            .remote_tag
+            .as_ref()
+            .map(|t| format!(";tag={t}"))
+            .unwrap_or_default();
+
+        let mut headers = vec![
+            (
+                "Via".to_string(),
+                format!(
+                    "SIP/2.0/UDP {}:{};branch={branch};rport",
+                    self.local_host, self.local_port
+                ),
+            ),
+            (
+                "From".to_string(),
+                format!("<{}>;tag={}", self.local_uri, self.local_tag),
+            ),
+            (
+                "To".to_string(),
+                format!("<{}>{remote_tag_str}", self.remote_uri),
+            ),
+            ("Call-ID".to_string(), self.call_id.clone()),
+            (
+                "CSeq".to_string(),
+                format!("{} ACK", self.local_cseq),
+            ),
+            ("Max-Forwards".to_string(), "70".to_string()),
+        ];
+
+        for route in &self.route_set {
+            headers.push(("Route".to_string(), route.clone()));
+        }
+
+        headers.push(("Content-Length".to_string(), "0".to_string()));
+
+        let ruri = self.resolve_ruri();
+        SipMessage::new(format!("ACK {ruri} SIP/2.0"), headers, String::new())
+    }
+
+    /// Build a CANCEL for the original INVITE (same branch, CSeq).
+    pub fn create_cancel(&self, original_invite: &SipMessage) -> SipMessage {
+        let via = original_invite.get_header("Via").unwrap_or("").to_string();
+        let from = original_invite.get_header("From").unwrap_or("").to_string();
+        let to = original_invite.get_header("To").unwrap_or("").to_string();
+
+        let headers = vec![
+            ("Via".to_string(), via),
+            ("From".to_string(), from),
+            ("To".to_string(), to),
+            ("Call-ID".to_string(), self.call_id.clone()),
+            (
+                "CSeq".to_string(),
+                format!("{} CANCEL", self.local_cseq),
+            ),
+            ("Max-Forwards".to_string(), "70".to_string()),
+            ("Content-Length".to_string(), "0".to_string()),
+        ];
+
+        let ruri = original_invite
+            .request_uri()
+            .unwrap_or(&self.remote_target)
+            .to_string();
+
+        SipMessage::new(
+            format!("CANCEL {ruri} SIP/2.0"),
+            headers,
+            String::new(),
+        )
+    }
+
+    /// Transition the dialog to terminated state.
+    pub fn terminate(&mut self) {
+        self.state = DialogState::Terminated;
+    }
+
+    /// Resolve Request-URI from route set or remote target.
+    fn resolve_ruri(&self) -> &str {
+        if !self.route_set.is_empty() {
+            if let Some(top_route) = SipMessage::extract_uri(&self.route_set[0]) {
+                if top_route.contains(";lr") {
+                    return &self.remote_target; // loose routing
+                }
+                return top_route; // strict routing
+            }
+        }
+        &self.remote_target
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::message::RequestOptions;
+
+    fn make_invite() -> SipMessage {
+        SipMessage::create_request(
+            "INVITE",
+            "sip:callee@host",
+            RequestOptions {
+                via_host: "192.168.1.1".to_string(),
+                via_port: 5070,
+                via_transport: None,
+                via_branch: Some("z9hG4bK-test".to_string()),
+                from_uri: "sip:caller@proxy".to_string(),
+                from_display_name: None,
+                from_tag: Some("from-tag".to_string()),
+                to_uri: "sip:callee@host".to_string(),
+                to_display_name: None,
+                to_tag: None,
+                call_id: Some("test-dialog-call".to_string()),
+                cseq: Some(1),
+                contact: Some("<sip:caller@192.168.1.1:5070>".to_string()),
+                max_forwards: None,
+                body: None,
+                content_type: None,
+                extra_headers: None,
+            },
+        )
+    }
+
+    #[test]
+    fn uac_dialog_lifecycle() {
+        let invite = make_invite();
+        let mut dialog = SipDialog::from_uac_invite(&invite, "192.168.1.1", 5070);
+
+        assert_eq!(dialog.state, DialogState::Early);
+        assert_eq!(dialog.call_id, "test-dialog-call");
+        assert_eq!(dialog.local_tag, "from-tag");
+        assert!(dialog.remote_tag.is_none());
+
+        // Simulate 200 OK
+        let response = SipMessage::create_response(
+            200,
+            "OK",
+            &invite,
+            Some(crate::message::ResponseOptions {
+                to_tag: Some("remote-tag".to_string()),
+                contact: Some("<sip:callee@10.0.0.1:5060>".to_string()),
+                ..Default::default()
+            }),
+        );
+
+        dialog.process_response(&response);
+        assert_eq!(dialog.state, DialogState::Confirmed);
+        assert_eq!(dialog.remote_tag.as_deref(), Some("remote-tag"));
+        assert_eq!(dialog.remote_target, "sip:callee@10.0.0.1:5060");
+    }
+
+    #[test]
+    fn create_bye() {
+        let invite = make_invite();
+        let mut dialog = SipDialog::from_uac_invite(&invite, "192.168.1.1", 5070);
+        dialog.remote_tag = Some("remote-tag".to_string());
+        dialog.state = DialogState::Confirmed;
+
+        let bye = dialog.create_request("BYE", None, None, None);
+        assert_eq!(bye.method(), Some("BYE"));
+        assert_eq!(bye.call_id(), "test-dialog-call");
+        assert_eq!(dialog.local_cseq, 2);
+        let to = bye.get_header("To").unwrap();
+        assert!(to.contains("tag=remote-tag"));
+    }
+
+    #[test]
+    fn create_ack() {
+        let invite = make_invite();
+        let mut dialog = SipDialog::from_uac_invite(&invite, "192.168.1.1", 5070);
+        dialog.remote_tag = Some("remote-tag".to_string());
+
+        let ack = dialog.create_ack();
+        assert_eq!(ack.method(), Some("ACK"));
+        assert!(ack.get_header("CSeq").unwrap().contains("ACK"));
+    }
+
+    #[test]
+    fn create_cancel() {
+        let invite = make_invite();
+        let dialog = SipDialog::from_uac_invite(&invite, "192.168.1.1", 5070);
+
+        let cancel = dialog.create_cancel(&invite);
+        assert_eq!(cancel.method(), Some("CANCEL"));
+        assert!(cancel.get_header("CSeq").unwrap().contains("CANCEL"));
+        assert!(cancel.start_line.contains("sip:callee@host"));
+    }
+}

rust/crates/sip-proto/src/helpers.rs

@@ -0,0 +1,331 @@
+//! SIP helper utilities — ID generation, codec registry, SDP builder,
+//! Digest authentication, SDP parser, and MWI body builder.
+
+use md5::{Digest, Md5};
+use rand::Rng;
+
+// ---- ID generators ---------------------------------------------------------
+
+/// Generate a random SIP Call-ID (32 hex chars).
+pub fn generate_call_id(domain: Option<&str>) -> String {
+    let id = random_hex(16);
+    match domain {
+        Some(d) => format!("{id}@{d}"),
+        None => id,
+    }
+}
+
+/// Generate a random SIP From/To tag (16 hex chars).
+pub fn generate_tag() -> String {
+    random_hex(8)
+}
+
+/// Generate an RFC 3261 compliant Via branch (starts with `z9hG4bK` magic cookie).
+pub fn generate_branch() -> String {
+    format!("z9hG4bK-{}", random_hex(8))
+}
+
+fn random_hex(bytes: usize) -> String {
+    let mut rng = rand::thread_rng();
+    (0..bytes).map(|_| format!("{:02x}", rng.gen::<u8>())).collect()
+}
+
+// ---- Codec registry --------------------------------------------------------
+
+/// Look up the rtpmap name for a static payload type.
+pub fn codec_name(pt: u8) -> &'static str {
+    match pt {
+        0 => "PCMU/8000",
+        3 => "GSM/8000",
+        4 => "G723/8000",
+        8 => "PCMA/8000",
+        9 => "G722/8000",
+        18 => "G729/8000",
+        101 => "telephone-event/8000",
+        _ => "unknown",
+    }
+}
+
+// ---- SDP builder -----------------------------------------------------------
+
+/// Options for building an SDP body.
+pub struct SdpOptions<'a> {
+    pub ip: &'a str,
+    pub port: u16,
+    pub payload_types: &'a [u8],
+    pub session_id: Option<&'a str>,
+    pub session_name: Option<&'a str>,
+    pub direction: Option<&'a str>,
+    pub attributes: &'a [&'a str],
+}
+
+impl<'a> Default for SdpOptions<'a> {
+    fn default() -> Self {
+        Self {
+            ip: "0.0.0.0",
+            port: 0,
+            payload_types: &[9, 0, 8, 101],
+            session_id: None,
+            session_name: None,
+            direction: None,
+            attributes: &[],
+        }
+    }
+}
+
+/// Build a minimal SDP body suitable for SIP INVITE offers/answers.
+pub fn build_sdp(opts: &SdpOptions) -> String {
+    let session_id = opts
+        .session_id
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| format!("{}", rand::thread_rng().gen_range(0..1_000_000_000u64)));
+    let session_name = opts.session_name.unwrap_or("-");
+    let direction = opts.direction.unwrap_or("sendrecv");
+    let pts: Vec<String> = opts.payload_types.iter().map(|pt| pt.to_string()).collect();
+
+    let mut lines = vec![
+        "v=0".to_string(),
+        format!("o=- {session_id} {session_id} IN IP4 {}", opts.ip),
+        format!("s={session_name}"),
+        format!("c=IN IP4 {}", opts.ip),
+        "t=0 0".to_string(),
+        format!("m=audio {} RTP/AVP {}", opts.port, pts.join(" ")),
+    ];
+
+    for &pt in opts.payload_types {
+        let name = codec_name(pt);
+        if name != "unknown" {
+            lines.push(format!("a=rtpmap:{pt} {name}"));
+        }
+        if pt == 101 {
+            lines.push("a=fmtp:101 0-16".to_string());
+        }
+    }
+
+    lines.push(format!("a={direction}"));
+    for attr in opts.attributes {
+        lines.push(format!("a={attr}"));
+    }
+    lines.push(String::new()); // trailing CRLF
+
+    lines.join("\r\n")
+}
+
+// ---- SIP Digest authentication (RFC 2617) ----------------------------------
+
+/// Parsed fields from a Proxy-Authenticate or WWW-Authenticate header.
+#[derive(Debug, Clone)]
+pub struct DigestChallenge {
+    pub realm: String,
+    pub nonce: String,
+    pub algorithm: Option<String>,
+    pub opaque: Option<String>,
+    pub qop: Option<String>,
+}
+
+/// Parse a `Proxy-Authenticate` or `WWW-Authenticate` header value.
+pub fn parse_digest_challenge(header: &str) -> Option<DigestChallenge> {
+    let lower = header.to_ascii_lowercase();
+    if !lower.starts_with("digest ") {
+        return None;
+    }
+    let params = &header[7..];
+
+    let get = |key: &str| -> Option<String> {
+        // Try quoted value first.
+        let pat = format!("{}=", key);
+        if let Some(pos) = params.to_ascii_lowercase().find(&pat) {
+            let after = &params[pos + pat.len()..];
+            let after = after.trim_start();
+            if after.starts_with('"') {
+                let end = after[1..].find('"')?;
+                return Some(after[1..1 + end].to_string());
+            }
+            // Unquoted value.
+            let end = after.find(|c: char| c == ',' || c.is_whitespace()).unwrap_or(after.len());
+            return Some(after[..end].to_string());
+        }
+        None
+    };
+
+    let realm = get("realm")?;
+    let nonce = get("nonce")?;
+
+    Some(DigestChallenge {
+        realm,
+        nonce,
+        algorithm: get("algorithm"),
+        opaque: get("opaque"),
+        qop: get("qop"),
+    })
+}
+
+fn md5_hex(s: &str) -> String {
+    let mut hasher = Md5::new();
+    hasher.update(s.as_bytes());
+    format!("{:x}", hasher.finalize())
+}
+
+/// Compute a SIP Digest Authorization header value.
+pub fn compute_digest_auth(
+    username: &str,
+    password: &str,
+    realm: &str,
+    nonce: &str,
+    method: &str,
+    uri: &str,
+    algorithm: Option<&str>,
+    opaque: Option<&str>,
+) -> String {
+    let ha1 = md5_hex(&format!("{username}:{realm}:{password}"));
+    let ha2 = md5_hex(&format!("{method}:{uri}"));
+    let response = md5_hex(&format!("{ha1}:{nonce}:{ha2}"));
+    let alg = algorithm.unwrap_or("MD5");
+
+    let mut header = format!(
+        "Digest username=\"{username}\", realm=\"{realm}\", \
+         nonce=\"{nonce}\", uri=\"{uri}\", response=\"{response}\", \
+         algorithm={alg}"
+    );
+    if let Some(op) = opaque {
+        header.push_str(&format!(", opaque=\"{op}\""));
+    }
+    header
+}
+
+// ---- SDP parser ------------------------------------------------------------
+
+use crate::Endpoint;
+
+/// Parse the audio media port and connection address from an SDP body.
+pub fn parse_sdp_endpoint(sdp: &str) -> Option<Endpoint> {
+    let mut addr: Option<&str> = None;
+    let mut port: Option<u16> = None;
+
+    let normalized = sdp.replace("\r\n", "\n");
+    for raw in normalized.split('\n') {
+        let line = raw.trim();
+        if let Some(rest) = line.strip_prefix("c=IN IP4 ") {
+            addr = Some(rest.trim());
+        } else if let Some(rest) = line.strip_prefix("m=audio ") {
+            let parts: Vec<&str> = rest.split_whitespace().collect();
+            if !parts.is_empty() {
+                port = parts[0].parse().ok();
+            }
+        }
+    }
+
+    match (addr, port) {
+        (Some(a), Some(p)) => Some(Endpoint {
+            address: a.to_string(),
+            port: p,
+        }),
+        _ => None,
+    }
+}
+
+// ---- MWI (RFC 3842) --------------------------------------------------------
+
+/// Build the body and extra headers for an MWI NOTIFY (RFC 3842 message-summary).
+pub struct MwiResult {
+    pub body: String,
+    pub content_type: &'static str,
+    pub extra_headers: Vec<(String, String)>,
+}
+
+pub fn build_mwi_body(
+    new_messages: u32,
+    old_messages: u32,
+    account_uri: &str,
+) -> MwiResult {
+    let waiting = if new_messages > 0 { "yes" } else { "no" };
+    let body = format!(
+        "Messages-Waiting: {waiting}\r\n\
+         Message-Account: {account_uri}\r\n\
+         Voice-Message: {new_messages}/{old_messages}\r\n"
+    );
+
+    MwiResult {
+        body,
+        content_type: "application/simple-message-summary",
+        extra_headers: vec![
+            ("Event".to_string(), "message-summary".to_string()),
+            (
+                "Subscription-State".to_string(),
+                "terminated;reason=noresource".to_string(),
+            ),
+        ],
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_generate_branch_has_magic_cookie() {
+        let branch = generate_branch();
+        assert!(branch.starts_with("z9hG4bK-"));
+        assert!(branch.len() > 8);
+    }
+
+    #[test]
+    fn test_codec_name() {
+        assert_eq!(codec_name(0), "PCMU/8000");
+        assert_eq!(codec_name(9), "G722/8000");
+        assert_eq!(codec_name(101), "telephone-event/8000");
+        assert_eq!(codec_name(255), "unknown");
+    }
+
+    #[test]
+    fn test_build_sdp() {
+        let sdp = build_sdp(&SdpOptions {
+            ip: "192.168.1.1",
+            port: 20000,
+            payload_types: &[9, 0, 101],
+            ..Default::default()
+        });
+        assert!(sdp.contains("m=audio 20000 RTP/AVP 9 0 101"));
+        assert!(sdp.contains("c=IN IP4 192.168.1.1"));
+        assert!(sdp.contains("a=rtpmap:9 G722/8000"));
+        assert!(sdp.contains("a=fmtp:101 0-16"));
+        assert!(sdp.contains("a=sendrecv"));
+    }
+
+    #[test]
+    fn test_parse_digest_challenge() {
+        let header = r#"Digest realm="asterisk", nonce="abc123", algorithm=MD5, opaque="xyz""#;
+        let ch = parse_digest_challenge(header).unwrap();
+        assert_eq!(ch.realm, "asterisk");
+        assert_eq!(ch.nonce, "abc123");
+        assert_eq!(ch.algorithm.as_deref(), Some("MD5"));
+        assert_eq!(ch.opaque.as_deref(), Some("xyz"));
+    }
+
+    #[test]
+    fn test_compute_digest_auth() {
+        let auth = compute_digest_auth(
+            "user", "pass", "realm", "nonce", "REGISTER", "sip:host", None, None,
+        );
+        assert!(auth.starts_with("Digest "));
+        assert!(auth.contains("username=\"user\""));
+        assert!(auth.contains("realm=\"realm\""));
+        assert!(auth.contains("response=\""));
+    }
+
+    #[test]
+    fn test_parse_sdp_endpoint() {
+        let sdp = "v=0\r\nc=IN IP4 10.0.0.1\r\nm=audio 5060 RTP/AVP 0\r\n";
+        let ep = parse_sdp_endpoint(sdp).unwrap();
+        assert_eq!(ep.address, "10.0.0.1");
+        assert_eq!(ep.port, 5060);
+    }
+
+    #[test]
+    fn test_build_mwi_body() {
+        let mwi = build_mwi_body(3, 5, "sip:user@host");
+        assert!(mwi.body.contains("Messages-Waiting: yes"));
+        assert!(mwi.body.contains("Voice-Message: 3/5"));
+        assert_eq!(mwi.content_type, "application/simple-message-summary");
+    }
+}

rust/crates/sip-proto/src/lib.rs

@@ -0,0 +1,17 @@
+//! SIP protocol library for the proxy engine.
+//!
+//! Provides SIP message parsing/serialization, dialog state management,
+//! SDP handling, Digest authentication, and URI rewriting.
+//! Ported from the TypeScript `ts/sip/` library.
+
+pub mod message;
+pub mod dialog;
+pub mod helpers;
+pub mod rewrite;
+
+/// Network endpoint (address + port).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Endpoint {
+    pub address: String,
+    pub port: u16,
+}

rust/crates/sip-proto/src/message.rs

@@ -0,0 +1,563 @@
+//! SIP message parsing, serialization, inspection, mutation, and factory methods.
+//!
+//! Ported from ts/sip/message.ts.
+
+use crate::helpers::{generate_branch, generate_call_id, generate_tag};
+
+/// A parsed SIP message (request or response).
+#[derive(Debug, Clone)]
+pub struct SipMessage {
+    pub start_line: String,
+    pub headers: Vec<(String, String)>,
+    pub body: String,
+}
+
+impl SipMessage {
+    pub fn new(start_line: String, headers: Vec<(String, String)>, body: String) -> Self {
+        Self { start_line, headers, body }
+    }
+
+    // ---- Parsing -----------------------------------------------------------
+
+    /// Parse a raw buffer into a SipMessage. Returns None for invalid data.
+    pub fn parse(buf: &[u8]) -> Option<Self> {
+        if buf.is_empty() {
+            return None;
+        }
+        // First byte must be ASCII A-z.
+        if buf[0] < 0x41 || buf[0] > 0x7a {
+            return None;
+        }
+
+        let text = std::str::from_utf8(buf).ok()?;
+
+        let (head, body) = if let Some(sep) = text.find("\r\n\r\n") {
+            (&text[..sep], &text[sep + 4..])
+        } else if let Some(sep) = text.find("\n\n") {
+            (&text[..sep], &text[sep + 2..])
+        } else {
+            (text, "")
+        };
+
+        let normalized = head.replace("\r\n", "\n");
+        let lines: Vec<&str> = normalized.split('\n').collect();
+        if lines.is_empty() || lines[0].is_empty() {
+            return None;
+        }
+
+        let start_line = lines[0];
+        // Validate: must be a SIP request or response start line.
+        if !is_sip_first_line(start_line) {
+            return None;
+        }
+
+        let mut headers = Vec::new();
+        for &line in &lines[1..] {
+            let trimmed = line.trim();
+            if trimmed.is_empty() {
+                continue;
+            }
+            if let Some(colon) = line.find(':') {
+                let name = line[..colon].trim().to_string();
+                let value = line[colon + 1..].trim().to_string();
+                headers.push((name, value));
+            }
+        }
+
+        Some(SipMessage {
+            start_line: start_line.to_string(),
+            headers,
+            body: body.to_string(),
+        })
+    }
+
+    // ---- Serialization -----------------------------------------------------
+
+    /// Serialize the message to a byte buffer suitable for UDP transmission.
+    pub fn serialize(&self) -> Vec<u8> {
+        let mut head = self.start_line.clone();
+        for (name, value) in &self.headers {
+            head.push_str("\r\n");
+            head.push_str(name);
+            head.push_str(": ");
+            head.push_str(value);
+        }
+        head.push_str("\r\n\r\n");
+
+        let mut buf = head.into_bytes();
+        if !self.body.is_empty() {
+            buf.extend_from_slice(self.body.as_bytes());
+        }
+        buf
+    }
+
+    // ---- Inspectors --------------------------------------------------------
+
+    pub fn is_request(&self) -> bool {
+        !self.start_line.starts_with("SIP/")
+    }
+
+    pub fn is_response(&self) -> bool {
+        self.start_line.starts_with("SIP/")
+    }
+
+    /// Request method (INVITE, REGISTER, ...) or None for responses.
+    pub fn method(&self) -> Option<&str> {
+        if !self.is_request() {
+            return None;
+        }
+        self.start_line.split_whitespace().next()
+    }
+
+    /// Response status code or None for requests.
+    pub fn status_code(&self) -> Option<u16> {
+        if !self.is_response() {
+            return None;
+        }
+        self.start_line
+            .split_whitespace()
+            .nth(1)
+            .and_then(|s| s.parse().ok())
+    }
+
+    pub fn call_id(&self) -> &str {
+        self.get_header("Call-ID").unwrap_or("noid")
+    }
+
+    /// Method from the CSeq header (e.g. "INVITE").
+    pub fn cseq_method(&self) -> Option<&str> {
+        let cseq = self.get_header("CSeq")?;
+        cseq.split_whitespace().nth(1)
+    }
+
+    /// True for INVITE, SUBSCRIBE, REFER, NOTIFY, UPDATE.
+    pub fn is_dialog_establishing(&self) -> bool {
+        matches!(
+            self.method(),
+            Some("INVITE" | "SUBSCRIBE" | "REFER" | "NOTIFY" | "UPDATE")
+        )
+    }
+
+    /// True when the body carries an SDP payload.
+    pub fn has_sdp_body(&self) -> bool {
+        if self.body.is_empty() {
+            return false;
+        }
+        let ct = self.get_header("Content-Type").unwrap_or("");
+        ct.to_ascii_lowercase().starts_with("application/sdp")
+    }
+
+    // ---- Header accessors --------------------------------------------------
+
+    /// Get the first header value matching `name` (case-insensitive).
+    pub fn get_header(&self, name: &str) -> Option<&str> {
+        let nl = name.to_ascii_lowercase();
+        for (n, v) in &self.headers {
+            if n.to_ascii_lowercase() == nl {
+                return Some(v.as_str());
+            }
+        }
+        None
+    }
+
+    /// Overwrites the first header with the given name, or appends it.
+    pub fn set_header(&mut self, name: &str, value: &str) -> &mut Self {
+        let nl = name.to_ascii_lowercase();
+        for h in &mut self.headers {
+            if h.0.to_ascii_lowercase() == nl {
+                h.1 = value.to_string();
+                return self;
+            }
+        }
+        self.headers.push((name.to_string(), value.to_string()));
+        self
+    }
+
+    /// Inserts a header at the top of the header list.
+    pub fn prepend_header(&mut self, name: &str, value: &str) -> &mut Self {
+        self.headers.insert(0, (name.to_string(), value.to_string()));
+        self
+    }
+
+    /// Removes all headers with the given name.
+    pub fn remove_header(&mut self, name: &str) -> &mut Self {
+        let nl = name.to_ascii_lowercase();
+        self.headers.retain(|(n, _)| n.to_ascii_lowercase() != nl);
+        self
+    }
+
+    /// Recalculates Content-Length to match the current body.
+    pub fn update_content_length(&mut self) -> &mut Self {
+        let len = self.body.len();
+        self.set_header("Content-Length", &len.to_string())
+    }
+
+    // ---- Start-line mutation -----------------------------------------------
+
+    /// Replace the Request-URI (second token) of a request start line.
+    pub fn set_request_uri(&mut self, uri: &str) -> &mut Self {
+        if !self.is_request() {
+            return self;
+        }
+        let parts: Vec<&str> = self.start_line.splitn(3, ' ').collect();
+        if parts.len() >= 3 {
+            self.start_line = format!("{} {} {}", parts[0], uri, parts[2]);
+        }
+        self
+    }
+
+    /// Returns the Request-URI (second token) of a request start line.
+    pub fn request_uri(&self) -> Option<&str> {
+        if !self.is_request() {
+            return None;
+        }
+        self.start_line.split_whitespace().nth(1)
+    }
+
+    // ---- Factory methods ---------------------------------------------------
+
+    /// Build a new SIP request.
+    pub fn create_request(method: &str, request_uri: &str, opts: RequestOptions) -> Self {
+        let branch = opts.via_branch.unwrap_or_else(|| generate_branch());
+        let transport = opts.via_transport.unwrap_or_else(|| "UDP".to_string());
+        let from_tag = opts.from_tag.unwrap_or_else(|| generate_tag());
+        let call_id = opts.call_id.unwrap_or_else(|| generate_call_id(None));
+        let cseq = opts.cseq.unwrap_or(1);
+        let max_forwards = opts.max_forwards.unwrap_or(70);
+
+        let from_display = opts
+            .from_display_name
+            .map(|d| format!("\"{d}\" "))
+            .unwrap_or_default();
+        let to_display = opts
+            .to_display_name
+            .map(|d| format!("\"{d}\" "))
+            .unwrap_or_default();
+        let to_tag_str = opts
+            .to_tag
+            .map(|t| format!(";tag={t}"))
+            .unwrap_or_default();
+
+        let mut headers = vec![
+            (
+                "Via".to_string(),
+                format!(
+                    "SIP/2.0/{transport} {}:{};branch={branch};rport",
+                    opts.via_host, opts.via_port
+                ),
+            ),
+            (
+                "From".to_string(),
+                format!("{from_display}<{}>;tag={from_tag}", opts.from_uri),
+            ),
+            (
+                "To".to_string(),
+                format!("{to_display}<{}>{to_tag_str}", opts.to_uri),
+            ),
+            ("Call-ID".to_string(), call_id),
+            ("CSeq".to_string(), format!("{cseq} {method}")),
+            ("Max-Forwards".to_string(), max_forwards.to_string()),
+        ];
+
+        if let Some(contact) = &opts.contact {
+            headers.push(("Contact".to_string(), contact.clone()));
+        }
+
+        if let Some(extra) = opts.extra_headers {
+            headers.extend(extra);
+        }
+
+        let body = opts.body.unwrap_or_default();
+        if !body.is_empty() {
+            if let Some(ct) = &opts.content_type {
+                headers.push(("Content-Type".to_string(), ct.clone()));
+            }
+        }
+        headers.push(("Content-Length".to_string(), body.len().to_string()));
+
+        SipMessage {
+            start_line: format!("{method} {request_uri} SIP/2.0"),
+            headers,
+            body,
+        }
+    }
+
+    /// Build a SIP response to an incoming request.
+    /// Copies Via, From, To, Call-ID, and CSeq from the original request.
+    pub fn create_response(
+        status_code: u16,
+        reason_phrase: &str,
+        request: &SipMessage,
+        opts: Option<ResponseOptions>,
+    ) -> Self {
+        let opts = opts.unwrap_or_default();
+        let mut headers: Vec<(String, String)> = Vec::new();
+
+        // Copy all Via headers (order matters).
+        for (n, v) in &request.headers {
+            if n.to_ascii_lowercase() == "via" {
+                headers.push(("Via".to_string(), v.clone()));
+            }
+        }
+
+        // From — copied verbatim.
+        if let Some(from) = request.get_header("From") {
+            headers.push(("From".to_string(), from.to_string()));
+        }
+
+        // To — add tag if provided and not already present.
+        let mut to = request.get_header("To").unwrap_or("").to_string();
+        if let Some(tag) = &opts.to_tag {
+            if !to.contains("tag=") {
+                to.push_str(&format!(";tag={tag}"));
+            }
+        }
+        headers.push(("To".to_string(), to));
+
+        headers.push(("Call-ID".to_string(), request.call_id().to_string()));
+
+        if let Some(cseq) = request.get_header("CSeq") {
+            headers.push(("CSeq".to_string(), cseq.to_string()));
+        }
+
+        if let Some(contact) = &opts.contact {
+            headers.push(("Contact".to_string(), contact.clone()));
+        }
+
+        if let Some(extra) = opts.extra_headers {
+            headers.extend(extra);
+        }
+
+        let body = opts.body.unwrap_or_default();
+        if !body.is_empty() {
+            if let Some(ct) = &opts.content_type {
+                headers.push(("Content-Type".to_string(), ct.clone()));
+            }
+        }
+        headers.push(("Content-Length".to_string(), body.len().to_string()));
+
+        SipMessage {
+            start_line: format!("SIP/2.0 {status_code} {reason_phrase}"),
+            headers,
+            body,
+        }
+    }
+
+    /// Extract the tag from a From or To header value.
+    pub fn extract_tag(header_value: &str) -> Option<&str> {
+        let idx = header_value.find(";tag=")?;
+        let rest = &header_value[idx + 5..];
+        let end = rest
+            .find(|c: char| c.is_whitespace() || c == ';' || c == '>')
+            .unwrap_or(rest.len());
+        Some(&rest[..end])
+    }
+
+    /// Extract the URI from an addr-spec or name-addr (From/To/Contact).
+    pub fn extract_uri(header_value: &str) -> Option<&str> {
+        if let Some(start) = header_value.find('<') {
+            let end = header_value[start..].find('>')?;
+            Some(&header_value[start + 1..start + end])
+        } else {
+            let trimmed = header_value.trim();
+            let end = trimmed
+                .find(|c: char| c == ';' || c == '>')
+                .unwrap_or(trimmed.len());
+            let result = &trimmed[..end];
+            if result.is_empty() { None } else { Some(result) }
+        }
+    }
+}
+
+/// Options for `SipMessage::create_request`.
+pub struct RequestOptions {
+    pub via_host: String,
+    pub via_port: u16,
+    pub via_transport: Option<String>,
+    pub via_branch: Option<String>,
+    pub from_uri: String,
+    pub from_display_name: Option<String>,
+    pub from_tag: Option<String>,
+    pub to_uri: String,
+    pub to_display_name: Option<String>,
+    pub to_tag: Option<String>,
+    pub call_id: Option<String>,
+    pub cseq: Option<u32>,
+    pub contact: Option<String>,
+    pub max_forwards: Option<u16>,
+    pub body: Option<String>,
+    pub content_type: Option<String>,
+    pub extra_headers: Option<Vec<(String, String)>>,
+}
+
+/// Options for `SipMessage::create_response`.
+#[derive(Default)]
+pub struct ResponseOptions {
+    pub to_tag: Option<String>,
+    pub contact: Option<String>,
+    pub body: Option<String>,
+    pub content_type: Option<String>,
+    pub extra_headers: Option<Vec<(String, String)>>,
+}
+
+/// Check if a string matches the SIP first-line pattern.
+fn is_sip_first_line(line: &str) -> bool {
+    // Request: METHOD SP URI SP SIP/X.Y
+    // Response: SIP/X.Y SP STATUS SP REASON
+    if line.starts_with("SIP/") {
+        // Response: SIP/2.0 200 OK
+        let parts: Vec<&str> = line.splitn(3, ' ').collect();
+        if parts.len() >= 2 {
+            return parts[1].chars().all(|c| c.is_ascii_digit());
+        }
+    } else {
+        // Request: INVITE sip:user@host SIP/2.0
+        let parts: Vec<&str> = line.splitn(3, ' ').collect();
+        if parts.len() >= 3 {
+            return parts[0].chars().all(|c| c.is_ascii_uppercase())
+                && parts[2].starts_with("SIP/");
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const INVITE_RAW: &str = "INVITE sip:user@host SIP/2.0\r\n\
+        Via: SIP/2.0/UDP 192.168.1.1:5060;branch=z9hG4bK-test\r\n\
+        From: <sip:caller@host>;tag=abc\r\n\
+        To: <sip:user@host>\r\n\
+        Call-ID: test-call-id\r\n\
+        CSeq: 1 INVITE\r\n\
+        Content-Length: 0\r\n\r\n";
+
+    #[test]
+    fn parse_invite() {
+        let msg = SipMessage::parse(INVITE_RAW.as_bytes()).unwrap();
+        assert!(msg.is_request());
+        assert!(!msg.is_response());
+        assert_eq!(msg.method(), Some("INVITE"));
+        assert_eq!(msg.call_id(), "test-call-id");
+        assert_eq!(msg.cseq_method(), Some("INVITE"));
+        assert!(msg.is_dialog_establishing());
+        assert_eq!(msg.request_uri(), Some("sip:user@host"));
+    }
+
+    #[test]
+    fn parse_response() {
+        let raw = "SIP/2.0 200 OK\r\n\
+            Via: SIP/2.0/UDP 192.168.1.1:5060;branch=z9hG4bK-test\r\n\
+            From: <sip:caller@host>;tag=abc\r\n\
+            To: <sip:user@host>;tag=def\r\n\
+            Call-ID: test-call-id\r\n\
+            CSeq: 1 INVITE\r\n\
+            Content-Length: 0\r\n\r\n";
+        let msg = SipMessage::parse(raw.as_bytes()).unwrap();
+        assert!(msg.is_response());
+        assert_eq!(msg.status_code(), Some(200));
+        assert_eq!(msg.cseq_method(), Some("INVITE"));
+    }
+
+    #[test]
+    fn serialize_roundtrip() {
+        let msg = SipMessage::parse(INVITE_RAW.as_bytes()).unwrap();
+        let serialized = msg.serialize();
+        let reparsed = SipMessage::parse(&serialized).unwrap();
+        assert_eq!(reparsed.call_id(), "test-call-id");
+        assert_eq!(reparsed.method(), Some("INVITE"));
+        assert_eq!(reparsed.headers.len(), msg.headers.len());
+    }
+
+    #[test]
+    fn header_mutation() {
+        let mut msg = SipMessage::parse(INVITE_RAW.as_bytes()).unwrap();
+        msg.set_header("X-Custom", "value1");
+        assert_eq!(msg.get_header("X-Custom"), Some("value1"));
+        msg.set_header("X-Custom", "value2");
+        assert_eq!(msg.get_header("X-Custom"), Some("value2"));
+        msg.prepend_header("X-First", "first");
+        assert_eq!(msg.headers[0].0, "X-First");
+        msg.remove_header("X-Custom");
+        assert_eq!(msg.get_header("X-Custom"), None);
+    }
+
+    #[test]
+    fn set_request_uri() {
+        let mut msg = SipMessage::parse(INVITE_RAW.as_bytes()).unwrap();
+        msg.set_request_uri("sip:new@host");
+        assert_eq!(msg.request_uri(), Some("sip:new@host"));
+        assert!(msg.start_line.starts_with("INVITE sip:new@host SIP/2.0"));
+    }
+
+    #[test]
+    fn extract_tag_and_uri() {
+        assert_eq!(
+            SipMessage::extract_tag("<sip:user@host>;tag=abc123"),
+            Some("abc123")
+        );
+        assert_eq!(SipMessage::extract_tag("<sip:user@host>"), None);
+        assert_eq!(
+            SipMessage::extract_uri("<sip:user@host>"),
+            Some("sip:user@host")
+        );
+        assert_eq!(
+            SipMessage::extract_uri("\"Name\" <sip:user@host>;tag=abc"),
+            Some("sip:user@host")
+        );
+    }
+
+    #[test]
+    fn create_request_and_response() {
+        let invite = SipMessage::create_request(
+            "INVITE",
+            "sip:user@host",
+            RequestOptions {
+                via_host: "192.168.1.1".to_string(),
+                via_port: 5070,
+                via_transport: None,
+                via_branch: None,
+                from_uri: "sip:caller@proxy".to_string(),
+                from_display_name: None,
+                from_tag: Some("mytag".to_string()),
+                to_uri: "sip:user@host".to_string(),
+                to_display_name: None,
+                to_tag: None,
+                call_id: Some("test-123".to_string()),
+                cseq: Some(1),
+                contact: Some("<sip:caller@192.168.1.1:5070>".to_string()),
+                max_forwards: None,
+                body: None,
+                content_type: None,
+                extra_headers: None,
+            },
+        );
+        assert_eq!(invite.method(), Some("INVITE"));
+        assert_eq!(invite.call_id(), "test-123");
+        assert!(invite.get_header("Via").unwrap().contains("192.168.1.1:5070"));
+
+        let response = SipMessage::create_response(
+            200,
+            "OK",
+            &invite,
+            Some(ResponseOptions {
+                to_tag: Some("remotetag".to_string()),
+                ..Default::default()
+            }),
+        );
+        assert!(response.is_response());
+        assert_eq!(response.status_code(), Some(200));
+        let to = response.get_header("To").unwrap();
+        assert!(to.contains("tag=remotetag"));
+    }
+
+    #[test]
+    fn has_sdp_body() {
+        let mut msg = SipMessage::parse(INVITE_RAW.as_bytes()).unwrap();
+        assert!(!msg.has_sdp_body());
+        msg.body = "v=0\r\no=- 1 1 IN IP4 0.0.0.0\r\n".to_string();
+        msg.set_header("Content-Type", "application/sdp");
+        assert!(msg.has_sdp_body());
+    }
+}

rust/crates/sip-proto/src/rewrite.rs

@@ -0,0 +1,130 @@
+//! SIP URI and SDP body rewriting helpers.
+//!
+//! Ported from ts/sip/rewrite.ts.
+
+use crate::Endpoint;
+
+/// Replaces the host:port in every `sip:` / `sips:` URI found in `value`.
+pub fn rewrite_sip_uri(value: &str, host: &str, port: u16) -> String {
+    let mut result = String::with_capacity(value.len());
+    let mut i = 0;
+    let bytes = value.as_bytes();
+
+    while i < bytes.len() {
+        // Look for "sip:" or "sips:"
+        let scheme_len = if i + 4 <= bytes.len()
+            && (bytes[i..].starts_with(b"sip:") || bytes[i..].starts_with(b"SIP:"))
+        {
+            4
+        } else if i + 5 <= bytes.len()
+            && (bytes[i..].starts_with(b"sips:") || bytes[i..].starts_with(b"SIPS:"))
+        {
+            5
+        } else {
+            result.push(value[i..].chars().next().unwrap());
+            i += value[i..].chars().next().unwrap().len_utf8();
+            continue;
+        };
+
+        let scheme = &value[i..i + scheme_len];
+        let rest = &value[i + scheme_len..];
+
+        // Check for userpart (contains '@')
+        let (userpart, host_start) = if let Some(at) = rest.find('@') {
+            // Make sure @ comes before any delimiters
+            let delim = rest.find(|c: char| c == '>' || c == ';' || c == ',' || c.is_whitespace());
+            if delim.is_none() || at < delim.unwrap() {
+                (&rest[..=at], at + 1)
+            } else {
+                ("", 0)
+            }
+        } else {
+            ("", 0)
+        };
+
+        // Find the end of the host:port portion
+        let host_rest = &rest[host_start..];
+        let end = host_rest
+            .find(|c: char| c == '>' || c == ';' || c == ',' || c.is_whitespace())
+            .unwrap_or(host_rest.len());
+
+        result.push_str(scheme);
+        result.push_str(userpart);
+        result.push_str(&format!("{host}:{port}"));
+        i += scheme_len + host_start + end;
+    }
+
+    result
+}
+
+/// Rewrites the connection address (`c=`) and audio media port (`m=audio`)
+/// in an SDP body. Returns the rewritten body together with the original
+/// endpoint that was replaced (if any).
+pub fn rewrite_sdp(body: &str, ip: &str, port: u16) -> (String, Option<Endpoint>) {
+    let mut orig_addr: Option<String> = None;
+    let mut orig_port: Option<u16> = None;
+
+    let lines: Vec<String> = body
+        .replace("\r\n", "\n")
+        .split('\n')
+        .map(|line| {
+            if let Some(rest) = line.strip_prefix("c=IN IP4 ") {
+                orig_addr = Some(rest.trim().to_string());
+                format!("c=IN IP4 {ip}")
+            } else if line.starts_with("m=audio ") {
+                let parts: Vec<&str> = line.split(' ').collect();
+                if parts.len() >= 2 {
+                    orig_port = parts[1].parse().ok();
+                    let mut rebuilt = parts[0].to_string();
+                    rebuilt.push(' ');
+                    rebuilt.push_str(&port.to_string());
+                    for part in &parts[2..] {
+                        rebuilt.push(' ');
+                        rebuilt.push_str(part);
+                    }
+                    return rebuilt;
+                }
+                line.to_string()
+            } else {
+                line.to_string()
+            }
+        })
+        .collect();
+
+    let original = match (orig_addr, orig_port) {
+        (Some(a), Some(p)) => Some(Endpoint { address: a, port: p }),
+        _ => None,
+    };
+
+    (lines.join("\r\n"), original)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rewrite_sip_uri() {
+        let input = "<sip:user@10.0.0.1:5060>";
+        let result = rewrite_sip_uri(input, "192.168.1.1", 5070);
+        assert_eq!(result, "<sip:user@192.168.1.1:5070>");
+    }
+
+    #[test]
+    fn test_rewrite_sip_uri_no_port() {
+        let input = "sip:user@10.0.0.1";
+        let result = rewrite_sip_uri(input, "192.168.1.1", 5070);
+        assert_eq!(result, "sip:user@192.168.1.1:5070");
+    }
+
+    #[test]
+    fn test_rewrite_sdp() {
+        let sdp = "v=0\r\nc=IN IP4 10.0.0.1\r\nm=audio 5060 RTP/AVP 0 9\r\na=sendrecv\r\n";
+        let (rewritten, orig) = rewrite_sdp(sdp, "192.168.1.1", 20000);
+        assert!(rewritten.contains("c=IN IP4 192.168.1.1"));
+        assert!(rewritten.contains("m=audio 20000 RTP/AVP 0 9"));
+        let ep = orig.unwrap();
+        assert_eq!(ep.address, "10.0.0.1");
+        assert_eq!(ep.port, 5060);
+    }
+}

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'siprouter',
-  version: '1.9.0',
+  version: '1.11.0',
   description: 'undefined'
 }

ts/call/audio-recorder.ts

@@ -0,0 +1,323 @@
+/**
+ * Audio recorder — captures RTP packets from a single direction,
+ * decodes them to PCM, and writes a WAV file.
+ *
+ * Uses the Rust codec bridge to transcode incoming audio (G.722, Opus,
+ * PCMU, PCMA) to PCMU, then decodes mu-law to 16-bit PCM in TypeScript.
+ * Output: 8kHz 16-bit mono WAV (standard telephony quality).
+ *
+ * Supports:
+ * - Max recording duration limit
+ * - Silence detection (stop after N seconds of silence)
+ * - Manual stop
+ * - DTMF packets (PT 101) are automatically skipped
+ */
+
+import { Buffer } from 'node:buffer';
+import fs from 'node:fs';
+import path from 'node:path';
+import { WavWriter } from './wav-writer.ts';
+import type { IWavWriterResult } from './wav-writer.ts';
+import { transcode, createSession, destroySession } from '../opusbridge.ts';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface IRecordingOptions {
+  /** Output directory for WAV files. */
+  outputDir: string;
+  /** Target sample rate for the WAV output (default 8000). */
+  sampleRate?: number;
+  /** Maximum recording duration in seconds. 0 = unlimited. Default 120. */
+  maxDurationSec?: number;
+  /** Stop after this many consecutive seconds of silence. 0 = disabled. Default 5. */
+  silenceTimeoutSec?: number;
+  /** Silence threshold: max PCM amplitude below this is "silent". Default 200. */
+  silenceThreshold?: number;
+  /** Logging function. */
+  log: (msg: string) => void;
+}
+
+export interface IRecordingResult {
+  /** Full path to the WAV file. */
+  filePath: string;
+  /** Duration in milliseconds. */
+  durationMs: number;
+  /** Sample rate of the WAV. */
+  sampleRate: number;
+  /** Size of the WAV file in bytes. */
+  fileSize: number;
+  /** Why the recording was stopped. */
+  stopReason: TRecordingStopReason;
+}
+
+export type TRecordingStopReason = 'manual' | 'max-duration' | 'silence' | 'cancelled';
+
+// ---------------------------------------------------------------------------
+// Mu-law decode table (ITU-T G.711)
+// ---------------------------------------------------------------------------
+
+/** Pre-computed mu-law → 16-bit linear PCM lookup table (256 entries). */
+const MULAW_DECODE: Int16Array = buildMulawDecodeTable();
+
+function buildMulawDecodeTable(): Int16Array {
+  const table = new Int16Array(256);
+  for (let i = 0; i < 256; i++) {
+    // Invert all bits per mu-law standard.
+    let mu = ~i & 0xff;
+    const sign = mu & 0x80;
+    const exponent = (mu >> 4) & 0x07;
+    const mantissa = mu & 0x0f;
+    let magnitude = ((mantissa << 1) + 33) << (exponent + 2);
+    magnitude -= 0x84; // Bias adjustment
+    table[i] = sign ? -magnitude : magnitude;
+  }
+  return table;
+}
+
+/** Decode a PCMU payload to 16-bit LE PCM. */
+function decodeMulaw(mulaw: Buffer): Buffer {
+  const pcm = Buffer.alloc(mulaw.length * 2);
+  for (let i = 0; i < mulaw.length; i++) {
+    pcm.writeInt16LE(MULAW_DECODE[mulaw[i]], i * 2);
+  }
+  return pcm;
+}
+
+// ---------------------------------------------------------------------------
+// AudioRecorder
+// ---------------------------------------------------------------------------
+
+export class AudioRecorder {
+  /** Current state. */
+  state: 'idle' | 'recording' | 'stopped' = 'idle';
+
+  /** Called when recording stops automatically (silence or max duration). */
+  onStopped: ((result: IRecordingResult) => void) | null = null;
+
+  private outputDir: string;
+  private sampleRate: number;
+  private maxDurationSec: number;
+  private silenceTimeoutSec: number;
+  private silenceThreshold: number;
+  private log: (msg: string) => void;
+
+  private wavWriter: WavWriter | null = null;
+  private filePath: string = '';
+  private codecSessionId: string | null = null;
+  private stopReason: TRecordingStopReason = 'manual';
+
+  // Silence detection.
+  private consecutiveSilentFrames = 0;
+  /** Number of 20ms frames that constitute silence timeout. */
+  private silenceFrameThreshold = 0;
+
+  // Max duration timer.
+  private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;
+
+  // Processing queue to avoid concurrent transcodes.
+  private processQueue: Promise<void> = Promise.resolve();
+
+  constructor(options: IRecordingOptions) {
+    this.outputDir = options.outputDir;
+    this.sampleRate = options.sampleRate ?? 8000;
+    this.maxDurationSec = options.maxDurationSec ?? 120;
+    this.silenceTimeoutSec = options.silenceTimeoutSec ?? 5;
+    this.silenceThreshold = options.silenceThreshold ?? 200;
+    this.log = options.log;
+  }
+
+  /**
+   * Start recording. Creates the output directory, WAV file, and codec session.
+   * @param fileId - unique ID for the recording file name
+   */
+  async start(fileId?: string): Promise<void> {
+    if (this.state !== 'idle') return;
+
+    // Ensure output directory exists.
+    if (!fs.existsSync(this.outputDir)) {
+      fs.mkdirSync(this.outputDir, { recursive: true });
+    }
+
+    // Generate file path.
+    const id = fileId ?? `rec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    this.filePath = path.join(this.outputDir, `${id}.wav`);
+
+    // Create a codec session for isolated decoding.
+    this.codecSessionId = `recorder-${id}`;
+    await createSession(this.codecSessionId);
+
+    // Open WAV writer.
+    this.wavWriter = new WavWriter({
+      filePath: this.filePath,
+      sampleRate: this.sampleRate,
+    });
+    this.wavWriter.open();
+
+    // Silence detection threshold: frames in timeout period.
+    this.silenceFrameThreshold = this.silenceTimeoutSec > 0
+      ? Math.ceil((this.silenceTimeoutSec * 1000) / 20)
+      : 0;
+    this.consecutiveSilentFrames = 0;
+
+    // Max duration timer.
+    if (this.maxDurationSec > 0) {
+      this.maxDurationTimer = setTimeout(() => {
+        if (this.state === 'recording') {
+          this.stopReason = 'max-duration';
+          this.log(`[recorder] max duration reached (${this.maxDurationSec}s)`);
+          this.stop().then((result) => this.onStopped?.(result));
+        }
+      }, this.maxDurationSec * 1000);
+    }
+
+    this.state = 'recording';
+    this.stopReason = 'manual';
+    this.log(`[recorder] started → ${this.filePath}`);
+  }
+
+  /**
+   * Feed an RTP packet. Strips the 12-byte header, transcodes the payload
+   * to PCMU via the Rust bridge, decodes to PCM, and writes to WAV.
+   * Skips telephone-event (DTMF) and comfort noise packets.
+   */
+  processRtp(data: Buffer): void {
+    if (this.state !== 'recording') return;
+    if (data.length < 13) return; // too short
+
+    const pt = data[1] & 0x7f;
+
+    // Skip DTMF (telephone-event) and comfort noise.
+    if (pt === 101 || pt === 13) return;
+
+    const payload = data.subarray(12);
+    if (payload.length === 0) return;
+
+    // Queue processing to avoid concurrent transcodes corrupting codec state.
+    this.processQueue = this.processQueue.then(() => this.decodeAndWrite(payload, pt));
+  }
+
+  /** Decode a single RTP payload to PCM and write to WAV. */
+  private async decodeAndWrite(payload: Buffer, pt: number): Promise<void> {
+    if (this.state !== 'recording' || !this.wavWriter) return;
+
+    let pcm: Buffer;
+
+    if (pt === 0) {
+      // PCMU: decode directly in TypeScript (no Rust round-trip needed).
+      pcm = decodeMulaw(payload);
+    } else {
+      // All other codecs: transcode to PCMU via Rust, then decode mu-law.
+      const mulaw = await transcode(payload, pt, 0, this.codecSessionId ?? undefined);
+      if (!mulaw) return;
+      pcm = decodeMulaw(mulaw);
+    }
+
+    // Silence detection.
+    if (this.silenceFrameThreshold > 0) {
+      if (isSilent(pcm, this.silenceThreshold)) {
+        this.consecutiveSilentFrames++;
+        if (this.consecutiveSilentFrames >= this.silenceFrameThreshold) {
+          this.stopReason = 'silence';
+          this.log(`[recorder] silence detected (${this.silenceTimeoutSec}s)`);
+          this.stop().then((result) => this.onStopped?.(result));
+          return;
+        }
+      } else {
+        this.consecutiveSilentFrames = 0;
+      }
+    }
+
+    this.wavWriter.write(pcm);
+  }
+
+  /**
+   * Stop recording and finalize the WAV file.
+   */
+  async stop(): Promise<IRecordingResult> {
+    if (this.state === 'stopped' || this.state === 'idle') {
+      return {
+        filePath: this.filePath,
+        durationMs: 0,
+        sampleRate: this.sampleRate,
+        fileSize: 0,
+        stopReason: this.stopReason,
+      };
+    }
+
+    this.state = 'stopped';
+
+    // Wait for pending decode operations to finish.
+    await this.processQueue;
+
+    // Clear timers.
+    if (this.maxDurationTimer) {
+      clearTimeout(this.maxDurationTimer);
+      this.maxDurationTimer = null;
+    }
+
+    // Finalize WAV.
+    let wavResult: IWavWriterResult | null = null;
+    if (this.wavWriter) {
+      wavResult = this.wavWriter.close();
+      this.wavWriter = null;
+    }
+
+    // Destroy codec session.
+    if (this.codecSessionId) {
+      await destroySession(this.codecSessionId);
+      this.codecSessionId = null;
+    }
+
+    const result: IRecordingResult = {
+      filePath: this.filePath,
+      durationMs: wavResult?.durationMs ?? 0,
+      sampleRate: this.sampleRate,
+      fileSize: wavResult?.fileSize ?? 0,
+      stopReason: this.stopReason,
+    };
+
+    this.log(`[recorder] stopped (${result.stopReason}): ${result.durationMs}ms → ${this.filePath}`);
+    return result;
+  }
+
+  /** Cancel recording — stops and deletes the WAV file. */
+  async cancel(): Promise<void> {
+    this.stopReason = 'cancelled';
+    await this.stop();
+
+    // Delete the incomplete file.
+    try {
+      if (fs.existsSync(this.filePath)) {
+        fs.unlinkSync(this.filePath);
+        this.log(`[recorder] cancelled — deleted ${this.filePath}`);
+      }
+    } catch { /* best effort */ }
+  }
+
+  /** Clean up all resources. */
+  destroy(): void {
+    if (this.state === 'recording') {
+      this.cancel();
+    }
+    this.onStopped = null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Check if a PCM buffer is "silent" (max amplitude below threshold). */
+function isSilent(pcm: Buffer, threshold: number): boolean {
+  let maxAmp = 0;
+  for (let i = 0; i < pcm.length - 1; i += 2) {
+    const sample = pcm.readInt16LE(i);
+    const abs = sample < 0 ? -sample : sample;
+    if (abs > maxAmp) maxAmp = abs;
+    // Early exit: already above threshold.
+    if (maxAmp >= threshold) return false;
+  }
+  return true;
+}

ts/call/call-manager.ts

@@ -22,6 +22,7 @@ import {
   rewriteSdp,
   rewriteSipUri,
   generateTag,
+  buildMwiBody,
 } from '../sip/index.ts';
 import type { IEndpoint } from '../sip/index.ts';
 import type { IAppConfig, IProviderConfig } from '../config.ts';
@@ -39,6 +40,13 @@ import {
   isKnownDeviceAddress,
 } from '../registrar.ts';
 import { WebSocket } from 'ws';
+import { SystemLeg } from './system-leg.ts';
+import type { ISystemLegConfig } from './system-leg.ts';
+import { PromptCache } from './prompt-cache.ts';
+import { VoiceboxManager } from '../voicebox.ts';
+import type { IVoicemailMessage } from '../voicebox.ts';
+import { IvrEngine } from '../ivr.ts';
+import type { IIvrConfig, TIvrAction, IVoiceboxConfig as IVoiceboxCfg } from '../config.ts';
 
 // ---------------------------------------------------------------------------
 // CallManager config
@@ -53,6 +61,10 @@ export interface ICallManagerConfig {
   getAllBrowserDeviceIds: () => string[];
   sendToBrowserDevice: (deviceId: string, data: unknown) => boolean;
   getBrowserDeviceWs: (deviceId: string) => WebSocket | null;
+  /** Prompt cache for IVR/voicemail audio playback. */
+  promptCache?: PromptCache;
+  /** Voicebox manager for voicemail storage and retrieval. */
+  voiceboxManager?: VoiceboxManager;
 }
 
 // ---------------------------------------------------------------------------
@@ -179,6 +191,41 @@ export class CallManager {
           return;
         }
       }
+
+      // Intercept busy/unavailable responses — route to voicemail if configured.
+      // When the device rejects the call (486 Busy, 480 Unavailable, 600/603 Decline),
+      // answer the provider's INVITE with our own SDP and start voicemail.
+      if (msg.isResponse && msg.cseqMethod?.toUpperCase() === 'INVITE') {
+        const code = msg.statusCode;
+        if (code === 486 || code === 480 || code === 600 || code === 603) {
+          const callId = pt.call.id;
+          const boxId = this.findVoiceboxForCall(pt.call);
+          if (boxId) {
+            this.config.log(`[call-mgr] device responded ${code} — routing to voicemail box "${boxId}"`);
+
+            // Build a 200 OK with our own SDP to answer the provider's INVITE.
+            const sdpBody = buildSdp({
+              address: pub,
+              port: pt.rtpPort,
+              payloadTypes: pt.providerConfig.codecs || [9, 0, 8, 101],
+            });
+            // We need to construct the 200 OK as if *we* are answering the provider.
+            // The original INVITE from the provider used the passthrough SIP Call-ID.
+            // Build a response using the forwarded INVITE's headers.
+            const ok200 = SipMessage.createResponse(200, 'OK', msg, {
+              body: sdpBody,
+              contentType: 'application/sdp',
+              contact: `<sip:${lanIp}:${lanPort}>`,
+            });
+            this.config.sendSip(ok200.serialize(), pt.providerConfig.outboundProxy);
+
+            // Now route to voicemail.
+            this.routeToVoicemail(callId, boxId);
+            return;
+          }
+        }
+      }
+
       // Rewrite Contact.
       const contact = msg.getHeader('Contact');
       if (contact) {
@@ -601,6 +648,49 @@ export class CallManager {
     }
 
     call.state = 'ringing';
+
+    // --- IVR / Voicemail routing ---
+    if (routeResult.ivrMenuId && this.config.appConfig.ivr?.enabled) {
+      // Route directly to IVR — don't ring devices.
+      this.config.log(`[call-mgr] inbound call ${callId} routed to IVR menu "${routeResult.ivrMenuId}"`);
+      // Respond 200 OK to the provider INVITE first.
+      const okForProvider = SipMessage.createResponse(200, 'OK', invite, {
+        body: fwdInvite.body, // rewritten SDP
+        contentType: 'application/sdp',
+      });
+      this.config.sendSip(okForProvider.serialize(), rinfo);
+      this.routeToIvr(callId, this.config.appConfig.ivr);
+    } else if (routeResult.voicemailBox) {
+      // Route directly to voicemail — don't ring devices.
+      this.config.log(`[call-mgr] inbound call ${callId} routed directly to voicemail box "${routeResult.voicemailBox}"`);
+      const okForProvider = SipMessage.createResponse(200, 'OK', invite, {
+        body: fwdInvite.body,
+        contentType: 'application/sdp',
+      });
+      this.config.sendSip(okForProvider.serialize(), rinfo);
+      this.routeToVoicemail(callId, routeResult.voicemailBox);
+    } else {
+      // Normal ringing — start voicemail no-answer timer if applicable.
+      const vm = this.config.voiceboxManager;
+      if (vm) {
+        // Find first voicebox for the target devices.
+        const boxId = this.findVoiceboxForDevices(targetDeviceIds);
+        if (boxId) {
+          const box = vm.getBox(boxId);
+          if (box?.enabled) {
+            const timeoutSec = routeResult.noAnswerTimeout ?? box.noAnswerTimeoutSec ?? 25;
+            setTimeout(() => {
+              const c = this.calls.get(callId);
+              if (c && c.state === 'ringing') {
+                this.config.log(`[call-mgr] no answer after ${timeoutSec}s — routing to voicemail box "${boxId}"`);
+                this.routeToVoicemail(callId, boxId);
+              }
+            }, timeoutSec * 1000);
+          }
+        }
+      }
+    }
+
     return call;
   }
 
@@ -1092,6 +1182,371 @@ export class CallManager {
     }
   }
 
+  // -------------------------------------------------------------------------
+  // Voicemail routing
+  // -------------------------------------------------------------------------
+
+  /**
+   * Route a call to voicemail. Cancels ringing devices, creates a SystemLeg,
+   * plays the greeting, then starts recording.
+   */
+  routeToVoicemail(callId: string, boxId: string): void {
+    const call = this.calls.get(callId);
+    if (!call) return;
+
+    const vm = this.config.voiceboxManager;
+    const pc = this.config.promptCache;
+    if (!vm || !pc) {
+      this.config.log(`[call-mgr] voicemail not available (manager or prompt cache missing)`);
+      return;
+    }
+
+    const box = vm.getBox(boxId);
+    if (!box) {
+      this.config.log(`[call-mgr] voicebox "${boxId}" not found`);
+      return;
+    }
+
+    // Cancel all ringing/device legs — keep only provider leg(s).
+    const legsToRemove: string[] = [];
+    for (const leg of call.getLegs()) {
+      if (leg.type === 'sip-device' || leg.type === 'webrtc') {
+        legsToRemove.push(leg.id);
+      }
+    }
+    for (const legId of legsToRemove) {
+      const leg = call.getLeg(legId);
+      if (leg && (leg.type === 'sip-device' || leg.type === 'sip-provider')) {
+        (leg as SipLeg).sendHangup(); // CANCEL ringing devices
+      }
+      call.removeLeg(legId);
+    }
+
+    // Cancel passthrough tracking for this call (if applicable).
+    for (const [sipCallId, pt] of this.passthroughCalls) {
+      if (pt.call === call) {
+        // Keep the RTP socket — the SystemLeg will use it indirectly through the hub.
+        this.passthroughCalls.delete(sipCallId);
+        break;
+      }
+    }
+
+    // Create a SystemLeg.
+    const systemLegId = `${callId}-vm`;
+    const systemLeg = new SystemLeg(systemLegId, {
+      log: this.config.log,
+      promptCache: pc,
+      callerCodecPt: 9, // SIP callers use G.722 by default
+      onDtmfDigit: (digit) => {
+        // '#' during recording = stop and save.
+        if (digit.digit === '#' && systemLeg.mode === 'voicemail-recording') {
+          this.config.log(`[call-mgr] voicemail: caller pressed # — stopping recording`);
+          systemLeg.stopRecording().then((result) => {
+            if (result && result.durationMs > 500) {
+              this.saveVoicemailMessage(boxId, call, result);
+            }
+            call.hangup();
+          });
+        }
+      },
+      onRecordingComplete: (result) => {
+        if (result.durationMs > 500) {
+          this.saveVoicemailMessage(boxId, call, result);
+        }
+      },
+    });
+
+    call.addLeg(systemLeg);
+    call.state = 'voicemail';
+
+    // Determine greeting prompt ID.
+    const greetingPromptId = `voicemail-greeting-${boxId}`;
+    const beepPromptId = 'voicemail-beep';
+
+    // Play greeting, then beep, then start recording.
+    systemLeg.mode = 'voicemail-greeting';
+
+    const startSequence = () => {
+      systemLeg.playPrompt(greetingPromptId, () => {
+        // Greeting done — play beep.
+        systemLeg.playPrompt(beepPromptId, () => {
+          // Beep done — start recording.
+          const recordDir = vm.getBoxDir(boxId);
+          const fileId = `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+          systemLeg.startRecording(recordDir, fileId);
+          this.config.log(`[call-mgr] voicemail recording started for box "${boxId}"`);
+        });
+      });
+    };
+
+    // Check if the greeting prompt is already cached; if not, generate it.
+    if (pc.has(greetingPromptId)) {
+      startSequence();
+    } else {
+      // Generate the greeting on-the-fly.
+      const wavPath = vm.getCustomGreetingWavPath(boxId);
+      const generatePromise = wavPath
+        ? pc.loadWavPrompt(greetingPromptId, wavPath)
+        : pc.generatePrompt(greetingPromptId, vm.getGreetingText(boxId), vm.getGreetingVoice(boxId));
+
+      generatePromise.then(() => {
+        if (call.state !== 'terminated') startSequence();
+      });
+    }
+  }
+
+  /** Save a voicemail message after recording completes. */
+  private saveVoicemailMessage(boxId: string, call: Call, result: import('./audio-recorder.ts').IRecordingResult): void {
+    const vm = this.config.voiceboxManager;
+    if (!vm) return;
+
+    const fileName = result.filePath.split('/').pop() || 'unknown.wav';
+    const msg: IVoicemailMessage = {
+      id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      boxId,
+      callerNumber: call.callerNumber || 'Unknown',
+      timestamp: Date.now(),
+      durationMs: result.durationMs,
+      fileName,
+      heard: false,
+    };
+
+    vm.saveMessage(msg);
+    this.config.log(`[call-mgr] voicemail saved: ${msg.id} (${result.durationMs}ms) in box "${boxId}"`);
+
+    // Send MWI NOTIFY to the associated device.
+    this.sendMwiNotify(boxId);
+  }
+
+  /** Send MWI (Message Waiting Indicator) NOTIFY to a device for a voicebox. */
+  private sendMwiNotify(boxId: string): void {
+    const vm = this.config.voiceboxManager;
+    if (!vm) return;
+
+    const reg = getRegisteredDevice(boxId);
+    if (!reg?.contact) return; // Device not registered — skip.
+
+    const newCount = vm.getUnheardCount(boxId);
+    const totalCount = vm.getTotalCount(boxId);
+    const oldCount = totalCount - newCount;
+
+    const lanIp = this.config.appConfig.proxy.lanIp;
+    const lanPort = this.config.appConfig.proxy.lanPort;
+    const accountUri = `sip:${boxId}@${lanIp}`;
+    const targetUri = `sip:${reg.aor || boxId}@${reg.contact.address}:${reg.contact.port}`;
+
+    const mwi = buildMwiBody(newCount, oldCount, accountUri);
+    const notify = SipMessage.createRequest('NOTIFY', targetUri, {
+      via: { host: lanIp, port: lanPort },
+      from: { uri: accountUri },
+      to: { uri: targetUri },
+      contact: `<sip:${lanIp}:${lanPort}>`,
+      body: mwi.body,
+      contentType: mwi.contentType,
+      extraHeaders: mwi.extraHeaders,
+    });
+
+    this.config.sendSip(notify.serialize(), reg.contact);
+    this.config.log(`[call-mgr] MWI NOTIFY sent to ${boxId}: ${newCount} new, ${oldCount} old`);
+  }
+
+  // -------------------------------------------------------------------------
+  // IVR routing
+  // -------------------------------------------------------------------------
+
+  /**
+   * Route a call to IVR. Creates a SystemLeg and starts the IVR engine.
+   */
+  routeToIvr(callId: string, ivrConfig: IIvrConfig): void {
+    const call = this.calls.get(callId);
+    if (!call) return;
+
+    const pc = this.config.promptCache;
+    if (!pc) {
+      this.config.log(`[call-mgr] IVR not available (prompt cache missing)`);
+      return;
+    }
+
+    // Cancel all ringing device legs.
+    const legsToRemove: string[] = [];
+    for (const leg of call.getLegs()) {
+      if (leg.type === 'sip-device' || leg.type === 'webrtc') {
+        legsToRemove.push(leg.id);
+      }
+    }
+    for (const legId of legsToRemove) {
+      const leg = call.getLeg(legId);
+      if (leg && (leg.type === 'sip-device' || leg.type === 'sip-provider')) {
+        (leg as SipLeg).sendHangup();
+      }
+      call.removeLeg(legId);
+    }
+
+    // Remove passthrough tracking.
+    for (const [sipCallId, pt] of this.passthroughCalls) {
+      if (pt.call === call) {
+        this.passthroughCalls.delete(sipCallId);
+        break;
+      }
+    }
+
+    // Create SystemLeg for IVR.
+    const systemLegId = `${callId}-ivr`;
+    const systemLeg = new SystemLeg(systemLegId, {
+      log: this.config.log,
+      promptCache: pc,
+      callerCodecPt: 9,
+    });
+
+    call.addLeg(systemLeg);
+    call.state = 'ivr';
+    systemLeg.mode = 'ivr';
+
+    // Create IVR engine.
+    const ivrEngine = new IvrEngine(
+      ivrConfig,
+      systemLeg,
+      (action: TIvrAction) => this.handleIvrAction(callId, action, ivrEngine, systemLeg),
+      this.config.log,
+    );
+
+    // Wire DTMF digits to the IVR engine.
+    systemLeg.config.onDtmfDigit = (digit) => {
+      ivrEngine.handleDigit(digit.digit);
+    };
+
+    // Start the IVR.
+    ivrEngine.start();
+  }
+
+  /** Handle an action from the IVR engine. */
+  private handleIvrAction(
+    callId: string,
+    action: TIvrAction,
+    ivrEngine: IvrEngine,
+    systemLeg: SystemLeg,
+  ): void {
+    const call = this.calls.get(callId);
+    if (!call) return;
+
+    switch (action.type) {
+      case 'route-extension': {
+        // Tear down IVR and ring the target device.
+        ivrEngine.destroy();
+        call.removeLeg(systemLeg.id);
+
+        const extTarget = this.resolveDeviceTarget(action.extensionId);
+        if (!extTarget) {
+          this.config.log(`[call-mgr] IVR: extension "${action.extensionId}" not found — hanging up`);
+          call.hangup();
+          break;
+        }
+
+        const rtpExt = this.portPool.allocate();
+        if (!rtpExt) {
+          this.config.log(`[call-mgr] IVR: port pool exhausted — hanging up`);
+          call.hangup();
+          break;
+        }
+
+        const ps = [...this.config.appConfig.providers]
+          .map((p) => this.config.getProviderState(p.id))
+          .find((s) => s?.publicIp);
+
+        const extLegConfig: ISipLegConfig = {
+          role: 'device',
+          lanIp: this.config.appConfig.proxy.lanIp,
+          lanPort: this.config.appConfig.proxy.lanPort,
+          getPublicIp: () => ps?.publicIp ?? null,
+          sendSip: this.config.sendSip,
+          log: this.config.log,
+          sipTarget: extTarget,
+          rtpPort: rtpExt.port,
+          rtpSock: rtpExt.sock,
+        };
+
+        const extLeg = new SipLeg(`${callId}-ext`, extLegConfig);
+        extLeg.onTerminated = (leg) => call.handleLegTerminated(leg.id);
+        extLeg.onStateChange = () => call.notifyLegStateChange(extLeg);
+        call.addLeg(extLeg);
+        call.state = 'ringing';
+
+        const sipCallIdExt = `${callId}-ext-${Date.now()}`;
+        extLeg.sendInvite({
+          fromUri: `sip:${call.callerNumber || 'unknown'}@${this.config.appConfig.proxy.lanIp}`,
+          fromDisplayName: call.callerNumber || 'Unknown',
+          toUri: `sip:user@${extTarget.address}`,
+          callId: sipCallIdExt,
+        });
+        this.sipCallIdIndex.set(sipCallIdExt, call);
+        this.config.log(`[call-mgr] IVR: ringing extension "${action.extensionId}"`);
+        break;
+      }
+
+      case 'route-voicemail': {
+        ivrEngine.destroy();
+        call.removeLeg(systemLeg.id);
+        this.routeToVoicemail(callId, action.boxId);
+        break;
+      }
+
+      case 'transfer': {
+        ivrEngine.destroy();
+        call.removeLeg(systemLeg.id);
+
+        // Resolve provider for outbound dial.
+        const xferRoute = resolveOutboundRoute(
+          this.config.appConfig,
+          action.number,
+          undefined,
+          (pid) => !!this.config.getProviderState(pid)?.registeredAor,
+        );
+        if (!xferRoute) {
+          this.config.log(`[call-mgr] IVR: no provider for transfer to ${action.number} — hanging up`);
+          call.hangup();
+          break;
+        }
+
+        const xferPs = this.config.getProviderState(xferRoute.provider.id);
+        if (!xferPs) {
+          call.hangup();
+          break;
+        }
+
+        this.startProviderLeg(call, xferRoute.provider, xferRoute.transformedNumber, xferPs);
+        this.config.log(`[call-mgr] IVR: transferring to ${action.number} via ${xferRoute.provider.displayName}`);
+        break;
+      }
+
+      case 'hangup': {
+        ivrEngine.destroy();
+        call.hangup();
+        break;
+      }
+
+      default:
+        break;
+    }
+  }
+
+  /** Find the voicebox for a call (uses all device IDs or fallback to first enabled). */
+  private findVoiceboxForCall(call: Call): string | null {
+    const allDeviceIds = this.config.appConfig.devices.map((d) => d.id);
+    return this.findVoiceboxForDevices(allDeviceIds);
+  }
+
+  /** Find the first voicebox ID associated with a set of target device IDs. */
+  private findVoiceboxForDevices(deviceIds: string[]): string | null {
+    const voiceboxes = this.config.appConfig.voiceboxes ?? [];
+    for (const deviceId of deviceIds) {
+      const box = voiceboxes.find((vb) => vb.id === deviceId);
+      if (box?.enabled) return box.id;
+    }
+    // Fallback: first enabled voicebox.
+    const first = voiceboxes.find((vb) => vb.enabled);
+    return first?.id ?? null;
+  }
+
   // -------------------------------------------------------------------------
   // Status
   // -------------------------------------------------------------------------

ts/call/call.ts

@@ -138,7 +138,16 @@ export class Call {
     } else if (legs.every((l) => l.state === 'terminated')) {
       this.state = 'terminated';
     } else if (legs.some((l) => l.state === 'connected') && legs.filter((l) => l.state !== 'terminated').length >= 2) {
-      this.state = 'connected';
+      // If a system leg is connected, report voicemail/ivr state for the dashboard.
+      const systemLeg = legs.find((l) => l.type === 'system');
+      if (systemLeg) {
+        // Keep voicemail/ivr state if already set; otherwise set connected.
+        if (this.state !== 'voicemail' && this.state !== 'ivr') {
+          this.state = 'connected';
+        }
+      } else {
+        this.state = 'connected';
+      }
     } else if (legs.some((l) => l.state === 'ringing')) {
       this.state = 'ringing';
     } else {
@@ -164,7 +173,7 @@ export class Call {
     this.log(`[call:${this.id}] hanging up (${this.legs.size} legs)`);
 
     for (const [id, leg] of this.legs) {
-      // Send BYE/CANCEL for SIP legs.
+      // Send BYE/CANCEL for SIP legs (system legs have no SIP signaling).
       if (leg.type === 'sip-device' || leg.type === 'sip-provider') {
         (leg as SipLeg).sendHangup();
       }
@@ -197,6 +206,7 @@ export class Call {
     // If this is a 2-party call, hang up the other leg too.
     if (this.legs.size <= 1) {
       for (const [id, leg] of this.legs) {
+        // Send BYE/CANCEL for SIP legs (system legs just get torn down).
         if (leg.type === 'sip-device' || leg.type === 'sip-provider') {
           (leg as SipLeg).sendHangup();
         }

ts/call/dtmf-detector.ts

@@ -0,0 +1,272 @@
+/**
+ * DTMF detection — parses RFC 2833 telephone-event RTP packets
+ * and SIP INFO (application/dtmf-relay) messages.
+ *
+ * Designed to be attached to any leg or RTP stream. The detector
+ * deduplicates repeated telephone-event packets (same digit is sent
+ * multiple times with increasing duration) and fires a callback
+ * once per detected digit.
+ */
+
+import { Buffer } from 'node:buffer';
+import type { SipMessage } from '../sip/index.ts';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** A single detected DTMF digit. */
+export interface IDtmfDigit {
+  /** The digit character: '0'-'9', '*', '#', 'A'-'D'. */
+  digit: string;
+  /** Duration in milliseconds. */
+  durationMs: number;
+  /** Detection source. */
+  source: 'rfc2833' | 'sip-info';
+  /** Wall-clock timestamp when the digit was detected. */
+  timestamp: number;
+}
+
+/** Callback fired once per detected DTMF digit. */
+export type TDtmfCallback = (digit: IDtmfDigit) => void;
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** RFC 2833 event ID → character mapping. */
+const EVENT_CHARS: string[] = [
+  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+  '*', '#', 'A', 'B', 'C', 'D',
+];
+
+/** Safety timeout: report digit if no End packet arrives within this many ms. */
+const SAFETY_TIMEOUT_MS = 200;
+
+// ---------------------------------------------------------------------------
+// DtmfDetector
+// ---------------------------------------------------------------------------
+
+/**
+ * Detects DTMF digits from RFC 2833 RTP packets and SIP INFO messages.
+ *
+ * Usage:
+ * ```
+ * const detector = new DtmfDetector(log);
+ * detector.onDigit = (d) => console.log('DTMF:', d.digit);
+ * // Feed every RTP packet (detector checks PT internally):
+ * detector.processRtp(rtpPacket);
+ * // Or feed a SIP INFO message:
+ * detector.processSipInfo(sipMsg);
+ * ```
+ */
+export class DtmfDetector {
+  /** Callback fired once per detected digit. */
+  onDigit: TDtmfCallback | null = null;
+
+  /** Negotiated telephone-event payload type (default 101). */
+  private telephoneEventPt: number;
+
+  /** Clock rate for duration calculation (default 8000 Hz). */
+  private clockRate: number;
+
+  // -- Deduplication state for RFC 2833 --
+  /** Event ID of the digit currently being received. */
+  private currentEventId: number | null = null;
+  /** RTP timestamp of the first packet for the current event. */
+  private currentEventTs: number | null = null;
+  /** Whether the current event has already been reported. */
+  private currentEventReported = false;
+  /** Latest duration value seen (in clock ticks). */
+  private currentEventDuration = 0;
+  /** Latest volume value seen (dBm0, 0 = loudest). */
+  private currentEventVolume = 0;
+  /** Safety timer: fires if no End packet arrives. */
+  private safetyTimer: ReturnType<typeof setTimeout> | null = null;
+
+  private log: (msg: string) => void;
+
+  constructor(
+    log: (msg: string) => void,
+    telephoneEventPt = 101,
+    clockRate = 8000,
+  ) {
+    this.log = log;
+    this.telephoneEventPt = telephoneEventPt;
+    this.clockRate = clockRate;
+  }
+
+  // -------------------------------------------------------------------------
+  // RFC 2833 RTP processing
+  // -------------------------------------------------------------------------
+
+  /**
+   * Feed an RTP packet. Checks PT; ignores non-DTMF packets.
+   * Expects the full RTP packet (12-byte header + payload).
+   */
+  processRtp(data: Buffer): void {
+    if (data.length < 16) return; // 12-byte header + 4-byte telephone-event payload minimum
+
+    const pt = data[1] & 0x7f;
+    if (pt !== this.telephoneEventPt) return;
+
+    // Parse RTP header fields we need.
+    const marker = (data[1] & 0x80) !== 0;
+    const rtpTimestamp = data.readUInt32BE(4);
+
+    // Parse telephone-event payload (4 bytes starting at offset 12).
+    const eventId = data[12];
+    const endBit = (data[13] & 0x80) !== 0;
+    const volume = data[13] & 0x3f;
+    const duration = data.readUInt16BE(14);
+
+    // Validate event ID.
+    if (eventId >= EVENT_CHARS.length) return;
+
+    // Detect new event: marker bit, different event ID, or different RTP timestamp.
+    const isNewEvent =
+      marker ||
+      eventId !== this.currentEventId ||
+      rtpTimestamp !== this.currentEventTs;
+
+    if (isNewEvent) {
+      // If there was an unreported previous event, report it now (fallback).
+      this.reportPendingEvent();
+
+      // Start tracking the new event.
+      this.currentEventId = eventId;
+      this.currentEventTs = rtpTimestamp;
+      this.currentEventReported = false;
+      this.currentEventDuration = duration;
+      this.currentEventVolume = volume;
+
+      // Start safety timer.
+      this.clearSafetyTimer();
+      this.safetyTimer = setTimeout(() => {
+        this.reportPendingEvent();
+      }, SAFETY_TIMEOUT_MS);
+    }
+
+    // Update duration (it increases with each retransmission).
+    if (duration > this.currentEventDuration) {
+      this.currentEventDuration = duration;
+    }
+
+    // Report on End bit (first time only).
+    if (endBit && !this.currentEventReported) {
+      this.currentEventReported = true;
+      this.clearSafetyTimer();
+
+      const digit = EVENT_CHARS[eventId];
+      const durationMs = (this.currentEventDuration / this.clockRate) * 1000;
+
+      this.log(`[dtmf] RFC 2833 digit '${digit}' (${Math.round(durationMs)}ms)`);
+      this.onDigit?.({
+        digit,
+        durationMs,
+        source: 'rfc2833',
+        timestamp: Date.now(),
+      });
+    }
+  }
+
+  /** Report a pending (unreported) event — called by safety timer or on new event start. */
+  private reportPendingEvent(): void {
+    if (
+      this.currentEventId !== null &&
+      !this.currentEventReported &&
+      this.currentEventId < EVENT_CHARS.length
+    ) {
+      this.currentEventReported = true;
+      this.clearSafetyTimer();
+
+      const digit = EVENT_CHARS[this.currentEventId];
+      const durationMs = (this.currentEventDuration / this.clockRate) * 1000;
+
+      this.log(`[dtmf] RFC 2833 digit '${digit}' (${Math.round(durationMs)}ms, safety timeout)`);
+      this.onDigit?.({
+        digit,
+        durationMs,
+        source: 'rfc2833',
+        timestamp: Date.now(),
+      });
+    }
+  }
+
+  private clearSafetyTimer(): void {
+    if (this.safetyTimer) {
+      clearTimeout(this.safetyTimer);
+      this.safetyTimer = null;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // SIP INFO processing
+  // -------------------------------------------------------------------------
+
+  /**
+   * Parse a SIP INFO message carrying DTMF.
+   * Supports Content-Type: application/dtmf-relay (Signal=X / Duration=Y).
+   */
+  processSipInfo(msg: SipMessage): void {
+    const ct = (msg.getHeader('Content-Type') || '').toLowerCase();
+    if (!ct.includes('application/dtmf-relay') && !ct.includes('application/dtmf')) return;
+
+    const body = msg.body || '';
+
+    if (ct.includes('application/dtmf-relay')) {
+      // Format: "Signal= 5\r\nDuration= 160\r\n"
+      const signalMatch = body.match(/Signal\s*=\s*(\S+)/i);
+      const durationMatch = body.match(/Duration\s*=\s*(\d+)/i);
+      if (!signalMatch) return;
+
+      const signal = signalMatch[1];
+      const durationTicks = durationMatch ? parseInt(durationMatch[1], 10) : 160;
+
+      // Validate digit.
+      if (signal.length !== 1 || !/[0-9*#A-Da-d]/.test(signal)) return;
+      const digit = signal.toUpperCase();
+      const durationMs = (durationTicks / this.clockRate) * 1000;
+
+      this.log(`[dtmf] SIP INFO digit '${digit}' (${Math.round(durationMs)}ms)`);
+      this.onDigit?.({
+        digit,
+        durationMs,
+        source: 'sip-info',
+        timestamp: Date.now(),
+      });
+    } else if (ct.includes('application/dtmf')) {
+      // Simple format: just the digit character in the body.
+      const digit = body.trim().toUpperCase();
+      if (digit.length !== 1 || !/[0-9*#A-D]/.test(digit)) return;
+
+      this.log(`[dtmf] SIP INFO digit '${digit}' (application/dtmf)`);
+      this.onDigit?.({
+        digit,
+        durationMs: 250, // default duration
+        source: 'sip-info',
+        timestamp: Date.now(),
+      });
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+
+  /** Reset detection state (e.g., between calls). */
+  reset(): void {
+    this.currentEventId = null;
+    this.currentEventTs = null;
+    this.currentEventReported = false;
+    this.currentEventDuration = 0;
+    this.currentEventVolume = 0;
+    this.clearSafetyTimer();
+  }
+
+  /** Clean up timers and references. */
+  destroy(): void {
+    this.clearSafetyTimer();
+    this.onDigit = null;
+  }
+}

ts/call/prompt-cache.ts

@@ -0,0 +1,404 @@
+/**
+ * PromptCache — manages multiple named audio prompts for IVR and voicemail.
+ *
+ * Each prompt is pre-encoded as both G.722 frames (for SIP legs) and Opus
+ * frames (for WebRTC legs), ready for 20ms RTP playback.
+ *
+ * Supports three sources:
+ * 1. TTS generation via espeak-ng (primary) or Kokoro (fallback)
+ * 2. Loading from a pre-existing WAV file
+ * 3. Programmatic tone generation (beep, etc.)
+ *
+ * The existing announcement.ts system continues to work independently;
+ * this module provides generalized prompt management for IVR/voicemail.
+ */
+
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { Buffer } from 'node:buffer';
+import { buildRtpHeader, rtpClockIncrement } from './leg.ts';
+import { encodePcm, isCodecReady } from '../opusbridge.ts';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** A pre-encoded prompt ready for RTP playback. */
+export interface ICachedPrompt {
+  /** Unique prompt identifier. */
+  id: string;
+  /** G.722 encoded frames (20ms each, no RTP header). */
+  g722Frames: Buffer[];
+  /** Opus encoded frames (20ms each, no RTP header). */
+  opusFrames: Buffer[];
+  /** Total duration in milliseconds. */
+  durationMs: number;
+}
+
+// ---------------------------------------------------------------------------
+// TTS helpers
+// ---------------------------------------------------------------------------
+
+const TTS_DIR = path.join(process.cwd(), '.nogit', 'tts');
+
+/** Check if espeak-ng is available. */
+function isEspeakAvailable(): boolean {
+  try {
+    execSync('which espeak-ng', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Generate WAV via espeak-ng. */
+function generateViaEspeak(wavPath: string, text: string): boolean {
+  try {
+    execSync(
+      `espeak-ng -v en-us -s 150 -w "${wavPath}" "${text}"`,
+      { timeout: 10000, stdio: 'pipe' },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Generate WAV via Kokoro TTS. */
+function generateViaKokoro(wavPath: string, text: string, voice: string): boolean {
+  const modelPath = path.join(TTS_DIR, 'kokoro-v1.0.onnx');
+  const voicesPath = path.join(TTS_DIR, 'voices.bin');
+  if (!fs.existsSync(modelPath) || !fs.existsSync(voicesPath)) return false;
+
+  const root = process.cwd();
+  const ttsBin = [
+    path.join(root, 'dist_rust', 'tts-engine'),
+    path.join(root, 'rust', 'target', 'release', 'tts-engine'),
+    path.join(root, 'rust', 'target', 'debug', 'tts-engine'),
+  ].find((p) => fs.existsSync(p));
+  if (!ttsBin) return false;
+
+  try {
+    execSync(
+      `"${ttsBin}" --model "${modelPath}" --voices "${voicesPath}" --voice "${voice}" --output "${wavPath}" --text "${text}"`,
+      { timeout: 120000, stdio: 'pipe' },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Read a WAV file and return raw PCM + sample rate. */
+function readWavWithRate(wavPath: string): { pcm: Buffer; sampleRate: number } | null {
+  const wav = fs.readFileSync(wavPath);
+  if (wav.length < 44) return null;
+  if (wav.toString('ascii', 0, 4) !== 'RIFF') return null;
+  if (wav.toString('ascii', 8, 12) !== 'WAVE') return null;
+
+  let sampleRate = 22050;
+  let pcm: Buffer | null = null;
+  let offset = 12;
+
+  while (offset < wav.length - 8) {
+    const chunkId = wav.toString('ascii', offset, offset + 4);
+    const chunkSize = wav.readUInt32LE(offset + 4);
+    if (chunkId === 'fmt ') {
+      sampleRate = wav.readUInt32LE(offset + 12);
+    }
+    if (chunkId === 'data') {
+      pcm = wav.subarray(offset + 8, offset + 8 + chunkSize);
+    }
+    offset += 8 + chunkSize;
+    if (offset % 2 !== 0) offset++;
+  }
+
+  return pcm ? { pcm, sampleRate } : null;
+}
+
+/** Encode raw PCM frames to G.722 + Opus. */
+async function encodePcmFrames(
+  pcm: Buffer,
+  sampleRate: number,
+  log: (msg: string) => void,
+): Promise<{ g722Frames: Buffer[]; opusFrames: Buffer[] } | null> {
+  if (!isCodecReady()) return null;
+
+  const frameSamples = Math.floor(sampleRate * 0.02); // 20ms
+  const frameBytes = frameSamples * 2; // 16-bit
+  const totalFrames = Math.floor(pcm.length / frameBytes);
+
+  const g722Frames: Buffer[] = [];
+  const opusFrames: Buffer[] = [];
+
+  for (let i = 0; i < totalFrames; i++) {
+    const framePcm = Buffer.from(pcm.subarray(i * frameBytes, (i + 1) * frameBytes));
+    const [g722, opus] = await Promise.all([
+      encodePcm(framePcm, sampleRate, 9),   // G.722
+      encodePcm(framePcm, sampleRate, 111),  // Opus
+    ]);
+    if (g722) g722Frames.push(g722);
+    if (opus) opusFrames.push(opus);
+  }
+
+  return { g722Frames, opusFrames };
+}
+
+// ---------------------------------------------------------------------------
+// PromptCache
+// ---------------------------------------------------------------------------
+
+export class PromptCache {
+  private prompts = new Map<string, ICachedPrompt>();
+  private log: (msg: string) => void;
+  private espeakAvailable: boolean | null = null;
+
+  constructor(log: (msg: string) => void) {
+    this.log = log;
+  }
+
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+
+  /** Get a cached prompt by ID. */
+  get(id: string): ICachedPrompt | null {
+    return this.prompts.get(id) ?? null;
+  }
+
+  /** Check if a prompt is cached. */
+  has(id: string): boolean {
+    return this.prompts.has(id);
+  }
+
+  /** List all cached prompt IDs. */
+  listIds(): string[] {
+    return [...this.prompts.keys()];
+  }
+
+  /**
+   * Generate a TTS prompt and cache it.
+   * Uses espeak-ng (primary) or Kokoro (fallback).
+   */
+  async generatePrompt(id: string, text: string, voice = 'af_bella'): Promise<ICachedPrompt | null> {
+    fs.mkdirSync(TTS_DIR, { recursive: true });
+    const wavPath = path.join(TTS_DIR, `prompt-${id}.wav`);
+
+    // Check espeak availability once.
+    if (this.espeakAvailable === null) {
+      this.espeakAvailable = isEspeakAvailable();
+    }
+
+    // Generate WAV.
+    let generated = false;
+    if (!fs.existsSync(wavPath)) {
+      if (this.espeakAvailable) {
+        generated = generateViaEspeak(wavPath, text);
+      }
+      if (!generated) {
+        generated = generateViaKokoro(wavPath, text, voice);
+      }
+      if (!generated) {
+        this.log(`[prompt-cache] failed to generate TTS for "${id}"`);
+        return null;
+      }
+      this.log(`[prompt-cache] generated WAV for "${id}"`);
+    }
+
+    return this.loadWavPrompt(id, wavPath);
+  }
+
+  /**
+   * Load a WAV file as a prompt and cache it.
+   */
+  async loadWavPrompt(id: string, wavPath: string): Promise<ICachedPrompt | null> {
+    if (!fs.existsSync(wavPath)) {
+      this.log(`[prompt-cache] WAV not found: ${wavPath}`);
+      return null;
+    }
+
+    const result = readWavWithRate(wavPath);
+    if (!result) {
+      this.log(`[prompt-cache] failed to parse WAV: ${wavPath}`);
+      return null;
+    }
+
+    const encoded = await encodePcmFrames(result.pcm, result.sampleRate, this.log);
+    if (!encoded) {
+      this.log(`[prompt-cache] encoding failed for "${id}" (codec bridge not ready?)`);
+      return null;
+    }
+
+    const durationMs = encoded.g722Frames.length * 20;
+    const prompt: ICachedPrompt = {
+      id,
+      g722Frames: encoded.g722Frames,
+      opusFrames: encoded.opusFrames,
+      durationMs,
+    };
+
+    this.prompts.set(id, prompt);
+    this.log(`[prompt-cache] cached "${id}": ${encoded.g722Frames.length} frames (${(durationMs / 1000).toFixed(1)}s)`);
+    return prompt;
+  }
+
+  /**
+   * Generate a beep tone prompt (sine wave).
+   * @param id - prompt ID
+   * @param freqHz - tone frequency (default 1000 Hz)
+   * @param durationMs - tone duration (default 500ms)
+   * @param amplitude - 16-bit amplitude (default 8000)
+   */
+  async generateBeep(
+    id: string,
+    freqHz = 1000,
+    durationMs = 500,
+    amplitude = 8000,
+  ): Promise<ICachedPrompt | null> {
+    // Generate at 16kHz for decent quality.
+    const sampleRate = 16000;
+    const totalSamples = Math.floor((sampleRate * durationMs) / 1000);
+    const pcm = Buffer.alloc(totalSamples * 2);
+
+    for (let i = 0; i < totalSamples; i++) {
+      const t = i / sampleRate;
+      // Apply a short fade-in/fade-out to avoid click artifacts.
+      const fadeLen = Math.floor(sampleRate * 0.01); // 10ms fade
+      let envelope = 1.0;
+      if (i < fadeLen) envelope = i / fadeLen;
+      else if (i > totalSamples - fadeLen) envelope = (totalSamples - i) / fadeLen;
+
+      const sample = Math.round(Math.sin(2 * Math.PI * freqHz * t) * amplitude * envelope);
+      pcm.writeInt16LE(Math.max(-32768, Math.min(32767, sample)), i * 2);
+    }
+
+    const encoded = await encodePcmFrames(pcm, sampleRate, this.log);
+    if (!encoded) {
+      this.log(`[prompt-cache] beep encoding failed for "${id}"`);
+      return null;
+    }
+
+    const actualDuration = encoded.g722Frames.length * 20;
+    const prompt: ICachedPrompt = {
+      id,
+      g722Frames: encoded.g722Frames,
+      opusFrames: encoded.opusFrames,
+      durationMs: actualDuration,
+    };
+
+    this.prompts.set(id, prompt);
+    this.log(`[prompt-cache] beep "${id}" cached: ${actualDuration}ms @ ${freqHz}Hz`);
+    return prompt;
+  }
+
+  /**
+   * Remove a prompt from the cache.
+   */
+  remove(id: string): void {
+    this.prompts.delete(id);
+  }
+
+  /**
+   * Clear all cached prompts.
+   */
+  clear(): void {
+    this.prompts.clear();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Standalone playback helpers (for use by SystemLeg)
+// ---------------------------------------------------------------------------
+
+/**
+ * Play a cached prompt's G.722 frames as RTP packets at 20ms intervals.
+ *
+ * @param prompt - the cached prompt to play
+ * @param sendPacket - function to send a raw RTP packet (12-byte header + payload)
+ * @param ssrc - SSRC for RTP headers
+ * @param onDone - called when playback finishes
+ * @returns cancel function, or null if prompt has no G.722 frames
+ */
+export function playPromptG722(
+  prompt: ICachedPrompt,
+  sendPacket: (pkt: Buffer) => void,
+  ssrc: number,
+  onDone?: () => void,
+): (() => void) | null {
+  if (prompt.g722Frames.length === 0) {
+    onDone?.();
+    return null;
+  }
+
+  const frames = prompt.g722Frames;
+  const PT = 9;
+  let frameIdx = 0;
+  let seq = Math.floor(Math.random() * 0xffff);
+  let rtpTs = Math.floor(Math.random() * 0xffffffff);
+
+  const timer = setInterval(() => {
+    if (frameIdx >= frames.length) {
+      clearInterval(timer);
+      onDone?.();
+      return;
+    }
+
+    const payload = frames[frameIdx];
+    const hdr = buildRtpHeader(PT, seq & 0xffff, rtpTs >>> 0, ssrc >>> 0, frameIdx === 0);
+    const pkt = Buffer.concat([hdr, payload]);
+    sendPacket(pkt);
+
+    seq++;
+    rtpTs += rtpClockIncrement(PT);
+    frameIdx++;
+  }, 20);
+
+  return () => clearInterval(timer);
+}
+
+/**
+ * Play a cached prompt's Opus frames as RTP packets at 20ms intervals.
+ *
+ * @param prompt - the cached prompt to play
+ * @param sendPacket - function to send a raw RTP packet
+ * @param ssrc - SSRC for RTP headers
+ * @param counters - shared seq/ts counters (mutated in place for seamless transitions)
+ * @param onDone - called when playback finishes
+ * @returns cancel function, or null if prompt has no Opus frames
+ */
+export function playPromptOpus(
+  prompt: ICachedPrompt,
+  sendPacket: (pkt: Buffer) => void,
+  ssrc: number,
+  counters: { seq: number; ts: number },
+  onDone?: () => void,
+): (() => void) | null {
+  if (prompt.opusFrames.length === 0) {
+    onDone?.();
+    return null;
+  }
+
+  const frames = prompt.opusFrames;
+  const PT = 111;
+  let frameIdx = 0;
+
+  const timer = setInterval(() => {
+    if (frameIdx >= frames.length) {
+      clearInterval(timer);
+      onDone?.();
+      return;
+    }
+
+    const payload = frames[frameIdx];
+    const hdr = buildRtpHeader(PT, counters.seq & 0xffff, counters.ts >>> 0, ssrc >>> 0, frameIdx === 0);
+    const pkt = Buffer.concat([hdr, payload]);
+    sendPacket(pkt);
+
+    counters.seq++;
+    counters.ts += 960; // Opus 48kHz: 960 samples per 20ms
+    frameIdx++;
+  }, 20);
+
+  return () => clearInterval(timer);
+}

ts/call/sip-leg.ts

@@ -122,6 +122,9 @@ export class SipLeg implements ILeg {
   onConnected: ((leg: SipLeg) => void) | null = null;
   onTerminated: ((leg: SipLeg) => void) | null = null;
 
+  /** Callback for SIP INFO messages (used for DTMF relay). */
+  onInfoReceived: ((msg: SipMessage) => void) | null = null;
+
   constructor(id: string, config: ISipLegConfig) {
     this.id = id;
     this.type = config.role === 'device' ? 'sip-device' : 'sip-provider';
@@ -464,7 +467,15 @@ export class SipLeg implements ILeg {
       this.onTerminated?.(this);
       this.onStateChange?.(this);
     }
-    // Other in-dialog requests (re-INVITE, INFO, etc.) can be handled here in the future.
+    if (method === 'INFO') {
+      // Respond 200 OK to the INFO request.
+      const ok = SipMessage.createResponse(200, 'OK', msg);
+      this.config.sendSip(ok.serialize(), { address: rinfo.address, port: rinfo.port });
+
+      // Forward to DTMF handler (if attached).
+      this.onInfoReceived?.(msg);
+    }
+    // Other in-dialog requests (re-INVITE, etc.) can be handled here in the future.
   }
 
   // -------------------------------------------------------------------------

ts/call/system-leg.ts

@@ -0,0 +1,336 @@
+/**
+ * SystemLeg — virtual ILeg for IVR menus and voicemail.
+ *
+ * Plugs into the Call hub exactly like SipLeg or WebRtcLeg:
+ * - Receives caller audio via sendRtp() (called by Call.forwardRtp)
+ * - Plays prompts by firing onRtpReceived (picked up by Call.forwardRtp → caller's leg)
+ * - Detects DTMF from caller's audio (RFC 2833 telephone-event)
+ * - Records caller's audio to WAV files (for voicemail)
+ *
+ * No UDP socket or SIP dialog needed — purely virtual.
+ */
+
+import { Buffer } from 'node:buffer';
+import type dgram from 'node:dgram';
+import type { IEndpoint } from '../sip/index.ts';
+import type { SipMessage } from '../sip/index.ts';
+import type { SipDialog } from '../sip/index.ts';
+import type { IRtpTranscoder } from '../codec.ts';
+import type { ILeg } from './leg.ts';
+import type { TLegState, TLegType, ILegStatus } from './types.ts';
+import { DtmfDetector } from './dtmf-detector.ts';
+import type { IDtmfDigit } from './dtmf-detector.ts';
+import { AudioRecorder } from './audio-recorder.ts';
+import type { IRecordingResult } from './audio-recorder.ts';
+import { PromptCache, playPromptG722, playPromptOpus } from './prompt-cache.ts';
+import type { ICachedPrompt } from './prompt-cache.ts';
+import { buildRtpHeader, rtpClockIncrement } from './leg.ts';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type TSystemLegMode = 'ivr' | 'voicemail-greeting' | 'voicemail-recording' | 'idle';
+
+export interface ISystemLegConfig {
+  /** Logging function. */
+  log: (msg: string) => void;
+  /** The prompt cache for TTS playback. */
+  promptCache: PromptCache;
+  /**
+   * Codec payload type used by the caller's leg.
+   * Determines whether G.722 (9) or Opus (111) frames are played.
+   * Default: 9 (G.722, typical for SIP callers).
+   */
+  callerCodecPt?: number;
+  /** Called when a DTMF digit is detected. */
+  onDtmfDigit?: (digit: IDtmfDigit) => void;
+  /** Called when a voicemail recording is complete. */
+  onRecordingComplete?: (result: IRecordingResult) => void;
+  /** Called when the SystemLeg wants to signal an IVR action. */
+  onAction?: (action: string, data?: any) => void;
+}
+
+// ---------------------------------------------------------------------------
+// SystemLeg
+// ---------------------------------------------------------------------------
+
+export class SystemLeg implements ILeg {
+  readonly id: string;
+  readonly type: TLegType = 'system';
+  state: TLegState = 'connected'; // Immediately "connected" — no setup phase.
+
+  /** Current operating mode. */
+  mode: TSystemLegMode = 'idle';
+
+  // --- ILeg required fields (virtual — no real network resources) ---
+  readonly sipCallId: string;
+  readonly rtpPort: number | null = null;
+  readonly rtpSock: dgram.Socket | null = null;
+  remoteMedia: IEndpoint | null = null;
+  codec: number | null = null;
+  transcoder: IRtpTranscoder | null = null;
+  pktSent = 0;
+  pktReceived = 0;
+  readonly dialog: SipDialog | null = null;
+
+  /**
+   * Set by Call.addLeg() — firing this injects audio into the Call hub,
+   * which forwards it to the caller's leg.
+   */
+  onRtpReceived: ((data: Buffer) => void) | null = null;
+
+  // --- Internal components ---
+  private dtmfDetector: DtmfDetector;
+  private recorder: AudioRecorder | null = null;
+  private promptCache: PromptCache;
+  private promptCancel: (() => void) | null = null;
+  private callerCodecPt: number;
+  private log: (msg: string) => void;
+  readonly config: ISystemLegConfig;
+
+  /** Stable SSRC for all prompt playback (random, stays constant for the leg's lifetime). */
+  private ssrc: number;
+
+  /** Sequence/timestamp counters for Opus prompt playback (shared for seamless transitions). */
+  private opusCounters = { seq: 0, ts: 0 };
+
+  constructor(id: string, config: ISystemLegConfig) {
+    this.id = id;
+    this.sipCallId = `system-${id}`; // Virtual Call-ID — not a real SIP dialog.
+    this.config = config;
+    this.log = config.log;
+    this.promptCache = config.promptCache;
+    this.callerCodecPt = config.callerCodecPt ?? 9; // Default G.722
+
+    this.ssrc = (Math.random() * 0xffffffff) >>> 0;
+    this.opusCounters.seq = Math.floor(Math.random() * 0xffff);
+    this.opusCounters.ts = Math.floor(Math.random() * 0xffffffff);
+
+    // Initialize DTMF detector.
+    this.dtmfDetector = new DtmfDetector(this.log);
+    this.dtmfDetector.onDigit = (digit) => {
+      this.log(`[system-leg:${this.id}] DTMF '${digit.digit}' (${digit.source})`);
+      this.config.onDtmfDigit?.(digit);
+    };
+  }
+
+  // -------------------------------------------------------------------------
+  // ILeg: sendRtp — receives caller's audio from the Call hub
+  // -------------------------------------------------------------------------
+
+  /**
+   * Called by the Call hub (via forwardRtp) to deliver the caller's audio
+   * to this leg. We use this for DTMF detection and recording.
+   */
+  sendRtp(data: Buffer): void {
+    this.pktReceived++;
+
+    // Feed DTMF detector (it checks PT internally, ignores non-101 packets).
+    this.dtmfDetector.processRtp(data);
+
+    // Feed recorder if active.
+    if (this.mode === 'voicemail-recording' && this.recorder) {
+      this.recorder.processRtp(data);
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // ILeg: handleSipMessage — handles SIP INFO for DTMF
+  // -------------------------------------------------------------------------
+
+  /**
+   * Handle a SIP message routed to this leg. Only SIP INFO (DTMF) is relevant.
+   */
+  handleSipMessage(msg: SipMessage, _rinfo: IEndpoint): void {
+    if (msg.method === 'INFO') {
+      this.dtmfDetector.processSipInfo(msg);
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Prompt playback
+  // -------------------------------------------------------------------------
+
+  /**
+   * Play a cached prompt by ID.
+   * The audio is injected into the Call hub via onRtpReceived.
+   *
+   * @param promptId - ID of the prompt in the PromptCache
+   * @param onDone - called when playback completes (not on cancel)
+   * @returns true if playback started, false if prompt not found
+   */
+  playPrompt(promptId: string, onDone?: () => void): boolean {
+    const prompt = this.promptCache.get(promptId);
+    if (!prompt) {
+      this.log(`[system-leg:${this.id}] prompt "${promptId}" not found`);
+      onDone?.();
+      return false;
+    }
+
+    // Cancel any in-progress playback.
+    this.cancelPrompt();
+
+    this.log(`[system-leg:${this.id}] playing prompt "${promptId}" (${prompt.durationMs}ms)`);
+
+    // Select G.722 or Opus frames based on caller codec.
+    if (this.callerCodecPt === 111) {
+      // WebRTC caller: play Opus frames.
+      this.promptCancel = playPromptOpus(
+        prompt,
+        (pkt) => this.injectPacket(pkt),
+        this.ssrc,
+        this.opusCounters,
+        () => {
+          this.promptCancel = null;
+          onDone?.();
+        },
+      );
+    } else {
+      // SIP caller: play G.722 frames (works for all SIP codecs since the
+      // SipLeg's RTP socket sends whatever we give it — the provider's
+      // media endpoint accepts the codec negotiated in the SDP).
+      this.promptCancel = playPromptG722(
+        prompt,
+        (pkt) => this.injectPacket(pkt),
+        this.ssrc,
+        () => {
+          this.promptCancel = null;
+          onDone?.();
+        },
+      );
+    }
+
+    return this.promptCancel !== null;
+  }
+
+  /**
+   * Play a sequence of prompts, one after another.
+   */
+  playPromptSequence(promptIds: string[], onDone?: () => void): void {
+    let index = 0;
+    const playNext = () => {
+      if (index >= promptIds.length) {
+        onDone?.();
+        return;
+      }
+      const id = promptIds[index++];
+      if (!this.playPrompt(id, playNext)) {
+        // Prompt not found — skip and play next.
+        playNext();
+      }
+    };
+    playNext();
+  }
+
+  /** Cancel any in-progress prompt playback. */
+  cancelPrompt(): void {
+    if (this.promptCancel) {
+      this.promptCancel();
+      this.promptCancel = null;
+    }
+  }
+
+  /** Whether a prompt is currently playing. */
+  get isPlaying(): boolean {
+    return this.promptCancel !== null;
+  }
+
+  /**
+   * Inject an RTP packet into the Call hub.
+   * This simulates "receiving" audio on this leg — the hub
+   * will forward it to the caller's leg.
+   */
+  private injectPacket(pkt: Buffer): void {
+    this.pktSent++;
+    this.onRtpReceived?.(pkt);
+  }
+
+  // -------------------------------------------------------------------------
+  // Recording
+  // -------------------------------------------------------------------------
+
+  /**
+   * Start recording the caller's audio.
+   * @param outputDir - directory to write the WAV file
+   * @param fileId - unique ID for the file name
+   */
+  async startRecording(outputDir: string, fileId?: string): Promise<void> {
+    if (this.recorder) {
+      await this.recorder.stop();
+    }
+
+    this.recorder = new AudioRecorder({
+      outputDir,
+      log: this.log,
+      maxDurationSec: 120,
+      silenceTimeoutSec: 5,
+    });
+
+    this.recorder.onStopped = (result) => {
+      this.log(`[system-leg:${this.id}] recording auto-stopped (${result.stopReason})`);
+      this.config.onRecordingComplete?.(result);
+    };
+
+    this.mode = 'voicemail-recording';
+    await this.recorder.start(fileId);
+  }
+
+  /**
+   * Stop recording and finalize the WAV file.
+   */
+  async stopRecording(): Promise<IRecordingResult | null> {
+    if (!this.recorder) return null;
+
+    const result = await this.recorder.stop();
+    this.recorder = null;
+    return result;
+  }
+
+  /** Cancel recording — stops and deletes the file. */
+  async cancelRecording(): Promise<void> {
+    if (this.recorder) {
+      await this.recorder.cancel();
+      this.recorder = null;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+
+  /** Release all resources. */
+  teardown(): void {
+    this.cancelPrompt();
+
+    // Stop recording gracefully.
+    if (this.recorder && this.recorder.state === 'recording') {
+      this.recorder.stop().then((result) => {
+        this.config.onRecordingComplete?.(result);
+      });
+      this.recorder = null;
+    }
+
+    this.dtmfDetector.destroy();
+    this.state = 'terminated';
+    this.mode = 'idle';
+    this.onRtpReceived = null;
+
+    this.log(`[system-leg:${this.id}] torn down`);
+  }
+
+  /** Status snapshot for the dashboard. */
+  getStatus(): ILegStatus {
+    return {
+      id: this.id,
+      type: this.type,
+      state: this.state,
+      remoteMedia: null,
+      rtpPort: null,
+      pktSent: this.pktSent,
+      pktReceived: this.pktReceived,
+      codec: this.callerCodecPt === 111 ? 'Opus' : 'G.722',
+      transcoding: false,
+    };
+  }
+}

ts/call/types.ts

@@ -13,6 +13,8 @@ export type TCallState =
   | 'ringing'
   | 'connected'
   | 'on-hold'
+  | 'voicemail'
+  | 'ivr'
   | 'transferring'
   | 'terminating'
   | 'terminated';
@@ -25,7 +27,7 @@ export type TLegState =
   | 'terminating'
   | 'terminated';
 
-export type TLegType = 'sip-device' | 'sip-provider' | 'webrtc';
+export type TLegType = 'sip-device' | 'sip-provider' | 'webrtc' | 'system';
 
 export type TCallDirection = 'inbound' | 'outbound' | 'internal';
 

ts/call/wav-writer.ts

@@ -0,0 +1,163 @@
+/**
+ * Streaming WAV file writer — opens a file, writes a placeholder header,
+ * appends raw PCM data in chunks, and finalizes (patches sizes) on close.
+ *
+ * Produces standard RIFF/WAVE format compatible with the WAV parser
+ * in announcement.ts (extractPcmFromWav).
+ */
+
+import fs from 'node:fs';
+import { Buffer } from 'node:buffer';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface IWavWriterOptions {
+  /** Full path to the output WAV file. */
+  filePath: string;
+  /** Sample rate in Hz (e.g. 16000). */
+  sampleRate: number;
+  /** Number of channels (default 1 = mono). */
+  channels?: number;
+  /** Bits per sample (default 16). */
+  bitsPerSample?: number;
+}
+
+export interface IWavWriterResult {
+  /** Full path to the WAV file. */
+  filePath: string;
+  /** Total duration in milliseconds. */
+  durationMs: number;
+  /** Sample rate of the output file. */
+  sampleRate: number;
+  /** Total number of audio samples written. */
+  totalSamples: number;
+  /** File size in bytes. */
+  fileSize: number;
+}
+
+// ---------------------------------------------------------------------------
+// WAV header constants
+// ---------------------------------------------------------------------------
+
+/** Standard WAV header size: RIFF(12) + fmt(24) + data-header(8) = 44 bytes. */
+const HEADER_SIZE = 44;
+
+// ---------------------------------------------------------------------------
+// WavWriter
+// ---------------------------------------------------------------------------
+
+export class WavWriter {
+  private fd: number | null = null;
+  private totalDataBytes = 0;
+  private closed = false;
+
+  private filePath: string;
+  private sampleRate: number;
+  private channels: number;
+  private bitsPerSample: number;
+
+  constructor(options: IWavWriterOptions) {
+    this.filePath = options.filePath;
+    this.sampleRate = options.sampleRate;
+    this.channels = options.channels ?? 1;
+    this.bitsPerSample = options.bitsPerSample ?? 16;
+  }
+
+  /** Open the file and write a placeholder 44-byte WAV header. */
+  open(): void {
+    if (this.fd !== null) throw new Error('WavWriter already open');
+
+    this.fd = fs.openSync(this.filePath, 'w');
+    this.totalDataBytes = 0;
+    this.closed = false;
+
+    // Write 44 bytes of zeros as placeholder — patched in close().
+    const placeholder = Buffer.alloc(HEADER_SIZE);
+    fs.writeSync(this.fd, placeholder, 0, HEADER_SIZE, 0);
+  }
+
+  /** Append raw 16-bit little-endian PCM samples. */
+  write(pcm: Buffer): void {
+    if (this.fd === null || this.closed) return;
+    if (pcm.length === 0) return;
+
+    fs.writeSync(this.fd, pcm, 0, pcm.length);
+    this.totalDataBytes += pcm.length;
+  }
+
+  /**
+   * Finalize: rewrite the RIFF and data chunk sizes in the header, close the file.
+   * Returns metadata about the written WAV.
+   */
+  close(): IWavWriterResult {
+    if (this.fd === null || this.closed) {
+      return {
+        filePath: this.filePath,
+        durationMs: 0,
+        sampleRate: this.sampleRate,
+        totalSamples: 0,
+        fileSize: HEADER_SIZE,
+      };
+    }
+
+    this.closed = true;
+
+    const blockAlign = this.channels * (this.bitsPerSample / 8);
+    const byteRate = this.sampleRate * blockAlign;
+    const fileSize = HEADER_SIZE + this.totalDataBytes;
+
+    // Build the complete 44-byte header.
+    const hdr = Buffer.alloc(HEADER_SIZE);
+    let offset = 0;
+
+    // RIFF chunk descriptor.
+    hdr.write('RIFF', offset); offset += 4;
+    hdr.writeUInt32LE(fileSize - 8, offset); offset += 4; // ChunkSize = fileSize - 8
+    hdr.write('WAVE', offset); offset += 4;
+
+    // fmt sub-chunk.
+    hdr.write('fmt ', offset); offset += 4;
+    hdr.writeUInt32LE(16, offset); offset += 4;           // Subchunk1Size (PCM = 16)
+    hdr.writeUInt16LE(1, offset); offset += 2;            // AudioFormat (1 = PCM)
+    hdr.writeUInt16LE(this.channels, offset); offset += 2;
+    hdr.writeUInt32LE(this.sampleRate, offset); offset += 4;
+    hdr.writeUInt32LE(byteRate, offset); offset += 4;
+    hdr.writeUInt16LE(blockAlign, offset); offset += 2;
+    hdr.writeUInt16LE(this.bitsPerSample, offset); offset += 2;
+
+    // data sub-chunk.
+    hdr.write('data', offset); offset += 4;
+    hdr.writeUInt32LE(this.totalDataBytes, offset); offset += 4;
+
+    // Patch the header at the beginning of the file.
+    fs.writeSync(this.fd, hdr, 0, HEADER_SIZE, 0);
+    fs.closeSync(this.fd);
+    this.fd = null;
+
+    const bytesPerSample = this.bitsPerSample / 8;
+    const totalSamples = Math.floor(this.totalDataBytes / (bytesPerSample * this.channels));
+    const durationMs = (totalSamples / this.sampleRate) * 1000;
+
+    return {
+      filePath: this.filePath,
+      durationMs: Math.round(durationMs),
+      sampleRate: this.sampleRate,
+      totalSamples,
+      fileSize,
+    };
+  }
+
+  /** Current recording duration in milliseconds. */
+  get durationMs(): number {
+    const bytesPerSample = this.bitsPerSample / 8;
+    const totalSamples = Math.floor(this.totalDataBytes / (bytesPerSample * this.channels));
+    return (totalSamples / this.sampleRate) * 1000;
+  }
+
+  /** Whether the writer is still open and accepting data. */
+  get isOpen(): boolean {
+    return this.fd !== null && !this.closed;
+  }
+}

ts/config.ts

@@ -78,6 +78,17 @@ export interface ISipRouteAction {
   /** Also ring connected browser clients. Default false. */
   ringBrowsers?: boolean;
 
+  // --- Inbound actions (IVR / voicemail) ---
+
+  /** Route directly to a voicemail box (skip ringing devices). */
+  voicemailBox?: string;
+
+  /** Route to an IVR menu by menu ID (skip ringing devices). */
+  ivrMenuId?: string;
+
+  /** Override no-answer timeout (seconds) before routing to voicemail. */
+  noAnswerTimeout?: number;
+
   // --- Outbound actions (provider selection) ---
 
   /** Provider ID to use for outbound. */
@@ -137,12 +148,95 @@ export interface IContact {
   starred?: boolean;
 }
 
+// ---------------------------------------------------------------------------
+// Voicebox configuration
+// ---------------------------------------------------------------------------
+
+export interface IVoiceboxConfig {
+  /** Unique ID — typically matches device ID or extension. */
+  id: string;
+  /** Whether this voicebox is active. */
+  enabled: boolean;
+  /** Custom TTS greeting text. */
+  greetingText?: string;
+  /** TTS voice ID (default 'af_bella'). */
+  greetingVoice?: string;
+  /** Path to uploaded WAV greeting (overrides TTS). */
+  greetingWavPath?: string;
+  /** Seconds to wait before routing to voicemail (default 25). */
+  noAnswerTimeoutSec?: number;
+  /** Maximum recording duration in seconds (default 120). */
+  maxRecordingSec?: number;
+  /** Maximum stored messages per box (default 50). */
+  maxMessages?: number;
+}
+
+// ---------------------------------------------------------------------------
+// IVR configuration
+// ---------------------------------------------------------------------------
+
+/** An action triggered by a digit press in an IVR menu. */
+export type TIvrAction =
+  | { type: 'route-extension'; extensionId: string }
+  | { type: 'route-voicemail'; boxId: string }
+  | { type: 'submenu'; menuId: string }
+  | { type: 'play-message'; promptId: string }
+  | { type: 'transfer'; number: string; providerId?: string }
+  | { type: 'repeat' }
+  | { type: 'hangup' };
+
+/** A single digit→action mapping in an IVR menu. */
+export interface IIvrMenuEntry {
+  /** Digit: '0'-'9', '*', '#'. */
+  digit: string;
+  /** Action to take when this digit is pressed. */
+  action: TIvrAction;
+}
+
+/** An IVR menu with a prompt and digit mappings. */
+export interface IIvrMenu {
+  /** Unique menu ID. */
+  id: string;
+  /** Human-readable name. */
+  name: string;
+  /** TTS text for the menu prompt. */
+  promptText: string;
+  /** TTS voice ID for the prompt. */
+  promptVoice?: string;
+  /** Digit→action entries. */
+  entries: IIvrMenuEntry[];
+  /** Seconds to wait for a digit after prompt finishes (default 5). */
+  timeoutSec?: number;
+  /** Maximum retries before executing timeout action (default 3). */
+  maxRetries?: number;
+  /** Action on timeout (no digit pressed). */
+  timeoutAction: TIvrAction;
+  /** Action on invalid digit. */
+  invalidAction: TIvrAction;
+}
+
+/** Top-level IVR configuration. */
+export interface IIvrConfig {
+  /** Whether the IVR system is active. */
+  enabled: boolean;
+  /** IVR menu definitions. */
+  menus: IIvrMenu[];
+  /** The menu to start with for incoming calls. */
+  entryMenuId: string;
+}
+
+// ---------------------------------------------------------------------------
+// App config
+// ---------------------------------------------------------------------------
+
 export interface IAppConfig {
   proxy: IProxyConfig;
   providers: IProviderConfig[];
   devices: IDeviceConfig[];
   routing: IRoutingConfig;
   contacts: IContact[];
+  voiceboxes?: IVoiceboxConfig[];
+  ivr?: IIvrConfig;
 }
 
 // ---------------------------------------------------------------------------
@@ -201,6 +295,27 @@ export function loadConfig(): IAppConfig {
     c.starred ??= false;
   }
 
+  // Voicebox defaults.
+  cfg.voiceboxes ??= [];
+  for (const vb of cfg.voiceboxes) {
+    vb.enabled ??= true;
+    vb.noAnswerTimeoutSec ??= 25;
+    vb.maxRecordingSec ??= 120;
+    vb.maxMessages ??= 50;
+    vb.greetingVoice ??= 'af_bella';
+  }
+
+  // IVR defaults.
+  if (cfg.ivr) {
+    cfg.ivr.enabled ??= false;
+    cfg.ivr.menus ??= [];
+    for (const menu of cfg.ivr.menus) {
+      menu.timeoutSec ??= 5;
+      menu.maxRetries ??= 3;
+      menu.entries ??= [];
+    }
+  }
+
   return cfg;
 }
 
@@ -251,6 +366,12 @@ export interface IInboundRouteResult {
   /** Device IDs to ring (empty = all devices). */
   deviceIds: string[];
   ringBrowsers: boolean;
+  /** If set, route directly to this voicemail box (skip ringing). */
+  voicemailBox?: string;
+  /** If set, route to this IVR menu (skip ringing). */
+  ivrMenuId?: string;
+  /** Override for no-answer timeout in seconds. */
+  noAnswerTimeout?: number;
 }
 
 /**
@@ -332,6 +453,9 @@ export function resolveInboundRoute(
     return {
       deviceIds: route.action.targets || [],
       ringBrowsers: route.action.ringBrowsers ?? false,
+      voicemailBox: route.action.voicemailBox,
+      ivrMenuId: route.action.ivrMenuId,
+      noAnswerTimeout: route.action.noAnswerTimeout,
     };
   }
 

ts/frontend.ts

@@ -13,6 +13,7 @@ import https from 'node:https';
 import { WebSocketServer, WebSocket } from 'ws';
 import type { CallManager } from './call/index.ts';
 import { handleWebRtcSignaling } from './webrtcbridge.ts';
+import type { VoiceboxManager } from './voicebox.ts';
 
 const CONFIG_PATH = path.join(process.cwd(), '.nogit', 'config.json');
 
@@ -84,6 +85,7 @@ async function handleRequest(
   onHangupCall: (callId: string) => boolean,
   onConfigSaved?: () => void,
   callManager?: CallManager,
+  voiceboxManager?: VoiceboxManager,
 ): Promise<void> {
   const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
   const method = req.method || 'GET';
@@ -242,6 +244,8 @@ async function handleRequest(
         }
       }
       if (updates.contacts !== undefined) cfg.contacts = updates.contacts;
+      if (updates.voiceboxes !== undefined) cfg.voiceboxes = updates.voiceboxes;
+      if (updates.ivr !== undefined) cfg.ivr = updates.ivr;
 
       fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n');
       log('[config] updated config.json');
@@ -252,6 +256,50 @@ async function handleRequest(
     }
   }
 
+  // API: voicemail - list messages.
+  const vmListMatch = url.pathname.match(/^\/api\/voicemail\/([^/]+)$/);
+  if (vmListMatch && method === 'GET' && voiceboxManager) {
+    const boxId = vmListMatch[1];
+    return sendJson(res, { ok: true, messages: voiceboxManager.getMessages(boxId) });
+  }
+
+  // API: voicemail - unheard count.
+  const vmUnheardMatch = url.pathname.match(/^\/api\/voicemail\/([^/]+)\/unheard$/);
+  if (vmUnheardMatch && method === 'GET' && voiceboxManager) {
+    const boxId = vmUnheardMatch[1];
+    return sendJson(res, { ok: true, count: voiceboxManager.getUnheardCount(boxId) });
+  }
+
+  // API: voicemail - stream audio.
+  const vmAudioMatch = url.pathname.match(/^\/api\/voicemail\/([^/]+)\/([^/]+)\/audio$/);
+  if (vmAudioMatch && method === 'GET' && voiceboxManager) {
+    const [, boxId, msgId] = vmAudioMatch;
+    const audioPath = voiceboxManager.getMessageAudioPath(boxId, msgId);
+    if (!audioPath) return sendJson(res, { ok: false, error: 'not found' }, 404);
+    const stat = fs.statSync(audioPath);
+    res.writeHead(200, {
+      'Content-Type': 'audio/wav',
+      'Content-Length': stat.size.toString(),
+      'Accept-Ranges': 'bytes',
+    });
+    fs.createReadStream(audioPath).pipe(res);
+    return;
+  }
+
+  // API: voicemail - mark as heard.
+  const vmHeardMatch = url.pathname.match(/^\/api\/voicemail\/([^/]+)\/([^/]+)\/heard$/);
+  if (vmHeardMatch && method === 'POST' && voiceboxManager) {
+    const [, boxId, msgId] = vmHeardMatch;
+    return sendJson(res, { ok: voiceboxManager.markHeard(boxId, msgId) });
+  }
+
+  // API: voicemail - delete message.
+  const vmDeleteMatch = url.pathname.match(/^\/api\/voicemail\/([^/]+)\/([^/]+)$/);
+  if (vmDeleteMatch && method === 'DELETE' && voiceboxManager) {
+    const [, boxId, msgId] = vmDeleteMatch;
+    return sendJson(res, { ok: voiceboxManager.deleteMessage(boxId, msgId) });
+  }
+
   // Static files.
   const file = staticFiles.get(url.pathname);
   if (file) {
@@ -288,6 +336,7 @@ export function initWebUi(
   onHangupCall: (callId: string) => boolean,
   onConfigSaved?: () => void,
   callManager?: CallManager,
+  voiceboxManager?: VoiceboxManager,
 ): void {
   const WEB_PORT = 3060;
 
@@ -303,12 +352,12 @@ export function initWebUi(
     const cert = fs.readFileSync(certPath, 'utf8');
     const key = fs.readFileSync(keyPath, 'utf8');
     server = https.createServer({ cert, key }, (req, res) =>
-      handleRequest(req, res, getStatus, log, onStartCall, onHangupCall, onConfigSaved, callManager).catch(() => { res.writeHead(500); res.end(); }),
+      handleRequest(req, res, getStatus, log, onStartCall, onHangupCall, onConfigSaved, callManager, voiceboxManager).catch(() => { res.writeHead(500); res.end(); }),
     );
     useTls = true;
   } catch {
     server = http.createServer((req, res) =>
-      handleRequest(req, res, getStatus, log, onStartCall, onHangupCall, onConfigSaved, callManager).catch(() => { res.writeHead(500); res.end(); }),
+      handleRequest(req, res, getStatus, log, onStartCall, onHangupCall, onConfigSaved, callManager, voiceboxManager).catch(() => { res.writeHead(500); res.end(); }),
     );
   }
 

ts/ivr.ts

@@ -0,0 +1,209 @@
+/**
+ * IVR engine — state machine that navigates callers through menus
+ * based on DTMF digit input.
+ *
+ * The IvrEngine is instantiated per-call and drives a SystemLeg:
+ * - Plays menu prompts via the SystemLeg's prompt playback
+ * - Receives DTMF digits and resolves them to actions
+ * - Fires an onAction callback for the CallManager to execute
+ *   (route to extension, voicemail, transfer, etc.)
+ */
+
+import type { IIvrConfig, IIvrMenu, TIvrAction } from './config.ts';
+import type { SystemLeg } from './call/system-leg.ts';
+
+// ---------------------------------------------------------------------------
+// IVR Engine
+// ---------------------------------------------------------------------------
+
+export class IvrEngine {
+  private config: IIvrConfig;
+  private systemLeg: SystemLeg;
+  private onAction: (action: TIvrAction) => void;
+  private log: (msg: string) => void;
+
+  /** The currently active menu. */
+  private currentMenu: IIvrMenu | null = null;
+
+  /** How many times the current menu has been replayed (for retry limit). */
+  private retryCount = 0;
+
+  /** Timer for digit input timeout. */
+  private digitTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  /** Whether the engine is waiting for a digit (prompt finished playing). */
+  private waitingForDigit = false;
+
+  /** Whether the engine has been destroyed. */
+  private destroyed = false;
+
+  constructor(
+    config: IIvrConfig,
+    systemLeg: SystemLeg,
+    onAction: (action: TIvrAction) => void,
+    log: (msg: string) => void,
+  ) {
+    this.config = config;
+    this.systemLeg = systemLeg;
+    this.onAction = onAction;
+    this.log = log;
+  }
+
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+
+  /**
+   * Start the IVR — navigates to the entry menu and plays its prompt.
+   */
+  start(): void {
+    const entryMenu = this.getMenu(this.config.entryMenuId);
+    if (!entryMenu) {
+      this.log(`[ivr] entry menu "${this.config.entryMenuId}" not found — hanging up`);
+      this.onAction({ type: 'hangup' });
+      return;
+    }
+
+    this.navigateToMenu(entryMenu);
+  }
+
+  /**
+   * Handle a DTMF digit from the caller.
+   */
+  handleDigit(digit: string): void {
+    if (this.destroyed || !this.currentMenu) return;
+
+    // Clear the timeout — caller pressed something.
+    this.clearDigitTimeout();
+
+    // Cancel any playing prompt (caller interrupted it).
+    this.systemLeg.cancelPrompt();
+    this.waitingForDigit = false;
+
+    this.log(`[ivr] digit '${digit}' in menu "${this.currentMenu.id}"`);
+
+    // Look up the digit in the current menu.
+    const entry = this.currentMenu.entries.find((e) => e.digit === digit);
+    if (entry) {
+      this.executeAction(entry.action);
+    } else {
+      this.log(`[ivr] invalid digit '${digit}' in menu "${this.currentMenu.id}"`);
+      this.executeAction(this.currentMenu.invalidAction);
+    }
+  }
+
+  /**
+   * Clean up timers and state.
+   */
+  destroy(): void {
+    this.destroyed = true;
+    this.clearDigitTimeout();
+    this.currentMenu = null;
+  }
+
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+
+  /** Navigate to a menu: play its prompt, then wait for digit. */
+  private navigateToMenu(menu: IIvrMenu): void {
+    if (this.destroyed) return;
+
+    this.currentMenu = menu;
+    this.waitingForDigit = false;
+    this.clearDigitTimeout();
+
+    const promptId = `ivr-menu-${menu.id}`;
+    this.log(`[ivr] playing menu "${menu.id}" prompt`);
+
+    this.systemLeg.playPrompt(promptId, () => {
+      if (this.destroyed) return;
+      // Prompt finished — start digit timeout.
+      this.waitingForDigit = true;
+      this.startDigitTimeout();
+    });
+  }
+
+  /** Start the timeout timer for digit input. */
+  private startDigitTimeout(): void {
+    const timeoutSec = this.currentMenu?.timeoutSec ?? 5;
+
+    this.digitTimeout = setTimeout(() => {
+      if (this.destroyed || !this.currentMenu) return;
+      this.log(`[ivr] digit timeout in menu "${this.currentMenu.id}"`);
+      this.handleTimeout();
+    }, timeoutSec * 1000);
+  }
+
+  /** Handle timeout (no digit pressed). */
+  private handleTimeout(): void {
+    if (!this.currentMenu) return;
+
+    this.retryCount++;
+    const maxRetries = this.currentMenu.maxRetries ?? 3;
+
+    if (this.retryCount >= maxRetries) {
+      this.log(`[ivr] max retries (${maxRetries}) reached in menu "${this.currentMenu.id}"`);
+      this.executeAction(this.currentMenu.timeoutAction);
+    } else {
+      this.log(`[ivr] retry ${this.retryCount}/${maxRetries} in menu "${this.currentMenu.id}"`);
+      // Replay the current menu.
+      this.navigateToMenu(this.currentMenu);
+    }
+  }
+
+  /** Execute an IVR action. */
+  private executeAction(action: TIvrAction): void {
+    if (this.destroyed) return;
+
+    switch (action.type) {
+      case 'submenu': {
+        const submenu = this.getMenu(action.menuId);
+        if (submenu) {
+          this.retryCount = 0;
+          this.navigateToMenu(submenu);
+        } else {
+          this.log(`[ivr] submenu "${action.menuId}" not found — hanging up`);
+          this.onAction({ type: 'hangup' });
+        }
+        break;
+      }
+
+      case 'repeat': {
+        if (this.currentMenu) {
+          this.navigateToMenu(this.currentMenu);
+        }
+        break;
+      }
+
+      case 'play-message': {
+        // Play a message prompt, then return to the current menu.
+        this.systemLeg.playPrompt(action.promptId, () => {
+          if (this.destroyed || !this.currentMenu) return;
+          this.navigateToMenu(this.currentMenu);
+        });
+        break;
+      }
+
+      default:
+        // All other actions (route-extension, route-voicemail, transfer, hangup)
+        // are handled by the CallManager via the onAction callback.
+        this.log(`[ivr] action: ${action.type}`);
+        this.onAction(action);
+        break;
+    }
+  }
+
+  /** Look up a menu by ID. */
+  private getMenu(menuId: string): IIvrMenu | null {
+    return this.config.menus.find((m) => m.id === menuId) ?? null;
+  }
+
+  /** Clear the digit timeout timer. */
+  private clearDigitTimeout(): void {
+    if (this.digitTimeout) {
+      clearTimeout(this.digitTimeout);
+      this.digitTimeout = null;
+    }
+  }
+}

ts/proxybridge.ts

@@ -0,0 +1,196 @@
+/**
+ * Proxy engine bridge — manages the Rust proxy-engine subprocess.
+ *
+ * The proxy-engine handles ALL SIP protocol mechanics. TypeScript only:
+ * - Sends configuration
+ * - Receives high-level events (incoming_call, call_ended, etc.)
+ * - Sends high-level commands (hangup, make_call, play_audio)
+ *
+ * No raw SIP ever touches TypeScript.
+ */
+
+import path from 'node:path';
+import { RustBridge } from '@push.rocks/smartrust';
+
+// ---------------------------------------------------------------------------
+// Command type map for smartrust
+// ---------------------------------------------------------------------------
+
+type TProxyCommands = {
+  configure: {
+    params: Record<string, unknown>;
+    result: { bound: string };
+  };
+  hangup: {
+    params: { call_id: string };
+    result: Record<string, never>;
+  };
+  make_call: {
+    params: { number: string; device_id?: string; provider_id?: string };
+    result: { call_id: string };
+  };
+  play_audio: {
+    params: { call_id: string; leg_id?: string; file_path: string; codec?: number };
+    result: Record<string, never>;
+  };
+  start_recording: {
+    params: { call_id: string; file_path: string; max_duration_ms?: number };
+    result: Record<string, never>;
+  };
+  stop_recording: {
+    params: { call_id: string };
+    result: { file_path: string; duration_ms: number };
+  };
+};
+
+// ---------------------------------------------------------------------------
+// Event types from Rust
+// ---------------------------------------------------------------------------
+
+export interface IIncomingCallEvent {
+  call_id: string;
+  from_uri: string;
+  to_number: string;
+  provider_id: string;
+}
+
+export interface IOutboundCallEvent {
+  call_id: string;
+  from_device: string | null;
+  to_number: string;
+}
+
+export interface ICallEndedEvent {
+  call_id: string;
+  reason: string;
+  duration: number;
+  from_side?: string;
+}
+
+export interface IProviderRegisteredEvent {
+  provider_id: string;
+  registered: boolean;
+  public_ip: string | null;
+}
+
+export interface IDeviceRegisteredEvent {
+  device_id: string;
+  display_name: string;
+  address: string;
+  port: number;
+  aor: string;
+  expires: number;
+}
+
+// ---------------------------------------------------------------------------
+// Bridge singleton
+// ---------------------------------------------------------------------------
+
+let bridge: RustBridge<TProxyCommands> | null = null;
+let initialized = false;
+let logFn: ((msg: string) => void) | undefined;
+
+function buildLocalPaths(): string[] {
+  const root = process.cwd();
+  return [
+    path.join(root, 'dist_rust', 'proxy-engine'),
+    path.join(root, 'rust', 'target', 'release', 'proxy-engine'),
+    path.join(root, 'rust', 'target', 'debug', 'proxy-engine'),
+  ];
+}
+
+/**
+ * Initialize the proxy engine — spawn the Rust binary.
+ * Call configure() separately to push config and start SIP.
+ */
+export async function initProxyEngine(log?: (msg: string) => void): Promise<boolean> {
+  if (initialized && bridge) return true;
+  logFn = log;
+
+  try {
+    bridge = new RustBridge<TProxyCommands>({
+      binaryName: 'proxy-engine',
+      localPaths: buildLocalPaths(),
+    });
+
+    const spawned = await bridge.spawn();
+    if (!spawned) {
+      log?.('[proxy-engine] failed to spawn binary');
+      bridge = null;
+      return false;
+    }
+
+    bridge.on('exit', () => {
+      logFn?.('[proxy-engine] process exited — will need re-init');
+      bridge = null;
+      initialized = false;
+    });
+
+    // Forward stderr for debugging.
+    bridge.on('stderr', (line: string) => {
+      logFn?.(`[proxy-engine:stderr] ${line}`);
+    });
+
+    initialized = true;
+    log?.('[proxy-engine] spawned and ready');
+    return true;
+  } catch (e: any) {
+    log?.(`[proxy-engine] init error: ${e.message}`);
+    bridge = null;
+    return false;
+  }
+}
+
+/**
+ * Send the full app config to the proxy engine.
+ * This binds the SIP socket, starts provider registrations, etc.
+ */
+export async function configureProxyEngine(config: Record<string, unknown>): Promise<boolean> {
+  if (!bridge || !initialized) return false;
+  try {
+    const result = await bridge.sendCommand('configure', config as any);
+    logFn?.(`[proxy-engine] configured, SIP bound on ${(result as any)?.bound || '?'}`);
+    return true;
+  } catch (e: any) {
+    logFn?.(`[proxy-engine] configure error: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Send a hangup command.
+ */
+export async function hangupCall(callId: string): Promise<boolean> {
+  if (!bridge || !initialized) return false;
+  try {
+    await bridge.sendCommand('hangup', { call_id: callId } as any);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Subscribe to an event from the proxy engine.
+ * Event names: incoming_call, outbound_device_call, call_ringing,
+ * call_answered, call_ended, provider_registered, device_registered,
+ * dtmf_digit, recording_done, sip_unhandled
+ */
+export function onProxyEvent(event: string, handler: (data: any) => void): void {
+  if (!bridge) throw new Error('proxy engine not initialized');
+  bridge.on(`management:${event}`, handler);
+}
+
+/** Check if the proxy engine is ready. */
+export function isProxyReady(): boolean {
+  return initialized && bridge !== null;
+}
+
+/** Shut down the proxy engine. */
+export function shutdownProxyEngine(): void {
+  if (bridge) {
+    try { bridge.kill(); } catch { /* ignore */ }
+    bridge = null;
+    initialized = false;
+  }
+}

ts/sip/helpers.ts

@@ -188,3 +188,54 @@ export function parseSdpEndpoint(sdp: string): { address: string; port: number }
   }
   return addr && port ? { address: addr, port } : null;
 }
+
+// ---------------------------------------------------------------------------
+// MWI (Message Waiting Indicator) — RFC 3842
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a SIP NOTIFY request for Message Waiting Indicator.
+ *
+ * Sent out-of-dialog to notify a device about voicemail message counts.
+ * Uses the message-summary event package per RFC 3842.
+ */
+export interface IMwiOptions {
+  /** Proxy LAN IP and port (Via / From / Contact). */
+  proxyHost: string;
+  proxyPort: number;
+  /** Target device URI (e.g. "sip:user@192.168.5.100:5060"). */
+  targetUri: string;
+  /** Account URI for the voicebox (used in the From header). */
+  accountUri: string;
+  /** Number of new (unheard) voice messages. */
+  newMessages: number;
+  /** Number of old (heard) voice messages. */
+  oldMessages: number;
+}
+
+/**
+ * Build the body and headers for an MWI NOTIFY (RFC 3842 message-summary).
+ *
+ * Returns the body string and extra headers needed. The caller builds
+ * the SipMessage via SipMessage.createRequest('NOTIFY', ...).
+ */
+export function buildMwiBody(newMessages: number, oldMessages: number, accountUri: string): {
+  body: string;
+  contentType: string;
+  extraHeaders: [string, string][];
+} {
+  const hasNew = newMessages > 0;
+  const body =
+    `Messages-Waiting: ${hasNew ? 'yes' : 'no'}\r\n` +
+    `Message-Account: ${accountUri}\r\n` +
+    `Voice-Message: ${newMessages}/${oldMessages}\r\n`;
+
+  return {
+    body,
+    contentType: 'application/simple-message-summary',
+    extraHeaders: [
+      ['Event', 'message-summary'],
+      ['Subscription-State', 'terminated;reason=noresource'],
+    ],
+  };
+}

ts/sip/index.ts

@@ -11,6 +11,7 @@ export {
   parseSdpEndpoint,
   parseDigestChallenge,
   computeDigestAuth,
+  buildMwiBody,
 } from './helpers.ts';
-export type { ISdpOptions, IDigestChallenge } from './helpers.ts';
+export type { ISdpOptions, IDigestChallenge, IMwiOptions } from './helpers.ts';
 export type { IEndpoint } from './types.ts';

ts/sipproxy.ts

@@ -1,39 +1,22 @@
 /**
- * SIP proxy — hub model entry point.
+ * SIP proxy — entry point.
  *
- * Thin bootstrap that wires together:
- * - UDP socket for all SIP signaling
- * - CallManager (the hub model core)
- * - Provider registration
- * - Local device registrar
- * - WebRTC signaling
- * - Web dashboard
- * - Rust codec bridge
+ * Spawns the Rust proxy-engine which handles ALL SIP protocol mechanics.
+ * TypeScript is the control plane:
+ * - Loads config and pushes it to Rust
+ * - Receives high-level events (incoming calls, registration, etc.)
+ * - Drives the web dashboard
+ * - Manages IVR, voicemail, announcements
+ * - Handles WebRTC browser signaling (forwarded to Rust in Phase 2)
  *
- * All call/media logic lives in ts/call/.
+ * No raw SIP ever touches TypeScript.
  */
 
-import dgram from 'node:dgram';
 import fs from 'node:fs';
 import path from 'node:path';
-import { Buffer } from 'node:buffer';
 
-import { SipMessage } from './sip/index.ts';
-import type { IEndpoint } from './sip/index.ts';
-import { loadConfig, resolveOutboundRoute } from './config.ts';
-import type { IAppConfig, IProviderConfig } from './config.ts';
-import {
-  initProviderStates,
-  syncProviderStates,
-  getProviderByUpstreamAddress,
-  handleProviderRegistrationResponse,
-} from './providerstate.ts';
-import {
-  initRegistrar,
-  handleDeviceRegister,
-  isKnownDeviceAddress,
-  getAllDeviceStatuses,
-} from './registrar.ts';
+import { loadConfig } from './config.ts';
+import type { IAppConfig } from './config.ts';
 import { broadcastWs, initWebUi } from './frontend.ts';
 import {
   initWebRtcSignaling,
@@ -43,17 +26,28 @@ import {
 } from './webrtcbridge.ts';
 import { initCodecBridge } from './opusbridge.ts';
 import { initAnnouncement } from './announcement.ts';
-import { CallManager } from './call/index.ts';
+import { PromptCache } from './call/prompt-cache.ts';
+import { VoiceboxManager } from './voicebox.ts';
+import {
+  initProxyEngine,
+  configureProxyEngine,
+  onProxyEvent,
+  hangupCall,
+  shutdownProxyEngine,
+} from './proxybridge.ts';
+import type {
+  IIncomingCallEvent,
+  IOutboundCallEvent,
+  ICallEndedEvent,
+  IProviderRegisteredEvent,
+  IDeviceRegisteredEvent,
+} from './proxybridge.ts';
 
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
 
 let appConfig: IAppConfig = loadConfig();
-const { proxy } = appConfig;
-
-const LAN_IP   = proxy.lanIp;
-const LAN_PORT = proxy.lanPort;
 
 const LOG_PATH = path.join(process.cwd(), 'sip_trace.log');
 
@@ -75,35 +69,82 @@ function log(msg: string): void {
   broadcastWs('log', { message: msg });
 }
 
-function logPacket(label: string, data: Buffer): void {
-  const head = `\n========== ${now()} ${label} (${data.length}b) ==========\n`;
-  const looksText = data.length > 0 && data[0] >= 0x41 && data[0] <= 0x7a;
-  const body = looksText
-    ? data.toString('utf8')
-    : `[${data.length} bytes binary] ${data.toString('hex').slice(0, 80)}`;
-  fs.appendFileSync(LOG_PATH, head + body + '\n');
+// ---------------------------------------------------------------------------
+// Shadow state — maintained from Rust events for the dashboard
+// ---------------------------------------------------------------------------
+
+interface IProviderStatus {
+  id: string;
+  displayName: string;
+  registered: boolean;
+  publicIp: string | null;
+}
+
+interface IDeviceStatus {
+  id: string;
+  displayName: string;
+  address: string | null;
+  port: number;
+  connected: boolean;
+  isBrowser: boolean;
+}
+
+interface IActiveCall {
+  id: string;
+  direction: string;
+  callerNumber: string | null;
+  calleeNumber: string | null;
+  providerUsed: string | null;
+  state: string;
+  startedAt: number;
+}
+
+interface ICallHistoryEntry {
+  id: string;
+  direction: string;
+  callerNumber: string | null;
+  calleeNumber: string | null;
+  startedAt: number;
+  duration: number;
+}
+
+const providerStatuses = new Map<string, IProviderStatus>();
+const deviceStatuses = new Map<string, IDeviceStatus>();
+const activeCalls = new Map<string, IActiveCall>();
+const callHistory: ICallHistoryEntry[] = [];
+const MAX_HISTORY = 100;
+
+// Initialize provider statuses from config (all start as unregistered).
+for (const p of appConfig.providers) {
+  providerStatuses.set(p.id, {
+    id: p.id,
+    displayName: p.displayName,
+    registered: false,
+    publicIp: null,
+  });
+}
+
+// Initialize device statuses from config.
+for (const d of appConfig.devices) {
+  deviceStatuses.set(d.id, {
+    id: d.id,
+    displayName: d.displayName,
+    address: null,
+    port: 0,
+    connected: false,
+    isBrowser: false,
+  });
 }
 
 // ---------------------------------------------------------------------------
 // Initialize subsystems
 // ---------------------------------------------------------------------------
 
-const providerStates = initProviderStates(appConfig.providers, proxy.publicIpSeed);
+const promptCache = new PromptCache(log);
+const voiceboxManager = new VoiceboxManager(log);
+voiceboxManager.init(appConfig.voiceboxes ?? []);
 
-initRegistrar(appConfig.devices, log);
-
-const callManager = new CallManager({
-  appConfig,
-  sendSip: (buf, dest) => sock.send(buf, dest.port, dest.address),
-  log,
-  broadcastWs,
-  getProviderState: (id) => providerStates.get(id),
-  getAllBrowserDeviceIds,
-  sendToBrowserDevice,
-  getBrowserDeviceWs,
-});
-
-// Initialize WebRTC signaling (browser device registration only).
+// WebRTC signaling (browser device registration).
 initWebRtcSignaling({ log });
 
 // ---------------------------------------------------------------------------
@@ -111,149 +152,176 @@ initWebRtcSignaling({ log });
 // ---------------------------------------------------------------------------
 
 function getStatus() {
-  const providers: unknown[] = [];
-  for (const ps of providerStates.values()) {
-    providers.push({
-      id: ps.config.id,
-      displayName: ps.config.displayName,
-      registered: ps.isRegistered,
-      publicIp: ps.publicIp,
-    });
-  }
-
   return {
     instanceId,
     uptime: Math.floor((Date.now() - startTime) / 1000),
-    lanIp: LAN_IP,
-    providers,
-    devices: getAllDeviceStatuses(),
-    calls: callManager.getStatus(),
-    callHistory: callManager.getHistory(),
+    lanIp: appConfig.proxy.lanIp,
+    providers: [...providerStatuses.values()],
+    devices: [...deviceStatuses.values()],
+    calls: [...activeCalls.values()].map((c) => ({
+      ...c,
+      duration: Math.floor((Date.now() - c.startedAt) / 1000),
+      legs: [],
+    })),
+    callHistory,
     contacts: appConfig.contacts || [],
+    voicemailCounts: voiceboxManager.getAllUnheardCounts(),
   };
 }
 
 // ---------------------------------------------------------------------------
-// Main UDP socket
+// Start Rust proxy engine
 // ---------------------------------------------------------------------------
 
-const sock = dgram.createSocket('udp4');
-
-sock.on('message', (data: Buffer, rinfo: dgram.RemoteInfo) => {
-  try {
-    const ps = getProviderByUpstreamAddress(rinfo.address, rinfo.port);
-
-    const msg = SipMessage.parse(data);
-    if (!msg) {
-      // Non-SIP data — forward raw based on direction.
-      if (ps) {
-        // From provider, forward to... nowhere useful without a call context.
-        logPacket(`UP->DN RAW (unparsed) from ${rinfo.address}:${rinfo.port}`, data);
-      } else {
-        // From device, forward to default provider.
-        const dp = resolveOutboundRoute(appConfig, '');
-        if (dp) sock.send(data, dp.provider.outboundProxy.port, dp.provider.outboundProxy.address);
-      }
-      return;
-    }
-
-    // 1. Provider registration responses — consumed by providerstate.
-    if (handleProviderRegistrationResponse(msg)) return;
-
-    // 2. Device REGISTER — handled by local registrar.
-    if (!ps && msg.method === 'REGISTER') {
-      const response = handleDeviceRegister(msg, { address: rinfo.address, port: rinfo.port });
-      if (response) {
-        sock.send(response.serialize(), rinfo.port, rinfo.address);
-        return;
-      }
-    }
-
-    // 3. Route to existing call by SIP Call-ID.
-    if (callManager.routeSipMessage(msg, rinfo)) {
-      return;
-    }
-
-    // 4. New inbound call from provider.
-    if (ps && msg.isRequest && msg.method === 'INVITE') {
-      logPacket(`[new inbound] INVITE from ${rinfo.address}:${rinfo.port}`, data);
-
-      // Detect public IP from Via.
-      const via = msg.getHeader('Via');
-      if (via) ps.detectPublicIp(via);
-
-      callManager.createInboundCall(ps, msg, { address: rinfo.address, port: rinfo.port });
-      return;
-    }
-
-    // 5. New outbound call from device (passthrough).
-    if (!ps && msg.isRequest && msg.method === 'INVITE') {
-      logPacket(`[new outbound] INVITE from ${rinfo.address}:${rinfo.port}`, data);
-      const dialedNumber = SipMessage.extractUri(msg.requestUri || '') || '';
-      const routeResult = resolveOutboundRoute(
-        appConfig,
-        dialedNumber,
-        undefined,
-        (pid) => !!providerStates.get(pid)?.registeredAor,
-      );
-      if (routeResult) {
-        const provState = providerStates.get(routeResult.provider.id);
-        if (provState) {
-          // Apply number transformation to the INVITE if needed.
-          if (routeResult.transformedNumber !== dialedNumber) {
-            const newUri = msg.requestUri?.replace(dialedNumber, routeResult.transformedNumber);
-            if (newUri) msg.setRequestUri(newUri);
-          }
-          callManager.handlePassthroughOutbound(msg, { address: rinfo.address, port: rinfo.port }, routeResult.provider, provState);
-        }
-      }
-      return;
-    }
-
-    // 6. Fallback: forward based on direction (for mid-dialog messages
-    //    that don't match any tracked call, e.g. OPTIONS, NOTIFY).
-    if (ps) {
-      // From provider -> forward to device.
-      logPacket(`[fallback inbound] from ${rinfo.address}:${rinfo.port}`, data);
-      const via = msg.getHeader('Via');
-      if (via) ps.detectPublicIp(via);
-      // Try to figure out where to send it...
-      // For now, just log. These should become rare once all calls are tracked.
-      log(`[fallback] unrouted inbound ${msg.isRequest ? msg.method : msg.statusCode} Call-ID=${msg.callId.slice(0, 30)}`);
-    } else {
-      // From device -> forward to provider.
-      logPacket(`[fallback outbound] from ${rinfo.address}:${rinfo.port}`, data);
-      const fallback = resolveOutboundRoute(appConfig, '');
-      if (fallback) sock.send(msg.serialize(), fallback.provider.outboundProxy.port, fallback.provider.outboundProxy.address);
-    }
-  } catch (e: any) {
-    log(`[err] ${e?.stack || e}`);
+async function startProxyEngine(): Promise<void> {
+  const ok = await initProxyEngine(log);
+  if (!ok) {
+    log('[FATAL] failed to start proxy engine');
+    process.exit(1);
   }
-});
 
-sock.on('error', (err: Error) => log(`[main] sock err: ${err.message}`));
+  // Subscribe to events from Rust BEFORE sending configure.
+  onProxyEvent('provider_registered', (data: IProviderRegisteredEvent) => {
+    const ps = providerStatuses.get(data.provider_id);
+    if (ps) {
+      const wasRegistered = ps.registered;
+      ps.registered = data.registered;
+      ps.publicIp = data.public_ip;
+      if (data.registered && !wasRegistered) {
+        log(`[provider:${data.provider_id}] registered (publicIp=${data.public_ip})`);
+      } else if (!data.registered && wasRegistered) {
+        log(`[provider:${data.provider_id}] registration lost`);
+      }
+      broadcastWs('registration', { providerId: data.provider_id, registered: data.registered });
+    }
+  });
+
+  onProxyEvent('device_registered', (data: IDeviceRegisteredEvent) => {
+    const ds = deviceStatuses.get(data.device_id);
+    if (ds) {
+      ds.address = data.address;
+      ds.port = data.port;
+      ds.connected = true;
+      log(`[registrar] ${data.display_name} registered from ${data.address}:${data.port}`);
+    }
+  });
+
+  onProxyEvent('incoming_call', (data: IIncomingCallEvent) => {
+    log(`[call] incoming: ${data.from_uri} → ${data.to_number} via ${data.provider_id} (${data.call_id})`);
+    activeCalls.set(data.call_id, {
+      id: data.call_id,
+      direction: 'inbound',
+      callerNumber: data.from_uri,
+      calleeNumber: data.to_number,
+      providerUsed: data.provider_id,
+      state: 'ringing',
+      startedAt: Date.now(),
+    });
+
+    // Notify browsers of incoming call.
+    const browserIds = getAllBrowserDeviceIds();
+    for (const bid of browserIds) {
+      sendToBrowserDevice(bid, {
+        type: 'webrtc-incoming',
+        callId: data.call_id,
+        from: data.from_uri,
+        deviceId: bid,
+      });
+    }
+  });
+
+  onProxyEvent('outbound_device_call', (data: IOutboundCallEvent) => {
+    log(`[call] outbound: device ${data.from_device} → ${data.to_number} (${data.call_id})`);
+    activeCalls.set(data.call_id, {
+      id: data.call_id,
+      direction: 'outbound',
+      callerNumber: data.from_device,
+      calleeNumber: data.to_number,
+      providerUsed: null,
+      state: 'setting-up',
+      startedAt: Date.now(),
+    });
+  });
+
+  onProxyEvent('call_ringing', (data: { call_id: string }) => {
+    const call = activeCalls.get(data.call_id);
+    if (call) call.state = 'ringing';
+  });
+
+  onProxyEvent('call_answered', (data: { call_id: string }) => {
+    const call = activeCalls.get(data.call_id);
+    if (call) {
+      call.state = 'connected';
+      log(`[call] ${data.call_id} connected`);
+    }
+  });
+
+  onProxyEvent('call_ended', (data: ICallEndedEvent) => {
+    const call = activeCalls.get(data.call_id);
+    if (call) {
+      log(`[call] ${data.call_id} ended: ${data.reason} (${data.duration}s)`);
+      // Move to history.
+      callHistory.unshift({
+        id: call.id,
+        direction: call.direction,
+        callerNumber: call.callerNumber,
+        calleeNumber: call.calleeNumber,
+        startedAt: call.startedAt,
+        duration: data.duration,
+      });
+      if (callHistory.length > MAX_HISTORY) callHistory.pop();
+      activeCalls.delete(data.call_id);
+    }
+  });
+
+  onProxyEvent('sip_unhandled', (data: any) => {
+    log(`[sip] unhandled ${data.method_or_status} Call-ID=${data.call_id?.slice(0, 20)} from=${data.from_addr}:${data.from_port}`);
+  });
+
+  // Send full config to Rust — this binds the SIP socket and starts registrations.
+  const configured = await configureProxyEngine({
+    proxy: appConfig.proxy,
+    providers: appConfig.providers,
+    devices: appConfig.devices,
+    routing: appConfig.routing,
+  });
+
+  if (!configured) {
+    log('[FATAL] failed to configure proxy engine');
+    process.exit(1);
+  }
 
-sock.bind(LAN_PORT, '0.0.0.0', () => {
   const providerList = appConfig.providers.map((p) => p.displayName).join(', ');
   const deviceList = appConfig.devices.map((d) => d.displayName).join(', ');
-  log(`sip proxy bound 0.0.0.0:${LAN_PORT} | providers: ${providerList} | devices: ${deviceList}`);
+  log(`proxy engine started | LAN ${appConfig.proxy.lanIp}:${appConfig.proxy.lanPort} | providers: ${providerList} | devices: ${deviceList}`);
 
-  // Start upstream provider registrations.
-  for (const ps of providerStates.values()) {
-    ps.startRegistration(
-      LAN_IP,
-      LAN_PORT,
-      (buf, dest) => sock.send(buf, dest.port, dest.address),
-      log,
-      (provider) => broadcastWs('registration', { providerId: provider.config.id, registered: provider.isRegistered }),
-    );
+  // Initialize audio codec bridge (still needed for WebRTC transcoding).
+  try {
+    await initCodecBridge(log);
+    await initAnnouncement(log);
+
+    // Pre-generate prompts.
+    await promptCache.generateBeep('voicemail-beep', 1000, 500, 8000);
+    for (const vb of appConfig.voiceboxes ?? []) {
+      if (!vb.enabled) continue;
+      const promptId = `voicemail-greeting-${vb.id}`;
+      if (vb.greetingWavPath) {
+        await promptCache.loadWavPrompt(promptId, vb.greetingWavPath);
+      } else {
+        const text = vb.greetingText || 'The person you are trying to reach is not available. Please leave a message after the tone.';
+        await promptCache.generatePrompt(promptId, text, vb.greetingVoice || 'af_bella');
+      }
+    }
+    if (appConfig.ivr?.enabled) {
+      for (const menu of appConfig.ivr.menus) {
+        await promptCache.generatePrompt(`ivr-menu-${menu.id}`, menu.promptText, menu.promptVoice || 'af_bella');
+      }
+    }
+    log(`[startup] prompts cached: ${promptCache.listIds().join(', ') || 'none'}`);
+  } catch (e) {
+    log(`[codec] init failed: ${e}`);
   }
-
-  // Initialize audio codec bridge (Rust binary via smartrust).
-  initCodecBridge(log)
-    .then(() => initAnnouncement(log))
-    .catch((e) => log(`[codec] init failed: ${e}`));
-});
+}
 
 // ---------------------------------------------------------------------------
 // Web UI
@@ -262,33 +330,62 @@ sock.bind(LAN_PORT, '0.0.0.0', () => {
 initWebUi(
   getStatus,
   log,
-  (number, deviceId, providerId) => {
-    const call = callManager.createOutboundCall(number, deviceId, providerId);
-    return call ? { id: call.id } : null;
+  (number, _deviceId, _providerId) => {
+    // Outbound calls from dashboard — send make_call command to Rust.
+    // For now, log only. Full implementation needs make_call in Rust.
+    log(`[dashboard] start call requested: ${number}`);
+    // TODO: send make_call command when implemented in Rust
+    return null;
+  },
+  (callId) => {
+    hangupCall(callId);
+    return true;
   },
-  (callId) => callManager.hangup(callId),
   () => {
-    // Reload config after UI save.
+    // Config saved — reconfigure Rust engine.
     try {
       const fresh = loadConfig();
       Object.assign(appConfig, fresh);
-      // Sync provider registrations: add new, remove deleted, re-register changed.
-      syncProviderStates(
-        fresh.providers,
-        proxy.publicIpSeed,
-        LAN_IP,
-        LAN_PORT,
-        (buf, dest) => sock.send(buf, dest.port, dest.address),
-        log,
-        (provider) => broadcastWs('registration', { providerId: provider.config.id, registered: provider.isRegistered }),
-      );
-      log('[config] reloaded config after save');
+
+      // Update shadow state.
+      for (const p of fresh.providers) {
+        if (!providerStatuses.has(p.id)) {
+          providerStatuses.set(p.id, {
+            id: p.id, displayName: p.displayName, registered: false, publicIp: null,
+          });
+        }
+      }
+      for (const d of fresh.devices) {
+        if (!deviceStatuses.has(d.id)) {
+          deviceStatuses.set(d.id, {
+            id: d.id, displayName: d.displayName, address: null, port: 0, connected: false, isBrowser: false,
+          });
+        }
+      }
+
+      // Re-send config to Rust.
+      configureProxyEngine({
+        proxy: fresh.proxy,
+        providers: fresh.providers,
+        devices: fresh.devices,
+        routing: fresh.routing,
+      }).then((ok) => {
+        if (ok) log('[config] reloaded — proxy engine reconfigured');
+        else log('[config] reload failed — proxy engine rejected config');
+      });
     } catch (e: any) {
       log(`[config] reload failed: ${e.message}`);
     }
   },
-  callManager,
+  undefined, // callManager — WebRTC calls handled separately in Phase 2
+  voiceboxManager,
 );
 
-process.on('SIGINT', () => { log('SIGINT, exiting'); process.exit(0); });
-process.on('SIGTERM', () => { log('SIGTERM, exiting'); process.exit(0); });
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+
+startProxyEngine();
+
+process.on('SIGINT', () => { log('SIGINT, exiting'); shutdownProxyEngine(); process.exit(0); });
+process.on('SIGTERM', () => { log('SIGTERM, exiting'); shutdownProxyEngine(); process.exit(0); });

ts/voicebox.ts

@@ -0,0 +1,314 @@
+/**
+ * VoiceboxManager — manages voicemail boxes, message storage, and MWI.
+ *
+ * Each voicebox corresponds to a device/extension. Messages are stored
+ * as WAV files with JSON metadata in .nogit/voicemail/{boxId}/.
+ *
+ * Supports:
+ * - Per-box configurable TTS greetings (text + voice) or uploaded WAV
+ * - Message CRUD: save, list, mark heard, delete
+ * - Unheard count for MWI (Message Waiting Indicator)
+ * - Storage limit (max messages per box)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface IVoiceboxConfig {
+  /** Unique ID — typically matches device ID or extension. */
+  id: string;
+  /** Whether this voicebox is active. */
+  enabled: boolean;
+  /** Custom TTS greeting text (overrides default). */
+  greetingText?: string;
+  /** Kokoro TTS voice ID for the greeting (default 'af_bella'). */
+  greetingVoice?: string;
+  /** Path to uploaded WAV greeting (overrides TTS). */
+  greetingWavPath?: string;
+  /** Seconds to wait before routing to voicemail (default 25). */
+  noAnswerTimeoutSec: number;
+  /** Maximum recording duration in seconds (default 120). */
+  maxRecordingSec: number;
+  /** Maximum stored messages per box (default 50). */
+  maxMessages: number;
+}
+
+export interface IVoicemailMessage {
+  /** Unique message ID. */
+  id: string;
+  /** Which voicebox this message belongs to. */
+  boxId: string;
+  /** Caller's phone number. */
+  callerNumber: string;
+  /** Caller's display name (if available from SIP From header). */
+  callerName?: string;
+  /** Unix timestamp (ms) when the message was recorded. */
+  timestamp: number;
+  /** Duration in milliseconds. */
+  durationMs: number;
+  /** Relative path to the WAV file (within the box directory). */
+  fileName: string;
+  /** Whether the message has been listened to. */
+  heard: boolean;
+}
+
+// Default greeting text when no custom text is configured.
+const DEFAULT_GREETING = 'The person you are trying to reach is not available. Please leave a message after the tone.';
+
+// ---------------------------------------------------------------------------
+// VoiceboxManager
+// ---------------------------------------------------------------------------
+
+export class VoiceboxManager {
+  private boxes = new Map<string, IVoiceboxConfig>();
+  private basePath: string;
+  private log: (msg: string) => void;
+
+  constructor(log: (msg: string) => void) {
+    this.basePath = path.join(process.cwd(), '.nogit', 'voicemail');
+    this.log = log;
+  }
+
+  // -------------------------------------------------------------------------
+  // Initialization
+  // -------------------------------------------------------------------------
+
+  /**
+   * Load voicebox configurations from the app config.
+   */
+  init(voiceboxConfigs: IVoiceboxConfig[]): void {
+    this.boxes.clear();
+
+    for (const cfg of voiceboxConfigs) {
+      // Apply defaults.
+      cfg.noAnswerTimeoutSec ??= 25;
+      cfg.maxRecordingSec ??= 120;
+      cfg.maxMessages ??= 50;
+      cfg.greetingVoice ??= 'af_bella';
+
+      this.boxes.set(cfg.id, cfg);
+    }
+
+    // Ensure base directory exists.
+    fs.mkdirSync(this.basePath, { recursive: true });
+
+    this.log(`[voicebox] initialized ${this.boxes.size} voicebox(es)`);
+  }
+
+  // -------------------------------------------------------------------------
+  // Box management
+  // -------------------------------------------------------------------------
+
+  /** Get config for a specific voicebox. */
+  getBox(boxId: string): IVoiceboxConfig | null {
+    return this.boxes.get(boxId) ?? null;
+  }
+
+  /** Get all configured voicebox IDs. */
+  getBoxIds(): string[] {
+    return [...this.boxes.keys()];
+  }
+
+  /** Get the greeting text for a voicebox. */
+  getGreetingText(boxId: string): string {
+    const box = this.boxes.get(boxId);
+    return box?.greetingText || DEFAULT_GREETING;
+  }
+
+  /** Get the greeting voice for a voicebox. */
+  getGreetingVoice(boxId: string): string {
+    const box = this.boxes.get(boxId);
+    return box?.greetingVoice || 'af_bella';
+  }
+
+  /** Check if a voicebox has a custom WAV greeting. */
+  hasCustomGreetingWav(boxId: string): boolean {
+    const box = this.boxes.get(boxId);
+    if (!box?.greetingWavPath) return false;
+    return fs.existsSync(box.greetingWavPath);
+  }
+
+  /** Get the greeting WAV path (custom or null). */
+  getCustomGreetingWavPath(boxId: string): string | null {
+    const box = this.boxes.get(boxId);
+    if (!box?.greetingWavPath) return null;
+    return fs.existsSync(box.greetingWavPath) ? box.greetingWavPath : null;
+  }
+
+  /** Get the directory path for a voicebox. */
+  getBoxDir(boxId: string): string {
+    return path.join(this.basePath, boxId);
+  }
+
+  // -------------------------------------------------------------------------
+  // Message CRUD
+  // -------------------------------------------------------------------------
+
+  /**
+   * Save a new voicemail message.
+   * The WAV file should already exist at the expected path.
+   */
+  saveMessage(msg: IVoicemailMessage): void {
+    const boxDir = this.getBoxDir(msg.boxId);
+    fs.mkdirSync(boxDir, { recursive: true });
+
+    const messages = this.loadMessages(msg.boxId);
+    messages.unshift(msg); // newest first
+
+    // Enforce max messages — delete oldest.
+    const box = this.boxes.get(msg.boxId);
+    const maxMessages = box?.maxMessages ?? 50;
+    while (messages.length > maxMessages) {
+      const old = messages.pop()!;
+      const oldPath = path.join(boxDir, old.fileName);
+      try {
+        if (fs.existsSync(oldPath)) fs.unlinkSync(oldPath);
+      } catch { /* best effort */ }
+    }
+
+    this.writeMessages(msg.boxId, messages);
+    this.log(`[voicebox] saved message ${msg.id} in box "${msg.boxId}" (${msg.durationMs}ms from ${msg.callerNumber})`);
+  }
+
+  /**
+   * List messages for a voicebox (newest first).
+   */
+  getMessages(boxId: string): IVoicemailMessage[] {
+    return this.loadMessages(boxId);
+  }
+
+  /**
+   * Get a single message by ID.
+   */
+  getMessage(boxId: string, messageId: string): IVoicemailMessage | null {
+    const messages = this.loadMessages(boxId);
+    return messages.find((m) => m.id === messageId) ?? null;
+  }
+
+  /**
+   * Mark a message as heard.
+   */
+  markHeard(boxId: string, messageId: string): boolean {
+    const messages = this.loadMessages(boxId);
+    const msg = messages.find((m) => m.id === messageId);
+    if (!msg) return false;
+
+    msg.heard = true;
+    this.writeMessages(boxId, messages);
+    return true;
+  }
+
+  /**
+   * Delete a message (both metadata and WAV file).
+   */
+  deleteMessage(boxId: string, messageId: string): boolean {
+    const messages = this.loadMessages(boxId);
+    const idx = messages.findIndex((m) => m.id === messageId);
+    if (idx === -1) return false;
+
+    const msg = messages[idx];
+    const boxDir = this.getBoxDir(boxId);
+    const wavPath = path.join(boxDir, msg.fileName);
+
+    // Delete WAV file.
+    try {
+      if (fs.existsSync(wavPath)) fs.unlinkSync(wavPath);
+    } catch { /* best effort */ }
+
+    // Remove from list and save.
+    messages.splice(idx, 1);
+    this.writeMessages(boxId, messages);
+    this.log(`[voicebox] deleted message ${messageId} from box "${boxId}"`);
+    return true;
+  }
+
+  /**
+   * Get the full file path for a message's WAV file.
+   */
+  getMessageAudioPath(boxId: string, messageId: string): string | null {
+    const msg = this.getMessage(boxId, messageId);
+    if (!msg) return null;
+    const filePath = path.join(this.getBoxDir(boxId), msg.fileName);
+    return fs.existsSync(filePath) ? filePath : null;
+  }
+
+  // -------------------------------------------------------------------------
+  // Counts
+  // -------------------------------------------------------------------------
+
+  /** Get count of unheard messages for a voicebox. */
+  getUnheardCount(boxId: string): number {
+    const messages = this.loadMessages(boxId);
+    return messages.filter((m) => !m.heard).length;
+  }
+
+  /** Get total message count for a voicebox. */
+  getTotalCount(boxId: string): number {
+    return this.loadMessages(boxId).length;
+  }
+
+  /** Get unheard counts for all voiceboxes. */
+  getAllUnheardCounts(): Record<string, number> {
+    const counts: Record<string, number> = {};
+    for (const boxId of this.boxes.keys()) {
+      counts[boxId] = this.getUnheardCount(boxId);
+    }
+    return counts;
+  }
+
+  // -------------------------------------------------------------------------
+  // Greeting management
+  // -------------------------------------------------------------------------
+
+  /**
+   * Save a custom greeting WAV file for a voicebox.
+   */
+  saveCustomGreeting(boxId: string, wavData: Buffer): string {
+    const boxDir = this.getBoxDir(boxId);
+    fs.mkdirSync(boxDir, { recursive: true });
+    const greetingPath = path.join(boxDir, 'greeting.wav');
+    fs.writeFileSync(greetingPath, wavData);
+    this.log(`[voicebox] saved custom greeting for box "${boxId}"`);
+    return greetingPath;
+  }
+
+  /**
+   * Delete the custom greeting for a voicebox (falls back to TTS).
+   */
+  deleteCustomGreeting(boxId: string): void {
+    const boxDir = this.getBoxDir(boxId);
+    const greetingPath = path.join(boxDir, 'greeting.wav');
+    try {
+      if (fs.existsSync(greetingPath)) fs.unlinkSync(greetingPath);
+    } catch { /* best effort */ }
+  }
+
+  // -------------------------------------------------------------------------
+  // Internal: JSON persistence
+  // -------------------------------------------------------------------------
+
+  private messagesPath(boxId: string): string {
+    return path.join(this.getBoxDir(boxId), 'messages.json');
+  }
+
+  private loadMessages(boxId: string): IVoicemailMessage[] {
+    const filePath = this.messagesPath(boxId);
+    try {
+      if (!fs.existsSync(filePath)) return [];
+      const raw = fs.readFileSync(filePath, 'utf8');
+      return JSON.parse(raw) as IVoicemailMessage[];
+    } catch {
+      return [];
+    }
+  }
+
+  private writeMessages(boxId: string, messages: IVoicemailMessage[]): void {
+    const boxDir = this.getBoxDir(boxId);
+    fs.mkdirSync(boxDir, { recursive: true });
+    fs.writeFileSync(this.messagesPath(boxId), JSON.stringify(messages, null, 2), 'utf8');
+  }
+}

ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'siprouter',
-  version: '1.9.0',
+  version: '1.11.0',
   description: 'undefined'
 }

ts_web/elements/index.ts

@@ -5,8 +5,10 @@ export * from './sipproxy-view-calls.js';
 export * from './sipproxy-view-phone.js';
 export * from './sipproxy-view-contacts.js';
 export * from './sipproxy-view-providers.js';
+export * from './sipproxy-view-voicemail.js';
 export * from './sipproxy-view-log.js';
 export * from './sipproxy-view-routes.js';
+export * from './sipproxy-view-ivr.js';
 
 // Sub-components (used within views)
 export * from './sipproxy-devices.js';

ts_web/elements/sipproxy-app.ts

@@ -9,12 +9,16 @@ import { SipproxyViewContacts } from './sipproxy-view-contacts.js';
 import { SipproxyViewProviders } from './sipproxy-view-providers.js';
 import { SipproxyViewLog } from './sipproxy-view-log.js';
 import { SipproxyViewRoutes } from './sipproxy-view-routes.js';
+import { SipproxyViewVoicemail } from './sipproxy-view-voicemail.js';
+import { SipproxyViewIvr } from './sipproxy-view-ivr.js';
 
 const VIEW_TABS = [
   { name: 'Overview', iconName: 'lucide:layoutDashboard', element: SipproxyViewOverview },
   { name: 'Calls', iconName: 'lucide:phone', element: SipproxyViewCalls },
   { name: 'Phone', iconName: 'lucide:headset', element: SipproxyViewPhone },
   { name: 'Routes', iconName: 'lucide:route', element: SipproxyViewRoutes },
+  { name: 'Voicemail', iconName: 'lucide:voicemail', element: SipproxyViewVoicemail },
+  { name: 'IVR', iconName: 'lucide:list-tree', element: SipproxyViewIvr },
   { name: 'Contacts', iconName: 'lucide:contactRound', element: SipproxyViewContacts },
   { name: 'Providers', iconName: 'lucide:server', element: SipproxyViewProviders },
   { name: 'Log', iconName: 'lucide:scrollText', element: SipproxyViewLog },

ts_web/elements/sipproxy-view-ivr.ts

@@ -0,0 +1,657 @@
+import { DeesElement, customElement, html, css, cssManager, state, type TemplateResult } from '../plugins.js';
+import { deesCatalog } from '../plugins.js';
+import { appState, type IAppState } from '../state/appstate.js';
+import { viewHostCss } from './shared/index.js';
+import type { IStatsTile } from '@design.estate/dees-catalog';
+
+const { DeesModal, DeesToast } = deesCatalog;
+
+// ---------------------------------------------------------------------------
+// IVR types (mirrors ts/config.ts)
+// ---------------------------------------------------------------------------
+
+type TIvrAction =
+  | { type: 'route-extension'; extensionId: string }
+  | { type: 'route-voicemail'; boxId: string }
+  | { type: 'submenu'; menuId: string }
+  | { type: 'play-message'; promptId: string }
+  | { type: 'transfer'; number: string; providerId?: string }
+  | { type: 'repeat' }
+  | { type: 'hangup' };
+
+interface IIvrMenuEntry {
+  digit: string;
+  action: TIvrAction;
+}
+
+interface IIvrMenu {
+  id: string;
+  name: string;
+  promptText: string;
+  promptVoice?: string;
+  entries: IIvrMenuEntry[];
+  timeoutSec?: number;
+  maxRetries?: number;
+  timeoutAction: TIvrAction;
+  invalidAction: TIvrAction;
+}
+
+interface IIvrConfig {
+  enabled: boolean;
+  menus: IIvrMenu[];
+  entryMenuId: string;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '') || `menu-${Date.now()}`;
+}
+
+const VOICE_OPTIONS = [
+  { option: 'af_bella (Female)', key: 'af_bella' },
+  { option: 'af_sarah (Female)', key: 'af_sarah' },
+  { option: 'am_adam (Male)', key: 'am_adam' },
+  { option: 'bf_alice (Female)', key: 'bf_alice' },
+];
+
+const ACTION_TYPE_OPTIONS = [
+  { option: 'Route to Extension', key: 'route-extension' },
+  { option: 'Route to Voicemail', key: 'route-voicemail' },
+  { option: 'Submenu', key: 'submenu' },
+  { option: 'Play Message', key: 'play-message' },
+  { option: 'Transfer', key: 'transfer' },
+  { option: 'Repeat', key: 'repeat' },
+  { option: 'Hangup', key: 'hangup' },
+];
+
+const DIGIT_OPTIONS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '*', '#'];
+
+function describeAction(action: TIvrAction): string {
+  switch (action.type) {
+    case 'route-extension': return `Extension: ${action.extensionId}`;
+    case 'route-voicemail': return `Voicemail: ${action.boxId}`;
+    case 'submenu': return `Submenu: ${action.menuId}`;
+    case 'play-message': return `Play: ${action.promptId}`;
+    case 'transfer': return `Transfer: ${action.number}${action.providerId ? ` (${action.providerId})` : ''}`;
+    case 'repeat': return 'Repeat';
+    case 'hangup': return 'Hangup';
+    default: return 'Unknown';
+  }
+}
+
+function makeDefaultAction(): TIvrAction {
+  return { type: 'hangup' };
+}
+
+// ---------------------------------------------------------------------------
+// View element
+// ---------------------------------------------------------------------------
+
+@customElement('sipproxy-view-ivr')
+export class SipproxyViewIvr extends DeesElement {
+  @state() accessor appData: IAppState = appState.getState();
+  @state() accessor config: any = null;
+
+  public static styles = [
+    cssManager.defaultStyles,
+    viewHostCss,
+    css`
+      .view-section { margin-bottom: 24px; }
+    `,
+  ];
+
+  // ---- lifecycle -----------------------------------------------------------
+
+  connectedCallback() {
+    super.connectedCallback();
+    this.rxSubscriptions.push({
+      unsubscribe: appState.subscribe((s) => { this.appData = s; }),
+    } as any);
+    this.loadConfig();
+  }
+
+  private async loadConfig() {
+    try {
+      this.config = await appState.apiGetConfig();
+    } catch {
+      // Will show empty state.
+    }
+  }
+
+  private getIvrConfig(): IIvrConfig {
+    return this.config?.ivr || { enabled: false, menus: [], entryMenuId: '' };
+  }
+
+  // ---- stats tiles ---------------------------------------------------------
+
+  private getStatsTiles(): IStatsTile[] {
+    const ivr = this.getIvrConfig();
+    const entryMenu = ivr.menus.find((m) => m.id === ivr.entryMenuId);
+
+    return [
+      {
+        id: 'total-menus',
+        title: 'Total Menus',
+        value: ivr.menus.length,
+        type: 'number',
+        icon: 'lucide:list-tree',
+        description: 'IVR menu definitions',
+      },
+      {
+        id: 'entry-menu',
+        title: 'Entry Menu',
+        value: entryMenu?.name || '(none)',
+        type: 'text' as any,
+        icon: 'lucide:door-open',
+        description: entryMenu ? `ID: ${entryMenu.id}` : 'No entry menu set',
+      },
+      {
+        id: 'status',
+        title: 'Status',
+        value: ivr.enabled ? 'Enabled' : 'Disabled',
+        type: 'text' as any,
+        icon: ivr.enabled ? 'lucide:check-circle' : 'lucide:x-circle',
+        color: ivr.enabled ? 'hsl(142.1 76.2% 36.3%)' : 'hsl(0 84.2% 60.2%)',
+        description: ivr.enabled ? 'IVR is active' : 'IVR is inactive',
+      },
+    ];
+  }
+
+  // ---- table columns -------------------------------------------------------
+
+  private getColumns() {
+    const ivr = this.getIvrConfig();
+    return [
+      {
+        key: 'name',
+        header: 'Name',
+        sortable: true,
+        renderer: (val: string, row: IIvrMenu) => {
+          const isEntry = row.id === ivr.entryMenuId;
+          return html`
+            <span>${val}</span>
+            ${isEntry ? html`<span style="display:inline-block;margin-left:8px;padding:1px 6px;border-radius:4px;font-size:.65rem;font-weight:600;text-transform:uppercase;background:#1e3a5f;color:#60a5fa">entry</span>` : ''}
+          `;
+        },
+      },
+      {
+        key: 'promptText',
+        header: 'Prompt',
+        renderer: (val: string) => {
+          const truncated = val && val.length > 60 ? val.slice(0, 60) + '...' : val || '--';
+          return html`<span style="font-size:.82rem;color:#94a3b8">${truncated}</span>`;
+        },
+      },
+      {
+        key: 'entries',
+        header: 'Digits',
+        renderer: (_val: any, row: IIvrMenu) => {
+          const digits = (row.entries || []).map((e) => e.digit).join(', ');
+          return html`<span style="font-family:'JetBrains Mono',monospace;font-size:.75rem">${digits || '(none)'}</span>`;
+        },
+      },
+      {
+        key: 'timeoutAction',
+        header: 'Timeout Action',
+        renderer: (_val: any, row: IIvrMenu) => {
+          return html`<span style="font-size:.82rem;color:#94a3b8">${describeAction(row.timeoutAction)}</span>`;
+        },
+      },
+    ];
+  }
+
+  // ---- table actions -------------------------------------------------------
+
+  private getDataActions() {
+    return [
+      {
+        name: 'Add Menu',
+        iconName: 'lucide:plus' as any,
+        type: ['header'] as any,
+        actionFunc: async () => {
+          await this.openMenuEditor(null);
+        },
+      },
+      {
+        name: 'Edit',
+        iconName: 'lucide:pencil' as any,
+        type: ['inRow'] as any,
+        actionFunc: async ({ item }: { item: IIvrMenu }) => {
+          await this.openMenuEditor(item);
+        },
+      },
+      {
+        name: 'Set as Entry',
+        iconName: 'lucide:door-open' as any,
+        type: ['inRow'] as any,
+        actionFunc: async ({ item }: { item: IIvrMenu }) => {
+          await this.setEntryMenu(item.id);
+        },
+      },
+      {
+        name: 'Delete',
+        iconName: 'lucide:trash-2' as any,
+        type: ['inRow'] as any,
+        actionFunc: async ({ item }: { item: IIvrMenu }) => {
+          await this.confirmDeleteMenu(item);
+        },
+      },
+    ];
+  }
+
+  // ---- toggle enabled ------------------------------------------------------
+
+  private async toggleEnabled() {
+    const ivr = this.getIvrConfig();
+    const updated: IIvrConfig = { ...ivr, enabled: !ivr.enabled };
+    const result = await appState.apiSaveConfig({ ivr: updated });
+    if (result.ok) {
+      DeesToast.success(updated.enabled ? 'IVR enabled' : 'IVR disabled');
+      await this.loadConfig();
+    } else {
+      DeesToast.error('Failed to update IVR status');
+    }
+  }
+
+  // ---- set entry menu ------------------------------------------------------
+
+  private async setEntryMenu(menuId: string) {
+    const ivr = this.getIvrConfig();
+    const updated: IIvrConfig = { ...ivr, entryMenuId: menuId };
+    const result = await appState.apiSaveConfig({ ivr: updated });
+    if (result.ok) {
+      DeesToast.success('Entry menu updated');
+      await this.loadConfig();
+    } else {
+      DeesToast.error('Failed to set entry menu');
+    }
+  }
+
+  // ---- delete menu ---------------------------------------------------------
+
+  private async confirmDeleteMenu(menu: IIvrMenu) {
+    await DeesModal.createAndShow({
+      heading: 'Delete IVR Menu',
+      width: 'small',
+      showCloseButton: true,
+      content: html`
+        <div style="padding:8px 0;font-size:.9rem;color:#e2e8f0;">
+          Are you sure you want to delete
+          <strong style="color:#f87171;">${menu.name}</strong>?
+          This action cannot be undone.
+        </div>
+      `,
+      menuOptions: [
+        {
+          name: 'Cancel',
+          iconName: 'lucide:x',
+          action: async (modalRef: any) => { modalRef.destroy(); },
+        },
+        {
+          name: 'Delete',
+          iconName: 'lucide:trash-2',
+          action: async (modalRef: any) => {
+            const ivr = this.getIvrConfig();
+            const menus = ivr.menus.filter((m) => m.id !== menu.id);
+            const updated: IIvrConfig = {
+              ...ivr,
+              menus,
+              entryMenuId: ivr.entryMenuId === menu.id ? '' : ivr.entryMenuId,
+            };
+            const result = await appState.apiSaveConfig({ ivr: updated });
+            if (result.ok) {
+              modalRef.destroy();
+              DeesToast.success(`Menu "${menu.name}" deleted`);
+              await this.loadConfig();
+            } else {
+              DeesToast.error('Failed to delete menu');
+            }
+          },
+        },
+      ],
+    });
+  }
+
+  // ---- action editor helper ------------------------------------------------
+
+  private renderActionEditor(
+    action: TIvrAction,
+    onChange: (a: TIvrAction) => void,
+    label: string,
+    cfg: any,
+  ): TemplateResult {
+    const devices = cfg?.devices || [];
+    const menus: IIvrMenu[] = cfg?.ivr?.menus || [];
+    const providers = cfg?.providers || [];
+
+    const currentType = ACTION_TYPE_OPTIONS.find((o) => o.key === action.type) || ACTION_TYPE_OPTIONS[ACTION_TYPE_OPTIONS.length - 1];
+
+    return html`
+      <div style="margin-bottom:12px;">
+        <div style="font-size:.75rem;color:#94a3b8;text-transform:uppercase;letter-spacing:.04em;margin-bottom:6px;font-weight:600;">${label}</div>
+        <dees-input-dropdown
+          .label=${'Action Type'}
+          .selectedOption=${currentType}
+          .options=${ACTION_TYPE_OPTIONS}
+          @selectedOption=${(e: CustomEvent) => {
+            const type = e.detail.key;
+            switch (type) {
+              case 'route-extension': onChange({ type, extensionId: devices[0]?.extension || '100' }); break;
+              case 'route-voicemail': onChange({ type, boxId: '' }); break;
+              case 'submenu': onChange({ type, menuId: menus[0]?.id || '' }); break;
+              case 'play-message': onChange({ type, promptId: '' }); break;
+              case 'transfer': onChange({ type, number: '' }); break;
+              case 'repeat': onChange({ type }); break;
+              case 'hangup': onChange({ type }); break;
+            }
+          }}
+        ></dees-input-dropdown>
+
+        ${action.type === 'route-extension' ? html`
+          <dees-input-dropdown
+            .label=${'Extension'}
+            .selectedOption=${{ option: action.extensionId, key: action.extensionId }}
+            .options=${devices.map((d: any) => ({ option: `${d.displayName} (${d.extension})`, key: d.extension }))}
+            @selectedOption=${(e: CustomEvent) => { onChange({ ...action, extensionId: e.detail.key }); }}
+          ></dees-input-dropdown>
+        ` : ''}
+
+        ${action.type === 'route-voicemail' ? html`
+          <dees-input-text
+            .label=${'Voicemail Box ID'}
+            .value=${action.boxId}
+            @input=${(e: Event) => { onChange({ ...action, boxId: (e.target as any).value }); }}
+          ></dees-input-text>
+        ` : ''}
+
+        ${action.type === 'submenu' ? html`
+          <dees-input-dropdown
+            .label=${'Menu'}
+            .selectedOption=${menus.find((m) => m.id === action.menuId)
+              ? { option: menus.find((m) => m.id === action.menuId)!.name, key: action.menuId }
+              : { option: '(select)', key: '' }}
+            .options=${menus.map((m) => ({ option: m.name, key: m.id }))}
+            @selectedOption=${(e: CustomEvent) => { onChange({ ...action, menuId: e.detail.key }); }}
+          ></dees-input-dropdown>
+        ` : ''}
+
+        ${action.type === 'play-message' ? html`
+          <dees-input-text
+            .label=${'Prompt ID'}
+            .value=${action.promptId}
+            @input=${(e: Event) => { onChange({ ...action, promptId: (e.target as any).value }); }}
+          ></dees-input-text>
+        ` : ''}
+
+        ${action.type === 'transfer' ? html`
+          <dees-input-text
+            .label=${'Transfer Number'}
+            .value=${action.number}
+            @input=${(e: Event) => { onChange({ ...action, number: (e.target as any).value }); }}
+          ></dees-input-text>
+          <dees-input-dropdown
+            .label=${'Provider (optional)'}
+            .selectedOption=${action.providerId
+              ? { option: action.providerId, key: action.providerId }
+              : { option: '(default)', key: '' }}
+            .options=${[
+              { option: '(default)', key: '' },
+              ...providers.map((p: any) => ({ option: p.displayName || p.id, key: p.id })),
+            ]}
+            @selectedOption=${(e: CustomEvent) => { onChange({ ...action, providerId: e.detail.key || undefined }); }}
+          ></dees-input-dropdown>
+        ` : ''}
+      </div>
+    `;
+  }
+
+  // ---- menu editor modal ---------------------------------------------------
+
+  private async openMenuEditor(existing: IIvrMenu | null) {
+    const cfg = this.config;
+
+    const formData: IIvrMenu = existing
+      ? JSON.parse(JSON.stringify(existing))
+      : {
+          id: '',
+          name: '',
+          promptText: '',
+          promptVoice: 'af_bella',
+          entries: [],
+          timeoutSec: 5,
+          maxRetries: 3,
+          timeoutAction: { type: 'hangup' as const },
+          invalidAction: { type: 'repeat' as const },
+        };
+
+    // For re-rendering the modal content on state changes we track a version counter.
+    let version = 0;
+    const modalContentId = `ivr-modal-${Date.now()}`;
+
+    const rerenderContent = () => {
+      version++;
+      const container = document.querySelector(`#${modalContentId}`) as HTMLElement
+        || document.getElementById(modalContentId);
+      if (container) {
+        // Force a re-render by removing and re-adding the modal content.
+        // We can't use lit's render directly here, so we close and reopen.
+      }
+    };
+
+    const buildContent = (): TemplateResult => html`
+      <div style="display:flex;flex-direction:column;gap:12px;padding:4px 0;">
+        <dees-input-text
+          .key=${'name'} .label=${'Menu Name'} .value=${formData.name}
+          @input=${(e: Event) => {
+            formData.name = (e.target as any).value;
+            if (!existing) {
+              formData.id = slugify(formData.name);
+            }
+          }}
+        ></dees-input-text>
+
+        <dees-input-text
+          .key=${'id'} .label=${'Menu ID'} .value=${formData.id}
+          .description=${'Auto-generated from name. Editable for custom IDs.'}
+          @input=${(e: Event) => { formData.id = (e.target as any).value; }}
+        ></dees-input-text>
+
+        <dees-input-text
+          .key=${'promptText'} .label=${'Prompt Text (TTS)'}
+          .value=${formData.promptText}
+          .description=${'Text that will be read aloud to the caller.'}
+          @input=${(e: Event) => { formData.promptText = (e.target as any).value; }}
+        ></dees-input-text>
+
+        <dees-input-dropdown
+          .key=${'promptVoice'} .label=${'Voice'}
+          .selectedOption=${VOICE_OPTIONS.find((v) => v.key === formData.promptVoice) || VOICE_OPTIONS[0]}
+          .options=${VOICE_OPTIONS}
+          @selectedOption=${(e: CustomEvent) => { formData.promptVoice = e.detail.key; }}
+        ></dees-input-dropdown>
+
+        <div style="margin-top:8px;padding-top:12px;border-top:1px solid #334155;">
+          <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:8px;">
+            <div style="font-size:.75rem;color:#94a3b8;text-transform:uppercase;letter-spacing:.04em;font-weight:600;">
+              Digit Entries
+            </div>
+            <div
+              style="font-size:.75rem;color:#60a5fa;cursor:pointer;user-select:none;"
+              @click=${() => {
+                const usedDigits = new Set(formData.entries.map((e) => e.digit));
+                const nextDigit = DIGIT_OPTIONS.find((d) => !usedDigits.has(d)) || '1';
+                formData.entries = [...formData.entries, { digit: nextDigit, action: makeDefaultAction() }];
+                rerenderContent();
+              }}
+            >+ Add Digit</div>
+          </div>
+
+          ${formData.entries.length === 0
+            ? html`<div style="font-size:.82rem;color:#64748b;font-style:italic;margin-bottom:8px;">No digit entries configured.</div>`
+            : formData.entries.map((entry, idx) => html`
+              <div style="padding:8px;margin-bottom:8px;border:1px solid #334155;border-radius:6px;background:#0f172a;">
+                <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:8px;">
+                  <dees-input-dropdown
+                    .label=${'Digit'}
+                    .selectedOption=${{ option: entry.digit, key: entry.digit }}
+                    .options=${DIGIT_OPTIONS.map((d) => ({ option: d, key: d }))}
+                    @selectedOption=${(e: CustomEvent) => {
+                      formData.entries[idx].digit = e.detail.key;
+                    }}
+                  ></dees-input-dropdown>
+                  <div
+                    style="font-size:.75rem;color:#f87171;cursor:pointer;user-select:none;margin-left:12px;padding:4px 8px;"
+                    @click=${() => {
+                      formData.entries = formData.entries.filter((_, i) => i !== idx);
+                      rerenderContent();
+                    }}
+                  >Remove</div>
+                </div>
+                ${this.renderActionEditor(
+                  entry.action,
+                  (a) => { formData.entries[idx].action = a; rerenderContent(); },
+                  'Action',
+                  cfg,
+                )}
+              </div>
+            `)
+          }
+        </div>
+
+        <div style="margin-top:8px;padding-top:12px;border-top:1px solid #334155;">
+          <div style="font-size:.75rem;color:#94a3b8;text-transform:uppercase;letter-spacing:.04em;margin-bottom:8px;font-weight:600;">
+            Timeout Settings
+          </div>
+          <div style="display:flex;gap:12px;">
+            <dees-input-text
+              .key=${'timeoutSec'} .label=${'Timeout (sec)'}
+              .value=${String(formData.timeoutSec ?? 5)}
+              @input=${(e: Event) => { formData.timeoutSec = parseInt((e.target as any).value, 10) || 5; }}
+            ></dees-input-text>
+            <dees-input-text
+              .key=${'maxRetries'} .label=${'Max Retries'}
+              .value=${String(formData.maxRetries ?? 3)}
+              @input=${(e: Event) => { formData.maxRetries = parseInt((e.target as any).value, 10) || 3; }}
+            ></dees-input-text>
+          </div>
+        </div>
+
+        <div style="margin-top:8px;padding-top:12px;border-top:1px solid #334155;">
+          ${this.renderActionEditor(
+            formData.timeoutAction,
+            (a) => { formData.timeoutAction = a; rerenderContent(); },
+            'Timeout Action (no digit pressed)',
+            cfg,
+          )}
+          ${this.renderActionEditor(
+            formData.invalidAction,
+            (a) => { formData.invalidAction = a; rerenderContent(); },
+            'Invalid Digit Action',
+            cfg,
+          )}
+        </div>
+      </div>
+    `;
+
+    await DeesModal.createAndShow({
+      heading: existing ? `Edit Menu: ${existing.name}` : 'New IVR Menu',
+      width: 'small',
+      showCloseButton: true,
+      content: html`<div id="${modalContentId}">${buildContent()}</div>`,
+      menuOptions: [
+        {
+          name: 'Cancel',
+          iconName: 'lucide:x',
+          action: async (modalRef: any) => { modalRef.destroy(); },
+        },
+        {
+          name: 'Save',
+          iconName: 'lucide:check',
+          action: async (modalRef: any) => {
+            if (!formData.name.trim()) {
+              DeesToast.error('Menu name is required');
+              return;
+            }
+            if (!formData.id.trim()) {
+              DeesToast.error('Menu ID is required');
+              return;
+            }
+            if (!formData.promptText.trim()) {
+              DeesToast.error('Prompt text is required');
+              return;
+            }
+
+            const ivr = this.getIvrConfig();
+            const menus = [...ivr.menus];
+            const idx = menus.findIndex((m) => m.id === (existing?.id || formData.id));
+            if (idx >= 0) {
+              menus[idx] = formData;
+            } else {
+              menus.push(formData);
+            }
+
+            const updated: IIvrConfig = {
+              ...ivr,
+              menus,
+              // Auto-set entry menu if this is the first menu.
+              entryMenuId: ivr.entryMenuId || formData.id,
+            };
+
+            const result = await appState.apiSaveConfig({ ivr: updated });
+            if (result.ok) {
+              modalRef.destroy();
+              DeesToast.success(existing ? 'Menu updated' : 'Menu created');
+              await this.loadConfig();
+            } else {
+              DeesToast.error('Failed to save menu');
+            }
+          },
+        },
+      ],
+    });
+  }
+
+  // ---- render --------------------------------------------------------------
+
+  public render(): TemplateResult {
+    const ivr = this.getIvrConfig();
+    const menus = ivr.menus || [];
+
+    return html`
+      <div class="view-section">
+        <dees-statsgrid
+          .tiles=${this.getStatsTiles()}
+          .minTileWidth=${220}
+          .gap=${16}
+        ></dees-statsgrid>
+      </div>
+
+      <div class="view-section" style="display:flex;align-items:center;gap:12px;margin-bottom:16px;">
+        <dees-input-checkbox
+          .key=${'ivr-enabled'}
+          .label=${'Enable IVR System'}
+          .value=${ivr.enabled}
+          @newValue=${() => { this.toggleEnabled(); }}
+        ></dees-input-checkbox>
+      </div>
+
+      <div class="view-section">
+        <dees-table
+          heading1="IVR Menus"
+          heading2="${menus.length} configured"
+          dataName="menus"
+          .data=${menus}
+          .rowKey=${'id'}
+          .columns=${this.getColumns()}
+          .dataActions=${this.getDataActions()}
+        ></dees-table>
+      </div>
+    `;
+  }
+}

ts_web/elements/sipproxy-view-voicemail.ts

@@ -0,0 +1,446 @@
+import { DeesElement, customElement, html, css, cssManager, state, type TemplateResult } from '../plugins.js';
+import { deesCatalog } from '../plugins.js';
+import { appState, type IAppState } from '../state/appstate.js';
+import { viewHostCss } from './shared/index.js';
+import type { IStatsTile } from '@design.estate/dees-catalog';
+
+// ---------------------------------------------------------------------------
+// Voicemail message shape (mirrors server IVoicemailMessage)
+// ---------------------------------------------------------------------------
+interface IVoicemailMessage {
+  id: string;
+  boxId: string;
+  callerNumber: string;
+  callerName?: string;
+  timestamp: number;
+  durationMs: number;
+  fileName: string;
+  heard: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function formatDuration(ms: number): string {
+  const totalSec = Math.round(ms / 1000);
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  return `${min}:${sec.toString().padStart(2, '0')}`;
+}
+
+function formatDateTime(ts: number): string {
+  const d = new Date(ts);
+  const date = d.toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric' });
+  const time = d.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
+  return `${date} ${time}`;
+}
+
+// ---------------------------------------------------------------------------
+// View element
+// ---------------------------------------------------------------------------
+@customElement('sipproxy-view-voicemail')
+export class SipproxyViewVoicemail extends DeesElement {
+  @state() accessor appData: IAppState = appState.getState();
+  @state() accessor messages: IVoicemailMessage[] = [];
+  @state() accessor voiceboxIds: string[] = [];
+  @state() accessor selectedBoxId: string = '';
+  @state() accessor playingMessageId: string | null = null;
+  @state() accessor loading: boolean = false;
+
+  private audioElement: HTMLAudioElement | null = null;
+
+  public static styles = [
+    cssManager.defaultStyles,
+    viewHostCss,
+    css`
+      :host {
+        display: block;
+        padding: 16px;
+      }
+      .view-section {
+        margin-bottom: 24px;
+      }
+      .box-selector {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        margin-bottom: 24px;
+      }
+      .box-selector label {
+        font-size: 0.85rem;
+        font-weight: 600;
+        color: #94a3b8;
+        text-transform: uppercase;
+        letter-spacing: 0.04em;
+      }
+      .audio-player {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding: 8px 12px;
+        background: #1e293b;
+        border-radius: 8px;
+        margin-top: 16px;
+      }
+      .audio-player audio {
+        flex: 1;
+        height: 32px;
+      }
+      .audio-player .close-btn {
+        cursor: pointer;
+        color: #94a3b8;
+        font-size: 1.1rem;
+        padding: 2px 6px;
+        border-radius: 4px;
+        transition: background 0.15s;
+      }
+      .audio-player .close-btn:hover {
+        background: #334155;
+        color: #e2e8f0;
+      }
+      .empty-state {
+        text-align: center;
+        padding: 48px 16px;
+        color: #64748b;
+        font-size: 0.9rem;
+      }
+      .empty-state .icon {
+        font-size: 2.5rem;
+        margin-bottom: 12px;
+        opacity: 0.5;
+      }
+    `,
+  ];
+
+  // ---- lifecycle -----------------------------------------------------------
+
+  connectedCallback() {
+    super.connectedCallback();
+    this.rxSubscriptions.push({
+      unsubscribe: appState.subscribe((s) => { this.appData = s; }),
+    } as any);
+    this.loadVoiceboxes();
+  }
+
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.stopAudio();
+  }
+
+  // ---- data loading --------------------------------------------------------
+
+  private async loadVoiceboxes() {
+    try {
+      const cfg = await appState.apiGetConfig();
+      const boxes: { id: string }[] = cfg.voiceboxes || [];
+      this.voiceboxIds = boxes.map((b) => b.id);
+      if (this.voiceboxIds.length > 0 && !this.selectedBoxId) {
+        this.selectedBoxId = this.voiceboxIds[0];
+        await this.loadMessages();
+      }
+    } catch {
+      // Config unavailable.
+    }
+  }
+
+  private async loadMessages() {
+    if (!this.selectedBoxId) {
+      this.messages = [];
+      return;
+    }
+    this.loading = true;
+    try {
+      const res = await fetch(`/api/voicemail/${encodeURIComponent(this.selectedBoxId)}`);
+      const data = await res.json();
+      this.messages = data.messages || [];
+    } catch {
+      this.messages = [];
+    }
+    this.loading = false;
+  }
+
+  private async selectBox(boxId: string) {
+    this.selectedBoxId = boxId;
+    this.stopAudio();
+    await this.loadMessages();
+  }
+
+  // ---- audio playback ------------------------------------------------------
+
+  private playMessage(msg: IVoicemailMessage) {
+    this.stopAudio();
+    const url = `/api/voicemail/${encodeURIComponent(msg.boxId)}/${encodeURIComponent(msg.id)}/audio`;
+    const audio = new Audio(url);
+    this.audioElement = audio;
+    this.playingMessageId = msg.id;
+
+    audio.addEventListener('ended', () => {
+      this.playingMessageId = null;
+      // Auto-mark as heard after playback completes.
+      if (!msg.heard) {
+        this.markHeard(msg);
+      }
+    });
+
+    audio.addEventListener('error', () => {
+      this.playingMessageId = null;
+      deesCatalog.DeesToast.error('Failed to play audio');
+    });
+
+    audio.play().catch(() => {
+      this.playingMessageId = null;
+    });
+  }
+
+  private stopAudio() {
+    if (this.audioElement) {
+      this.audioElement.pause();
+      this.audioElement.src = '';
+      this.audioElement = null;
+    }
+    this.playingMessageId = null;
+  }
+
+  // ---- message actions -----------------------------------------------------
+
+  private async markHeard(msg: IVoicemailMessage) {
+    try {
+      await fetch(`/api/voicemail/${encodeURIComponent(msg.boxId)}/${encodeURIComponent(msg.id)}/heard`, {
+        method: 'POST',
+      });
+      // Update local state without full reload.
+      this.messages = this.messages.map((m) =>
+        m.id === msg.id ? { ...m, heard: true } : m,
+      );
+    } catch {
+      deesCatalog.DeesToast.error('Failed to mark message as heard');
+    }
+  }
+
+  private async deleteMessage(msg: IVoicemailMessage) {
+    const { DeesModal } = await import('@design.estate/dees-catalog');
+    await DeesModal.createAndShow({
+      heading: 'Delete Voicemail',
+      width: 'small',
+      showCloseButton: true,
+      content: html`
+        <div style="padding:8px 0;font-size:.9rem;color:#e2e8f0;">
+          Are you sure you want to delete the voicemail from
+          <strong style="color:#f87171;">${msg.callerName || msg.callerNumber}</strong>
+          (${formatDateTime(msg.timestamp)})?
+        </div>
+      `,
+      menuOptions: [
+        {
+          name: 'Cancel',
+          iconName: 'lucide:x',
+          action: async (modalRef: any) => { modalRef.destroy(); },
+        },
+        {
+          name: 'Delete',
+          iconName: 'lucide:trash-2',
+          action: async (modalRef: any) => {
+            try {
+              await fetch(
+                `/api/voicemail/${encodeURIComponent(msg.boxId)}/${encodeURIComponent(msg.id)}`,
+                { method: 'DELETE' },
+              );
+              if (this.playingMessageId === msg.id) {
+                this.stopAudio();
+              }
+              this.messages = this.messages.filter((m) => m.id !== msg.id);
+              modalRef.destroy();
+              deesCatalog.DeesToast.success('Voicemail deleted');
+            } catch {
+              deesCatalog.DeesToast.error('Failed to delete voicemail');
+            }
+          },
+        },
+      ],
+    });
+  }
+
+  // ---- stats tiles ---------------------------------------------------------
+
+  private getStatsTiles(): IStatsTile[] {
+    const total = this.messages.length;
+    const unheard = this.messages.filter((m) => !m.heard).length;
+
+    return [
+      {
+        id: 'total',
+        title: 'Total Messages',
+        value: total,
+        type: 'number',
+        icon: 'lucide:voicemail',
+        description: this.selectedBoxId ? `Box: ${this.selectedBoxId}` : 'No box selected',
+      },
+      {
+        id: 'unheard',
+        title: 'Unheard Messages',
+        value: unheard,
+        type: 'number',
+        icon: 'lucide:bell-ring',
+        color: unheard > 0 ? 'hsl(0 84.2% 60.2%)' : 'hsl(142.1 76.2% 36.3%)',
+        description: unheard > 0 ? 'Needs attention' : 'All caught up',
+      },
+    ];
+  }
+
+  // ---- table columns -------------------------------------------------------
+
+  private getColumns() {
+    return [
+      {
+        key: 'callerNumber',
+        header: 'Caller',
+        sortable: true,
+        renderer: (_val: string, row: IVoicemailMessage) => {
+          const display = row.callerName
+            ? html`<span>${row.callerName}</span><br><span style="font-size:.75rem;color:#64748b">${row.callerNumber}</span>`
+            : html`<span style="font-family:'JetBrains Mono',monospace;font-size:.85rem">${row.callerNumber}</span>`;
+          return html`<div>${display}</div>`;
+        },
+      },
+      {
+        key: 'timestamp',
+        header: 'Date/Time',
+        sortable: true,
+        value: (row: IVoicemailMessage) => formatDateTime(row.timestamp),
+        renderer: (val: string) =>
+          html`<span style="font-size:.85rem">${val}</span>`,
+      },
+      {
+        key: 'durationMs',
+        header: 'Duration',
+        sortable: true,
+        value: (row: IVoicemailMessage) => formatDuration(row.durationMs),
+        renderer: (val: string) =>
+          html`<span style="font-family:'JetBrains Mono',monospace;font-size:.85rem">${val}</span>`,
+      },
+      {
+        key: 'heard',
+        header: 'Status',
+        renderer: (val: boolean, row: IVoicemailMessage) => {
+          const isPlaying = this.playingMessageId === row.id;
+          if (isPlaying) {
+            return html`
+              <span style="display:inline-block;padding:2px 8px;border-radius:4px;font-size:.7rem;font-weight:600;text-transform:uppercase;background:#1e3a5f;color:#60a5fa">Playing</span>
+            `;
+          }
+          const heard = val;
+          const color = heard ? '#71717a' : '#f59e0b';
+          const bg = heard ? '#3f3f46' : '#422006';
+          const label = heard ? 'Heard' : 'New';
+          return html`
+            <span style="display:inline-block;padding:2px 8px;border-radius:4px;font-size:.7rem;font-weight:600;text-transform:uppercase;background:${bg};color:${color}">${label}</span>
+          `;
+        },
+      },
+    ];
+  }
+
+  // ---- table actions -------------------------------------------------------
+
+  private getDataActions() {
+    return [
+      {
+        name: 'Play',
+        iconName: 'lucide:play',
+        type: ['inRow'] as any,
+        actionFunc: async (actionData: any) => {
+          const msg = actionData.item as IVoicemailMessage;
+          if (this.playingMessageId === msg.id) {
+            this.stopAudio();
+          } else {
+            this.playMessage(msg);
+          }
+        },
+      },
+      {
+        name: 'Mark Heard',
+        iconName: 'lucide:check',
+        type: ['inRow'] as any,
+        actionFunc: async (actionData: any) => {
+          const msg = actionData.item as IVoicemailMessage;
+          if (!msg.heard) {
+            await this.markHeard(msg);
+            deesCatalog.DeesToast.success('Marked as heard');
+          }
+        },
+      },
+      {
+        name: 'Delete',
+        iconName: 'lucide:trash-2',
+        type: ['inRow'] as any,
+        actionFunc: async (actionData: any) => {
+          await this.deleteMessage(actionData.item as IVoicemailMessage);
+        },
+      },
+      {
+        name: 'Refresh',
+        iconName: 'lucide:refreshCw',
+        type: ['header'] as any,
+        actionFunc: async () => {
+          await this.loadMessages();
+          deesCatalog.DeesToast.success('Messages refreshed');
+        },
+      },
+    ];
+  }
+
+  // ---- render --------------------------------------------------------------
+
+  public render(): TemplateResult {
+    return html`
+      ${this.voiceboxIds.length > 1 ? html`
+        <div class="box-selector">
+          <label>Voicebox</label>
+          <dees-input-dropdown
+            .key=${'voicebox'}
+            .selectedOption=${{ option: this.selectedBoxId, key: this.selectedBoxId }}
+            .options=${this.voiceboxIds.map((id) => ({ option: id, key: id }))}
+            @selectedOption=${(e: CustomEvent) => { this.selectBox(e.detail.key); }}
+          ></dees-input-dropdown>
+        </div>
+      ` : ''}
+
+      <div class="view-section">
+        <dees-statsgrid
+          .tiles=${this.getStatsTiles()}
+          .minTileWidth=${220}
+          .gap=${16}
+        ></dees-statsgrid>
+      </div>
+
+      ${this.messages.length === 0 && !this.loading ? html`
+        <div class="empty-state">
+          <div class="icon">&#9993;</div>
+          <div>No voicemail messages${this.selectedBoxId ? ` in box "${this.selectedBoxId}"` : ''}</div>
+        </div>
+      ` : html`
+        <div class="view-section">
+          <dees-table
+            heading1="Voicemail"
+            heading2="${this.messages.length} message${this.messages.length !== 1 ? 's' : ''}"
+            dataName="voicemail"
+            .data=${this.messages}
+            .rowKey=${'id'}
+            .searchable=${true}
+            .columns=${this.getColumns()}
+            .dataActions=${this.getDataActions()}
+          ></dees-table>
+        </div>
+      `}
+
+      ${this.playingMessageId ? html`
+        <div class="audio-player">
+          <span style="color:#60a5fa;font-size:.8rem;font-weight:600;">Now playing</span>
+          <span style="flex:1"></span>
+          <span class="close-btn" @click=${() => this.stopAudio()}>&#10005;</span>
+        </div>
+      ` : ''}
+    `;
+  }
+}

ts_web/router.ts

@@ -3,7 +3,7 @@
  * Maps URL paths to views in dees-simple-appdash.
  */
 
-const VIEWS = ['overview', 'calls', 'phone', 'routes', 'contacts', 'providers', 'log'] as const;
+const VIEWS = ['overview', 'calls', 'phone', 'routes', 'voicemail', 'ivr', 'contacts', 'providers', 'log'] as const;
 type TViewSlug = (typeof VIEWS)[number];
 
 class AppRouter {

ts_web/state/appstate.ts

@@ -72,6 +72,8 @@ export interface IAppState {
   contacts: IContact[];
   selectedContact: IContact | null;
   logLines: string[];
+  /** Unheard voicemail count per voicebox ID. */
+  voicemailCounts: Record<string, number>;
 }
 
 const MAX_LOG = 200;
@@ -89,6 +91,7 @@ class AppStateManager {
     contacts: [],
     selectedContact: null,
     logLines: [],
+    voicemailCounts: {},
   };
 
   private listeners = new Set<(state: IAppState) => void>();
@@ -155,6 +158,7 @@ class AppStateManager {
             calls: m.data.calls || [],
             callHistory: m.data.callHistory || [],
             contacts: m.data.contacts || [],
+            voicemailCounts: m.data.voicemailCounts || {},
           });
         } else if (m.type === 'log') {
           this.addLog(`${m.ts} ${m.data.message}`);