feat: Add wifi-Mat disaster detection enhancements

Implement 6 optional enhancements for the wifi-Mat module:

1. Hardware Integration (csi_receiver.rs + hardware_adapter.rs)
   - ESP32 CSI support via serial/UDP
   - Intel 5300 BFEE file parsing
   - Atheros CSI Tool integration
   - Live UDP packet streaming
   - PCAP replay capability

2. CLI Commands (wifi-densepose-cli/src/mat.rs)
   - `wifi-mat scan` - Run disaster detection scan
   - `wifi-mat status` - Check event status
   - `wifi-mat zones` - Manage scan zones
   - `wifi-mat survivors` - List detected survivors
   - `wifi-mat alerts` - View and acknowledge alerts
   - `wifi-mat export` - Export data in various formats

3. REST API (wifi-densepose-mat/src/api/)
   - Full CRUD for disaster events
   - Zone management endpoints
   - Survivor and alert queries
   - WebSocket streaming for real-time updates
   - Comprehensive DTOs and error handling

4. WASM Build (wifi-densepose-wasm/src/mat.rs)
   - Browser-based disaster dashboard
   - Real-time survivor tracking
   - Zone visualization
   - Alert management
   - JavaScript API bindings

5. Detection Benchmarks (benches/detection_bench.rs)
   - Single survivor detection
   - Multi-survivor detection
   - Full pipeline benchmarks
   - Signal processing benchmarks
   - Hardware adapter benchmarks

6. ML Models for Debris Penetration (ml/)
   - DebrisModel for material analysis
   - VitalSignsClassifier for triage
   - FFT-based feature extraction
   - Bandpass filtering
   - Monte Carlo dropout for uncertainty

All 134 unit tests pass. Compilation verified for:
- wifi-densepose-mat
- wifi-densepose-cli
- wifi-densepose-wasm (with mat feature)

rust-port/wifi-densepose-rs/crates/wifi-densepose-cli/Cargo.toml

@@ -3,5 +3,54 @@ name = "wifi-densepose-cli"
 version.workspace = true
 edition.workspace = true
 description = "CLI for WiFi-DensePose"
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[[bin]]
+name = "wifi-densepose"
+path = "src/main.rs"
+
+[features]
+default = ["mat"]
+mat = []
 
 [dependencies]
+# Internal crates
+wifi-densepose-mat = { path = "../wifi-densepose-mat" }
+
+# CLI framework
+clap = { version = "4.4", features = ["derive", "env", "cargo"] }
+
+# Output formatting
+colored = "2.1"
+tabled = { version = "0.15", features = ["ansi"] }
+indicatif = "0.17"
+console = "0.15"
+
+# Async runtime
+tokio = { version = "1.35", features = ["full"] }
+
+# Serialization
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+csv = "1.3"
+
+# Error handling
+anyhow = "1.0"
+thiserror = "1.0"
+
+# Time
+chrono = { version = "0.4", features = ["serde"] }
+
+# UUID
+uuid = { version = "1.6", features = ["v4", "serde"] }
+
+# Logging
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
+
+[dev-dependencies]
+assert_cmd = "2.0"
+predicates = "3.0"
+tempfile = "3.9"

rust-port/wifi-densepose-rs/crates/wifi-densepose-cli/src/lib.rs

@@ -1 +1,51 @@
-//! WiFi-DensePose CLI (stub)
+//! WiFi-DensePose CLI
+//!
+//! Command-line interface for WiFi-DensePose system, including the
+//! Mass Casualty Assessment Tool (MAT) for disaster response.
+//!
+//! # Features
+//!
+//! - **mat**: Disaster survivor detection and triage management
+//! - **version**: Display version information
+//!
+//! # Usage
+//!
+//! ```bash
+//! # Start scanning for survivors
+//! wifi-densepose mat scan --zone "Building A"
+//!
+//! # View current scan status
+//! wifi-densepose mat status
+//!
+//! # List detected survivors
+//! wifi-densepose mat survivors --sort-by triage
+//!
+//! # View and manage alerts
+//! wifi-densepose mat alerts
+//! ```
+
+use clap::{Parser, Subcommand};
+
+pub mod mat;
+
+/// WiFi-DensePose Command Line Interface
+#[derive(Parser, Debug)]
+#[command(name = "wifi-densepose")]
+#[command(author, version, about = "WiFi-based pose estimation and disaster response")]
+#[command(propagate_version = true)]
+pub struct Cli {
+    /// Command to execute
+    #[command(subcommand)]
+    pub command: Commands,
+}
+
+/// Top-level commands
+#[derive(Subcommand, Debug)]
+pub enum Commands {
+    /// Mass Casualty Assessment Tool commands
+    #[command(subcommand)]
+    Mat(mat::MatCommand),
+
+    /// Display version information
+    Version,
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-cli/src/main.rs

@@ -0,0 +1,31 @@
+//! WiFi-DensePose CLI Entry Point
+//!
+//! This is the main entry point for the wifi-densepose command-line tool.
+
+use clap::Parser;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+
+use wifi_densepose_cli::{Cli, Commands};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Initialize logging
+    tracing_subscriber::registry()
+        .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")))
+        .with(tracing_subscriber::fmt::layer().with_target(false))
+        .init();
+
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Mat(mat_cmd) => {
+            wifi_densepose_cli::mat::execute(mat_cmd).await?;
+        }
+        Commands::Version => {
+            println!("wifi-densepose {}", env!("CARGO_PKG_VERSION"));
+            println!("MAT module version: {}", wifi_densepose_mat::VERSION);
+        }
+    }
+
+    Ok(())
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/Cargo.toml

@@ -10,13 +10,14 @@ keywords = ["wifi", "disaster", "rescue", "detection", "vital-signs"]
 categories = ["science", "algorithms"]
 
 [features]
-default = ["std"]
+default = ["std", "api"]
 std = []
+api = ["dep:serde", "chrono/serde", "geo/use-serde"]
 portable = ["low-power"]
 low-power = []
 distributed = ["tokio/sync"]
 drone = ["distributed"]
-serde = ["dep:serde", "chrono/serde"]
+serde = ["dep:serde", "chrono/serde", "geo/use-serde"]
 
 [dependencies]
 # Workspace dependencies
@@ -28,6 +29,10 @@ wifi-densepose-nn = { path = "../wifi-densepose-nn" }
 tokio = { version = "1.35", features = ["rt", "sync", "time"] }
 async-trait = "0.1"
 
+# Web framework (REST API)
+axum = { version = "0.7", features = ["ws"] }
+futures-util = "0.3"
+
 # Error handling
 thiserror = "1.0"
 anyhow = "1.0"
@@ -58,6 +63,10 @@ criterion = { version = "0.5", features = ["html_reports"] }
 proptest = "1.4"
 approx = "0.5"
 
+[[bench]]
+name = "detection_bench"
+harness = false
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/benches/detection_bench.rs

@@ -0,0 +1,906 @@
+//! Performance benchmarks for wifi-densepose-mat detection algorithms.
+//!
+//! Run with: cargo bench --package wifi-densepose-mat
+//!
+//! Benchmarks cover:
+//! - Breathing detection at various signal lengths
+//! - Heartbeat detection performance
+//! - Movement classification
+//! - Full detection pipeline
+//! - Localization algorithms (triangulation, depth estimation)
+//! - Alert generation
+
+use criterion::{
+    black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput,
+};
+use std::f64::consts::PI;
+
+use wifi_densepose_mat::{
+    // Detection types
+    BreathingDetector, BreathingDetectorConfig,
+    HeartbeatDetector, HeartbeatDetectorConfig,
+    MovementClassifier, MovementClassifierConfig,
+    DetectionConfig, DetectionPipeline, VitalSignsDetector,
+    // Localization types
+    Triangulator, DepthEstimator,
+    // Alerting types
+    AlertGenerator,
+    // Domain types exported at crate root
+    BreathingPattern, BreathingType, VitalSignsReading,
+    MovementProfile, ScanZoneId, Survivor,
+};
+
+// Types that need to be accessed from submodules
+use wifi_densepose_mat::detection::CsiDataBuffer;
+use wifi_densepose_mat::domain::{
+    ConfidenceScore, SensorPosition, SensorType,
+    DebrisProfile, DebrisMaterial, MoistureLevel, MetalContent,
+};
+
+use chrono::Utc;
+
+// =============================================================================
+// Test Data Generators
+// =============================================================================
+
+/// Generate a clean breathing signal at specified rate
+fn generate_breathing_signal(rate_bpm: f64, sample_rate: f64, duration_secs: f64) -> Vec<f64> {
+    let num_samples = (sample_rate * duration_secs) as usize;
+    let freq = rate_bpm / 60.0;
+
+    (0..num_samples)
+        .map(|i| {
+            let t = i as f64 / sample_rate;
+            (2.0 * PI * freq * t).sin()
+        })
+        .collect()
+}
+
+/// Generate a breathing signal with noise
+fn generate_noisy_breathing_signal(
+    rate_bpm: f64,
+    sample_rate: f64,
+    duration_secs: f64,
+    noise_level: f64,
+) -> Vec<f64> {
+    let num_samples = (sample_rate * duration_secs) as usize;
+    let freq = rate_bpm / 60.0;
+
+    (0..num_samples)
+        .map(|i| {
+            let t = i as f64 / sample_rate;
+            let signal = (2.0 * PI * freq * t).sin();
+            // Simple pseudo-random noise based on sample index
+            let noise = ((i as f64 * 12345.6789).sin() * 2.0 - 1.0) * noise_level;
+            signal + noise
+        })
+        .collect()
+}
+
+/// Generate heartbeat signal with micro-Doppler characteristics
+fn generate_heartbeat_signal(rate_bpm: f64, sample_rate: f64, duration_secs: f64) -> Vec<f64> {
+    let num_samples = (sample_rate * duration_secs) as usize;
+    let freq = rate_bpm / 60.0;
+
+    (0..num_samples)
+        .map(|i| {
+            let t = i as f64 / sample_rate;
+            let phase = 2.0 * PI * freq * t;
+            // Heartbeat is more pulse-like than sinusoidal
+            0.3 * phase.sin() + 0.1 * (2.0 * phase).sin() + 0.05 * (3.0 * phase).sin()
+        })
+        .collect()
+}
+
+/// Generate combined breathing + heartbeat signal
+fn generate_combined_vital_signal(
+    breathing_rate: f64,
+    heart_rate: f64,
+    sample_rate: f64,
+    duration_secs: f64,
+) -> (Vec<f64>, Vec<f64>) {
+    let num_samples = (sample_rate * duration_secs) as usize;
+    let br_freq = breathing_rate / 60.0;
+    let hr_freq = heart_rate / 60.0;
+
+    let amplitudes: Vec<f64> = (0..num_samples)
+        .map(|i| {
+            let t = i as f64 / sample_rate;
+            // Breathing dominates amplitude
+            (2.0 * PI * br_freq * t).sin()
+        })
+        .collect();
+
+    let phases: Vec<f64> = (0..num_samples)
+        .map(|i| {
+            let t = i as f64 / sample_rate;
+            // Phase captures both but heartbeat is more prominent
+            let breathing = 0.3 * (2.0 * PI * br_freq * t).sin();
+            let heartbeat = 0.5 * (2.0 * PI * hr_freq * t).sin();
+            breathing + heartbeat
+        })
+        .collect();
+
+    (amplitudes, phases)
+}
+
+/// Generate multi-person scenario with overlapping signals
+fn generate_multi_person_signal(
+    person_count: usize,
+    sample_rate: f64,
+    duration_secs: f64,
+) -> Vec<f64> {
+    let num_samples = (sample_rate * duration_secs) as usize;
+
+    // Different breathing rates for each person
+    let base_rates: Vec<f64> = (0..person_count)
+        .map(|i| 12.0 + (i as f64 * 3.5)) // 12, 15.5, 19, 22.5... BPM
+        .collect();
+
+    (0..num_samples)
+        .map(|i| {
+            let t = i as f64 / sample_rate;
+            base_rates.iter()
+                .enumerate()
+                .map(|(idx, &rate)| {
+                    let freq = rate / 60.0;
+                    let amplitude = 1.0 / (idx + 1) as f64; // Distance-based attenuation
+                    let phase_offset = idx as f64 * PI / 4.0; // Different phases
+                    amplitude * (2.0 * PI * freq * t + phase_offset).sin()
+                })
+                .sum::<f64>()
+        })
+        .collect()
+}
+
+/// Generate movement signal with specified characteristics
+fn generate_movement_signal(
+    movement_type: &str,
+    sample_rate: f64,
+    duration_secs: f64,
+) -> Vec<f64> {
+    let num_samples = (sample_rate * duration_secs) as usize;
+
+    match movement_type {
+        "gross" => {
+            // Large, irregular movements
+            let mut signal = vec![0.0; num_samples];
+            for i in (num_samples / 4)..(num_samples / 2) {
+                signal[i] = 2.0;
+            }
+            for i in (3 * num_samples / 4)..(4 * num_samples / 5) {
+                signal[i] = -1.5;
+            }
+            signal
+        }
+        "tremor" => {
+            // High-frequency tremor (8-12 Hz)
+            (0..num_samples)
+                .map(|i| {
+                    let t = i as f64 / sample_rate;
+                    0.3 * (2.0 * PI * 10.0 * t).sin()
+                })
+                .collect()
+        }
+        "periodic" => {
+            // Low-frequency periodic (breathing-like)
+            (0..num_samples)
+                .map(|i| {
+                    let t = i as f64 / sample_rate;
+                    0.5 * (2.0 * PI * 0.25 * t).sin()
+                })
+                .collect()
+        }
+        _ => vec![0.0; num_samples], // No movement
+    }
+}
+
+/// Create test sensor positions in a triangular configuration
+fn create_test_sensors(count: usize) -> Vec<SensorPosition> {
+    (0..count)
+        .map(|i| {
+            let angle = 2.0 * PI * i as f64 / count as f64;
+            SensorPosition {
+                id: format!("sensor_{}", i),
+                x: 10.0 * angle.cos(),
+                y: 10.0 * angle.sin(),
+                z: 1.5,
+                sensor_type: SensorType::Transceiver,
+                is_operational: true,
+            }
+        })
+        .collect()
+}
+
+/// Create test debris profile
+fn create_test_debris() -> DebrisProfile {
+    DebrisProfile {
+        primary_material: DebrisMaterial::Mixed,
+        void_fraction: 0.25,
+        moisture_content: MoistureLevel::Dry,
+        metal_content: MetalContent::Low,
+    }
+}
+
+/// Create test survivor for alert generation
+fn create_test_survivor() -> Survivor {
+    let vitals = VitalSignsReading {
+        breathing: Some(BreathingPattern {
+            rate_bpm: 18.0,
+            amplitude: 0.8,
+            regularity: 0.9,
+            pattern_type: BreathingType::Normal,
+        }),
+        heartbeat: None,
+        movement: MovementProfile::default(),
+        timestamp: Utc::now(),
+        confidence: ConfidenceScore::new(0.85),
+    };
+
+    Survivor::new(ScanZoneId::new(), vitals, None)
+}
+
+// =============================================================================
+// Breathing Detection Benchmarks
+// =============================================================================
+
+fn bench_breathing_detection(c: &mut Criterion) {
+    let mut group = c.benchmark_group("breathing_detection");
+
+    let detector = BreathingDetector::with_defaults();
+    let sample_rate = 100.0; // 100 Hz
+
+    // Benchmark different signal lengths
+    for duration in [5.0, 10.0, 30.0, 60.0] {
+        let signal = generate_breathing_signal(16.0, sample_rate, duration);
+        let num_samples = signal.len();
+
+        group.throughput(Throughput::Elements(num_samples as u64));
+        group.bench_with_input(
+            BenchmarkId::new("clean_signal", format!("{}s", duration as u32)),
+            &signal,
+            |b, signal| {
+                b.iter(|| detector.detect(black_box(signal), black_box(sample_rate)))
+            },
+        );
+    }
+
+    // Benchmark different noise levels
+    for noise_level in [0.0, 0.1, 0.3, 0.5] {
+        let signal = generate_noisy_breathing_signal(16.0, sample_rate, 30.0, noise_level);
+
+        group.bench_with_input(
+            BenchmarkId::new("noisy_signal", format!("noise_{}", (noise_level * 10.0) as u32)),
+            &signal,
+            |b, signal| {
+                b.iter(|| detector.detect(black_box(signal), black_box(sample_rate)))
+            },
+        );
+    }
+
+    // Benchmark different breathing rates
+    for rate in [8.0, 16.0, 25.0, 35.0] {
+        let signal = generate_breathing_signal(rate, sample_rate, 30.0);
+
+        group.bench_with_input(
+            BenchmarkId::new("rate_variation", format!("{}bpm", rate as u32)),
+            &signal,
+            |b, signal| {
+                b.iter(|| detector.detect(black_box(signal), black_box(sample_rate)))
+            },
+        );
+    }
+
+    // Benchmark with custom config (high sensitivity)
+    let high_sensitivity_config = BreathingDetectorConfig {
+        min_rate_bpm: 2.0,
+        max_rate_bpm: 50.0,
+        min_amplitude: 0.05,
+        window_size: 1024,
+        window_overlap: 0.75,
+        confidence_threshold: 0.2,
+    };
+    let sensitive_detector = BreathingDetector::new(high_sensitivity_config);
+    let signal = generate_noisy_breathing_signal(16.0, sample_rate, 30.0, 0.3);
+
+    group.bench_with_input(
+        BenchmarkId::new("high_sensitivity", "30s_noisy"),
+        &signal,
+        |b, signal| {
+            b.iter(|| sensitive_detector.detect(black_box(signal), black_box(sample_rate)))
+        },
+    );
+
+    group.finish();
+}
+
+// =============================================================================
+// Heartbeat Detection Benchmarks
+// =============================================================================
+
+fn bench_heartbeat_detection(c: &mut Criterion) {
+    let mut group = c.benchmark_group("heartbeat_detection");
+
+    let detector = HeartbeatDetector::with_defaults();
+    let sample_rate = 1000.0; // 1 kHz for micro-Doppler
+
+    // Benchmark different signal lengths
+    for duration in [5.0, 10.0, 30.0] {
+        let signal = generate_heartbeat_signal(72.0, sample_rate, duration);
+        let num_samples = signal.len();
+
+        group.throughput(Throughput::Elements(num_samples as u64));
+        group.bench_with_input(
+            BenchmarkId::new("clean_signal", format!("{}s", duration as u32)),
+            &signal,
+            |b, signal| {
+                b.iter(|| detector.detect(black_box(signal), black_box(sample_rate), None))
+            },
+        );
+    }
+
+    // Benchmark with known breathing rate (improves filtering)
+    let signal = generate_heartbeat_signal(72.0, sample_rate, 30.0);
+    group.bench_with_input(
+        BenchmarkId::new("with_breathing_rate", "72bpm_known_br"),
+        &signal,
+        |b, signal| {
+            b.iter(|| {
+                detector.detect(
+                    black_box(signal),
+                    black_box(sample_rate),
+                    black_box(Some(16.0)), // Known breathing rate
+                )
+            })
+        },
+    );
+
+    // Benchmark different heart rates
+    for rate in [50.0, 72.0, 100.0, 150.0] {
+        let signal = generate_heartbeat_signal(rate, sample_rate, 10.0);
+
+        group.bench_with_input(
+            BenchmarkId::new("rate_variation", format!("{}bpm", rate as u32)),
+            &signal,
+            |b, signal| {
+                b.iter(|| detector.detect(black_box(signal), black_box(sample_rate), None))
+            },
+        );
+    }
+
+    // Benchmark enhanced processing config
+    let enhanced_config = HeartbeatDetectorConfig {
+        min_rate_bpm: 30.0,
+        max_rate_bpm: 200.0,
+        min_signal_strength: 0.02,
+        window_size: 2048,
+        enhanced_processing: true,
+        confidence_threshold: 0.3,
+    };
+    let enhanced_detector = HeartbeatDetector::new(enhanced_config);
+    let signal = generate_heartbeat_signal(72.0, sample_rate, 10.0);
+
+    group.bench_with_input(
+        BenchmarkId::new("enhanced_processing", "2048_window"),
+        &signal,
+        |b, signal| {
+            b.iter(|| enhanced_detector.detect(black_box(signal), black_box(sample_rate), None))
+        },
+    );
+
+    group.finish();
+}
+
+// =============================================================================
+// Movement Classification Benchmarks
+// =============================================================================
+
+fn bench_movement_classification(c: &mut Criterion) {
+    let mut group = c.benchmark_group("movement_classification");
+
+    let classifier = MovementClassifier::with_defaults();
+    let sample_rate = 100.0;
+
+    // Benchmark different movement types
+    for movement_type in ["none", "gross", "tremor", "periodic"] {
+        let signal = generate_movement_signal(movement_type, sample_rate, 10.0);
+        let num_samples = signal.len();
+
+        group.throughput(Throughput::Elements(num_samples as u64));
+        group.bench_with_input(
+            BenchmarkId::new("movement_type", movement_type),
+            &signal,
+            |b, signal| {
+                b.iter(|| classifier.classify(black_box(signal), black_box(sample_rate)))
+            },
+        );
+    }
+
+    // Benchmark different signal lengths
+    for duration in [2.0, 5.0, 10.0, 30.0] {
+        let signal = generate_movement_signal("gross", sample_rate, duration);
+
+        group.bench_with_input(
+            BenchmarkId::new("signal_length", format!("{}s", duration as u32)),
+            &signal,
+            |b, signal| {
+                b.iter(|| classifier.classify(black_box(signal), black_box(sample_rate)))
+            },
+        );
+    }
+
+    // Benchmark with custom sensitivity
+    let sensitive_config = MovementClassifierConfig {
+        movement_threshold: 0.05,
+        gross_movement_threshold: 0.3,
+        window_size: 200,
+        periodicity_threshold: 0.2,
+    };
+    let sensitive_classifier = MovementClassifier::new(sensitive_config);
+    let signal = generate_movement_signal("tremor", sample_rate, 10.0);
+
+    group.bench_with_input(
+        BenchmarkId::new("high_sensitivity", "tremor_detection"),
+        &signal,
+        |b, signal| {
+            b.iter(|| sensitive_classifier.classify(black_box(signal), black_box(sample_rate)))
+        },
+    );
+
+    group.finish();
+}
+
+// =============================================================================
+// Full Detection Pipeline Benchmarks
+// =============================================================================
+
+fn bench_detection_pipeline(c: &mut Criterion) {
+    let mut group = c.benchmark_group("detection_pipeline");
+    group.sample_size(50); // Reduce sample size for slower benchmarks
+
+    let sample_rate = 100.0;
+
+    // Standard pipeline (breathing + movement)
+    let standard_config = DetectionConfig {
+        sample_rate,
+        enable_heartbeat: false,
+        min_confidence: 0.3,
+        ..Default::default()
+    };
+    let standard_pipeline = DetectionPipeline::new(standard_config);
+
+    // Full pipeline (breathing + heartbeat + movement)
+    let full_config = DetectionConfig {
+        sample_rate: 1000.0,
+        enable_heartbeat: true,
+        min_confidence: 0.3,
+        ..Default::default()
+    };
+    let full_pipeline = DetectionPipeline::new(full_config);
+
+    // Benchmark standard pipeline at different data sizes
+    for duration in [5.0, 10.0, 30.0] {
+        let (amplitudes, phases) = generate_combined_vital_signal(16.0, 72.0, sample_rate, duration);
+        let mut buffer = CsiDataBuffer::new(sample_rate);
+        buffer.add_samples(&amplitudes, &phases);
+
+        group.throughput(Throughput::Elements(amplitudes.len() as u64));
+        group.bench_with_input(
+            BenchmarkId::new("standard_pipeline", format!("{}s", duration as u32)),
+            &buffer,
+            |b, buffer| {
+                b.iter(|| standard_pipeline.detect(black_box(buffer)))
+            },
+        );
+    }
+
+    // Benchmark full pipeline
+    for duration in [5.0, 10.0] {
+        let (amplitudes, phases) = generate_combined_vital_signal(16.0, 72.0, 1000.0, duration);
+        let mut buffer = CsiDataBuffer::new(1000.0);
+        buffer.add_samples(&amplitudes, &phases);
+
+        group.bench_with_input(
+            BenchmarkId::new("full_pipeline", format!("{}s", duration as u32)),
+            &buffer,
+            |b, buffer| {
+                b.iter(|| full_pipeline.detect(black_box(buffer)))
+            },
+        );
+    }
+
+    // Benchmark multi-person scenarios
+    for person_count in [1, 2, 3, 5] {
+        let signal = generate_multi_person_signal(person_count, sample_rate, 30.0);
+        let mut buffer = CsiDataBuffer::new(sample_rate);
+        buffer.add_samples(&signal, &signal);
+
+        group.bench_with_input(
+            BenchmarkId::new("multi_person", format!("{}_people", person_count)),
+            &buffer,
+            |b, buffer| {
+                b.iter(|| standard_pipeline.detect(black_box(buffer)))
+            },
+        );
+    }
+
+    group.finish();
+}
+
+// =============================================================================
+// Triangulation Benchmarks
+// =============================================================================
+
+fn bench_triangulation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("triangulation");
+
+    let triangulator = Triangulator::with_defaults();
+
+    // Benchmark with different sensor counts
+    for sensor_count in [3, 4, 5, 8, 12] {
+        let sensors = create_test_sensors(sensor_count);
+
+        // Generate RSSI values (simulate target at center)
+        let rssi_values: Vec<(String, f64)> = sensors.iter()
+            .map(|s| {
+                let distance = (s.x * s.x + s.y * s.y).sqrt();
+                let rssi = -30.0 - 20.0 * distance.log10(); // Path loss model
+                (s.id.clone(), rssi)
+            })
+            .collect();
+
+        group.bench_with_input(
+            BenchmarkId::new("rssi_position", format!("{}_sensors", sensor_count)),
+            &(sensors.clone(), rssi_values.clone()),
+            |b, (sensors, rssi)| {
+                b.iter(|| {
+                    triangulator.estimate_position(black_box(sensors), black_box(rssi))
+                })
+            },
+        );
+    }
+
+    // Benchmark ToA-based positioning
+    for sensor_count in [3, 4, 5, 8] {
+        let sensors = create_test_sensors(sensor_count);
+
+        // Generate ToA values (time in nanoseconds)
+        let toa_values: Vec<(String, f64)> = sensors.iter()
+            .map(|s| {
+                let distance = (s.x * s.x + s.y * s.y).sqrt();
+                // Round trip time: 2 * distance / speed_of_light
+                let toa_ns = 2.0 * distance / 299_792_458.0 * 1e9;
+                (s.id.clone(), toa_ns)
+            })
+            .collect();
+
+        group.bench_with_input(
+            BenchmarkId::new("toa_position", format!("{}_sensors", sensor_count)),
+            &(sensors.clone(), toa_values.clone()),
+            |b, (sensors, toa)| {
+                b.iter(|| {
+                    triangulator.estimate_from_toa(black_box(sensors), black_box(toa))
+                })
+            },
+        );
+    }
+
+    // Benchmark with noisy measurements
+    let sensors = create_test_sensors(5);
+    for noise_pct in [0, 5, 10, 20] {
+        let rssi_values: Vec<(String, f64)> = sensors.iter()
+            .enumerate()
+            .map(|(i, s)| {
+                let distance = (s.x * s.x + s.y * s.y).sqrt();
+                let rssi = -30.0 - 20.0 * distance.log10();
+                // Add noise based on index for determinism
+                let noise = (i as f64 / 10.0) * noise_pct as f64 / 100.0 * 10.0;
+                (s.id.clone(), rssi + noise)
+            })
+            .collect();
+
+        group.bench_with_input(
+            BenchmarkId::new("noisy_rssi", format!("{}pct_noise", noise_pct)),
+            &(sensors.clone(), rssi_values.clone()),
+            |b, (sensors, rssi)| {
+                b.iter(|| {
+                    triangulator.estimate_position(black_box(sensors), black_box(rssi))
+                })
+            },
+        );
+    }
+
+    group.finish();
+}
+
+// =============================================================================
+// Depth Estimation Benchmarks
+// =============================================================================
+
+fn bench_depth_estimation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("depth_estimation");
+
+    let estimator = DepthEstimator::with_defaults();
+    let debris = create_test_debris();
+
+    // Benchmark single-path depth estimation
+    for attenuation in [10.0, 20.0, 40.0, 60.0] {
+        group.bench_with_input(
+            BenchmarkId::new("single_path", format!("{}dB", attenuation as u32)),
+            &attenuation,
+            |b, &attenuation| {
+                b.iter(|| {
+                    estimator.estimate_depth(
+                        black_box(attenuation),
+                        black_box(5.0), // 5m horizontal distance
+                        black_box(&debris),
+                    )
+                })
+            },
+        );
+    }
+
+    // Benchmark different debris types
+    let debris_types = [
+        ("snow", DebrisMaterial::Snow),
+        ("wood", DebrisMaterial::Wood),
+        ("light_concrete", DebrisMaterial::LightConcrete),
+        ("heavy_concrete", DebrisMaterial::HeavyConcrete),
+        ("mixed", DebrisMaterial::Mixed),
+    ];
+
+    for (name, material) in debris_types {
+        let debris = DebrisProfile {
+            primary_material: material,
+            void_fraction: 0.25,
+            moisture_content: MoistureLevel::Dry,
+            metal_content: MetalContent::Low,
+        };
+
+        group.bench_with_input(
+            BenchmarkId::new("debris_type", name),
+            &debris,
+            |b, debris| {
+                b.iter(|| {
+                    estimator.estimate_depth(
+                        black_box(30.0),
+                        black_box(5.0),
+                        black_box(debris),
+                    )
+                })
+            },
+        );
+    }
+
+    // Benchmark multipath depth estimation
+    for path_count in [1, 2, 4, 8] {
+        let reflected_paths: Vec<(f64, f64)> = (0..path_count)
+            .map(|i| {
+                (
+                    30.0 + i as f64 * 5.0, // attenuation
+                    1e-9 * (i + 1) as f64, // delay in seconds
+                )
+            })
+            .collect();
+
+        group.bench_with_input(
+            BenchmarkId::new("multipath", format!("{}_paths", path_count)),
+            &reflected_paths,
+            |b, paths| {
+                b.iter(|| {
+                    estimator.estimate_from_multipath(
+                        black_box(25.0),
+                        black_box(paths),
+                        black_box(&debris),
+                    )
+                })
+            },
+        );
+    }
+
+    // Benchmark debris profile estimation
+    for (variance, multipath, moisture) in [
+        (0.2, 0.3, 0.2),
+        (0.5, 0.5, 0.5),
+        (0.7, 0.8, 0.8),
+    ] {
+        group.bench_with_input(
+            BenchmarkId::new("profile_estimation", format!("v{}_m{}", (variance * 10.0) as u32, (multipath * 10.0) as u32)),
+            &(variance, multipath, moisture),
+            |b, &(v, m, mo)| {
+                b.iter(|| {
+                    estimator.estimate_debris_profile(
+                        black_box(v),
+                        black_box(m),
+                        black_box(mo),
+                    )
+                })
+            },
+        );
+    }
+
+    group.finish();
+}
+
+// =============================================================================
+// Alert Generation Benchmarks
+// =============================================================================
+
+fn bench_alert_generation(c: &mut Criterion) {
+    let mut group = c.benchmark_group("alert_generation");
+
+    // Benchmark basic alert generation
+    let generator = AlertGenerator::new();
+    let survivor = create_test_survivor();
+
+    group.bench_function("generate_basic_alert", |b| {
+        b.iter(|| generator.generate(black_box(&survivor)))
+    });
+
+    // Benchmark escalation alert
+    group.bench_function("generate_escalation_alert", |b| {
+        b.iter(|| {
+            generator.generate_escalation(
+                black_box(&survivor),
+                black_box("Vital signs deteriorating"),
+            )
+        })
+    });
+
+    // Benchmark status change alert
+    use wifi_densepose_mat::domain::TriageStatus;
+    group.bench_function("generate_status_change_alert", |b| {
+        b.iter(|| {
+            generator.generate_status_change(
+                black_box(&survivor),
+                black_box(&TriageStatus::Minor),
+            )
+        })
+    });
+
+    // Benchmark with zone registration
+    let mut generator_with_zones = AlertGenerator::new();
+    for i in 0..100 {
+        generator_with_zones.register_zone(ScanZoneId::new(), format!("Zone {}", i));
+    }
+
+    group.bench_function("generate_with_zones_lookup", |b| {
+        b.iter(|| generator_with_zones.generate(black_box(&survivor)))
+    });
+
+    // Benchmark batch alert generation
+    let survivors: Vec<Survivor> = (0..10).map(|_| create_test_survivor()).collect();
+
+    group.bench_function("batch_generate_10_alerts", |b| {
+        b.iter(|| {
+            survivors.iter()
+                .map(|s| generator.generate(black_box(s)))
+                .collect::<Vec<_>>()
+        })
+    });
+
+    group.finish();
+}
+
+// =============================================================================
+// CSI Buffer Operations Benchmarks
+// =============================================================================
+
+fn bench_csi_buffer(c: &mut Criterion) {
+    let mut group = c.benchmark_group("csi_buffer");
+
+    let sample_rate = 100.0;
+
+    // Benchmark buffer creation and addition
+    for sample_count in [1000, 5000, 10000, 30000] {
+        let amplitudes: Vec<f64> = (0..sample_count)
+            .map(|i| (i as f64 / 100.0).sin())
+            .collect();
+        let phases: Vec<f64> = (0..sample_count)
+            .map(|i| (i as f64 / 50.0).cos())
+            .collect();
+
+        group.throughput(Throughput::Elements(sample_count as u64));
+        group.bench_with_input(
+            BenchmarkId::new("add_samples", format!("{}_samples", sample_count)),
+            &(amplitudes.clone(), phases.clone()),
+            |b, (amp, phase)| {
+                b.iter(|| {
+                    let mut buffer = CsiDataBuffer::new(sample_rate);
+                    buffer.add_samples(black_box(amp), black_box(phase));
+                    buffer
+                })
+            },
+        );
+    }
+
+    // Benchmark incremental addition (simulating real-time data)
+    let chunk_size = 100;
+    let total_samples = 10000;
+    let amplitudes: Vec<f64> = (0..chunk_size).map(|i| (i as f64 / 100.0).sin()).collect();
+    let phases: Vec<f64> = (0..chunk_size).map(|i| (i as f64 / 50.0).cos()).collect();
+
+    group.bench_function("incremental_add_100_chunks", |b| {
+        b.iter(|| {
+            let mut buffer = CsiDataBuffer::new(sample_rate);
+            for _ in 0..(total_samples / chunk_size) {
+                buffer.add_samples(black_box(&amplitudes), black_box(&phases));
+            }
+            buffer
+        })
+    });
+
+    // Benchmark has_sufficient_data check
+    let mut buffer = CsiDataBuffer::new(sample_rate);
+    let amplitudes: Vec<f64> = (0..3000).map(|i| (i as f64 / 100.0).sin()).collect();
+    let phases: Vec<f64> = (0..3000).map(|i| (i as f64 / 50.0).cos()).collect();
+    buffer.add_samples(&amplitudes, &phases);
+
+    group.bench_function("check_sufficient_data", |b| {
+        b.iter(|| buffer.has_sufficient_data(black_box(10.0)))
+    });
+
+    group.bench_function("calculate_duration", |b| {
+        b.iter(|| black_box(&buffer).duration())
+    });
+
+    group.finish();
+}
+
+// =============================================================================
+// Criterion Groups and Main
+// =============================================================================
+
+criterion_group!(
+    name = detection_benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_millis(500))
+        .measurement_time(std::time::Duration::from_secs(2));
+    targets =
+        bench_breathing_detection,
+        bench_heartbeat_detection,
+        bench_movement_classification
+);
+
+criterion_group!(
+    name = pipeline_benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_millis(500))
+        .measurement_time(std::time::Duration::from_secs(3))
+        .sample_size(50);
+    targets = bench_detection_pipeline
+);
+
+criterion_group!(
+    name = localization_benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_millis(500))
+        .measurement_time(std::time::Duration::from_secs(2));
+    targets =
+        bench_triangulation,
+        bench_depth_estimation
+);
+
+criterion_group!(
+    name = alerting_benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_millis(300))
+        .measurement_time(std::time::Duration::from_secs(1));
+    targets = bench_alert_generation
+);
+
+criterion_group!(
+    name = buffer_benches;
+    config = Criterion::default()
+        .warm_up_time(std::time::Duration::from_millis(300))
+        .measurement_time(std::time::Duration::from_secs(1));
+    targets = bench_csi_buffer
+);
+
+criterion_main!(
+    detection_benches,
+    pipeline_benches,
+    localization_benches,
+    alerting_benches,
+    buffer_benches
+);

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/api/dto.rs

@@ -0,0 +1,892 @@
+//! Data Transfer Objects (DTOs) for the MAT REST API.
+//!
+//! These types are used for serializing/deserializing API requests and responses.
+//! They provide a clean separation between domain models and API contracts.
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::domain::{
+    DisasterType, EventStatus, ZoneStatus, TriageStatus, Priority,
+    AlertStatus, SurvivorStatus,
+};
+
+// ============================================================================
+// Event DTOs
+// ============================================================================
+
+/// Request body for creating a new disaster event.
+///
+/// ## Example
+///
+/// ```json
+/// {
+///   "event_type": "Earthquake",
+///   "latitude": 37.7749,
+///   "longitude": -122.4194,
+///   "description": "Magnitude 6.8 earthquake in San Francisco",
+///   "estimated_occupancy": 500,
+///   "lead_agency": "SF Fire Department"
+/// }
+/// ```
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub struct CreateEventRequest {
+    /// Type of disaster event
+    pub event_type: DisasterTypeDto,
+    /// Latitude of disaster epicenter
+    pub latitude: f64,
+    /// Longitude of disaster epicenter
+    pub longitude: f64,
+    /// Human-readable description of the event
+    pub description: String,
+    /// Estimated number of people in the affected area
+    #[serde(default)]
+    pub estimated_occupancy: Option<u32>,
+    /// Lead responding agency
+    #[serde(default)]
+    pub lead_agency: Option<String>,
+}
+
+/// Response body for disaster event details.
+///
+/// ## Example Response
+///
+/// ```json
+/// {
+///   "id": "550e8400-e29b-41d4-a716-446655440000",
+///   "event_type": "Earthquake",
+///   "status": "Active",
+///   "start_time": "2024-01-15T14:30:00Z",
+///   "latitude": 37.7749,
+///   "longitude": -122.4194,
+///   "description": "Magnitude 6.8 earthquake",
+///   "zone_count": 5,
+///   "survivor_count": 12,
+///   "triage_summary": {
+///     "immediate": 3,
+///     "delayed": 5,
+///     "minor": 4,
+///     "deceased": 0
+///   }
+/// }
+/// ```
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct EventResponse {
+    /// Unique event identifier
+    pub id: Uuid,
+    /// Type of disaster
+    pub event_type: DisasterTypeDto,
+    /// Current event status
+    pub status: EventStatusDto,
+    /// When the event was created/started
+    pub start_time: DateTime<Utc>,
+    /// Latitude of epicenter
+    pub latitude: f64,
+    /// Longitude of epicenter
+    pub longitude: f64,
+    /// Event description
+    pub description: String,
+    /// Number of scan zones
+    pub zone_count: usize,
+    /// Number of detected survivors
+    pub survivor_count: usize,
+    /// Summary of triage classifications
+    pub triage_summary: TriageSummary,
+    /// Metadata about the event
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<EventMetadataDto>,
+}
+
+/// Summary of triage counts across all survivors.
+#[derive(Debug, Clone, Serialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub struct TriageSummary {
+    /// Immediate (Red) - life-threatening
+    pub immediate: u32,
+    /// Delayed (Yellow) - serious but stable
+    pub delayed: u32,
+    /// Minor (Green) - walking wounded
+    pub minor: u32,
+    /// Deceased (Black)
+    pub deceased: u32,
+    /// Unknown status
+    pub unknown: u32,
+}
+
+/// Event metadata DTO
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub struct EventMetadataDto {
+    /// Estimated number of people in area at time of disaster
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub estimated_occupancy: Option<u32>,
+    /// Known survivors (already rescued)
+    #[serde(default)]
+    pub confirmed_rescued: u32,
+    /// Known fatalities
+    #[serde(default)]
+    pub confirmed_deceased: u32,
+    /// Weather conditions
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub weather: Option<String>,
+    /// Lead agency
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lead_agency: Option<String>,
+}
+
+/// Paginated list of events.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct EventListResponse {
+    /// List of events
+    pub events: Vec<EventResponse>,
+    /// Total count of events
+    pub total: usize,
+    /// Current page number (0-indexed)
+    pub page: usize,
+    /// Number of items per page
+    pub page_size: usize,
+}
+
+// ============================================================================
+// Zone DTOs
+// ============================================================================
+
+/// Request body for adding a scan zone to an event.
+///
+/// ## Example
+///
+/// ```json
+/// {
+///   "name": "Building A - North Wing",
+///   "bounds": {
+///     "type": "rectangle",
+///     "min_x": 0.0,
+///     "min_y": 0.0,
+///     "max_x": 50.0,
+///     "max_y": 30.0
+///   },
+///   "parameters": {
+///     "sensitivity": 0.85,
+///     "max_depth": 5.0,
+///     "heartbeat_detection": true
+///   }
+/// }
+/// ```
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub struct CreateZoneRequest {
+    /// Human-readable zone name
+    pub name: String,
+    /// Geographic bounds of the zone
+    pub bounds: ZoneBoundsDto,
+    /// Optional scan parameters
+    #[serde(default)]
+    pub parameters: Option<ScanParametersDto>,
+}
+
+/// Zone boundary definition.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ZoneBoundsDto {
+    /// Rectangular boundary
+    Rectangle {
+        min_x: f64,
+        min_y: f64,
+        max_x: f64,
+        max_y: f64,
+    },
+    /// Circular boundary
+    Circle {
+        center_x: f64,
+        center_y: f64,
+        radius: f64,
+    },
+    /// Polygon boundary (list of vertices)
+    Polygon {
+        vertices: Vec<(f64, f64)>,
+    },
+}
+
+/// Scan parameters for a zone.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub struct ScanParametersDto {
+    /// Detection sensitivity (0.0-1.0)
+    #[serde(default = "default_sensitivity")]
+    pub sensitivity: f64,
+    /// Maximum depth to scan in meters
+    #[serde(default = "default_max_depth")]
+    pub max_depth: f64,
+    /// Scan resolution level
+    #[serde(default)]
+    pub resolution: ScanResolutionDto,
+    /// Enable enhanced breathing detection
+    #[serde(default = "default_true")]
+    pub enhanced_breathing: bool,
+    /// Enable heartbeat detection (slower but more accurate)
+    #[serde(default)]
+    pub heartbeat_detection: bool,
+}
+
+fn default_sensitivity() -> f64 { 0.8 }
+fn default_max_depth() -> f64 { 5.0 }
+fn default_true() -> bool { true }
+
+impl Default for ScanParametersDto {
+    fn default() -> Self {
+        Self {
+            sensitivity: default_sensitivity(),
+            max_depth: default_max_depth(),
+            resolution: ScanResolutionDto::default(),
+            enhanced_breathing: default_true(),
+            heartbeat_detection: false,
+        }
+    }
+}
+
+/// Scan resolution levels.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum ScanResolutionDto {
+    Quick,
+    #[default]
+    Standard,
+    High,
+    Maximum,
+}
+
+/// Response for zone details.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct ZoneResponse {
+    /// Zone identifier
+    pub id: Uuid,
+    /// Zone name
+    pub name: String,
+    /// Zone status
+    pub status: ZoneStatusDto,
+    /// Zone boundaries
+    pub bounds: ZoneBoundsDto,
+    /// Zone area in square meters
+    pub area: f64,
+    /// Scan parameters
+    pub parameters: ScanParametersDto,
+    /// Last scan time
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub last_scan: Option<DateTime<Utc>>,
+    /// Total scan count
+    pub scan_count: u32,
+    /// Number of detections in this zone
+    pub detections_count: u32,
+}
+
+/// List of zones response.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct ZoneListResponse {
+    /// List of zones
+    pub zones: Vec<ZoneResponse>,
+    /// Total count
+    pub total: usize,
+}
+
+// ============================================================================
+// Survivor DTOs
+// ============================================================================
+
+/// Response for survivor details.
+///
+/// ## Example Response
+///
+/// ```json
+/// {
+///   "id": "550e8400-e29b-41d4-a716-446655440001",
+///   "zone_id": "550e8400-e29b-41d4-a716-446655440002",
+///   "status": "Active",
+///   "triage_status": "Immediate",
+///   "location": {
+///     "x": 25.5,
+///     "y": 12.3,
+///     "z": -2.1,
+///     "uncertainty_radius": 1.5
+///   },
+///   "vital_signs": {
+///     "breathing_rate": 22.5,
+///     "has_heartbeat": true,
+///     "has_movement": false
+///   },
+///   "confidence": 0.87,
+///   "first_detected": "2024-01-15T14:32:00Z",
+///   "last_updated": "2024-01-15T14:45:00Z"
+/// }
+/// ```
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct SurvivorResponse {
+    /// Survivor identifier
+    pub id: Uuid,
+    /// Zone where survivor was detected
+    pub zone_id: Uuid,
+    /// Current survivor status
+    pub status: SurvivorStatusDto,
+    /// Triage classification
+    pub triage_status: TriageStatusDto,
+    /// Location information
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub location: Option<LocationDto>,
+    /// Latest vital signs summary
+    pub vital_signs: VitalSignsSummaryDto,
+    /// Detection confidence (0.0-1.0)
+    pub confidence: f64,
+    /// When survivor was first detected
+    pub first_detected: DateTime<Utc>,
+    /// Last update time
+    pub last_updated: DateTime<Utc>,
+    /// Whether survivor is deteriorating
+    pub is_deteriorating: bool,
+    /// Metadata
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<SurvivorMetadataDto>,
+}
+
+/// Location information DTO.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct LocationDto {
+    /// X coordinate (east-west, meters)
+    pub x: f64,
+    /// Y coordinate (north-south, meters)
+    pub y: f64,
+    /// Z coordinate (depth, negative is below surface)
+    pub z: f64,
+    /// Estimated depth below surface (positive meters)
+    pub depth: f64,
+    /// Horizontal uncertainty radius in meters
+    pub uncertainty_radius: f64,
+    /// Location confidence score
+    pub confidence: f64,
+}
+
+/// Summary of vital signs for API response.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct VitalSignsSummaryDto {
+    /// Breathing rate (breaths per minute)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub breathing_rate: Option<f32>,
+    /// Breathing pattern type
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub breathing_type: Option<String>,
+    /// Heart rate if detected (bpm)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub heart_rate: Option<f32>,
+    /// Whether heartbeat is detected
+    pub has_heartbeat: bool,
+    /// Whether movement is detected
+    pub has_movement: bool,
+    /// Movement type if present
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub movement_type: Option<String>,
+    /// Timestamp of reading
+    pub timestamp: DateTime<Utc>,
+}
+
+/// Survivor metadata DTO.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct SurvivorMetadataDto {
+    /// Estimated age category
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub estimated_age_category: Option<String>,
+    /// Assigned rescue team
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub assigned_team: Option<String>,
+    /// Notes
+    pub notes: Vec<String>,
+    /// Tags
+    pub tags: Vec<String>,
+}
+
+/// List of survivors response.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct SurvivorListResponse {
+    /// List of survivors
+    pub survivors: Vec<SurvivorResponse>,
+    /// Total count
+    pub total: usize,
+    /// Triage summary
+    pub triage_summary: TriageSummary,
+}
+
+// ============================================================================
+// Alert DTOs
+// ============================================================================
+
+/// Response for alert details.
+///
+/// ## Example Response
+///
+/// ```json
+/// {
+///   "id": "550e8400-e29b-41d4-a716-446655440003",
+///   "survivor_id": "550e8400-e29b-41d4-a716-446655440001",
+///   "priority": "Critical",
+///   "status": "Pending",
+///   "title": "Immediate: Survivor detected with abnormal breathing",
+///   "message": "Survivor in Zone A showing signs of respiratory distress",
+///   "triage_status": "Immediate",
+///   "location": { ... },
+///   "created_at": "2024-01-15T14:35:00Z"
+/// }
+/// ```
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct AlertResponse {
+    /// Alert identifier
+    pub id: Uuid,
+    /// Related survivor ID
+    pub survivor_id: Uuid,
+    /// Alert priority
+    pub priority: PriorityDto,
+    /// Alert status
+    pub status: AlertStatusDto,
+    /// Alert title
+    pub title: String,
+    /// Detailed message
+    pub message: String,
+    /// Associated triage status
+    pub triage_status: TriageStatusDto,
+    /// Location if available
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub location: Option<LocationDto>,
+    /// Recommended action
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub recommended_action: Option<String>,
+    /// When alert was created
+    pub created_at: DateTime<Utc>,
+    /// When alert was acknowledged
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub acknowledged_at: Option<DateTime<Utc>>,
+    /// Who acknowledged the alert
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub acknowledged_by: Option<String>,
+    /// Escalation count
+    pub escalation_count: u32,
+}
+
+/// Request to acknowledge an alert.
+///
+/// ## Example
+///
+/// ```json
+/// {
+///   "acknowledged_by": "Team Alpha",
+///   "notes": "En route to location"
+/// }
+/// ```
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub struct AcknowledgeAlertRequest {
+    /// Who is acknowledging the alert
+    pub acknowledged_by: String,
+    /// Optional notes
+    #[serde(default)]
+    pub notes: Option<String>,
+}
+
+/// Response after acknowledging an alert.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct AcknowledgeAlertResponse {
+    /// Whether acknowledgement was successful
+    pub success: bool,
+    /// Updated alert
+    pub alert: AlertResponse,
+}
+
+/// List of alerts response.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct AlertListResponse {
+    /// List of alerts
+    pub alerts: Vec<AlertResponse>,
+    /// Total count
+    pub total: usize,
+    /// Count by priority
+    pub priority_counts: PriorityCounts,
+}
+
+/// Count of alerts by priority.
+#[derive(Debug, Clone, Serialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub struct PriorityCounts {
+    pub critical: usize,
+    pub high: usize,
+    pub medium: usize,
+    pub low: usize,
+}
+
+// ============================================================================
+// WebSocket DTOs
+// ============================================================================
+
+/// WebSocket message types for real-time streaming.
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum WebSocketMessage {
+    /// New survivor detected
+    SurvivorDetected {
+        event_id: Uuid,
+        survivor: SurvivorResponse,
+    },
+    /// Survivor status updated
+    SurvivorUpdated {
+        event_id: Uuid,
+        survivor: SurvivorResponse,
+    },
+    /// Survivor lost (signal lost)
+    SurvivorLost {
+        event_id: Uuid,
+        survivor_id: Uuid,
+    },
+    /// New alert generated
+    AlertCreated {
+        event_id: Uuid,
+        alert: AlertResponse,
+    },
+    /// Alert status changed
+    AlertUpdated {
+        event_id: Uuid,
+        alert: AlertResponse,
+    },
+    /// Zone scan completed
+    ZoneScanComplete {
+        event_id: Uuid,
+        zone_id: Uuid,
+        detections: u32,
+    },
+    /// Event status changed
+    EventStatusChanged {
+        event_id: Uuid,
+        old_status: EventStatusDto,
+        new_status: EventStatusDto,
+    },
+    /// Heartbeat/keep-alive
+    Heartbeat {
+        timestamp: DateTime<Utc>,
+    },
+    /// Error message
+    Error {
+        code: String,
+        message: String,
+    },
+}
+
+/// WebSocket subscription request.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "action", rename_all = "snake_case")]
+pub enum WebSocketRequest {
+    /// Subscribe to events for a disaster event
+    Subscribe {
+        event_id: Uuid,
+    },
+    /// Unsubscribe from events
+    Unsubscribe {
+        event_id: Uuid,
+    },
+    /// Subscribe to all events
+    SubscribeAll,
+    /// Request current state
+    GetState {
+        event_id: Uuid,
+    },
+}
+
+// ============================================================================
+// Enum DTOs (mirroring domain enums with serde)
+// ============================================================================
+
+/// Disaster type DTO.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "PascalCase")]
+pub enum DisasterTypeDto {
+    BuildingCollapse,
+    Earthquake,
+    Landslide,
+    Avalanche,
+    Flood,
+    MineCollapse,
+    Industrial,
+    TunnelCollapse,
+    Unknown,
+}
+
+impl From<DisasterType> for DisasterTypeDto {
+    fn from(dt: DisasterType) -> Self {
+        match dt {
+            DisasterType::BuildingCollapse => DisasterTypeDto::BuildingCollapse,
+            DisasterType::Earthquake => DisasterTypeDto::Earthquake,
+            DisasterType::Landslide => DisasterTypeDto::Landslide,
+            DisasterType::Avalanche => DisasterTypeDto::Avalanche,
+            DisasterType::Flood => DisasterTypeDto::Flood,
+            DisasterType::MineCollapse => DisasterTypeDto::MineCollapse,
+            DisasterType::Industrial => DisasterTypeDto::Industrial,
+            DisasterType::TunnelCollapse => DisasterTypeDto::TunnelCollapse,
+            DisasterType::Unknown => DisasterTypeDto::Unknown,
+        }
+    }
+}
+
+impl From<DisasterTypeDto> for DisasterType {
+    fn from(dt: DisasterTypeDto) -> Self {
+        match dt {
+            DisasterTypeDto::BuildingCollapse => DisasterType::BuildingCollapse,
+            DisasterTypeDto::Earthquake => DisasterType::Earthquake,
+            DisasterTypeDto::Landslide => DisasterType::Landslide,
+            DisasterTypeDto::Avalanche => DisasterType::Avalanche,
+            DisasterTypeDto::Flood => DisasterType::Flood,
+            DisasterTypeDto::MineCollapse => DisasterType::MineCollapse,
+            DisasterTypeDto::Industrial => DisasterType::Industrial,
+            DisasterTypeDto::TunnelCollapse => DisasterType::TunnelCollapse,
+            DisasterTypeDto::Unknown => DisasterType::Unknown,
+        }
+    }
+}
+
+/// Event status DTO.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub enum EventStatusDto {
+    Initializing,
+    Active,
+    Suspended,
+    SecondarySearch,
+    Closed,
+}
+
+impl From<EventStatus> for EventStatusDto {
+    fn from(es: EventStatus) -> Self {
+        match es {
+            EventStatus::Initializing => EventStatusDto::Initializing,
+            EventStatus::Active => EventStatusDto::Active,
+            EventStatus::Suspended => EventStatusDto::Suspended,
+            EventStatus::SecondarySearch => EventStatusDto::SecondarySearch,
+            EventStatus::Closed => EventStatusDto::Closed,
+        }
+    }
+}
+
+/// Zone status DTO.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub enum ZoneStatusDto {
+    Active,
+    Paused,
+    Complete,
+    Inaccessible,
+    Deactivated,
+}
+
+impl From<ZoneStatus> for ZoneStatusDto {
+    fn from(zs: ZoneStatus) -> Self {
+        match zs {
+            ZoneStatus::Active => ZoneStatusDto::Active,
+            ZoneStatus::Paused => ZoneStatusDto::Paused,
+            ZoneStatus::Complete => ZoneStatusDto::Complete,
+            ZoneStatus::Inaccessible => ZoneStatusDto::Inaccessible,
+            ZoneStatus::Deactivated => ZoneStatusDto::Deactivated,
+        }
+    }
+}
+
+/// Triage status DTO.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub enum TriageStatusDto {
+    Immediate,
+    Delayed,
+    Minor,
+    Deceased,
+    Unknown,
+}
+
+impl From<TriageStatus> for TriageStatusDto {
+    fn from(ts: TriageStatus) -> Self {
+        match ts {
+            TriageStatus::Immediate => TriageStatusDto::Immediate,
+            TriageStatus::Delayed => TriageStatusDto::Delayed,
+            TriageStatus::Minor => TriageStatusDto::Minor,
+            TriageStatus::Deceased => TriageStatusDto::Deceased,
+            TriageStatus::Unknown => TriageStatusDto::Unknown,
+        }
+    }
+}
+
+/// Priority DTO.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub enum PriorityDto {
+    Critical,
+    High,
+    Medium,
+    Low,
+}
+
+impl From<Priority> for PriorityDto {
+    fn from(p: Priority) -> Self {
+        match p {
+            Priority::Critical => PriorityDto::Critical,
+            Priority::High => PriorityDto::High,
+            Priority::Medium => PriorityDto::Medium,
+            Priority::Low => PriorityDto::Low,
+        }
+    }
+}
+
+/// Alert status DTO.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub enum AlertStatusDto {
+    Pending,
+    Acknowledged,
+    InProgress,
+    Resolved,
+    Cancelled,
+    Expired,
+}
+
+impl From<AlertStatus> for AlertStatusDto {
+    fn from(as_: AlertStatus) -> Self {
+        match as_ {
+            AlertStatus::Pending => AlertStatusDto::Pending,
+            AlertStatus::Acknowledged => AlertStatusDto::Acknowledged,
+            AlertStatus::InProgress => AlertStatusDto::InProgress,
+            AlertStatus::Resolved => AlertStatusDto::Resolved,
+            AlertStatus::Cancelled => AlertStatusDto::Cancelled,
+            AlertStatus::Expired => AlertStatusDto::Expired,
+        }
+    }
+}
+
+/// Survivor status DTO.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub enum SurvivorStatusDto {
+    Active,
+    Rescued,
+    Lost,
+    Deceased,
+    FalsePositive,
+}
+
+impl From<SurvivorStatus> for SurvivorStatusDto {
+    fn from(ss: SurvivorStatus) -> Self {
+        match ss {
+            SurvivorStatus::Active => SurvivorStatusDto::Active,
+            SurvivorStatus::Rescued => SurvivorStatusDto::Rescued,
+            SurvivorStatus::Lost => SurvivorStatusDto::Lost,
+            SurvivorStatus::Deceased => SurvivorStatusDto::Deceased,
+            SurvivorStatus::FalsePositive => SurvivorStatusDto::FalsePositive,
+        }
+    }
+}
+
+// ============================================================================
+// Query Parameters
+// ============================================================================
+
+/// Query parameters for listing events.
+#[derive(Debug, Clone, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub struct ListEventsQuery {
+    /// Filter by status
+    pub status: Option<EventStatusDto>,
+    /// Filter by disaster type
+    pub event_type: Option<DisasterTypeDto>,
+    /// Page number (0-indexed)
+    #[serde(default)]
+    pub page: usize,
+    /// Page size (default 20, max 100)
+    #[serde(default = "default_page_size")]
+    pub page_size: usize,
+}
+
+fn default_page_size() -> usize { 20 }
+
+/// Query parameters for listing survivors.
+#[derive(Debug, Clone, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub struct ListSurvivorsQuery {
+    /// Filter by triage status
+    pub triage_status: Option<TriageStatusDto>,
+    /// Filter by zone ID
+    pub zone_id: Option<Uuid>,
+    /// Filter by minimum confidence
+    pub min_confidence: Option<f64>,
+    /// Include only deteriorating
+    #[serde(default)]
+    pub deteriorating_only: bool,
+}
+
+/// Query parameters for listing alerts.
+#[derive(Debug, Clone, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub struct ListAlertsQuery {
+    /// Filter by priority
+    pub priority: Option<PriorityDto>,
+    /// Filter by status
+    pub status: Option<AlertStatusDto>,
+    /// Only pending alerts
+    #[serde(default)]
+    pub pending_only: bool,
+    /// Only active alerts
+    #[serde(default)]
+    pub active_only: bool,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_event_request_deserialize() {
+        let json = r#"{
+            "event_type": "Earthquake",
+            "latitude": 37.7749,
+            "longitude": -122.4194,
+            "description": "Test earthquake"
+        }"#;
+
+        let req: CreateEventRequest = serde_json::from_str(json).unwrap();
+        assert_eq!(req.event_type, DisasterTypeDto::Earthquake);
+        assert!((req.latitude - 37.7749).abs() < 0.0001);
+    }
+
+    #[test]
+    fn test_zone_bounds_dto_deserialize() {
+        let rect_json = r#"{
+            "type": "rectangle",
+            "min_x": 0.0,
+            "min_y": 0.0,
+            "max_x": 10.0,
+            "max_y": 10.0
+        }"#;
+
+        let bounds: ZoneBoundsDto = serde_json::from_str(rect_json).unwrap();
+        assert!(matches!(bounds, ZoneBoundsDto::Rectangle { .. }));
+    }
+
+    #[test]
+    fn test_websocket_message_serialize() {
+        let msg = WebSocketMessage::Heartbeat {
+            timestamp: Utc::now(),
+        };
+        let json = serde_json::to_string(&msg).unwrap();
+        assert!(json.contains("\"type\":\"heartbeat\""));
+    }
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/api/error.rs

@@ -0,0 +1,276 @@
+//! API error types and handling for the MAT REST API.
+//!
+//! This module provides a unified error type that maps to appropriate HTTP status codes
+//! and JSON error responses for the API.
+
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+use serde::Serialize;
+use thiserror::Error;
+use uuid::Uuid;
+
+/// API error type that converts to HTTP responses.
+///
+/// All errors include:
+/// - An HTTP status code
+/// - A machine-readable error code
+/// - A human-readable message
+/// - Optional additional details
+#[derive(Debug, Error)]
+pub enum ApiError {
+    /// Resource not found (404)
+    #[error("Resource not found: {resource_type} with id {id}")]
+    NotFound {
+        resource_type: String,
+        id: String,
+    },
+
+    /// Invalid request data (400)
+    #[error("Bad request: {message}")]
+    BadRequest {
+        message: String,
+        #[source]
+        source: Option<Box<dyn std::error::Error + Send + Sync>>,
+    },
+
+    /// Validation error (422)
+    #[error("Validation failed: {message}")]
+    ValidationError {
+        message: String,
+        field: Option<String>,
+    },
+
+    /// Conflict with existing resource (409)
+    #[error("Conflict: {message}")]
+    Conflict {
+        message: String,
+    },
+
+    /// Resource is in invalid state for operation (409)
+    #[error("Invalid state: {message}")]
+    InvalidState {
+        message: String,
+        current_state: String,
+    },
+
+    /// Internal server error (500)
+    #[error("Internal error: {message}")]
+    Internal {
+        message: String,
+        #[source]
+        source: Option<Box<dyn std::error::Error + Send + Sync>>,
+    },
+
+    /// Service unavailable (503)
+    #[error("Service unavailable: {message}")]
+    ServiceUnavailable {
+        message: String,
+    },
+
+    /// Domain error from business logic
+    #[error("Domain error: {0}")]
+    Domain(#[from] crate::MatError),
+}
+
+impl ApiError {
+    /// Create a not found error for an event.
+    pub fn event_not_found(id: Uuid) -> Self {
+        Self::NotFound {
+            resource_type: "DisasterEvent".to_string(),
+            id: id.to_string(),
+        }
+    }
+
+    /// Create a not found error for a zone.
+    pub fn zone_not_found(id: Uuid) -> Self {
+        Self::NotFound {
+            resource_type: "ScanZone".to_string(),
+            id: id.to_string(),
+        }
+    }
+
+    /// Create a not found error for a survivor.
+    pub fn survivor_not_found(id: Uuid) -> Self {
+        Self::NotFound {
+            resource_type: "Survivor".to_string(),
+            id: id.to_string(),
+        }
+    }
+
+    /// Create a not found error for an alert.
+    pub fn alert_not_found(id: Uuid) -> Self {
+        Self::NotFound {
+            resource_type: "Alert".to_string(),
+            id: id.to_string(),
+        }
+    }
+
+    /// Create a bad request error.
+    pub fn bad_request(message: impl Into<String>) -> Self {
+        Self::BadRequest {
+            message: message.into(),
+            source: None,
+        }
+    }
+
+    /// Create a validation error.
+    pub fn validation(message: impl Into<String>, field: Option<String>) -> Self {
+        Self::ValidationError {
+            message: message.into(),
+            field,
+        }
+    }
+
+    /// Create an internal error.
+    pub fn internal(message: impl Into<String>) -> Self {
+        Self::Internal {
+            message: message.into(),
+            source: None,
+        }
+    }
+
+    /// Get the HTTP status code for this error.
+    pub fn status_code(&self) -> StatusCode {
+        match self {
+            Self::NotFound { .. } => StatusCode::NOT_FOUND,
+            Self::BadRequest { .. } => StatusCode::BAD_REQUEST,
+            Self::ValidationError { .. } => StatusCode::UNPROCESSABLE_ENTITY,
+            Self::Conflict { .. } => StatusCode::CONFLICT,
+            Self::InvalidState { .. } => StatusCode::CONFLICT,
+            Self::Internal { .. } => StatusCode::INTERNAL_SERVER_ERROR,
+            Self::ServiceUnavailable { .. } => StatusCode::SERVICE_UNAVAILABLE,
+            Self::Domain(_) => StatusCode::BAD_REQUEST,
+        }
+    }
+
+    /// Get the error code for this error.
+    pub fn error_code(&self) -> &'static str {
+        match self {
+            Self::NotFound { .. } => "NOT_FOUND",
+            Self::BadRequest { .. } => "BAD_REQUEST",
+            Self::ValidationError { .. } => "VALIDATION_ERROR",
+            Self::Conflict { .. } => "CONFLICT",
+            Self::InvalidState { .. } => "INVALID_STATE",
+            Self::Internal { .. } => "INTERNAL_ERROR",
+            Self::ServiceUnavailable { .. } => "SERVICE_UNAVAILABLE",
+            Self::Domain(_) => "DOMAIN_ERROR",
+        }
+    }
+}
+
+/// JSON error response body.
+#[derive(Debug, Serialize)]
+pub struct ErrorResponse {
+    /// Machine-readable error code
+    pub code: String,
+    /// Human-readable error message
+    pub message: String,
+    /// Additional error details
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub details: Option<ErrorDetails>,
+    /// Request ID for tracing (if available)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+}
+
+/// Additional error details.
+#[derive(Debug, Serialize)]
+pub struct ErrorDetails {
+    /// Resource type involved
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resource_type: Option<String>,
+    /// Resource ID involved
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    /// Field that caused the error
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub field: Option<String>,
+    /// Current state (for state errors)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+}
+
+impl IntoResponse for ApiError {
+    fn into_response(self) -> Response {
+        let status = self.status_code();
+        let code = self.error_code().to_string();
+        let message = self.to_string();
+
+        let details = match &self {
+            ApiError::NotFound { resource_type, id } => Some(ErrorDetails {
+                resource_type: Some(resource_type.clone()),
+                resource_id: Some(id.clone()),
+                field: None,
+                current_state: None,
+            }),
+            ApiError::ValidationError { field, .. } => Some(ErrorDetails {
+                resource_type: None,
+                resource_id: None,
+                field: field.clone(),
+                current_state: None,
+            }),
+            ApiError::InvalidState { current_state, .. } => Some(ErrorDetails {
+                resource_type: None,
+                resource_id: None,
+                field: None,
+                current_state: Some(current_state.clone()),
+            }),
+            _ => None,
+        };
+
+        // Log errors
+        match &self {
+            ApiError::Internal { source, .. } | ApiError::BadRequest { source, .. } => {
+                if let Some(src) = source {
+                    tracing::error!(error = %self, source = %src, "API error");
+                } else {
+                    tracing::error!(error = %self, "API error");
+                }
+            }
+            _ => {
+                tracing::warn!(error = %self, "API error");
+            }
+        }
+
+        let body = ErrorResponse {
+            code,
+            message,
+            details,
+            request_id: None, // Would be populated from request extension
+        };
+
+        (status, Json(body)).into_response()
+    }
+}
+
+/// Result type alias for API handlers.
+pub type ApiResult<T> = Result<T, ApiError>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_error_status_codes() {
+        let not_found = ApiError::event_not_found(Uuid::new_v4());
+        assert_eq!(not_found.status_code(), StatusCode::NOT_FOUND);
+
+        let bad_request = ApiError::bad_request("test");
+        assert_eq!(bad_request.status_code(), StatusCode::BAD_REQUEST);
+
+        let internal = ApiError::internal("test");
+        assert_eq!(internal.status_code(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+
+    #[test]
+    fn test_error_codes() {
+        let not_found = ApiError::event_not_found(Uuid::new_v4());
+        assert_eq!(not_found.error_code(), "NOT_FOUND");
+
+        let validation = ApiError::validation("test", Some("field".to_string()));
+        assert_eq!(validation.error_code(), "VALIDATION_ERROR");
+    }
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/api/handlers.rs

@@ -0,0 +1,886 @@
+//! Axum request handlers for the MAT REST API.
+//!
+//! This module contains all the HTTP endpoint handlers for disaster response operations.
+//! Each handler is documented with OpenAPI-style documentation comments.
+
+use axum::{
+    extract::{Path, Query, State},
+    http::StatusCode,
+    Json,
+};
+use geo::Point;
+use uuid::Uuid;
+
+use super::dto::*;
+use super::error::{ApiError, ApiResult};
+use super::state::AppState;
+use crate::domain::{
+    DisasterEvent, DisasterType, ScanZone, ZoneBounds,
+    ScanParameters, ScanResolution, MovementType,
+};
+
+// ============================================================================
+// Event Handlers
+// ============================================================================
+
+/// List all disaster events.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /api/v1/mat/events:
+///   get:
+///     summary: List disaster events
+///     description: Returns a paginated list of disaster events with optional filtering
+///     tags: [Events]
+///     parameters:
+///       - name: status
+///         in: query
+///         description: Filter by event status
+///         schema:
+///           type: string
+///           enum: [Initializing, Active, Suspended, SecondarySearch, Closed]
+///       - name: event_type
+///         in: query
+///         description: Filter by disaster type
+///         schema:
+///           type: string
+///       - name: page
+///         in: query
+///         description: Page number (0-indexed)
+///         schema:
+///           type: integer
+///           default: 0
+///       - name: page_size
+///         in: query
+///         description: Items per page (max 100)
+///         schema:
+///           type: integer
+///           default: 20
+///     responses:
+///       200:
+///         description: List of events
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/EventListResponse'
+/// ```
+#[tracing::instrument(skip(state))]
+pub async fn list_events(
+    State(state): State<AppState>,
+    Query(query): Query<ListEventsQuery>,
+) -> ApiResult<Json<EventListResponse>> {
+    let all_events = state.list_events();
+
+    // Apply filters
+    let filtered: Vec<_> = all_events
+        .into_iter()
+        .filter(|e| {
+            if let Some(ref status) = query.status {
+                let event_status: EventStatusDto = e.status().clone().into();
+                if !matches_status(&event_status, status) {
+                    return false;
+                }
+            }
+            if let Some(ref event_type) = query.event_type {
+                let et: DisasterTypeDto = e.event_type().clone().into();
+                if et != *event_type {
+                    return false;
+                }
+            }
+            true
+        })
+        .collect();
+
+    let total = filtered.len();
+
+    // Apply pagination
+    let page_size = query.page_size.min(100).max(1);
+    let start = query.page * page_size;
+    let events: Vec<_> = filtered
+        .into_iter()
+        .skip(start)
+        .take(page_size)
+        .map(event_to_response)
+        .collect();
+
+    Ok(Json(EventListResponse {
+        events,
+        total,
+        page: query.page,
+        page_size,
+    }))
+}
+
+/// Create a new disaster event.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /api/v1/mat/events:
+///   post:
+///     summary: Create a new disaster event
+///     description: Creates a new disaster event for search and rescue operations
+///     tags: [Events]
+///     requestBody:
+///       required: true
+///       content:
+///         application/json:
+///           schema:
+///             $ref: '#/components/schemas/CreateEventRequest'
+///     responses:
+///       201:
+///         description: Event created successfully
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/EventResponse'
+///       400:
+///         description: Invalid request data
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/ErrorResponse'
+/// ```
+#[tracing::instrument(skip(state))]
+pub async fn create_event(
+    State(state): State<AppState>,
+    Json(request): Json<CreateEventRequest>,
+) -> ApiResult<(StatusCode, Json<EventResponse>)> {
+    // Validate coordinates
+    if request.latitude < -90.0 || request.latitude > 90.0 {
+        return Err(ApiError::validation(
+            "Latitude must be between -90 and 90",
+            Some("latitude".to_string()),
+        ));
+    }
+    if request.longitude < -180.0 || request.longitude > 180.0 {
+        return Err(ApiError::validation(
+            "Longitude must be between -180 and 180",
+            Some("longitude".to_string()),
+        ));
+    }
+
+    let disaster_type: DisasterType = request.event_type.into();
+    let location = Point::new(request.longitude, request.latitude);
+    let mut event = DisasterEvent::new(disaster_type, location, &request.description);
+
+    // Set metadata if provided
+    if let Some(occupancy) = request.estimated_occupancy {
+        event.metadata_mut().estimated_occupancy = Some(occupancy);
+    }
+    if let Some(agency) = request.lead_agency {
+        event.metadata_mut().lead_agency = Some(agency);
+    }
+
+    let response = event_to_response(event.clone());
+    let event_id = *event.id().as_uuid();
+    state.store_event(event);
+
+    // Broadcast event creation
+    state.broadcast(WebSocketMessage::EventStatusChanged {
+        event_id,
+        old_status: EventStatusDto::Initializing,
+        new_status: response.status,
+    });
+
+    tracing::info!(event_id = %event_id, "Created new disaster event");
+
+    Ok((StatusCode::CREATED, Json(response)))
+}
+
+/// Get a specific disaster event by ID.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /api/v1/mat/events/{event_id}:
+///   get:
+///     summary: Get event details
+///     description: Returns detailed information about a specific disaster event
+///     tags: [Events]
+///     parameters:
+///       - name: event_id
+///         in: path
+///         required: true
+///         description: Event UUID
+///         schema:
+///           type: string
+///           format: uuid
+///     responses:
+///       200:
+///         description: Event details
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/EventResponse'
+///       404:
+///         description: Event not found
+/// ```
+#[tracing::instrument(skip(state))]
+pub async fn get_event(
+    State(state): State<AppState>,
+    Path(event_id): Path<Uuid>,
+) -> ApiResult<Json<EventResponse>> {
+    let event = state
+        .get_event(event_id)
+        .ok_or_else(|| ApiError::event_not_found(event_id))?;
+
+    Ok(Json(event_to_response(event)))
+}
+
+// ============================================================================
+// Zone Handlers
+// ============================================================================
+
+/// List all zones for a disaster event.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /api/v1/mat/events/{event_id}/zones:
+///   get:
+///     summary: List zones for an event
+///     description: Returns all scan zones configured for a disaster event
+///     tags: [Zones]
+///     parameters:
+///       - name: event_id
+///         in: path
+///         required: true
+///         schema:
+///           type: string
+///           format: uuid
+///     responses:
+///       200:
+///         description: List of zones
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/ZoneListResponse'
+///       404:
+///         description: Event not found
+/// ```
+#[tracing::instrument(skip(state))]
+pub async fn list_zones(
+    State(state): State<AppState>,
+    Path(event_id): Path<Uuid>,
+) -> ApiResult<Json<ZoneListResponse>> {
+    let event = state
+        .get_event(event_id)
+        .ok_or_else(|| ApiError::event_not_found(event_id))?;
+
+    let zones: Vec<_> = event.zones().iter().map(zone_to_response).collect();
+    let total = zones.len();
+
+    Ok(Json(ZoneListResponse { zones, total }))
+}
+
+/// Add a scan zone to a disaster event.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /api/v1/mat/events/{event_id}/zones:
+///   post:
+///     summary: Add a scan zone
+///     description: Creates a new scan zone within a disaster event area
+///     tags: [Zones]
+///     parameters:
+///       - name: event_id
+///         in: path
+///         required: true
+///         schema:
+///           type: string
+///           format: uuid
+///     requestBody:
+///       required: true
+///       content:
+///         application/json:
+///           schema:
+///             $ref: '#/components/schemas/CreateZoneRequest'
+///     responses:
+///       201:
+///         description: Zone created successfully
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/ZoneResponse'
+///       404:
+///         description: Event not found
+///       400:
+///         description: Invalid zone configuration
+/// ```
+#[tracing::instrument(skip(state))]
+pub async fn add_zone(
+    State(state): State<AppState>,
+    Path(event_id): Path<Uuid>,
+    Json(request): Json<CreateZoneRequest>,
+) -> ApiResult<(StatusCode, Json<ZoneResponse>)> {
+    // Convert DTO to domain
+    let bounds = match request.bounds {
+        ZoneBoundsDto::Rectangle { min_x, min_y, max_x, max_y } => {
+            if max_x <= min_x || max_y <= min_y {
+                return Err(ApiError::validation(
+                    "max coordinates must be greater than min coordinates",
+                    Some("bounds".to_string()),
+                ));
+            }
+            ZoneBounds::rectangle(min_x, min_y, max_x, max_y)
+        }
+        ZoneBoundsDto::Circle { center_x, center_y, radius } => {
+            if radius <= 0.0 {
+                return Err(ApiError::validation(
+                    "radius must be positive",
+                    Some("bounds.radius".to_string()),
+                ));
+            }
+            ZoneBounds::circle(center_x, center_y, radius)
+        }
+        ZoneBoundsDto::Polygon { vertices } => {
+            if vertices.len() < 3 {
+                return Err(ApiError::validation(
+                    "polygon must have at least 3 vertices",
+                    Some("bounds.vertices".to_string()),
+                ));
+            }
+            ZoneBounds::polygon(vertices)
+        }
+    };
+
+    let params = if let Some(p) = request.parameters {
+        ScanParameters {
+            sensitivity: p.sensitivity.clamp(0.0, 1.0),
+            max_depth: p.max_depth.max(0.0),
+            resolution: match p.resolution {
+                ScanResolutionDto::Quick => ScanResolution::Quick,
+                ScanResolutionDto::Standard => ScanResolution::Standard,
+                ScanResolutionDto::High => ScanResolution::High,
+                ScanResolutionDto::Maximum => ScanResolution::Maximum,
+            },
+            enhanced_breathing: p.enhanced_breathing,
+            heartbeat_detection: p.heartbeat_detection,
+        }
+    } else {
+        ScanParameters::default()
+    };
+
+    let zone = ScanZone::with_parameters(&request.name, bounds, params);
+    let zone_response = zone_to_response(&zone);
+    let zone_id = *zone.id().as_uuid();
+
+    // Add zone to event
+    let added = state.update_event(event_id, move |e| {
+        e.add_zone(zone);
+        true
+    });
+
+    if added.is_none() {
+        return Err(ApiError::event_not_found(event_id));
+    }
+
+    tracing::info!(event_id = %event_id, zone_id = %zone_id, "Added scan zone");
+
+    Ok((StatusCode::CREATED, Json(zone_response)))
+}
+
+// ============================================================================
+// Survivor Handlers
+// ============================================================================
+
+/// List survivors detected in a disaster event.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /api/v1/mat/events/{event_id}/survivors:
+///   get:
+///     summary: List survivors
+///     description: Returns all detected survivors in a disaster event
+///     tags: [Survivors]
+///     parameters:
+///       - name: event_id
+///         in: path
+///         required: true
+///         schema:
+///           type: string
+///           format: uuid
+///       - name: triage_status
+///         in: query
+///         description: Filter by triage status
+///         schema:
+///           type: string
+///           enum: [Immediate, Delayed, Minor, Deceased, Unknown]
+///       - name: zone_id
+///         in: query
+///         description: Filter by zone
+///         schema:
+///           type: string
+///           format: uuid
+///       - name: min_confidence
+///         in: query
+///         description: Minimum confidence threshold
+///         schema:
+///           type: number
+///       - name: deteriorating_only
+///         in: query
+///         description: Only return deteriorating survivors
+///         schema:
+///           type: boolean
+///     responses:
+///       200:
+///         description: List of survivors
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/SurvivorListResponse'
+///       404:
+///         description: Event not found
+/// ```
+#[tracing::instrument(skip(state))]
+pub async fn list_survivors(
+    State(state): State<AppState>,
+    Path(event_id): Path<Uuid>,
+    Query(query): Query<ListSurvivorsQuery>,
+) -> ApiResult<Json<SurvivorListResponse>> {
+    let event = state
+        .get_event(event_id)
+        .ok_or_else(|| ApiError::event_not_found(event_id))?;
+
+    let mut triage_summary = TriageSummary::default();
+    let survivors: Vec<_> = event
+        .survivors()
+        .into_iter()
+        .filter(|s| {
+            // Update triage counts for all survivors
+            update_triage_summary(&mut triage_summary, s.triage_status());
+
+            // Apply filters
+            if let Some(ref ts) = query.triage_status {
+                let survivor_triage: TriageStatusDto = s.triage_status().clone().into();
+                if !matches_triage_status(&survivor_triage, ts) {
+                    return false;
+                }
+            }
+            if let Some(zone_id) = query.zone_id {
+                if s.zone_id().as_uuid() != &zone_id {
+                    return false;
+                }
+            }
+            if let Some(min_conf) = query.min_confidence {
+                if s.confidence() < min_conf {
+                    return false;
+                }
+            }
+            if query.deteriorating_only && !s.is_deteriorating() {
+                return false;
+            }
+            true
+        })
+        .map(survivor_to_response)
+        .collect();
+
+    let total = survivors.len();
+
+    Ok(Json(SurvivorListResponse {
+        survivors,
+        total,
+        triage_summary,
+    }))
+}
+
+// ============================================================================
+// Alert Handlers
+// ============================================================================
+
+/// List alerts for a disaster event.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /api/v1/mat/events/{event_id}/alerts:
+///   get:
+///     summary: List alerts
+///     description: Returns all alerts generated for a disaster event
+///     tags: [Alerts]
+///     parameters:
+///       - name: event_id
+///         in: path
+///         required: true
+///         schema:
+///           type: string
+///           format: uuid
+///       - name: priority
+///         in: query
+///         description: Filter by priority
+///         schema:
+///           type: string
+///           enum: [Critical, High, Medium, Low]
+///       - name: status
+///         in: query
+///         description: Filter by status
+///         schema:
+///           type: string
+///       - name: pending_only
+///         in: query
+///         description: Only return pending alerts
+///         schema:
+///           type: boolean
+///       - name: active_only
+///         in: query
+///         description: Only return active alerts
+///         schema:
+///           type: boolean
+///     responses:
+///       200:
+///         description: List of alerts
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/AlertListResponse'
+///       404:
+///         description: Event not found
+/// ```
+#[tracing::instrument(skip(state))]
+pub async fn list_alerts(
+    State(state): State<AppState>,
+    Path(event_id): Path<Uuid>,
+    Query(query): Query<ListAlertsQuery>,
+) -> ApiResult<Json<AlertListResponse>> {
+    // Verify event exists
+    if state.get_event(event_id).is_none() {
+        return Err(ApiError::event_not_found(event_id));
+    }
+
+    let all_alerts = state.list_alerts_for_event(event_id);
+    let mut priority_counts = PriorityCounts::default();
+
+    let alerts: Vec<_> = all_alerts
+        .into_iter()
+        .filter(|a| {
+            // Update priority counts
+            update_priority_counts(&mut priority_counts, a.priority());
+
+            // Apply filters
+            if let Some(ref priority) = query.priority {
+                let alert_priority: PriorityDto = a.priority().into();
+                if !matches_priority(&alert_priority, priority) {
+                    return false;
+                }
+            }
+            if let Some(ref status) = query.status {
+                let alert_status: AlertStatusDto = a.status().clone().into();
+                if !matches_alert_status(&alert_status, status) {
+                    return false;
+                }
+            }
+            if query.pending_only && !a.is_pending() {
+                return false;
+            }
+            if query.active_only && !a.is_active() {
+                return false;
+            }
+            true
+        })
+        .map(|a| alert_to_response(&a))
+        .collect();
+
+    let total = alerts.len();
+
+    Ok(Json(AlertListResponse {
+        alerts,
+        total,
+        priority_counts,
+    }))
+}
+
+/// Acknowledge an alert.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /api/v1/mat/alerts/{alert_id}/acknowledge:
+///   post:
+///     summary: Acknowledge an alert
+///     description: Marks an alert as acknowledged by a rescue team
+///     tags: [Alerts]
+///     parameters:
+///       - name: alert_id
+///         in: path
+///         required: true
+///         schema:
+///           type: string
+///           format: uuid
+///     requestBody:
+///       required: true
+///       content:
+///         application/json:
+///           schema:
+///             $ref: '#/components/schemas/AcknowledgeAlertRequest'
+///     responses:
+///       200:
+///         description: Alert acknowledged
+///         content:
+///           application/json:
+///             schema:
+///               $ref: '#/components/schemas/AcknowledgeAlertResponse'
+///       404:
+///         description: Alert not found
+///       409:
+///         description: Alert already acknowledged
+/// ```
+#[tracing::instrument(skip(state))]
+pub async fn acknowledge_alert(
+    State(state): State<AppState>,
+    Path(alert_id): Path<Uuid>,
+    Json(request): Json<AcknowledgeAlertRequest>,
+) -> ApiResult<Json<AcknowledgeAlertResponse>> {
+    let alert_data = state
+        .get_alert(alert_id)
+        .ok_or_else(|| ApiError::alert_not_found(alert_id))?;
+
+    if !alert_data.alert.is_pending() {
+        return Err(ApiError::InvalidState {
+            message: "Alert is not in pending state".to_string(),
+            current_state: format!("{:?}", alert_data.alert.status()),
+        });
+    }
+
+    let event_id = alert_data.event_id;
+
+    // Acknowledge the alert
+    state.update_alert(alert_id, |a| {
+        a.acknowledge(&request.acknowledged_by);
+    });
+
+    // Get updated alert
+    let updated = state
+        .get_alert(alert_id)
+        .ok_or_else(|| ApiError::alert_not_found(alert_id))?;
+
+    let response = alert_to_response(&updated.alert);
+
+    // Broadcast update
+    state.broadcast(WebSocketMessage::AlertUpdated {
+        event_id,
+        alert: response.clone(),
+    });
+
+    tracing::info!(
+        alert_id = %alert_id,
+        acknowledged_by = %request.acknowledged_by,
+        "Alert acknowledged"
+    );
+
+    Ok(Json(AcknowledgeAlertResponse {
+        success: true,
+        alert: response,
+    }))
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+fn event_to_response(event: DisasterEvent) -> EventResponse {
+    let triage_counts = event.triage_counts();
+
+    EventResponse {
+        id: *event.id().as_uuid(),
+        event_type: event.event_type().clone().into(),
+        status: event.status().clone().into(),
+        start_time: *event.start_time(),
+        latitude: event.location().y(),
+        longitude: event.location().x(),
+        description: event.description().to_string(),
+        zone_count: event.zones().len(),
+        survivor_count: event.survivors().len(),
+        triage_summary: TriageSummary {
+            immediate: triage_counts.immediate,
+            delayed: triage_counts.delayed,
+            minor: triage_counts.minor,
+            deceased: triage_counts.deceased,
+            unknown: triage_counts.unknown,
+        },
+        metadata: Some(EventMetadataDto {
+            estimated_occupancy: event.metadata().estimated_occupancy,
+            confirmed_rescued: event.metadata().confirmed_rescued,
+            confirmed_deceased: event.metadata().confirmed_deceased,
+            weather: event.metadata().weather.clone(),
+            lead_agency: event.metadata().lead_agency.clone(),
+        }),
+    }
+}
+
+fn zone_to_response(zone: &ScanZone) -> ZoneResponse {
+    let bounds = match zone.bounds() {
+        ZoneBounds::Rectangle { min_x, min_y, max_x, max_y } => {
+            ZoneBoundsDto::Rectangle {
+                min_x: *min_x,
+                min_y: *min_y,
+                max_x: *max_x,
+                max_y: *max_y,
+            }
+        }
+        ZoneBounds::Circle { center_x, center_y, radius } => {
+            ZoneBoundsDto::Circle {
+                center_x: *center_x,
+                center_y: *center_y,
+                radius: *radius,
+            }
+        }
+        ZoneBounds::Polygon { vertices } => {
+            ZoneBoundsDto::Polygon {
+                vertices: vertices.clone(),
+            }
+        }
+    };
+
+    let params = zone.parameters();
+    let parameters = ScanParametersDto {
+        sensitivity: params.sensitivity,
+        max_depth: params.max_depth,
+        resolution: match params.resolution {
+            ScanResolution::Quick => ScanResolutionDto::Quick,
+            ScanResolution::Standard => ScanResolutionDto::Standard,
+            ScanResolution::High => ScanResolutionDto::High,
+            ScanResolution::Maximum => ScanResolutionDto::Maximum,
+        },
+        enhanced_breathing: params.enhanced_breathing,
+        heartbeat_detection: params.heartbeat_detection,
+    };
+
+    ZoneResponse {
+        id: *zone.id().as_uuid(),
+        name: zone.name().to_string(),
+        status: zone.status().clone().into(),
+        bounds,
+        area: zone.area(),
+        parameters,
+        last_scan: zone.last_scan().cloned(),
+        scan_count: zone.scan_count(),
+        detections_count: zone.detections_count(),
+    }
+}
+
+fn survivor_to_response(survivor: &crate::Survivor) -> SurvivorResponse {
+    let location = survivor.location().map(|loc| LocationDto {
+        x: loc.x,
+        y: loc.y,
+        z: loc.z,
+        depth: loc.depth(),
+        uncertainty_radius: loc.uncertainty.horizontal_error,
+        confidence: loc.uncertainty.confidence,
+    });
+
+    let latest_vitals = survivor.vital_signs().latest();
+    let vital_signs = VitalSignsSummaryDto {
+        breathing_rate: latest_vitals.and_then(|v| v.breathing.as_ref().map(|b| b.rate_bpm)),
+        breathing_type: latest_vitals.and_then(|v| v.breathing.as_ref().map(|b| format!("{:?}", b.pattern_type))),
+        heart_rate: latest_vitals.and_then(|v| v.heartbeat.as_ref().map(|h| h.rate_bpm)),
+        has_heartbeat: latest_vitals.map(|v| v.has_heartbeat()).unwrap_or(false),
+        has_movement: latest_vitals.map(|v| v.has_movement()).unwrap_or(false),
+        movement_type: latest_vitals.and_then(|v| {
+            if v.movement.movement_type != MovementType::None {
+                Some(format!("{:?}", v.movement.movement_type))
+            } else {
+                None
+            }
+        }),
+        timestamp: latest_vitals.map(|v| v.timestamp).unwrap_or_else(chrono::Utc::now),
+    };
+
+    let metadata = {
+        let m = survivor.metadata();
+        if m.notes.is_empty() && m.tags.is_empty() && m.assigned_team.is_none() {
+            None
+        } else {
+            Some(SurvivorMetadataDto {
+                estimated_age_category: m.estimated_age_category.as_ref().map(|a| format!("{:?}", a)),
+                assigned_team: m.assigned_team.clone(),
+                notes: m.notes.clone(),
+                tags: m.tags.clone(),
+            })
+        }
+    };
+
+    SurvivorResponse {
+        id: *survivor.id().as_uuid(),
+        zone_id: *survivor.zone_id().as_uuid(),
+        status: survivor.status().clone().into(),
+        triage_status: survivor.triage_status().clone().into(),
+        location,
+        vital_signs,
+        confidence: survivor.confidence(),
+        first_detected: *survivor.first_detected(),
+        last_updated: *survivor.last_updated(),
+        is_deteriorating: survivor.is_deteriorating(),
+        metadata,
+    }
+}
+
+fn alert_to_response(alert: &crate::Alert) -> AlertResponse {
+    let location = alert.payload().location.as_ref().map(|loc| LocationDto {
+        x: loc.x,
+        y: loc.y,
+        z: loc.z,
+        depth: loc.depth(),
+        uncertainty_radius: loc.uncertainty.horizontal_error,
+        confidence: loc.uncertainty.confidence,
+    });
+
+    AlertResponse {
+        id: *alert.id().as_uuid(),
+        survivor_id: *alert.survivor_id().as_uuid(),
+        priority: alert.priority().into(),
+        status: alert.status().clone().into(),
+        title: alert.payload().title.clone(),
+        message: alert.payload().message.clone(),
+        triage_status: alert.payload().triage_status.clone().into(),
+        location,
+        recommended_action: if alert.payload().recommended_action.is_empty() {
+            None
+        } else {
+            Some(alert.payload().recommended_action.clone())
+        },
+        created_at: *alert.created_at(),
+        acknowledged_at: alert.acknowledged_at().cloned(),
+        acknowledged_by: alert.acknowledged_by().map(String::from),
+        escalation_count: alert.escalation_count(),
+    }
+}
+
+fn update_triage_summary(summary: &mut TriageSummary, status: &crate::TriageStatus) {
+    match status {
+        crate::TriageStatus::Immediate => summary.immediate += 1,
+        crate::TriageStatus::Delayed => summary.delayed += 1,
+        crate::TriageStatus::Minor => summary.minor += 1,
+        crate::TriageStatus::Deceased => summary.deceased += 1,
+        crate::TriageStatus::Unknown => summary.unknown += 1,
+    }
+}
+
+fn update_priority_counts(counts: &mut PriorityCounts, priority: crate::Priority) {
+    match priority {
+        crate::Priority::Critical => counts.critical += 1,
+        crate::Priority::High => counts.high += 1,
+        crate::Priority::Medium => counts.medium += 1,
+        crate::Priority::Low => counts.low += 1,
+    }
+}
+
+// Match helper functions (avoiding PartialEq on DTOs for flexibility)
+fn matches_status(a: &EventStatusDto, b: &EventStatusDto) -> bool {
+    std::mem::discriminant(a) == std::mem::discriminant(b)
+}
+
+fn matches_triage_status(a: &TriageStatusDto, b: &TriageStatusDto) -> bool {
+    std::mem::discriminant(a) == std::mem::discriminant(b)
+}
+
+fn matches_priority(a: &PriorityDto, b: &PriorityDto) -> bool {
+    std::mem::discriminant(a) == std::mem::discriminant(b)
+}
+
+fn matches_alert_status(a: &AlertStatusDto, b: &AlertStatusDto) -> bool {
+    std::mem::discriminant(a) == std::mem::discriminant(b)
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/api/mod.rs

@@ -0,0 +1,71 @@
+//! REST API endpoints for WiFi-DensePose MAT disaster response monitoring.
+//!
+//! This module provides a complete REST API and WebSocket interface for
+//! managing disaster events, zones, survivors, and alerts in real-time.
+//!
+//! ## Endpoints
+//!
+//! ### Disaster Events
+//! - `GET /api/v1/mat/events` - List all disaster events
+//! - `POST /api/v1/mat/events` - Create new disaster event
+//! - `GET /api/v1/mat/events/{id}` - Get event details
+//!
+//! ### Zones
+//! - `GET /api/v1/mat/events/{id}/zones` - List zones for event
+//! - `POST /api/v1/mat/events/{id}/zones` - Add zone to event
+//!
+//! ### Survivors
+//! - `GET /api/v1/mat/events/{id}/survivors` - List survivors in event
+//!
+//! ### Alerts
+//! - `GET /api/v1/mat/events/{id}/alerts` - List alerts for event
+//! - `POST /api/v1/mat/alerts/{id}/acknowledge` - Acknowledge alert
+//!
+//! ### WebSocket
+//! - `WS /ws/mat/stream` - Real-time survivor and alert stream
+
+pub mod dto;
+pub mod handlers;
+pub mod error;
+pub mod state;
+pub mod websocket;
+
+use axum::{
+    Router,
+    routing::{get, post},
+};
+
+pub use dto::*;
+pub use error::ApiError;
+pub use state::AppState;
+
+/// Create the MAT API router with all endpoints.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// use wifi_densepose_mat::api::{create_router, AppState};
+///
+/// #[tokio::main]
+/// async fn main() {
+///     let state = AppState::new();
+///     let app = create_router(state);
+///     // ... serve with axum
+/// }
+/// ```
+pub fn create_router(state: AppState) -> Router {
+    Router::new()
+        // Event endpoints
+        .route("/api/v1/mat/events", get(handlers::list_events).post(handlers::create_event))
+        .route("/api/v1/mat/events/:event_id", get(handlers::get_event))
+        // Zone endpoints
+        .route("/api/v1/mat/events/:event_id/zones", get(handlers::list_zones).post(handlers::add_zone))
+        // Survivor endpoints
+        .route("/api/v1/mat/events/:event_id/survivors", get(handlers::list_survivors))
+        // Alert endpoints
+        .route("/api/v1/mat/events/:event_id/alerts", get(handlers::list_alerts))
+        .route("/api/v1/mat/alerts/:alert_id/acknowledge", post(handlers::acknowledge_alert))
+        // WebSocket endpoint
+        .route("/ws/mat/stream", get(websocket::ws_handler))
+        .with_state(state)
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/api/state.rs

@@ -0,0 +1,258 @@
+//! Application state for the MAT REST API.
+//!
+//! This module provides the shared state that is passed to all API handlers.
+//! It contains repositories, services, and real-time event broadcasting.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use parking_lot::RwLock;
+use tokio::sync::broadcast;
+use uuid::Uuid;
+
+use crate::domain::{
+    DisasterEvent, Alert,
+};
+use super::dto::WebSocketMessage;
+
+/// Shared application state for the API.
+///
+/// This is cloned for each request handler and provides thread-safe
+/// access to shared resources.
+#[derive(Clone)]
+pub struct AppState {
+    inner: Arc<AppStateInner>,
+}
+
+/// Inner state (not cloned, shared via Arc).
+struct AppStateInner {
+    /// In-memory event repository
+    events: RwLock<HashMap<Uuid, DisasterEvent>>,
+    /// In-memory alert repository
+    alerts: RwLock<HashMap<Uuid, AlertWithEventId>>,
+    /// Broadcast channel for real-time updates
+    broadcast_tx: broadcast::Sender<WebSocketMessage>,
+    /// Configuration
+    config: ApiConfig,
+}
+
+/// Alert with its associated event ID for lookup.
+#[derive(Clone)]
+pub struct AlertWithEventId {
+    pub alert: Alert,
+    pub event_id: Uuid,
+}
+
+/// API configuration.
+#[derive(Clone)]
+pub struct ApiConfig {
+    /// Maximum number of events to store
+    pub max_events: usize,
+    /// Maximum survivors per event
+    pub max_survivors_per_event: usize,
+    /// Broadcast channel capacity
+    pub broadcast_capacity: usize,
+}
+
+impl Default for ApiConfig {
+    fn default() -> Self {
+        Self {
+            max_events: 1000,
+            max_survivors_per_event: 10000,
+            broadcast_capacity: 1024,
+        }
+    }
+}
+
+impl AppState {
+    /// Create a new application state with default configuration.
+    pub fn new() -> Self {
+        Self::with_config(ApiConfig::default())
+    }
+
+    /// Create a new application state with custom configuration.
+    pub fn with_config(config: ApiConfig) -> Self {
+        let (broadcast_tx, _) = broadcast::channel(config.broadcast_capacity);
+
+        Self {
+            inner: Arc::new(AppStateInner {
+                events: RwLock::new(HashMap::new()),
+                alerts: RwLock::new(HashMap::new()),
+                broadcast_tx,
+                config,
+            }),
+        }
+    }
+
+    // ========================================================================
+    // Event Operations
+    // ========================================================================
+
+    /// Store a disaster event.
+    pub fn store_event(&self, event: DisasterEvent) -> Uuid {
+        let id = *event.id().as_uuid();
+        let mut events = self.inner.events.write();
+
+        // Check capacity
+        if events.len() >= self.inner.config.max_events {
+            // Remove oldest closed event
+            let oldest_closed = events
+                .iter()
+                .filter(|(_, e)| matches!(e.status(), crate::EventStatus::Closed))
+                .min_by_key(|(_, e)| e.start_time())
+                .map(|(id, _)| *id);
+
+            if let Some(old_id) = oldest_closed {
+                events.remove(&old_id);
+            }
+        }
+
+        events.insert(id, event);
+        id
+    }
+
+    /// Get an event by ID.
+    pub fn get_event(&self, id: Uuid) -> Option<DisasterEvent> {
+        self.inner.events.read().get(&id).cloned()
+    }
+
+    /// Get mutable access to an event (for updates).
+    pub fn update_event<F, R>(&self, id: Uuid, f: F) -> Option<R>
+    where
+        F: FnOnce(&mut DisasterEvent) -> R,
+    {
+        let mut events = self.inner.events.write();
+        events.get_mut(&id).map(f)
+    }
+
+    /// List all events.
+    pub fn list_events(&self) -> Vec<DisasterEvent> {
+        self.inner.events.read().values().cloned().collect()
+    }
+
+    /// Get event count.
+    pub fn event_count(&self) -> usize {
+        self.inner.events.read().len()
+    }
+
+    // ========================================================================
+    // Alert Operations
+    // ========================================================================
+
+    /// Store an alert.
+    pub fn store_alert(&self, alert: Alert, event_id: Uuid) -> Uuid {
+        let id = *alert.id().as_uuid();
+        let mut alerts = self.inner.alerts.write();
+        alerts.insert(id, AlertWithEventId { alert, event_id });
+        id
+    }
+
+    /// Get an alert by ID.
+    pub fn get_alert(&self, id: Uuid) -> Option<AlertWithEventId> {
+        self.inner.alerts.read().get(&id).cloned()
+    }
+
+    /// Update an alert.
+    pub fn update_alert<F, R>(&self, id: Uuid, f: F) -> Option<R>
+    where
+        F: FnOnce(&mut Alert) -> R,
+    {
+        let mut alerts = self.inner.alerts.write();
+        alerts.get_mut(&id).map(|a| f(&mut a.alert))
+    }
+
+    /// List alerts for an event.
+    pub fn list_alerts_for_event(&self, event_id: Uuid) -> Vec<Alert> {
+        self.inner
+            .alerts
+            .read()
+            .values()
+            .filter(|a| a.event_id == event_id)
+            .map(|a| a.alert.clone())
+            .collect()
+    }
+
+    // ========================================================================
+    // Broadcasting
+    // ========================================================================
+
+    /// Get a receiver for real-time updates.
+    pub fn subscribe(&self) -> broadcast::Receiver<WebSocketMessage> {
+        self.inner.broadcast_tx.subscribe()
+    }
+
+    /// Broadcast a message to all subscribers.
+    pub fn broadcast(&self, message: WebSocketMessage) {
+        // Ignore send errors (no subscribers)
+        let _ = self.inner.broadcast_tx.send(message);
+    }
+
+    /// Get the number of active subscribers.
+    pub fn subscriber_count(&self) -> usize {
+        self.inner.broadcast_tx.receiver_count()
+    }
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::domain::{DisasterType, DisasterEvent};
+    use geo::Point;
+
+    #[test]
+    fn test_store_and_get_event() {
+        let state = AppState::new();
+        let event = DisasterEvent::new(
+            DisasterType::Earthquake,
+            Point::new(-122.4194, 37.7749),
+            "Test earthquake",
+        );
+        let id = *event.id().as_uuid();
+
+        state.store_event(event);
+
+        let retrieved = state.get_event(id);
+        assert!(retrieved.is_some());
+        assert_eq!(retrieved.unwrap().id().as_uuid(), &id);
+    }
+
+    #[test]
+    fn test_update_event() {
+        let state = AppState::new();
+        let event = DisasterEvent::new(
+            DisasterType::Earthquake,
+            Point::new(0.0, 0.0),
+            "Test",
+        );
+        let id = *event.id().as_uuid();
+        state.store_event(event);
+
+        let result = state.update_event(id, |e| {
+            e.set_status(crate::EventStatus::Suspended);
+            true
+        });
+
+        assert!(result.unwrap());
+        let updated = state.get_event(id).unwrap();
+        assert!(matches!(updated.status(), crate::EventStatus::Suspended));
+    }
+
+    #[test]
+    fn test_broadcast_subscribe() {
+        let state = AppState::new();
+        let mut rx = state.subscribe();
+
+        state.broadcast(WebSocketMessage::Heartbeat {
+            timestamp: chrono::Utc::now(),
+        });
+
+        // Try to receive (in async context this would work)
+        assert_eq!(state.subscriber_count(), 1);
+    }
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/api/websocket.rs

@@ -0,0 +1,330 @@
+//! WebSocket handler for real-time survivor and alert streaming.
+//!
+//! This module provides a WebSocket endpoint that streams real-time updates
+//! for survivor detections, status changes, and alerts.
+//!
+//! ## Protocol
+//!
+//! Clients connect to `/ws/mat/stream` and receive JSON-formatted messages.
+//!
+//! ### Message Types
+//!
+//! - `survivor_detected` - New survivor found
+//! - `survivor_updated` - Survivor status/vitals changed
+//! - `survivor_lost` - Survivor signal lost
+//! - `alert_created` - New alert generated
+//! - `alert_updated` - Alert status changed
+//! - `zone_scan_complete` - Zone scan finished
+//! - `event_status_changed` - Event status changed
+//! - `heartbeat` - Keep-alive ping
+//! - `error` - Error message
+//!
+//! ### Client Commands
+//!
+//! Clients can send JSON commands:
+//! - `{"action": "subscribe", "event_id": "..."}`
+//! - `{"action": "unsubscribe", "event_id": "..."}`
+//! - `{"action": "subscribe_all"}`
+//! - `{"action": "get_state", "event_id": "..."}`
+
+use std::collections::HashSet;
+use std::sync::Arc;
+use std::time::Duration;
+
+use axum::{
+    extract::{
+        ws::{Message, WebSocket, WebSocketUpgrade},
+        State,
+    },
+    response::Response,
+};
+use futures_util::{SinkExt, StreamExt};
+use parking_lot::Mutex;
+use tokio::sync::broadcast;
+use uuid::Uuid;
+
+use super::dto::{WebSocketMessage, WebSocketRequest};
+use super::state::AppState;
+
+/// WebSocket connection handler.
+///
+/// # OpenAPI Specification
+///
+/// ```yaml
+/// /ws/mat/stream:
+///   get:
+///     summary: Real-time event stream
+///     description: |
+///       WebSocket endpoint for real-time updates on survivors and alerts.
+///
+///       ## Connection
+///
+///       Connect using a WebSocket client to receive real-time updates.
+///
+///       ## Messages
+///
+///       All messages are JSON-formatted with a "type" field indicating
+///       the message type.
+///
+///       ## Subscriptions
+///
+///       By default, clients receive updates for all events. Send a
+///       subscribe/unsubscribe command to filter to specific events.
+///     tags: [WebSocket]
+///     responses:
+///       101:
+///         description: WebSocket connection established
+/// ```
+#[tracing::instrument(skip(state, ws))]
+pub async fn ws_handler(
+    State(state): State<AppState>,
+    ws: WebSocketUpgrade,
+) -> Response {
+    ws.on_upgrade(move |socket| handle_socket(socket, state))
+}
+
+/// Handle an established WebSocket connection.
+async fn handle_socket(socket: WebSocket, state: AppState) {
+    let (mut sender, mut receiver) = socket.split();
+
+    // Subscription state for this connection
+    let subscriptions: Arc<Mutex<SubscriptionState>> = Arc::new(Mutex::new(SubscriptionState::new()));
+
+    // Subscribe to broadcast channel
+    let mut broadcast_rx = state.subscribe();
+
+    // Spawn task to forward broadcast messages to client
+    let subs_clone = subscriptions.clone();
+    let forward_task = tokio::spawn(async move {
+        loop {
+            tokio::select! {
+                // Receive from broadcast channel
+                result = broadcast_rx.recv() => {
+                    match result {
+                        Ok(msg) => {
+                            // Check if this message matches subscription filter
+                            if subs_clone.lock().should_receive(&msg) {
+                                if let Ok(json) = serde_json::to_string(&msg) {
+                                    if sender.send(Message::Text(json)).await.is_err() {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        Err(broadcast::error::RecvError::Lagged(n)) => {
+                            tracing::warn!(lagged = n, "WebSocket client lagged, messages dropped");
+                            // Send error notification
+                            let error = WebSocketMessage::Error {
+                                code: "MESSAGES_DROPPED".to_string(),
+                                message: format!("{} messages were dropped due to slow client", n),
+                            };
+                            if let Ok(json) = serde_json::to_string(&error) {
+                                if sender.send(Message::Text(json)).await.is_err() {
+                                    break;
+                                }
+                            }
+                        }
+                        Err(broadcast::error::RecvError::Closed) => {
+                            break;
+                        }
+                    }
+                }
+                // Periodic heartbeat
+                _ = tokio::time::sleep(Duration::from_secs(30)) => {
+                    let heartbeat = WebSocketMessage::Heartbeat {
+                        timestamp: chrono::Utc::now(),
+                    };
+                    if let Ok(json) = serde_json::to_string(&heartbeat) {
+                        if sender.send(Message::Ping(json.into_bytes())).await.is_err() {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    });
+
+    // Handle incoming messages from client
+    let subs_clone = subscriptions.clone();
+    let state_clone = state.clone();
+    while let Some(Ok(msg)) = receiver.next().await {
+        match msg {
+            Message::Text(text) => {
+                // Parse and handle client command
+                if let Err(e) = handle_client_message(&text, &subs_clone, &state_clone).await {
+                    tracing::warn!(error = %e, "Failed to handle WebSocket message");
+                }
+            }
+            Message::Binary(_) => {
+                // Binary messages not supported
+                tracing::debug!("Ignoring binary WebSocket message");
+            }
+            Message::Ping(data) => {
+                // Pong handled automatically by axum
+                tracing::trace!(len = data.len(), "Received ping");
+            }
+            Message::Pong(_) => {
+                // Heartbeat response
+                tracing::trace!("Received pong");
+            }
+            Message::Close(_) => {
+                tracing::debug!("Client closed WebSocket connection");
+                break;
+            }
+        }
+    }
+
+    // Clean up
+    forward_task.abort();
+    tracing::debug!("WebSocket connection closed");
+}
+
+/// Handle a client message (subscription commands).
+async fn handle_client_message(
+    text: &str,
+    subscriptions: &Arc<Mutex<SubscriptionState>>,
+    state: &AppState,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let request: WebSocketRequest = serde_json::from_str(text)?;
+
+    match request {
+        WebSocketRequest::Subscribe { event_id } => {
+            // Verify event exists
+            if state.get_event(event_id).is_some() {
+                subscriptions.lock().subscribe(event_id);
+                tracing::debug!(event_id = %event_id, "Client subscribed to event");
+            }
+        }
+        WebSocketRequest::Unsubscribe { event_id } => {
+            subscriptions.lock().unsubscribe(&event_id);
+            tracing::debug!(event_id = %event_id, "Client unsubscribed from event");
+        }
+        WebSocketRequest::SubscribeAll => {
+            subscriptions.lock().subscribe_all();
+            tracing::debug!("Client subscribed to all events");
+        }
+        WebSocketRequest::GetState { event_id } => {
+            // This would send current state - simplified for now
+            tracing::debug!(event_id = %event_id, "Client requested state");
+        }
+    }
+
+    Ok(())
+}
+
+/// Tracks subscription state for a WebSocket connection.
+struct SubscriptionState {
+    /// Subscribed event IDs (empty = all events)
+    event_ids: HashSet<Uuid>,
+    /// Whether subscribed to all events
+    all_events: bool,
+}
+
+impl SubscriptionState {
+    fn new() -> Self {
+        Self {
+            event_ids: HashSet::new(),
+            all_events: true, // Default to receiving all events
+        }
+    }
+
+    fn subscribe(&mut self, event_id: Uuid) {
+        self.all_events = false;
+        self.event_ids.insert(event_id);
+    }
+
+    fn unsubscribe(&mut self, event_id: &Uuid) {
+        self.event_ids.remove(event_id);
+        if self.event_ids.is_empty() {
+            self.all_events = true;
+        }
+    }
+
+    fn subscribe_all(&mut self) {
+        self.all_events = true;
+        self.event_ids.clear();
+    }
+
+    fn should_receive(&self, msg: &WebSocketMessage) -> bool {
+        if self.all_events {
+            return true;
+        }
+
+        // Extract event_id from message and check subscription
+        let event_id = match msg {
+            WebSocketMessage::SurvivorDetected { event_id, .. } => Some(*event_id),
+            WebSocketMessage::SurvivorUpdated { event_id, .. } => Some(*event_id),
+            WebSocketMessage::SurvivorLost { event_id, .. } => Some(*event_id),
+            WebSocketMessage::AlertCreated { event_id, .. } => Some(*event_id),
+            WebSocketMessage::AlertUpdated { event_id, .. } => Some(*event_id),
+            WebSocketMessage::ZoneScanComplete { event_id, .. } => Some(*event_id),
+            WebSocketMessage::EventStatusChanged { event_id, .. } => Some(*event_id),
+            WebSocketMessage::Heartbeat { .. } => None, // Always receive
+            WebSocketMessage::Error { .. } => None, // Always receive
+        };
+
+        match event_id {
+            Some(id) => self.event_ids.contains(&id),
+            None => true, // Non-event-specific messages always sent
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_subscription_state() {
+        let mut state = SubscriptionState::new();
+
+        // Default is all events
+        assert!(state.all_events);
+
+        // Subscribe to specific event
+        let event_id = Uuid::new_v4();
+        state.subscribe(event_id);
+        assert!(!state.all_events);
+        assert!(state.event_ids.contains(&event_id));
+
+        // Unsubscribe returns to all events
+        state.unsubscribe(&event_id);
+        assert!(state.all_events);
+    }
+
+    #[test]
+    fn test_should_receive() {
+        let mut state = SubscriptionState::new();
+        let event_id = Uuid::new_v4();
+        let other_id = Uuid::new_v4();
+
+        // All events mode - receive everything
+        let msg = WebSocketMessage::Heartbeat {
+            timestamp: chrono::Utc::now(),
+        };
+        assert!(state.should_receive(&msg));
+
+        // Subscribe to specific event
+        state.subscribe(event_id);
+
+        // Should receive messages for subscribed event
+        let msg = WebSocketMessage::SurvivorLost {
+            event_id,
+            survivor_id: Uuid::new_v4(),
+        };
+        assert!(state.should_receive(&msg));
+
+        // Should not receive messages for other events
+        let msg = WebSocketMessage::SurvivorLost {
+            event_id: other_id,
+            survivor_id: Uuid::new_v4(),
+        };
+        assert!(!state.should_receive(&msg));
+
+        // Heartbeats always received
+        let msg = WebSocketMessage::Heartbeat {
+            timestamp: chrono::Utc::now(),
+        };
+        assert!(state.should_receive(&msg));
+    }
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/detection/pipeline.rs

@@ -1,6 +1,10 @@
 //! Detection pipeline combining all vital signs detectors.
+//!
+//! This module provides both traditional signal-processing-based detection
+//! and optional ML-enhanced detection for improved accuracy.
 
 use crate::domain::{ScanZone, VitalSignsReading, ConfidenceScore};
+use crate::ml::{MlDetectionConfig, MlDetectionPipeline, MlDetectionResult};
 use crate::{DisasterConfig, MatError};
 use super::{
     BreathingDetector, BreathingDetectorConfig,
@@ -23,6 +27,10 @@ pub struct DetectionConfig {
     pub enable_heartbeat: bool,
     /// Minimum overall confidence to report detection
     pub min_confidence: f64,
+    /// Enable ML-enhanced detection
+    pub enable_ml: bool,
+    /// ML detection configuration (if enabled)
+    pub ml_config: Option<MlDetectionConfig>,
 }
 
 impl Default for DetectionConfig {
@@ -34,6 +42,8 @@ impl Default for DetectionConfig {
             sample_rate: 1000.0,
             enable_heartbeat: false,
             min_confidence: 0.3,
+            enable_ml: false,
+            ml_config: None,
         }
     }
 }
@@ -53,6 +63,20 @@ impl DetectionConfig {
 
         detection_config
     }
+
+    /// Enable ML-enhanced detection with the given configuration
+    pub fn with_ml(mut self, ml_config: MlDetectionConfig) -> Self {
+        self.enable_ml = true;
+        self.ml_config = Some(ml_config);
+        self
+    }
+
+    /// Enable ML-enhanced detection with default configuration
+    pub fn with_default_ml(mut self) -> Self {
+        self.enable_ml = true;
+        self.ml_config = Some(MlDetectionConfig::default());
+        self
+    }
 }
 
 /// Trait for vital signs detection
@@ -123,20 +147,42 @@ pub struct DetectionPipeline {
     heartbeat_detector: HeartbeatDetector,
     movement_classifier: MovementClassifier,
     data_buffer: parking_lot::RwLock<CsiDataBuffer>,
+    /// Optional ML detection pipeline
+    ml_pipeline: Option<MlDetectionPipeline>,
 }
 
 impl DetectionPipeline {
     /// Create a new detection pipeline
     pub fn new(config: DetectionConfig) -> Self {
+        let ml_pipeline = if config.enable_ml {
+            config.ml_config.clone().map(MlDetectionPipeline::new)
+        } else {
+            None
+        };
+
         Self {
             breathing_detector: BreathingDetector::new(config.breathing.clone()),
             heartbeat_detector: HeartbeatDetector::new(config.heartbeat.clone()),
             movement_classifier: MovementClassifier::new(config.movement.clone()),
             data_buffer: parking_lot::RwLock::new(CsiDataBuffer::new(config.sample_rate)),
+            ml_pipeline,
             config,
         }
     }
 
+    /// Initialize ML models asynchronously (if enabled)
+    pub async fn initialize_ml(&mut self) -> Result<(), MatError> {
+        if let Some(ref mut ml) = self.ml_pipeline {
+            ml.initialize().await.map_err(MatError::from)?;
+        }
+        Ok(())
+    }
+
+    /// Check if ML pipeline is ready
+    pub fn ml_ready(&self) -> bool {
+        self.ml_pipeline.as_ref().map_or(true, |ml| ml.is_ready())
+    }
+
     /// Process a scan zone and return detected vital signs
     pub async fn process_zone(&self, zone: &ScanZone) -> Result<Option<VitalSignsReading>, MatError> {
         // In a real implementation, this would:
@@ -152,17 +198,66 @@ impl DetectionPipeline {
             return Ok(None);
         }
 
-        // Detect vital signs
+        // Detect vital signs using traditional pipeline
         let reading = self.detect_from_buffer(&buffer, zone)?;
 
+        // If ML is enabled and ready, enhance with ML predictions
+        let enhanced_reading = if self.config.enable_ml && self.ml_ready() {
+            self.enhance_with_ml(reading, &buffer).await?
+        } else {
+            reading
+        };
+
         // Check minimum confidence
-        if let Some(ref r) = reading {
+        if let Some(ref r) = enhanced_reading {
             if r.confidence.value() < self.config.min_confidence {
                 return Ok(None);
             }
         }
 
-        Ok(reading)
+        Ok(enhanced_reading)
+    }
+
+    /// Enhance detection results with ML predictions
+    async fn enhance_with_ml(
+        &self,
+        traditional_reading: Option<VitalSignsReading>,
+        buffer: &CsiDataBuffer,
+    ) -> Result<Option<VitalSignsReading>, MatError> {
+        let ml_pipeline = match &self.ml_pipeline {
+            Some(ml) => ml,
+            None => return Ok(traditional_reading),
+        };
+
+        // Get ML predictions
+        let ml_result = ml_pipeline.process(buffer).await.map_err(MatError::from)?;
+
+        // If we have ML vital classification, use it to enhance or replace traditional
+        if let Some(ref ml_vital) = ml_result.vital_classification {
+            if let Some(vital_reading) = ml_vital.to_vital_signs_reading() {
+                // If ML result has higher confidence, prefer it
+                if let Some(ref traditional) = traditional_reading {
+                    if ml_result.overall_confidence() > traditional.confidence.value() as f32 {
+                        return Ok(Some(vital_reading));
+                    }
+                } else {
+                    // No traditional reading, use ML result
+                    return Ok(Some(vital_reading));
+                }
+            }
+        }
+
+        Ok(traditional_reading)
+    }
+
+    /// Get the latest ML detection results (if ML is enabled)
+    pub async fn get_ml_results(&self) -> Option<MlDetectionResult> {
+        let buffer = self.data_buffer.read();
+        if let Some(ref ml) = self.ml_pipeline {
+            ml.process(&buffer).await.ok()
+        } else {
+            None
+        }
     }
 
     /// Add CSI data to the processing buffer
@@ -236,8 +331,23 @@ impl DetectionPipeline {
         self.breathing_detector = BreathingDetector::new(config.breathing.clone());
         self.heartbeat_detector = HeartbeatDetector::new(config.heartbeat.clone());
         self.movement_classifier = MovementClassifier::new(config.movement.clone());
+
+        // Update ML pipeline if configuration changed
+        if config.enable_ml != self.config.enable_ml || config.ml_config != self.config.ml_config {
+            self.ml_pipeline = if config.enable_ml {
+                config.ml_config.clone().map(MlDetectionPipeline::new)
+            } else {
+                None
+            };
+        }
+
         self.config = config;
     }
+
+    /// Get the ML pipeline (if enabled)
+    pub fn ml_pipeline(&self) -> Option<&MlDetectionPipeline> {
+        self.ml_pipeline.as_ref()
+    }
 }
 
 impl VitalSignsDetector for DetectionPipeline {

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/integration/mod.rs

@@ -4,14 +4,102 @@
 //! - wifi-densepose-signal types and wifi-Mat domain types
 //! - wifi-densepose-nn inference results and detection results
 //! - wifi-densepose-hardware interfaces and sensor abstractions
+//!
+//! # Hardware Support
+//!
+//! The integration layer supports multiple WiFi CSI hardware platforms:
+//!
+//! - **ESP32**: Via serial communication using ESP-CSI firmware
+//! - **Intel 5300 NIC**: Using Linux CSI Tool (iwlwifi driver)
+//! - **Atheros NICs**: Using ath9k/ath10k/ath11k CSI patches
+//! - **Nexmon**: For Broadcom chips with CSI firmware
+//!
+//! # Example Usage
+//!
+//! ```ignore
+//! use wifi_densepose_mat::integration::{
+//!     HardwareAdapter, HardwareConfig, AtherosDriver,
+//!     csi_receiver::{UdpCsiReceiver, ReceiverConfig},
+//! };
+//!
+//! // Configure for ESP32
+//! let config = HardwareConfig::esp32("/dev/ttyUSB0", 921600);
+//! let mut adapter = HardwareAdapter::with_config(config);
+//! adapter.initialize().await?;
+//!
+//! // Or configure for Intel 5300
+//! let config = HardwareConfig::intel_5300("wlan0");
+//! let mut adapter = HardwareAdapter::with_config(config);
+//!
+//! // Or use UDP receiver for network streaming
+//! let config = ReceiverConfig::udp("0.0.0.0", 5500);
+//! let mut receiver = UdpCsiReceiver::new(config).await?;
+//! ```
 
 mod signal_adapter;
 mod neural_adapter;
 mod hardware_adapter;
+pub mod csi_receiver;
 
 pub use signal_adapter::SignalAdapter;
 pub use neural_adapter::NeuralAdapter;
-pub use hardware_adapter::HardwareAdapter;
+pub use hardware_adapter::{
+    // Main adapter
+    HardwareAdapter,
+    // Configuration types
+    HardwareConfig,
+    DeviceType,
+    DeviceSettings,
+    AtherosDriver,
+    ChannelConfig,
+    Bandwidth,
+    // Serial settings
+    SerialSettings,
+    Parity,
+    FlowControl,
+    // Network interface settings
+    NetworkInterfaceSettings,
+    AntennaConfig,
+    // UDP settings
+    UdpSettings,
+    // PCAP settings
+    PcapSettings,
+    // Sensor types
+    SensorInfo,
+    SensorStatus,
+    // CSI data types
+    CsiReadings,
+    CsiMetadata,
+    SensorCsiReading,
+    FrameControlType,
+    CsiStream,
+    // Health and stats
+    HardwareHealth,
+    HealthStatus,
+    StreamingStats,
+};
+
+pub use csi_receiver::{
+    // Receiver types
+    UdpCsiReceiver,
+    SerialCsiReceiver,
+    PcapCsiReader,
+    // Configuration
+    ReceiverConfig,
+    CsiSource,
+    UdpSourceConfig,
+    SerialSourceConfig,
+    PcapSourceConfig,
+    SerialParity,
+    // Packet types
+    CsiPacket,
+    CsiPacketMetadata,
+    CsiPacketFormat,
+    // Parser
+    CsiParser,
+    // Stats
+    ReceiverStats,
+};
 
 /// Configuration for integration layer
 #[derive(Debug, Clone, Default)]
@@ -22,6 +110,40 @@ pub struct IntegrationConfig {
     pub batch_size: usize,
     /// Enable signal preprocessing optimizations
     pub optimize_signal: bool,
+    /// Hardware configuration
+    pub hardware: Option<HardwareConfig>,
+}
+
+impl IntegrationConfig {
+    /// Create configuration for real-time processing
+    pub fn realtime() -> Self {
+        Self {
+            use_gpu: true,
+            batch_size: 1,
+            optimize_signal: true,
+            hardware: None,
+        }
+    }
+
+    /// Create configuration for batch processing
+    pub fn batch(batch_size: usize) -> Self {
+        Self {
+            use_gpu: true,
+            batch_size,
+            optimize_signal: true,
+            hardware: None,
+        }
+    }
+
+    /// Create configuration with specific hardware
+    pub fn with_hardware(hardware: HardwareConfig) -> Self {
+        Self {
+            use_gpu: true,
+            batch_size: 1,
+            optimize_signal: true,
+            hardware: Some(hardware),
+        }
+    }
 }
 
 /// Error type for integration layer
@@ -46,4 +168,68 @@ pub enum AdapterError {
     /// Data format error
     #[error("Data format error: {0}")]
     DataFormat(String),
+
+    /// I/O error
+    #[error("I/O error: {0}")]
+    Io(#[from] std::io::Error),
+
+    /// Timeout error
+    #[error("Timeout error: {0}")]
+    Timeout(String),
+}
+
+/// Prelude module for convenient imports
+pub mod prelude {
+    pub use super::{
+        AdapterError,
+        HardwareAdapter,
+        HardwareConfig,
+        DeviceType,
+        AtherosDriver,
+        Bandwidth,
+        CsiReadings,
+        CsiPacket,
+        CsiPacketFormat,
+        IntegrationConfig,
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_integration_config_defaults() {
+        let config = IntegrationConfig::default();
+        assert!(!config.use_gpu);
+        assert_eq!(config.batch_size, 0);
+        assert!(!config.optimize_signal);
+        assert!(config.hardware.is_none());
+    }
+
+    #[test]
+    fn test_integration_config_realtime() {
+        let config = IntegrationConfig::realtime();
+        assert!(config.use_gpu);
+        assert_eq!(config.batch_size, 1);
+        assert!(config.optimize_signal);
+    }
+
+    #[test]
+    fn test_integration_config_batch() {
+        let config = IntegrationConfig::batch(32);
+        assert!(config.use_gpu);
+        assert_eq!(config.batch_size, 32);
+    }
+
+    #[test]
+    fn test_integration_config_with_hardware() {
+        let hw_config = HardwareConfig::esp32("/dev/ttyUSB0", 921600);
+        let config = IntegrationConfig::with_hardware(hw_config);
+        assert!(config.hardware.is_some());
+        assert!(matches!(
+            config.hardware.as_ref().unwrap().device_type,
+            DeviceType::Esp32
+        ));
+    }
 }

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/lib.rs

@@ -78,10 +78,12 @@
 #![warn(rustdoc::missing_crate_level_docs)]
 
 pub mod alerting;
+pub mod api;
 pub mod detection;
 pub mod domain;
 pub mod integration;
 pub mod localization;
+pub mod ml;
 
 // Re-export main types
 pub use domain::{
@@ -121,6 +123,23 @@ pub use integration::{
     AdapterError, IntegrationConfig,
 };
 
+pub use api::{
+    create_router, AppState,
+};
+
+pub use ml::{
+    // Core ML types
+    MlError, MlResult, MlDetectionConfig, MlDetectionPipeline, MlDetectionResult,
+    // Debris penetration model
+    DebrisPenetrationModel, DebrisFeatures, DepthEstimate as MlDepthEstimate,
+    DebrisModel, DebrisModelConfig, DebrisFeatureExtractor,
+    MaterialType, DebrisClassification, AttenuationPrediction,
+    // Vital signs classifier
+    VitalSignsClassifier, VitalSignsClassifierConfig,
+    BreathingClassification, HeartbeatClassification,
+    UncertaintyEstimate, ClassifierOutput,
+};
+
 /// Library version
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
@@ -165,6 +184,10 @@ pub enum MatError {
     /// I/O error
     #[error("I/O error: {0}")]
     Io(#[from] std::io::Error),
+
+    /// Machine learning error
+    #[error("ML error: {0}")]
+    Ml(#[from] ml::MlError),
 }
 
 /// Configuration for the disaster response system
@@ -417,6 +440,10 @@ pub mod prelude {
         LocalizationService,
         // Alerting
         AlertDispatcher,
+        // ML types
+        MlDetectionConfig, MlDetectionPipeline, MlDetectionResult,
+        DebrisModel, MaterialType, DebrisClassification,
+        VitalSignsClassifier, UncertaintyEstimate,
     };
 }
 

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/ml/debris_model.rs

@@ -0,0 +1,765 @@
+//! ONNX-based debris penetration model for material classification and depth prediction.
+//!
+//! This module provides neural network models for analyzing debris characteristics
+//! from WiFi CSI signals. Key capabilities include:
+//!
+//! - Material type classification (concrete, wood, metal, etc.)
+//! - Signal attenuation prediction based on material properties
+//! - Penetration depth estimation with uncertainty quantification
+//!
+//! ## Model Architecture
+//!
+//! The debris model uses a multi-head architecture:
+//! - Shared feature encoder (CNN-based)
+//! - Material classification head (softmax output)
+//! - Attenuation regression head (linear output)
+//! - Depth estimation head with uncertainty (mean + variance output)
+
+use super::{DebrisFeatures, DepthEstimate, MlError, MlResult};
+use ndarray::{Array1, Array2, Array4, s};
+use std::collections::HashMap;
+use std::path::Path;
+use std::sync::Arc;
+use parking_lot::RwLock;
+use thiserror::Error;
+use tracing::{debug, info, instrument, warn};
+
+#[cfg(feature = "onnx")]
+use wifi_densepose_nn::{OnnxBackend, OnnxSession, InferenceOptions, Tensor, TensorShape};
+
+/// Errors specific to debris model operations
+#[derive(Debug, Error)]
+pub enum DebrisModelError {
+    /// Model file not found
+    #[error("Model file not found: {0}")]
+    FileNotFound(String),
+
+    /// Invalid model format
+    #[error("Invalid model format: {0}")]
+    InvalidFormat(String),
+
+    /// Inference error
+    #[error("Inference failed: {0}")]
+    InferenceFailed(String),
+
+    /// Feature extraction error
+    #[error("Feature extraction failed: {0}")]
+    FeatureExtractionFailed(String),
+}
+
+/// Types of materials that can be detected in debris
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum MaterialType {
+    /// Reinforced concrete (high attenuation)
+    Concrete,
+    /// Wood/timber (moderate attenuation)
+    Wood,
+    /// Metal/steel (very high attenuation, reflective)
+    Metal,
+    /// Glass (low attenuation)
+    Glass,
+    /// Brick/masonry (high attenuation)
+    Brick,
+    /// Drywall/plasterboard (low attenuation)
+    Drywall,
+    /// Mixed/composite materials
+    Mixed,
+    /// Unknown material type
+    Unknown,
+}
+
+impl MaterialType {
+    /// Get typical attenuation coefficient (dB/m)
+    pub fn typical_attenuation(&self) -> f32 {
+        match self {
+            MaterialType::Concrete => 25.0,
+            MaterialType::Wood => 8.0,
+            MaterialType::Metal => 50.0,
+            MaterialType::Glass => 3.0,
+            MaterialType::Brick => 18.0,
+            MaterialType::Drywall => 4.0,
+            MaterialType::Mixed => 15.0,
+            MaterialType::Unknown => 12.0,
+        }
+    }
+
+    /// Get typical delay spread (nanoseconds)
+    pub fn typical_delay_spread(&self) -> f32 {
+        match self {
+            MaterialType::Concrete => 150.0,
+            MaterialType::Wood => 50.0,
+            MaterialType::Metal => 200.0,
+            MaterialType::Glass => 20.0,
+            MaterialType::Brick => 100.0,
+            MaterialType::Drywall => 30.0,
+            MaterialType::Mixed => 80.0,
+            MaterialType::Unknown => 60.0,
+        }
+    }
+
+    /// From class index
+    pub fn from_index(index: usize) -> Self {
+        match index {
+            0 => MaterialType::Concrete,
+            1 => MaterialType::Wood,
+            2 => MaterialType::Metal,
+            3 => MaterialType::Glass,
+            4 => MaterialType::Brick,
+            5 => MaterialType::Drywall,
+            6 => MaterialType::Mixed,
+            _ => MaterialType::Unknown,
+        }
+    }
+
+    /// To class index
+    pub fn to_index(&self) -> usize {
+        match self {
+            MaterialType::Concrete => 0,
+            MaterialType::Wood => 1,
+            MaterialType::Metal => 2,
+            MaterialType::Glass => 3,
+            MaterialType::Brick => 4,
+            MaterialType::Drywall => 5,
+            MaterialType::Mixed => 6,
+            MaterialType::Unknown => 7,
+        }
+    }
+
+    /// Number of material classes
+    pub const NUM_CLASSES: usize = 8;
+}
+
+impl std::fmt::Display for MaterialType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MaterialType::Concrete => write!(f, "Concrete"),
+            MaterialType::Wood => write!(f, "Wood"),
+            MaterialType::Metal => write!(f, "Metal"),
+            MaterialType::Glass => write!(f, "Glass"),
+            MaterialType::Brick => write!(f, "Brick"),
+            MaterialType::Drywall => write!(f, "Drywall"),
+            MaterialType::Mixed => write!(f, "Mixed"),
+            MaterialType::Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
+/// Result of debris material classification
+#[derive(Debug, Clone)]
+pub struct DebrisClassification {
+    /// Primary material type detected
+    pub material_type: MaterialType,
+    /// Confidence score for the classification (0.0-1.0)
+    pub confidence: f32,
+    /// Per-class probabilities
+    pub class_probabilities: Vec<f32>,
+    /// Estimated layer count
+    pub estimated_layers: u8,
+    /// Whether multiple materials detected
+    pub is_composite: bool,
+}
+
+impl DebrisClassification {
+    /// Create a new debris classification
+    pub fn new(probabilities: Vec<f32>) -> Self {
+        let (max_idx, &max_prob) = probabilities.iter()
+            .enumerate()
+            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
+            .unwrap_or((7, &0.0));
+
+        // Check for composite materials (multiple high probabilities)
+        let high_prob_count = probabilities.iter()
+            .filter(|&&p| p > 0.2)
+            .count();
+
+        let is_composite = high_prob_count > 1 && max_prob < 0.7;
+        let material_type = if is_composite {
+            MaterialType::Mixed
+        } else {
+            MaterialType::from_index(max_idx)
+        };
+
+        // Estimate layer count from delay spread characteristics
+        let estimated_layers = Self::estimate_layers(&probabilities);
+
+        Self {
+            material_type,
+            confidence: max_prob,
+            class_probabilities: probabilities,
+            estimated_layers,
+            is_composite,
+        }
+    }
+
+    /// Estimate number of debris layers from probability distribution
+    fn estimate_layers(probabilities: &[f32]) -> u8 {
+        // More uniform distribution suggests more layers
+        let entropy: f32 = probabilities.iter()
+            .filter(|&&p| p > 0.01)
+            .map(|&p| -p * p.ln())
+            .sum();
+
+        let max_entropy = (probabilities.len() as f32).ln();
+        let normalized_entropy = entropy / max_entropy;
+
+        // Map entropy to layer count (1-5)
+        (1.0 + normalized_entropy * 4.0).round() as u8
+    }
+
+    /// Get secondary material if composite
+    pub fn secondary_material(&self) -> Option<MaterialType> {
+        if !self.is_composite {
+            return None;
+        }
+
+        let primary_idx = self.material_type.to_index();
+        self.class_probabilities.iter()
+            .enumerate()
+            .filter(|(i, _)| *i != primary_idx)
+            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
+            .map(|(i, _)| MaterialType::from_index(i))
+    }
+}
+
+/// Signal attenuation prediction result
+#[derive(Debug, Clone)]
+pub struct AttenuationPrediction {
+    /// Predicted attenuation in dB
+    pub attenuation_db: f32,
+    /// Attenuation per meter (dB/m)
+    pub attenuation_per_meter: f32,
+    /// Uncertainty in the prediction
+    pub uncertainty_db: f32,
+    /// Frequency-dependent attenuation profile
+    pub frequency_profile: Vec<f32>,
+    /// Confidence in the prediction
+    pub confidence: f32,
+}
+
+impl AttenuationPrediction {
+    /// Create new attenuation prediction
+    pub fn new(attenuation: f32, depth: f32, uncertainty: f32) -> Self {
+        let attenuation_per_meter = if depth > 0.0 {
+            attenuation / depth
+        } else {
+            0.0
+        };
+
+        Self {
+            attenuation_db: attenuation,
+            attenuation_per_meter,
+            uncertainty_db: uncertainty,
+            frequency_profile: vec![],
+            confidence: (1.0 - uncertainty / attenuation.abs().max(1.0)).max(0.0),
+        }
+    }
+
+    /// Predict signal at given depth
+    pub fn predict_signal_at_depth(&self, depth_m: f32) -> f32 {
+        -self.attenuation_per_meter * depth_m
+    }
+}
+
+/// Configuration for debris model
+#[derive(Debug, Clone)]
+pub struct DebrisModelConfig {
+    /// Use GPU for inference
+    pub use_gpu: bool,
+    /// Number of inference threads
+    pub num_threads: usize,
+    /// Minimum confidence threshold
+    pub confidence_threshold: f32,
+}
+
+impl Default for DebrisModelConfig {
+    fn default() -> Self {
+        Self {
+            use_gpu: false,
+            num_threads: 4,
+            confidence_threshold: 0.5,
+        }
+    }
+}
+
+/// Feature extractor for debris classification
+pub struct DebrisFeatureExtractor {
+    /// Number of subcarriers to analyze
+    num_subcarriers: usize,
+    /// Window size for temporal analysis
+    window_size: usize,
+    /// Whether to use advanced features
+    use_advanced_features: bool,
+}
+
+impl Default for DebrisFeatureExtractor {
+    fn default() -> Self {
+        Self {
+            num_subcarriers: 64,
+            window_size: 100,
+            use_advanced_features: true,
+        }
+    }
+}
+
+impl DebrisFeatureExtractor {
+    /// Create new feature extractor
+    pub fn new(num_subcarriers: usize, window_size: usize) -> Self {
+        Self {
+            num_subcarriers,
+            window_size,
+            use_advanced_features: true,
+        }
+    }
+
+    /// Extract features from debris features for model input
+    pub fn extract(&self, features: &DebrisFeatures) -> MlResult<Array2<f32>> {
+        let feature_vector = features.to_feature_vector();
+
+        // Reshape to 2D for model input (batch_size=1, features)
+        let arr = Array2::from_shape_vec(
+            (1, feature_vector.len()),
+            feature_vector,
+        ).map_err(|e| MlError::FeatureExtraction(e.to_string()))?;
+
+        Ok(arr)
+    }
+
+    /// Extract spatial-temporal features for CNN input
+    pub fn extract_spatial_temporal(&self, features: &DebrisFeatures) -> MlResult<Array4<f32>> {
+        let amp_len = features.amplitude_attenuation.len().min(self.num_subcarriers);
+        let phase_len = features.phase_shifts.len().min(self.num_subcarriers);
+
+        // Create 4D tensor: [batch, channels, height, width]
+        // channels: amplitude, phase
+        // height: subcarriers
+        // width: 1 (or temporal windows if available)
+        let mut tensor = Array4::<f32>::zeros((1, 2, self.num_subcarriers, 1));
+
+        // Fill amplitude channel
+        for (i, &v) in features.amplitude_attenuation.iter().take(amp_len).enumerate() {
+            tensor[[0, 0, i, 0]] = v;
+        }
+
+        // Fill phase channel
+        for (i, &v) in features.phase_shifts.iter().take(phase_len).enumerate() {
+            tensor[[0, 1, i, 0]] = v;
+        }
+
+        Ok(tensor)
+    }
+}
+
+/// ONNX-based debris penetration model
+pub struct DebrisModel {
+    config: DebrisModelConfig,
+    feature_extractor: DebrisFeatureExtractor,
+    /// Material classification model weights (for rule-based fallback)
+    material_weights: MaterialClassificationWeights,
+    /// Whether ONNX model is loaded
+    model_loaded: bool,
+    /// Cached model session
+    #[cfg(feature = "onnx")]
+    session: Option<Arc<RwLock<OnnxSession>>>,
+}
+
+/// Pre-computed weights for rule-based material classification
+struct MaterialClassificationWeights {
+    /// Weights for attenuation features
+    attenuation_weights: [f32; MaterialType::NUM_CLASSES],
+    /// Weights for delay spread features
+    delay_weights: [f32; MaterialType::NUM_CLASSES],
+    /// Weights for coherence bandwidth
+    coherence_weights: [f32; MaterialType::NUM_CLASSES],
+    /// Bias terms
+    biases: [f32; MaterialType::NUM_CLASSES],
+}
+
+impl Default for MaterialClassificationWeights {
+    fn default() -> Self {
+        // Pre-computed weights based on material RF properties
+        Self {
+            attenuation_weights: [0.8, 0.3, 0.95, 0.1, 0.6, 0.15, 0.5, 0.4],
+            delay_weights: [0.7, 0.2, 0.9, 0.1, 0.5, 0.1, 0.4, 0.3],
+            coherence_weights: [0.3, 0.7, 0.1, 0.9, 0.4, 0.8, 0.5, 0.5],
+            biases: [-0.5, 0.2, -0.8, 0.5, -0.3, 0.3, 0.0, 0.0],
+        }
+    }
+}
+
+impl DebrisModel {
+    /// Create a new debris model from ONNX file
+    #[instrument(skip(path))]
+    pub fn from_onnx<P: AsRef<Path>>(path: P, config: DebrisModelConfig) -> MlResult<Self> {
+        let path_ref = path.as_ref();
+        info!(?path_ref, "Loading debris model");
+
+        #[cfg(feature = "onnx")]
+        let session = if path_ref.exists() {
+            let options = InferenceOptions {
+                use_gpu: config.use_gpu,
+                num_threads: config.num_threads,
+                ..Default::default()
+            };
+            match OnnxSession::from_file(path_ref, &options) {
+                Ok(s) => {
+                    info!("ONNX debris model loaded successfully");
+                    Some(Arc::new(RwLock::new(s)))
+                }
+                Err(e) => {
+                    warn!(?e, "Failed to load ONNX model, using rule-based fallback");
+                    None
+                }
+            }
+        } else {
+            warn!(?path_ref, "Model file not found, using rule-based fallback");
+            None
+        };
+
+        #[cfg(feature = "onnx")]
+        let model_loaded = session.is_some();
+
+        #[cfg(not(feature = "onnx"))]
+        let model_loaded = false;
+
+        Ok(Self {
+            config,
+            feature_extractor: DebrisFeatureExtractor::default(),
+            material_weights: MaterialClassificationWeights::default(),
+            model_loaded,
+            #[cfg(feature = "onnx")]
+            session,
+        })
+    }
+
+    /// Create with in-memory model bytes
+    #[cfg(feature = "onnx")]
+    pub fn from_bytes(bytes: &[u8], config: DebrisModelConfig) -> MlResult<Self> {
+        let options = InferenceOptions {
+            use_gpu: config.use_gpu,
+            num_threads: config.num_threads,
+            ..Default::default()
+        };
+
+        let session = OnnxSession::from_bytes(bytes, &options)
+            .map_err(|e| MlError::ModelLoad(e.to_string()))?;
+
+        Ok(Self {
+            config,
+            feature_extractor: DebrisFeatureExtractor::default(),
+            material_weights: MaterialClassificationWeights::default(),
+            model_loaded: true,
+            session: Some(Arc::new(RwLock::new(session))),
+        })
+    }
+
+    /// Create a rule-based model (no ONNX required)
+    pub fn rule_based(config: DebrisModelConfig) -> Self {
+        Self {
+            config,
+            feature_extractor: DebrisFeatureExtractor::default(),
+            material_weights: MaterialClassificationWeights::default(),
+            model_loaded: false,
+            #[cfg(feature = "onnx")]
+            session: None,
+        }
+    }
+
+    /// Check if ONNX model is loaded
+    pub fn is_loaded(&self) -> bool {
+        self.model_loaded
+    }
+
+    /// Classify material type from debris features
+    #[instrument(skip(self, features))]
+    pub async fn classify(&self, features: &DebrisFeatures) -> MlResult<DebrisClassification> {
+        #[cfg(feature = "onnx")]
+        if let Some(ref session) = self.session {
+            return self.classify_onnx(features, session).await;
+        }
+
+        // Fall back to rule-based classification
+        self.classify_rules(features)
+    }
+
+    /// ONNX-based classification
+    #[cfg(feature = "onnx")]
+    async fn classify_onnx(
+        &self,
+        features: &DebrisFeatures,
+        session: &Arc<RwLock<OnnxSession>>,
+    ) -> MlResult<DebrisClassification> {
+        let input_features = self.feature_extractor.extract(features)?;
+
+        // Prepare input tensor
+        let input_array = Array4::from_shape_vec(
+            (1, 1, 1, input_features.len()),
+            input_features.iter().cloned().collect(),
+        ).map_err(|e| MlError::Inference(e.to_string()))?;
+
+        let input_tensor = Tensor::Float4D(input_array);
+
+        let mut inputs = HashMap::new();
+        inputs.insert("input".to_string(), input_tensor);
+
+        // Run inference
+        let outputs = session.write().run(inputs)
+            .map_err(|e| MlError::NeuralNetwork(e))?;
+
+        // Extract classification probabilities
+        let probabilities = if let Some(output) = outputs.get("material_probs") {
+            output.to_vec()
+                .map_err(|e| MlError::Inference(e.to_string()))?
+        } else {
+            // Fallback to rule-based
+            return self.classify_rules(features);
+        };
+
+        // Ensure we have enough classes
+        let mut probs = vec![0.0f32; MaterialType::NUM_CLASSES];
+        for (i, &p) in probabilities.iter().take(MaterialType::NUM_CLASSES).enumerate() {
+            probs[i] = p;
+        }
+
+        // Apply softmax normalization
+        let max_val = probs.iter().cloned().fold(f32::NEG_INFINITY, f32::max);
+        let exp_sum: f32 = probs.iter().map(|&x| (x - max_val).exp()).sum();
+        for p in &mut probs {
+            *p = (*p - max_val).exp() / exp_sum;
+        }
+
+        Ok(DebrisClassification::new(probs))
+    }
+
+    /// Rule-based material classification (fallback)
+    fn classify_rules(&self, features: &DebrisFeatures) -> MlResult<DebrisClassification> {
+        let mut scores = [0.0f32; MaterialType::NUM_CLASSES];
+
+        // Normalize input features
+        let attenuation_score = (features.snr_db.abs() / 30.0).min(1.0);
+        let delay_score = (features.delay_spread / 200.0).min(1.0);
+        let coherence_score = (features.coherence_bandwidth / 20.0).min(1.0);
+        let stability_score = features.temporal_stability;
+
+        // Compute weighted scores for each material
+        for i in 0..MaterialType::NUM_CLASSES {
+            scores[i] = self.material_weights.attenuation_weights[i] * attenuation_score
+                + self.material_weights.delay_weights[i] * delay_score
+                + self.material_weights.coherence_weights[i] * (1.0 - coherence_score)
+                + self.material_weights.biases[i]
+                + 0.1 * stability_score;
+        }
+
+        // Apply softmax
+        let max_score = scores.iter().cloned().fold(f32::NEG_INFINITY, f32::max);
+        let exp_sum: f32 = scores.iter().map(|&s| (s - max_score).exp()).sum();
+        let probabilities: Vec<f32> = scores.iter()
+            .map(|&s| (s - max_score).exp() / exp_sum)
+            .collect();
+
+        Ok(DebrisClassification::new(probabilities))
+    }
+
+    /// Predict signal attenuation through debris
+    #[instrument(skip(self, features))]
+    pub async fn predict_attenuation(&self, features: &DebrisFeatures) -> MlResult<AttenuationPrediction> {
+        // Get material classification first
+        let classification = self.classify(features).await?;
+
+        // Base attenuation from material type
+        let base_attenuation = classification.material_type.typical_attenuation();
+
+        // Adjust based on measured features
+        let measured_factor = if features.snr_db < 0.0 {
+            1.0 + (features.snr_db.abs() / 30.0).min(1.0)
+        } else {
+            1.0 - (features.snr_db / 30.0).min(0.5)
+        };
+
+        // Layer factor
+        let layer_factor = 1.0 + 0.2 * (classification.estimated_layers as f32 - 1.0);
+
+        // Composite factor
+        let composite_factor = if classification.is_composite { 1.2 } else { 1.0 };
+
+        let total_attenuation = base_attenuation * measured_factor * layer_factor * composite_factor;
+
+        // Uncertainty estimation
+        let uncertainty = if classification.is_composite {
+            total_attenuation * 0.3  // Higher uncertainty for composite
+        } else {
+            total_attenuation * (1.0 - classification.confidence) * 0.5
+        };
+
+        // Estimate depth (will be refined by depth estimation)
+        let estimated_depth = self.estimate_depth_internal(features, total_attenuation);
+
+        Ok(AttenuationPrediction::new(total_attenuation, estimated_depth, uncertainty))
+    }
+
+    /// Estimate penetration depth
+    #[instrument(skip(self, features))]
+    pub async fn estimate_depth(&self, features: &DebrisFeatures) -> MlResult<DepthEstimate> {
+        // Get attenuation prediction
+        let attenuation = self.predict_attenuation(features).await?;
+
+        // Estimate depth from attenuation and material properties
+        let depth = self.estimate_depth_internal(features, attenuation.attenuation_db);
+
+        // Calculate uncertainty
+        let uncertainty = self.calculate_depth_uncertainty(
+            features,
+            depth,
+            attenuation.confidence,
+        );
+
+        let confidence = (attenuation.confidence * features.temporal_stability).min(1.0);
+
+        Ok(DepthEstimate::new(depth, uncertainty, confidence))
+    }
+
+    /// Internal depth estimation logic
+    fn estimate_depth_internal(&self, features: &DebrisFeatures, attenuation_db: f32) -> f32 {
+        // Use coherence bandwidth for depth estimation
+        // Smaller coherence bandwidth suggests more multipath = deeper penetration
+        let cb_depth = (20.0 - features.coherence_bandwidth) / 5.0;
+
+        // Use delay spread
+        let ds_depth = features.delay_spread / 100.0;
+
+        // Use attenuation (assuming typical material)
+        let att_depth = attenuation_db / 15.0;
+
+        // Combine estimates with weights
+        let depth = 0.3 * cb_depth + 0.3 * ds_depth + 0.4 * att_depth;
+
+        // Clamp to reasonable range (0.1 - 10 meters)
+        depth.clamp(0.1, 10.0)
+    }
+
+    /// Calculate uncertainty in depth estimate
+    fn calculate_depth_uncertainty(
+        &self,
+        features: &DebrisFeatures,
+        depth: f32,
+        confidence: f32,
+    ) -> f32 {
+        // Base uncertainty proportional to depth
+        let base_uncertainty = depth * 0.2;
+
+        // Adjust by temporal stability (less stable = more uncertain)
+        let stability_factor = 1.0 + (1.0 - features.temporal_stability) * 0.5;
+
+        // Adjust by confidence (lower confidence = more uncertain)
+        let confidence_factor = 1.0 + (1.0 - confidence) * 0.5;
+
+        // Adjust by multipath richness (more multipath = harder to estimate)
+        let multipath_factor = 1.0 + features.multipath_richness * 0.3;
+
+        base_uncertainty * stability_factor * confidence_factor * multipath_factor
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::detection::CsiDataBuffer;
+
+    fn create_test_debris_features() -> DebrisFeatures {
+        DebrisFeatures {
+            amplitude_attenuation: vec![0.5; 64],
+            phase_shifts: vec![0.1; 64],
+            fading_profile: vec![0.8, 0.6, 0.4, 0.2, 0.1, 0.05, 0.02, 0.01],
+            coherence_bandwidth: 5.0,
+            delay_spread: 100.0,
+            snr_db: 15.0,
+            multipath_richness: 0.6,
+            temporal_stability: 0.8,
+        }
+    }
+
+    #[test]
+    fn test_material_type() {
+        assert_eq!(MaterialType::from_index(0), MaterialType::Concrete);
+        assert_eq!(MaterialType::Concrete.to_index(), 0);
+        assert!(MaterialType::Concrete.typical_attenuation() > MaterialType::Glass.typical_attenuation());
+    }
+
+    #[test]
+    fn test_debris_classification() {
+        let probs = vec![0.7, 0.1, 0.05, 0.05, 0.05, 0.02, 0.02, 0.01];
+        let classification = DebrisClassification::new(probs);
+
+        assert_eq!(classification.material_type, MaterialType::Concrete);
+        assert!(classification.confidence > 0.6);
+        assert!(!classification.is_composite);
+    }
+
+    #[test]
+    fn test_composite_detection() {
+        let probs = vec![0.4, 0.35, 0.1, 0.05, 0.05, 0.02, 0.02, 0.01];
+        let classification = DebrisClassification::new(probs);
+
+        assert!(classification.is_composite);
+        assert_eq!(classification.material_type, MaterialType::Mixed);
+    }
+
+    #[test]
+    fn test_attenuation_prediction() {
+        let pred = AttenuationPrediction::new(25.0, 2.0, 3.0);
+        assert_eq!(pred.attenuation_per_meter, 12.5);
+        assert!(pred.confidence > 0.0);
+    }
+
+    #[tokio::test]
+    async fn test_rule_based_classification() {
+        let config = DebrisModelConfig::default();
+        let model = DebrisModel::rule_based(config);
+
+        let features = create_test_debris_features();
+        let result = model.classify(&features).await;
+
+        assert!(result.is_ok());
+        let classification = result.unwrap();
+        assert!(classification.confidence > 0.0);
+    }
+
+    #[tokio::test]
+    async fn test_depth_estimation() {
+        let config = DebrisModelConfig::default();
+        let model = DebrisModel::rule_based(config);
+
+        let features = create_test_debris_features();
+        let result = model.estimate_depth(&features).await;
+
+        assert!(result.is_ok());
+        let estimate = result.unwrap();
+        assert!(estimate.depth_meters > 0.0);
+        assert!(estimate.depth_meters < 10.0);
+        assert!(estimate.uncertainty_meters > 0.0);
+    }
+
+    #[test]
+    fn test_feature_extractor() {
+        let extractor = DebrisFeatureExtractor::default();
+        let features = create_test_debris_features();
+
+        let result = extractor.extract(&features);
+        assert!(result.is_ok());
+
+        let arr = result.unwrap();
+        assert_eq!(arr.shape()[0], 1);
+        assert_eq!(arr.shape()[1], 256);
+    }
+
+    #[test]
+    fn test_spatial_temporal_extraction() {
+        let extractor = DebrisFeatureExtractor::new(64, 100);
+        let features = create_test_debris_features();
+
+        let result = extractor.extract_spatial_temporal(&features);
+        assert!(result.is_ok());
+
+        let arr = result.unwrap();
+        assert_eq!(arr.shape(), &[1, 2, 64, 1]);
+    }
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-mat/src/ml/mod.rs

@@ -0,0 +1,692 @@
+//! Machine Learning module for debris penetration pattern recognition.
+//!
+//! This module provides ML-based models for:
+//! - Debris material classification
+//! - Penetration depth prediction
+//! - Signal attenuation analysis
+//! - Vital signs classification with uncertainty estimation
+//!
+//! ## Architecture
+//!
+//! The ML subsystem integrates with the `wifi-densepose-nn` crate for ONNX inference
+//! and provides specialized models for disaster response scenarios.
+//!
+//! ```text
+//! CSI Data -> Feature Extraction -> Model Inference -> Predictions
+//!                |                        |                |
+//!                v                        v                v
+//!         [Debris Features]    [ONNX Models]    [Classifications]
+//!         [Signal Features]    [Neural Nets]    [Confidences]
+//! ```
+
+mod debris_model;
+mod vital_signs_classifier;
+
+pub use debris_model::{
+    DebrisModel, DebrisModelConfig, DebrisFeatureExtractor,
+    MaterialType, DebrisClassification, AttenuationPrediction,
+    DebrisModelError,
+};
+
+pub use vital_signs_classifier::{
+    VitalSignsClassifier, VitalSignsClassifierConfig,
+    BreathingClassification, HeartbeatClassification,
+    UncertaintyEstimate, ClassifierOutput,
+};
+
+use crate::detection::CsiDataBuffer;
+use crate::domain::{VitalSignsReading, BreathingPattern, HeartbeatSignature};
+use async_trait::async_trait;
+use std::path::Path;
+use thiserror::Error;
+
+/// Errors that can occur in ML operations
+#[derive(Debug, Error)]
+pub enum MlError {
+    /// Model loading error
+    #[error("Failed to load model: {0}")]
+    ModelLoad(String),
+
+    /// Inference error
+    #[error("Inference failed: {0}")]
+    Inference(String),
+
+    /// Feature extraction error
+    #[error("Feature extraction failed: {0}")]
+    FeatureExtraction(String),
+
+    /// Invalid input error
+    #[error("Invalid input: {0}")]
+    InvalidInput(String),
+
+    /// Model not initialized
+    #[error("Model not initialized: {0}")]
+    NotInitialized(String),
+
+    /// Configuration error
+    #[error("Configuration error: {0}")]
+    Config(String),
+
+    /// Integration error with wifi-densepose-nn
+    #[error("Neural network error: {0}")]
+    NeuralNetwork(#[from] wifi_densepose_nn::NnError),
+}
+
+/// Result type for ML operations
+pub type MlResult<T> = Result<T, MlError>;
+
+/// Trait for debris penetration models
+///
+/// This trait defines the interface for models that can predict
+/// material type and signal attenuation through debris layers.
+#[async_trait]
+pub trait DebrisPenetrationModel: Send + Sync {
+    /// Classify the material type from CSI features
+    async fn classify_material(&self, features: &DebrisFeatures) -> MlResult<MaterialType>;
+
+    /// Predict signal attenuation through debris
+    async fn predict_attenuation(&self, features: &DebrisFeatures) -> MlResult<AttenuationPrediction>;
+
+    /// Estimate penetration depth in meters
+    async fn estimate_depth(&self, features: &DebrisFeatures) -> MlResult<DepthEstimate>;
+
+    /// Get model confidence for the predictions
+    fn model_confidence(&self) -> f32;
+
+    /// Check if the model is loaded and ready
+    fn is_ready(&self) -> bool;
+}
+
+/// Features extracted from CSI data for debris analysis
+#[derive(Debug, Clone)]
+pub struct DebrisFeatures {
+    /// Amplitude attenuation across subcarriers
+    pub amplitude_attenuation: Vec<f32>,
+    /// Phase shift patterns
+    pub phase_shifts: Vec<f32>,
+    /// Frequency-selective fading characteristics
+    pub fading_profile: Vec<f32>,
+    /// Coherence bandwidth estimate
+    pub coherence_bandwidth: f32,
+    /// RMS delay spread
+    pub delay_spread: f32,
+    /// Signal-to-noise ratio estimate
+    pub snr_db: f32,
+    /// Multipath richness indicator
+    pub multipath_richness: f32,
+    /// Temporal stability metric
+    pub temporal_stability: f32,
+}
+
+impl DebrisFeatures {
+    /// Create new debris features from raw CSI data
+    pub fn from_csi(buffer: &CsiDataBuffer) -> MlResult<Self> {
+        if buffer.amplitudes.is_empty() {
+            return Err(MlError::FeatureExtraction("Empty CSI buffer".into()));
+        }
+
+        // Calculate amplitude attenuation
+        let amplitude_attenuation = Self::compute_amplitude_features(&buffer.amplitudes);
+
+        // Calculate phase shifts
+        let phase_shifts = Self::compute_phase_features(&buffer.phases);
+
+        // Compute fading profile
+        let fading_profile = Self::compute_fading_profile(&buffer.amplitudes);
+
+        // Estimate coherence bandwidth from frequency correlation
+        let coherence_bandwidth = Self::estimate_coherence_bandwidth(&buffer.amplitudes);
+
+        // Estimate delay spread
+        let delay_spread = Self::estimate_delay_spread(&buffer.amplitudes);
+
+        // Estimate SNR
+        let snr_db = Self::estimate_snr(&buffer.amplitudes);
+
+        // Multipath richness
+        let multipath_richness = Self::compute_multipath_richness(&buffer.amplitudes);
+
+        // Temporal stability
+        let temporal_stability = Self::compute_temporal_stability(&buffer.amplitudes);
+
+        Ok(Self {
+            amplitude_attenuation,
+            phase_shifts,
+            fading_profile,
+            coherence_bandwidth,
+            delay_spread,
+            snr_db,
+            multipath_richness,
+            temporal_stability,
+        })
+    }
+
+    /// Compute amplitude features
+    fn compute_amplitude_features(amplitudes: &[f64]) -> Vec<f32> {
+        if amplitudes.is_empty() {
+            return vec![];
+        }
+
+        let mean = amplitudes.iter().sum::<f64>() / amplitudes.len() as f64;
+        let variance = amplitudes.iter()
+            .map(|a| (a - mean).powi(2))
+            .sum::<f64>() / amplitudes.len() as f64;
+        let std_dev = variance.sqrt();
+
+        // Normalize amplitudes
+        amplitudes.iter()
+            .map(|a| ((a - mean) / (std_dev + 1e-8)) as f32)
+            .collect()
+    }
+
+    /// Compute phase features
+    fn compute_phase_features(phases: &[f64]) -> Vec<f32> {
+        if phases.len() < 2 {
+            return vec![];
+        }
+
+        // Compute phase differences (unwrapped)
+        phases.windows(2)
+            .map(|w| {
+                let diff = w[1] - w[0];
+                // Unwrap phase
+                let unwrapped = if diff > std::f64::consts::PI {
+                    diff - 2.0 * std::f64::consts::PI
+                } else if diff < -std::f64::consts::PI {
+                    diff + 2.0 * std::f64::consts::PI
+                } else {
+                    diff
+                };
+                unwrapped as f32
+            })
+            .collect()
+    }
+
+    /// Compute fading profile (power spectral characteristics)
+    fn compute_fading_profile(amplitudes: &[f64]) -> Vec<f32> {
+        use rustfft::{FftPlanner, num_complex::Complex};
+
+        if amplitudes.len() < 16 {
+            return vec![0.0; 8];
+        }
+
+        // Take a subset for FFT
+        let n = 64.min(amplitudes.len());
+        let mut buffer: Vec<Complex<f64>> = amplitudes.iter()
+            .take(n)
+            .map(|&a| Complex::new(a, 0.0))
+            .collect();
+
+        // Pad to power of 2
+        while buffer.len() < 64 {
+            buffer.push(Complex::new(0.0, 0.0));
+        }
+
+        // Compute FFT
+        let mut planner = FftPlanner::new();
+        let fft = planner.plan_fft_forward(64);
+        fft.process(&mut buffer);
+
+        // Extract power spectrum (first half)
+        buffer.iter()
+            .take(8)
+            .map(|c| (c.norm() / n as f64) as f32)
+            .collect()
+    }
+
+    /// Estimate coherence bandwidth from frequency correlation
+    fn estimate_coherence_bandwidth(amplitudes: &[f64]) -> f32 {
+        if amplitudes.len() < 10 {
+            return 0.0;
+        }
+
+        // Compute autocorrelation
+        let n = amplitudes.len();
+        let mean = amplitudes.iter().sum::<f64>() / n as f64;
+        let variance: f64 = amplitudes.iter()
+            .map(|a| (a - mean).powi(2))
+            .sum::<f64>() / n as f64;
+
+        if variance < 1e-10 {
+            return 0.0;
+        }
+
+        // Find lag where correlation drops below 0.5
+        let mut coherence_lag = n;
+        for lag in 1..n / 2 {
+            let correlation: f64 = amplitudes.iter()
+                .take(n - lag)
+                .zip(amplitudes.iter().skip(lag))
+                .map(|(a, b)| (a - mean) * (b - mean))
+                .sum::<f64>() / ((n - lag) as f64 * variance);
+
+            if correlation < 0.5 {
+                coherence_lag = lag;
+                break;
+            }
+        }
+
+        // Convert to bandwidth estimate (assuming 20 MHz channel)
+        (20.0 / coherence_lag as f32).min(20.0)
+    }
+
+    /// Estimate RMS delay spread
+    fn estimate_delay_spread(amplitudes: &[f64]) -> f32 {
+        if amplitudes.len() < 10 {
+            return 0.0;
+        }
+
+        // Use power delay profile approximation
+        let power: Vec<f64> = amplitudes.iter().map(|a| a.powi(2)).collect();
+        let total_power: f64 = power.iter().sum();
+
+        if total_power < 1e-10 {
+            return 0.0;
+        }
+
+        // Calculate mean delay
+        let mean_delay: f64 = power.iter()
+            .enumerate()
+            .map(|(i, p)| i as f64 * p)
+            .sum::<f64>() / total_power;
+
+        // Calculate RMS delay spread
+        let variance: f64 = power.iter()
+            .enumerate()
+            .map(|(i, p)| (i as f64 - mean_delay).powi(2) * p)
+            .sum::<f64>() / total_power;
+
+        // Convert to nanoseconds (assuming sample period)
+        (variance.sqrt() * 50.0) as f32 // 50 ns per sample assumed
+    }
+
+    /// Estimate SNR from amplitude variance
+    fn estimate_snr(amplitudes: &[f64]) -> f32 {
+        if amplitudes.is_empty() {
+            return 0.0;
+        }
+
+        let mean = amplitudes.iter().sum::<f64>() / amplitudes.len() as f64;
+        let variance = amplitudes.iter()
+            .map(|a| (a - mean).powi(2))
+            .sum::<f64>() / amplitudes.len() as f64;
+
+        if variance < 1e-10 {
+            return 30.0; // High SNR assumed
+        }
+
+        // SNR estimate based on signal power to noise power ratio
+        let signal_power = mean.powi(2);
+        let snr_linear = signal_power / variance;
+
+        (10.0 * snr_linear.log10()) as f32
+    }
+
+    /// Compute multipath richness indicator
+    fn compute_multipath_richness(amplitudes: &[f64]) -> f32 {
+        if amplitudes.len() < 10 {
+            return 0.0;
+        }
+
+        // Calculate amplitude variance as multipath indicator
+        let mean = amplitudes.iter().sum::<f64>() / amplitudes.len() as f64;
+        let variance = amplitudes.iter()
+            .map(|a| (a - mean).powi(2))
+            .sum::<f64>() / amplitudes.len() as f64;
+
+        // Normalize to 0-1 range
+        let std_dev = variance.sqrt();
+        let normalized = std_dev / (mean.abs() + 1e-8);
+
+        (normalized.min(1.0)) as f32
+    }
+
+    /// Compute temporal stability metric
+    fn compute_temporal_stability(amplitudes: &[f64]) -> f32 {
+        if amplitudes.len() < 2 {
+            return 1.0;
+        }
+
+        // Calculate coefficient of variation over time
+        let differences: Vec<f64> = amplitudes.windows(2)
+            .map(|w| (w[1] - w[0]).abs())
+            .collect();
+
+        let mean_diff = differences.iter().sum::<f64>() / differences.len() as f64;
+        let mean_amp = amplitudes.iter().sum::<f64>() / amplitudes.len() as f64;
+
+        // Stability is inverse of relative variation
+        let variation = mean_diff / (mean_amp.abs() + 1e-8);
+
+        (1.0 - variation.min(1.0)) as f32
+    }
+
+    /// Convert to feature vector for model input
+    pub fn to_feature_vector(&self) -> Vec<f32> {
+        let mut features = Vec::with_capacity(256);
+
+        // Add amplitude attenuation features (padded/truncated to 64)
+        let amp_len = self.amplitude_attenuation.len().min(64);
+        features.extend_from_slice(&self.amplitude_attenuation[..amp_len]);
+        features.resize(64, 0.0);
+
+        // Add phase shift features (padded/truncated to 64)
+        let phase_len = self.phase_shifts.len().min(64);
+        features.extend_from_slice(&self.phase_shifts[..phase_len]);
+        features.resize(128, 0.0);
+
+        // Add fading profile (padded to 16)
+        let fading_len = self.fading_profile.len().min(16);
+        features.extend_from_slice(&self.fading_profile[..fading_len]);
+        features.resize(144, 0.0);
+
+        // Add scalar features
+        features.push(self.coherence_bandwidth);
+        features.push(self.delay_spread);
+        features.push(self.snr_db);
+        features.push(self.multipath_richness);
+        features.push(self.temporal_stability);
+
+        // Pad to 256 for model input
+        features.resize(256, 0.0);
+
+        features
+    }
+}
+
+/// Depth estimate with uncertainty
+#[derive(Debug, Clone)]
+pub struct DepthEstimate {
+    /// Estimated depth in meters
+    pub depth_meters: f32,
+    /// Uncertainty (standard deviation) in meters
+    pub uncertainty_meters: f32,
+    /// Confidence in the estimate (0.0-1.0)
+    pub confidence: f32,
+    /// Lower bound of 95% confidence interval
+    pub lower_bound: f32,
+    /// Upper bound of 95% confidence interval
+    pub upper_bound: f32,
+}
+
+impl DepthEstimate {
+    /// Create a new depth estimate with uncertainty
+    pub fn new(depth: f32, uncertainty: f32, confidence: f32) -> Self {
+        Self {
+            depth_meters: depth,
+            uncertainty_meters: uncertainty,
+            confidence,
+            lower_bound: (depth - 1.96 * uncertainty).max(0.0),
+            upper_bound: depth + 1.96 * uncertainty,
+        }
+    }
+
+    /// Check if the estimate is reliable (high confidence, low uncertainty)
+    pub fn is_reliable(&self) -> bool {
+        self.confidence > 0.7 && self.uncertainty_meters < self.depth_meters * 0.3
+    }
+}
+
+/// Configuration for the ML-enhanced detection pipeline
+#[derive(Debug, Clone, PartialEq)]
+pub struct MlDetectionConfig {
+    /// Enable ML-based debris classification
+    pub enable_debris_classification: bool,
+    /// Enable ML-based vital signs classification
+    pub enable_vital_classification: bool,
+    /// Path to debris model file
+    pub debris_model_path: Option<String>,
+    /// Path to vital signs model file
+    pub vital_model_path: Option<String>,
+    /// Minimum confidence threshold for ML predictions
+    pub min_confidence: f32,
+    /// Use GPU for inference
+    pub use_gpu: bool,
+    /// Number of inference threads
+    pub num_threads: usize,
+}
+
+impl Default for MlDetectionConfig {
+    fn default() -> Self {
+        Self {
+            enable_debris_classification: false,
+            enable_vital_classification: false,
+            debris_model_path: None,
+            vital_model_path: None,
+            min_confidence: 0.5,
+            use_gpu: false,
+            num_threads: 4,
+        }
+    }
+}
+
+impl MlDetectionConfig {
+    /// Create configuration for CPU inference
+    pub fn cpu() -> Self {
+        Self::default()
+    }
+
+    /// Create configuration for GPU inference
+    pub fn gpu() -> Self {
+        Self {
+            use_gpu: true,
+            ..Default::default()
+        }
+    }
+
+    /// Enable debris classification with model path
+    pub fn with_debris_model<P: Into<String>>(mut self, path: P) -> Self {
+        self.debris_model_path = Some(path.into());
+        self.enable_debris_classification = true;
+        self
+    }
+
+    /// Enable vital signs classification with model path
+    pub fn with_vital_model<P: Into<String>>(mut self, path: P) -> Self {
+        self.vital_model_path = Some(path.into());
+        self.enable_vital_classification = true;
+        self
+    }
+
+    /// Set minimum confidence threshold
+    pub fn with_min_confidence(mut self, confidence: f32) -> Self {
+        self.min_confidence = confidence.clamp(0.0, 1.0);
+        self
+    }
+}
+
+/// ML-enhanced detection pipeline that combines traditional and ML-based detection
+pub struct MlDetectionPipeline {
+    config: MlDetectionConfig,
+    debris_model: Option<DebrisModel>,
+    vital_classifier: Option<VitalSignsClassifier>,
+}
+
+impl MlDetectionPipeline {
+    /// Create a new ML detection pipeline
+    pub fn new(config: MlDetectionConfig) -> Self {
+        Self {
+            config,
+            debris_model: None,
+            vital_classifier: None,
+        }
+    }
+
+    /// Initialize models asynchronously
+    pub async fn initialize(&mut self) -> MlResult<()> {
+        if self.config.enable_debris_classification {
+            if let Some(ref path) = self.config.debris_model_path {
+                let debris_config = DebrisModelConfig {
+                    use_gpu: self.config.use_gpu,
+                    num_threads: self.config.num_threads,
+                    confidence_threshold: self.config.min_confidence,
+                };
+                self.debris_model = Some(DebrisModel::from_onnx(path, debris_config)?);
+            }
+        }
+
+        if self.config.enable_vital_classification {
+            if let Some(ref path) = self.config.vital_model_path {
+                let vital_config = VitalSignsClassifierConfig {
+                    use_gpu: self.config.use_gpu,
+                    num_threads: self.config.num_threads,
+                    min_confidence: self.config.min_confidence,
+                    enable_uncertainty: true,
+                    mc_samples: 10,
+                    dropout_rate: 0.1,
+                };
+                self.vital_classifier = Some(VitalSignsClassifier::from_onnx(path, vital_config)?);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Process CSI data and return enhanced detection results
+    pub async fn process(&self, buffer: &CsiDataBuffer) -> MlResult<MlDetectionResult> {
+        let mut result = MlDetectionResult::default();
+
+        // Extract debris features and classify if enabled
+        if let Some(ref model) = self.debris_model {
+            let features = DebrisFeatures::from_csi(buffer)?;
+            result.debris_classification = Some(model.classify(&features).await?);
+            result.depth_estimate = Some(model.estimate_depth(&features).await?);
+        }
+
+        // Classify vital signs if enabled
+        if let Some(ref classifier) = self.vital_classifier {
+            let features = classifier.extract_features(buffer)?;
+            result.vital_classification = Some(classifier.classify(&features).await?);
+        }
+
+        Ok(result)
+    }
+
+    /// Check if the pipeline is ready for inference
+    pub fn is_ready(&self) -> bool {
+        let debris_ready = !self.config.enable_debris_classification
+            || self.debris_model.as_ref().map_or(false, |m| m.is_loaded());
+        let vital_ready = !self.config.enable_vital_classification
+            || self.vital_classifier.as_ref().map_or(false, |c| c.is_loaded());
+
+        debris_ready && vital_ready
+    }
+
+    /// Get configuration
+    pub fn config(&self) -> &MlDetectionConfig {
+        &self.config
+    }
+}
+
+/// Combined ML detection results
+#[derive(Debug, Clone, Default)]
+pub struct MlDetectionResult {
+    /// Debris classification result
+    pub debris_classification: Option<DebrisClassification>,
+    /// Depth estimate
+    pub depth_estimate: Option<DepthEstimate>,
+    /// Vital signs classification
+    pub vital_classification: Option<ClassifierOutput>,
+}
+
+impl MlDetectionResult {
+    /// Check if any ML detection was performed
+    pub fn has_results(&self) -> bool {
+        self.debris_classification.is_some()
+            || self.depth_estimate.is_some()
+            || self.vital_classification.is_some()
+    }
+
+    /// Get overall confidence
+    pub fn overall_confidence(&self) -> f32 {
+        let mut total = 0.0;
+        let mut count = 0;
+
+        if let Some(ref debris) = self.debris_classification {
+            total += debris.confidence;
+            count += 1;
+        }
+
+        if let Some(ref depth) = self.depth_estimate {
+            total += depth.confidence;
+            count += 1;
+        }
+
+        if let Some(ref vital) = self.vital_classification {
+            total += vital.overall_confidence;
+            count += 1;
+        }
+
+        if count > 0 {
+            total / count as f32
+        } else {
+            0.0
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn create_test_buffer() -> CsiDataBuffer {
+        let mut buffer = CsiDataBuffer::new(1000.0);
+        let amplitudes: Vec<f64> = (0..1000)
+            .map(|i| {
+                let t = i as f64 / 1000.0;
+                0.5 + 0.1 * (2.0 * std::f64::consts::PI * 0.25 * t).sin()
+            })
+            .collect();
+        let phases: Vec<f64> = (0..1000)
+            .map(|i| {
+                let t = i as f64 / 1000.0;
+                (2.0 * std::f64::consts::PI * 0.25 * t).sin() * 0.3
+            })
+            .collect();
+        buffer.add_samples(&amplitudes, &phases);
+        buffer
+    }
+
+    #[test]
+    fn test_debris_features_extraction() {
+        let buffer = create_test_buffer();
+        let features = DebrisFeatures::from_csi(&buffer);
+        assert!(features.is_ok());
+
+        let features = features.unwrap();
+        assert!(!features.amplitude_attenuation.is_empty());
+        assert!(!features.phase_shifts.is_empty());
+        assert!(features.coherence_bandwidth >= 0.0);
+        assert!(features.delay_spread >= 0.0);
+        assert!(features.temporal_stability >= 0.0);
+    }
+
+    #[test]
+    fn test_feature_vector_size() {
+        let buffer = create_test_buffer();
+        let features = DebrisFeatures::from_csi(&buffer).unwrap();
+        let vector = features.to_feature_vector();
+        assert_eq!(vector.len(), 256);
+    }
+
+    #[test]
+    fn test_depth_estimate() {
+        let estimate = DepthEstimate::new(2.5, 0.3, 0.85);
+        assert!(estimate.is_reliable());
+        assert!(estimate.lower_bound < estimate.depth_meters);
+        assert!(estimate.upper_bound > estimate.depth_meters);
+    }
+
+    #[test]
+    fn test_ml_config_builder() {
+        let config = MlDetectionConfig::cpu()
+            .with_debris_model("models/debris.onnx")
+            .with_vital_model("models/vitals.onnx")
+            .with_min_confidence(0.7);
+
+        assert!(config.enable_debris_classification);
+        assert!(config.enable_vital_classification);
+        assert_eq!(config.min_confidence, 0.7);
+        assert!(!config.use_gpu);
+    }
+}

rust-port/wifi-densepose-rs/crates/wifi-densepose-wasm/Cargo.toml

@@ -3,5 +3,61 @@ name = "wifi-densepose-wasm"
 version.workspace = true
 edition.workspace = true
 description = "WebAssembly bindings for WiFi-DensePose"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/ruvnet/wifi-densepose"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = ["console_error_panic_hook"]
+mat = ["wifi-densepose-mat"]
 
 [dependencies]
+# WASM bindings
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+js-sys = "0.3"
+web-sys = { version = "0.3", features = [
+    "console",
+    "Window",
+    "Document",
+    "Element",
+    "HtmlCanvasElement",
+    "CanvasRenderingContext2d",
+    "WebSocket",
+    "MessageEvent",
+    "ErrorEvent",
+    "CloseEvent",
+    "BinaryType",
+    "Performance",
+] }
+
+# Error handling and logging
+console_error_panic_hook = { version = "0.1", optional = true }
+wasm-logger = "0.2"
+log = "0.4"
+
+# Serialization for JS interop
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+serde-wasm-bindgen = "0.6"
+
+# Async runtime for WASM
+futures = "0.3"
+
+# Time handling
+chrono = { version = "0.4", features = ["serde", "wasmbind"] }
+
+# UUID generation (with JS random support)
+uuid = { version = "1.6", features = ["v4", "serde", "js"] }
+getrandom = { version = "0.2", features = ["js"] }
+
+# Optional: wifi-densepose-mat integration
+wifi-densepose-mat = { path = "../wifi-densepose-mat", optional = true, features = ["serde"] }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3"
+
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = ["-O4", "--enable-mutable-globals"]

rust-port/wifi-densepose-rs/crates/wifi-densepose-wasm/src/lib.rs

@@ -1 +1,132 @@
-//! WiFi-DensePose WebAssembly bindings (stub)
+//! WiFi-DensePose WebAssembly bindings
+//!
+//! This crate provides WebAssembly bindings for browser-based applications using
+//! WiFi-DensePose technology. It includes:
+//!
+//! - **mat**: WiFi-Mat disaster response dashboard module for browser integration
+//!
+//! # Features
+//!
+//! - `mat` - Enable WiFi-Mat disaster detection WASM bindings
+//! - `console_error_panic_hook` - Better panic messages in browser console
+//!
+//! # Building for WASM
+//!
+//! ```bash
+//! # Build with wasm-pack
+//! wasm-pack build --target web --features mat
+//!
+//! # Or with cargo
+//! cargo build --target wasm32-unknown-unknown --features mat
+//! ```
+//!
+//! # Example Usage (JavaScript)
+//!
+//! ```javascript
+//! import init, { MatDashboard, initLogging } from './wifi_densepose_wasm.js';
+//!
+//! async function main() {
+//!     await init();
+//!     initLogging('info');
+//!
+//!     const dashboard = new MatDashboard();
+//!
+//!     // Create a disaster event
+//!     const eventId = dashboard.createEvent('earthquake', 37.7749, -122.4194, 'Bay Area Earthquake');
+//!
+//!     // Add scan zones
+//!     dashboard.addRectangleZone('Building A', 50, 50, 200, 150);
+//!     dashboard.addCircleZone('Search Area B', 400, 200, 80);
+//!
+//!     // Subscribe to events
+//!     dashboard.onSurvivorDetected((survivor) => {
+//!         console.log('Survivor detected:', survivor);
+//!         updateUI(survivor);
+//!     });
+//!
+//!     dashboard.onAlertGenerated((alert) => {
+//!         showNotification(alert);
+//!     });
+//!
+//!     // Render to canvas
+//!     const canvas = document.getElementById('map');
+//!     const ctx = canvas.getContext('2d');
+//!
+//!     function render() {
+//!         ctx.clearRect(0, 0, canvas.width, canvas.height);
+//!         dashboard.renderZones(ctx);
+//!         dashboard.renderSurvivors(ctx);
+//!         requestAnimationFrame(render);
+//!     }
+//!     render();
+//! }
+//!
+//! main();
+//! ```
+
+use wasm_bindgen::prelude::*;
+
+// WiFi-Mat module for disaster response dashboard
+pub mod mat;
+pub use mat::*;
+
+/// Initialize the WASM module.
+/// Call this once at startup before using any other functions.
+#[wasm_bindgen(start)]
+pub fn init() {
+    // Set panic hook for better error messages in browser console
+    #[cfg(feature = "console_error_panic_hook")]
+    console_error_panic_hook::set_once();
+}
+
+/// Initialize logging with specified level.
+///
+/// @param {string} level - Log level: "trace", "debug", "info", "warn", "error"
+#[wasm_bindgen(js_name = initLogging)]
+pub fn init_logging(level: &str) {
+    let log_level = match level.to_lowercase().as_str() {
+        "trace" => log::Level::Trace,
+        "debug" => log::Level::Debug,
+        "info" => log::Level::Info,
+        "warn" => log::Level::Warn,
+        "error" => log::Level::Error,
+        _ => log::Level::Info,
+    };
+
+    let _ = wasm_logger::init(wasm_logger::Config::new(log_level));
+    log::info!("WiFi-DensePose WASM initialized with log level: {}", level);
+}
+
+/// Get the library version.
+///
+/// @returns {string} Version string
+#[wasm_bindgen(js_name = getVersion)]
+pub fn get_version() -> String {
+    env!("CARGO_PKG_VERSION").to_string()
+}
+
+/// Check if the MAT feature is enabled.
+///
+/// @returns {boolean} True if MAT module is available
+#[wasm_bindgen(js_name = isMatEnabled)]
+pub fn is_mat_enabled() -> bool {
+    true
+}
+
+/// Get current timestamp in milliseconds (for performance measurements).
+///
+/// @returns {number} Timestamp in milliseconds
+#[wasm_bindgen(js_name = getTimestamp)]
+pub fn get_timestamp() -> f64 {
+    let window = web_sys::window().expect("no global window");
+    let performance = window.performance().expect("no performance object");
+    performance.now()
+}
+
+// Re-export all public types from mat module for easy access
+pub mod types {
+    pub use super::mat::{
+        JsAlert, JsAlertPriority, JsDashboardStats, JsDisasterType, JsScanZone, JsSurvivor,
+        JsTriageStatus, JsZoneStatus,
+    };
+}