use crate::privacy::PrivacyClass;
use crate::tensor::{FieldTensor, SPEC_VERSION};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SensorDescriptor {
pub modality: String,
pub vendor: String,
pub device_id: String,
pub placement: String,
pub clock_domain: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Observation {
pub zone_id: Option<String>,
pub space_cell: Option<[i32; 3]>,
pub range_m: Option<f32>,
pub velocity_mps: Option<f32>,
pub motion_vector: Option<[f32; 3]>,
pub confidence: f32,
#[serde(default)]
pub features: std::collections::BTreeMap<String, f32>,
pub labels: Vec<String>,
pub privacy_class: PrivacyClass,
}
impl Observation {
#[must_use]
pub fn occupancy(confidence: f32, privacy_class: PrivacyClass) -> Self {
Observation {
zone_id: None,
space_cell: None,
range_m: None,
velocity_mps: None,
motion_vector: None,
confidence,
features: std::collections::BTreeMap::new(),
labels: Vec::new(),
privacy_class,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProvenanceRef {
pub raw_hash: String,
pub firmware_hash: String,
pub model_id: String,
pub calibration_id: String,
#[serde(default)]
pub synthetic: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub signature_hex: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub signer_pubkey_hex: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FieldEvent {
pub spec_version: String,
pub event_id: String,
pub timestamp_ns: u64,
pub sensor: SensorDescriptor,
pub tensor: FieldTensor,
pub observation: Observation,
pub provenance: ProvenanceRef,
}
impl FieldEvent {
#[must_use]
pub fn new(
event_id: impl Into<String>,
timestamp_ns: u64,
sensor: SensorDescriptor,
tensor: FieldTensor,
observation: Observation,
provenance: ProvenanceRef,
) -> Self {
FieldEvent {
spec_version: SPEC_VERSION.to_string(),
event_id: event_id.into(),
timestamp_ns,
sensor,
tensor,
observation,
provenance,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CalibrationReceipt {
pub calibration_id: String,
pub modality: String,
pub zone_id: String,
pub task: String,
pub created_ns: u64,
pub expires_ns: u64,
pub data_hash: String,
}
#[cfg(test)]
mod tests {
use super::*;
use crate::modality::{FieldAxis, Modality};
fn sample_tensor() -> FieldTensor {
FieldTensor::new(
1,
Modality::WifiCsi,
vec![FieldAxis::Frequency],
vec![3],
vec![0.1, 0.2, 0.3],
0.8,
0.01,
Some("room_cal_2026".into()),
PrivacyClass::P2,
)
.unwrap()
}
#[test]
fn event_round_trips() {
let ev = FieldEvent::new(
"01J00000000000000000000000",
1,
SensorDescriptor {
modality: "wifi_csi".into(),
vendor: "esp32_c6".into(),
device_id: "sensor_room_01".into(),
placement: "ceiling_corner".into(),
clock_domain: "local_ptp".into(),
},
sample_tensor(),
Observation::occupancy(0.87, PrivacyClass::P2),
ProvenanceRef {
raw_hash: "sha256:abc".into(),
firmware_hash: "sha256:def".into(),
model_id: "ruvector_field_encoder_v1".into(),
calibration_id: "room_cal_2026".into(),
synthetic: true,
signature_hex: None,
signer_pubkey_hex: None,
},
);
let j = serde_json::to_string(&ev).unwrap();
let back: FieldEvent = serde_json::from_str(&j).unwrap();
assert_eq!(ev, back);
}
}