pub struct ForkliftProximityDetector { /* ... */ }

impl ForkliftProximityDetector {
    /// Create a new detector. Requires 100-frame calibration (~5 s at 20 Hz).
    pub const fn new() -> Self;

    /// Process one CSI frame. Returns events as (event_id, value) pairs.
    pub fn process_frame(
        &mut self,
        phases: &[f32],       // per-subcarrier phase values
        amplitudes: &[f32],   // per-subcarrier amplitude values
        variance: &[f32],     // per-subcarrier variance values
        motion_energy: f32,   // host-reported motion energy
        presence: i32,        // host-reported presence flag (0/1)
        n_persons: i32,       // host-reported person count
    ) -> &[(i32, f32)];

    /// Whether a vehicle is currently detected.
    pub fn is_vehicle_present(&self) -> bool;

    /// Current amplitude ratio (proxy for vehicle proximity).
    pub fn amplitude_ratio(&self) -> f32;
}

                  +-----------+
                  |           |
        +-------->| No Vehicle|<---------+
        |         |           |          |
        |         +-----+-----+          |
        |               |               |
        |   amp_ratio > 2.5 AND         |
        |   low_freq_dominant AND        | debounce drops
        |   vibration > 0.08            | below threshold
        |   (4 frames debounce)          |
        |               |               |
        |         +-----v-----+          |
        |         |           |----------+
        +---------|  Vehicle  |
                  |  Present  |
                  +-----+-----+
                        |
          human present |  (presence + motion > 0.15)
          + debounce    |
                  +-----v-----+
                  | Proximity |----> EVENT 500 (cooldown 40 frames)
                  |  Warning  |----> EVENT 502 (once on transition)
                  +-----------+

use wifi_densepose_wasm_edge::ind_forklift_proximity::ForkliftProximityDetector;

let mut detector = ForkliftProximityDetector::new();

// Calibration phase: feed 100 frames of empty warehouse
for _ in 0..100 {
    detector.process_frame(&phases, &amps, &variance, 0.0, 0, 0);
}

// Normal operation
let events = detector.process_frame(&phases, &amps, &variance, 0.5, 1, 1);
for &(event_id, value) in events {
    match event_id {
        500 => {
            let category = match value as i32 {
                0 => "CRITICAL -- stop forklift immediately",
                1 => "WARNING -- reduce speed",
                _ => "CAUTION -- be alert",
            };
            trigger_alarm(category);
        }
        501 => log("Vehicle detected, amplitude ratio: {}", value),
        502 => log("Human entered vehicle zone"),
        _ => {}
    }
}

pub enum WorkerState {
    Empty,           // No worker in the space
    Present,         // Worker present, vitals normal
    BreathingCeased, // No breathing detected (danger)
    Immobile,        // No motion detected (danger)
}

pub struct ConfinedSpaceMonitor { /* ... */ }

impl ConfinedSpaceMonitor {
    pub const fn new() -> Self;

    /// Process one frame.
    pub fn process_frame(
        &mut self,
        presence: i32,       // host-reported presence (0/1)
        breathing_bpm: f32,  // host-reported breathing rate
        motion_energy: f32,  // host-reported motion energy
        variance: f32,       // mean CSI variance
    ) -> &[(i32, f32)];

    /// Current worker state.
    pub fn state(&self) -> WorkerState;

    /// Whether a worker is inside the space.
    pub fn is_worker_inside(&self) -> bool;

    /// Seconds since last confirmed breathing.
    pub fn seconds_since_breathing(&self) -> f32;

    /// Seconds since last detected motion.
    pub fn seconds_since_motion(&self) -> f32;
}

            +---------+
            |  Empty  |<----------+
            +----+----+           |
                 |                |
     presence    |                | absence (10 frames)
     (10 frames) |                |
                 v                |
            +---------+           |
    +------>| Present |-----------+
    |       +----+----+
    |            |          |
    |  breathing | no       | no motion
    |  resumes   | breathing| (1200 frames)
    |            | (300     |
    |            |  frames) |
    |       +----v------+   |
    +-------|Breathing  |   |
    |       | Ceased    |   |
    |       +-----------+   |
    |                       |
    |       +-----------+   |
    +-------| Immobile  |<--+
            +-----------+
              motion resumes -> Present

use wifi_densepose_wasm_edge::ind_confined_space::{
    ConfinedSpaceMonitor, WorkerState,
    EVENT_EXTRACTION_ALERT, EVENT_IMMOBILE_ALERT,
};

let mut monitor = ConfinedSpaceMonitor::new();

// Process each CSI frame
let events = monitor.process_frame(presence, breathing_bpm, motion_energy, variance);

for &(event_id, value) in events {
    match event_id {
        513 => {  // EXTRACTION_ALERT
            activate_rescue_alarm();
            notify_safety_attendant(value);  // seconds since last breath
        }
        514 => {  // IMMOBILE_ALERT
            notify_safety_attendant(value);  // seconds without motion
        }
        _ => {}
    }
}

// Query state for dashboard display
match monitor.state() {
    WorkerState::Empty => display_green("Space empty"),
    WorkerState::Present => display_green("Worker OK"),
    WorkerState::BreathingCeased => display_red("NO BREATHING"),
    WorkerState::Immobile => display_amber("Worker immobile"),
}

pub struct CleanRoomMonitor { /* ... */ }

impl CleanRoomMonitor {
    /// Create with default max occupancy of 4.
    pub const fn new() -> Self;

    /// Create with custom maximum occupancy.
    pub const fn with_max_occupancy(max: u8) -> Self;

    /// Process one frame.
    pub fn process_frame(
        &mut self,
        n_persons: i32,      // host-reported person count
        presence: i32,       // host-reported presence (0/1)
        motion_energy: f32,  // host-reported motion energy
    ) -> &[(i32, f32)];

    /// Current occupancy count.
    pub fn current_count(&self) -> u8;

    /// Maximum allowed occupancy.
    pub fn max_occupancy(&self) -> u8;

    /// Whether currently in violation.
    pub fn is_in_violation(&self) -> bool;

    /// Compliance percentage (0--100).
    pub fn compliance_percent(&self) -> f32;

    /// Total number of violation events.
    pub fn total_violations(&self) -> u32;
}

    +------------------+
    |  Monitoring      |
    |  (count <= max)  |
    +--------+---------+
             |  count > max
             |  (10 frames debounce)
    +--------v---------+
    |  Violation       |----> EVENT 521 (cooldown 200 frames)
    |  (count > max)   |
    +--------+---------+
             |  count <= max
             |
    +--------v---------+
    |  Monitoring      |
    +------------------+

    Parallel:
    motion_energy > 0.6 (3 frames) ----> EVENT 522 (cooldown 100 frames)
    Every 600 frames (~30 s) ----------> EVENT 523 (compliance %)

use wifi_densepose_wasm_edge::ind_clean_room::{
    CleanRoomMonitor, EVENT_OCCUPANCY_VIOLATION, EVENT_COMPLIANCE_REPORT,
};

// ISO Class 5 cleanroom: max 3 personnel
let mut monitor = CleanRoomMonitor::with_max_occupancy(3);

let events = monitor.process_frame(n_persons, presence, motion_energy);
for &(event_id, value) in events {
    match event_id {
        521 => alert_cleanroom_supervisor(value as u8),
        522 => alert_turbulent_motion(),
        523 => log_compliance_audit(value),
        _ => {}
    }
}

// Dashboard
println!("Occupancy: {}/{}", monitor.current_count(), monitor.max_occupancy());
println!("Compliance: {:.1}%", monitor.compliance_percent());

pub enum Species {
    Cattle,
    Sheep,
    Poultry,
    Custom { min_bpm: f32, max_bpm: f32 },
}

pub struct LivestockMonitor { /* ... */ }

impl LivestockMonitor {
    /// Create with default species (Cattle).
    pub const fn new() -> Self;

    /// Create with a specific species.
    pub const fn with_species(species: Species) -> Self;

    /// Process one frame.
    pub fn process_frame(
        &mut self,
        presence: i32,       // host-reported presence (0/1)
        breathing_bpm: f32,  // host-reported breathing rate
        motion_energy: f32,  // host-reported motion energy
        variance: f32,       // mean CSI variance (unused, reserved)
    ) -> &[(i32, f32)];

    /// Whether an animal is currently detected.
    pub fn is_animal_present(&self) -> bool;

    /// Configured species.
    pub fn species(&self) -> Species;

    /// Minutes of stillness.
    pub fn stillness_minutes(&self) -> f32;

    /// Last observed breathing BPM.
    pub fn last_breathing_bpm(&self) -> f32;
}

    +---------+
    |  Empty  |<---------+
    +----+----+          |
         |               |
   presence              | absence >= 20 frames
   (10 frames)           | (after >= 200 frames presence
         v               |  -> EVENT 533 escape alert)
    +---------+          |
    | Present |----------+
    +----+----+
         |
   no motion (6000 frames = 5 min) -> EVENT 531 (once)
   breathing outside range (20 frames) -> EVENT 532 (repeating)

use wifi_densepose_wasm_edge::ind_livestock_monitor::{
    LivestockMonitor, Species, EVENT_ESCAPE_ALERT, EVENT_LABORED_BREATHING,
};

// Dairy barn: monitor cows
let mut monitor = LivestockMonitor::with_species(Species::Cattle);

let events = monitor.process_frame(presence, breathing_bpm, motion_energy, variance);
for &(event_id, value) in events {
    match event_id {
        532 => alert_veterinarian(value),  // labored breathing BPM
        533 => alert_farm_security(value), // escape: minutes present before loss
        531 => log_health_concern(value),  // minutes of stillness
        _ => {}
    }
}

pub struct StructuralVibrationMonitor { /* ... */ }

impl StructuralVibrationMonitor {
    /// Create a new monitor. Requires 100-frame calibration when empty.
    pub const fn new() -> Self;

    /// Process one CSI frame.
    pub fn process_frame(
        &mut self,
        phases: &[f32],       // per-subcarrier phase values
        amplitudes: &[f32],   // per-subcarrier amplitude values
        variance: &[f32],     // per-subcarrier variance values
        presence: i32,        // 0 = empty (analyze), 1 = occupied (skip)
    ) -> &[(i32, f32)];

    /// Current RMS vibration level.
    pub fn rms_vibration(&self) -> f32;

    /// Whether baseline has been established.
    pub fn is_calibrated(&self) -> bool;
}

    +--------------+
    | Calibrating  |  (100 frames, presence=0 required)
    +------+-------+
           |
    +------v-------+
    |   Idle       |  (presence=1: skip analysis, reset drift)
    | (Occupied)   |
    +------+-------+
           |  presence=0
    +------v-------+
    |  Analyzing   |
    +------+-------+
           |
           +-----> RMS > 0.15 + broadband -------> EVENT 540 (seismic)
           +-----> autocorr peak ratio > 3.0 ----> EVENT 541 (resonance)
           +-----> monotonic drift > 30 s -------> EVENT 542 (drift)
           +-----> every 100 frames -------------> EVENT 543 (spectrum)

use wifi_densepose_wasm_edge::ind_structural_vibration::{
    StructuralVibrationMonitor, EVENT_SEISMIC_DETECTED, EVENT_STRUCTURAL_DRIFT,
};

let mut monitor = StructuralVibrationMonitor::new();

// Calibrate during unoccupied period
for _ in 0..100 {
    monitor.process_frame(&phases, &amps, &variance, 0);
}
assert!(monitor.is_calibrated());

// Normal operation
let events = monitor.process_frame(&phases, &amps, &variance, presence);
for &(event_id, value) in events {
    match event_id {
        540 => {
            trigger_building_alarm();
            log_seismic_event(value);  // RMS vibration level
        }
        542 => {
            notify_structural_engineer(value);  // drift rate rad/s
        }
        _ => {}
    }
}

    +---+---+---+---+---+
    | S |   |   |   | S |   S = WiFi sensor (ESP32)
    +---+ Aisle 1   +---+   Mounted at shelf height (1.5-2 m)
    |   |           |   |   One sensor per aisle intersection
    +---+ Aisle 2   +---+
    | S |           | S |   Coverage: ~15 m range per sensor
    +---+---+---+---+---+   For proximity: sensor every 10 m along aisle

    Ground Level
    +-----------+
    |  Sensor A | <-- Entry point monitoring
    +-----+-----+
          |
          | Manhole / Hatch
          |
    +-----v-----+
    |  Sensor B | <-- Inside space (if possible)
    +-----------+