use crate::layer2::sync::codec::{derive_delivery_id, derive_transfer_id, unframe_record};
use crate::layer2::sync::petri::{
compute_marking_state_hash, evaluate_lifecycle_guard, evaluate_transfer_guard,
resolve_concurrent_head_winner,
};
use crate::layer2::sync::types::{
MCardRecord, RecordFrame, SyncOutboxEntry, TransitionGateResult, TransitionPayload,
};
use std::collections::{BTreeMap, BTreeSet};
pub struct MCardSyncEngine {
pub node_id: String,
pub is_disposed: bool,
pub records: BTreeMap<String, MCardRecord>,
pub handle_markings: BTreeMap<String, BTreeMap<String, i64>>,
pub handle_heads: BTreeMap<String, Option<String>>,
pub handle_clocks: BTreeMap<String, BTreeMap<String, u64>>,
pub transitions: Vec<TransitionPayload>,
pub committed_transfers: BTreeSet<String>,
pub outbox: BTreeMap<String, SyncOutboxEntry>,
pub transfer_marking: BTreeMap<String, i64>,
}
impl MCardSyncEngine {
pub fn new(node_id: &str) -> Self {
let mut transfer_marking = BTreeMap::new();
transfer_marking.insert("p_source".to_string(), 0);
transfer_marking.insert("p_in_flight".to_string(), 0);
transfer_marking.insert("p_target".to_string(), 0);
transfer_marking.insert("p_rejected".to_string(), 0);
Self {
node_id: node_id.to_string(),
is_disposed: false,
records: BTreeMap::new(),
handle_markings: BTreeMap::new(),
handle_heads: BTreeMap::new(),
handle_clocks: BTreeMap::new(),
transitions: Vec::new(),
committed_transfers: BTreeSet::new(),
outbox: BTreeMap::new(),
transfer_marking,
}
}
pub fn default_lifecycle_marking() -> BTreeMap<String, i64> {
let mut m = BTreeMap::new();
m.insert("p_unborn".to_string(), 1);
m.insert("p_active".to_string(), 0);
m.insert("p_retired_tombstone".to_string(), 0);
m.insert("p_conflict_quarantine".to_string(), 0);
m
}
pub fn admit_record_frame(&mut self, frame: &RecordFrame) -> Result<(String, bool), (String, String)> {
let (rec, q_hash) = unframe_record(frame, "blake3")?;
let bare = q_hash.split(':').nth(1).unwrap_or("").to_string();
let replayed = self.records.contains_key(&bare);
if !replayed {
self.records.insert(bare, rec);
}
Ok((q_hash, replayed))
}
pub fn apply_transition(
&mut self,
transition_id: &str,
payload: &TransitionPayload,
record_frames: &[RecordFrame],
) -> TransitionGateResult {
let current = self
.handle_markings
.get(&payload.handle)
.cloned()
.unwrap_or_else(Self::default_lifecycle_marking);
let mut verified = Vec::new();
for frame in record_frames {
match unframe_record(frame, "blake3") {
Ok((rec, q_hash)) => {
let bare = q_hash.split(':').nth(1).unwrap_or("").to_string();
verified.push((bare, rec));
}
Err((err_code, reason)) => {
let pre_hash = compute_marking_state_hash(¤t);
return TransitionGateResult {
enabled: false,
transition_id: transition_id.to_string(),
pre_marking: current.clone(),
post_marking: current,
pre_state_hash: pre_hash.clone(),
post_state_hash: pre_hash,
error_code: Some(err_code),
reason: Some(reason),
};
}
}
}
let gate = evaluate_lifecycle_guard(¤t, transition_id, Some(payload));
if !gate.enabled {
return gate;
}
for (bare, rec) in verified {
self.records.insert(bare, rec);
}
self.handle_markings
.insert(payload.handle.clone(), gate.post_marking.clone());
let prev_clock = self.handle_clocks.get(&payload.handle).cloned().unwrap_or_default();
let prev_head = self.handle_heads.get(&payload.handle).and_then(|h| h.as_deref());
let (_, winner, _, merged_clock) = resolve_concurrent_head_winner(
prev_head,
payload.to.as_deref(),
&prev_clock,
&payload.clock,
);
self.handle_heads.insert(
payload.handle.clone(),
if payload.kind == "TOMBSTONE" { None } else { winner },
);
self.handle_clocks.insert(payload.handle.clone(), merged_clock);
self.transitions.push(payload.clone());
gate
}
pub fn enqueue_transfer(
&mut self,
target_node_id: &str,
records: Vec<RecordFrame>,
transitions: Vec<TransitionPayload>,
disambiguator: &str,
) -> SyncOutboxEntry {
let mut sorted_hashes: Vec<String> = records.iter().map(|r| r.hash.clone()).collect();
sorted_hashes.sort();
let hashes_json: Vec<String> = sorted_hashes.iter().map(|h| format!("\"{h}\"")).collect();
let canon = format!(
"{{\"disambiguator\":\"{}\",\"records\":[{}],\"targetNodeId\":\"{}\",\"transitions\":{}}}",
disambiguator,
hashes_json.join(","),
target_node_id,
transitions.len()
);
let q_ref = format!("blake3:{}", blake3::hash(canon.as_bytes()).to_hex());
let transfer_id = derive_transfer_id(&q_ref);
let delivery_id = derive_delivery_id(&q_ref, target_node_id);
*self.transfer_marking.entry("p_source".to_string()).or_insert(0) += 1;
let gate = evaluate_transfer_guard(&self.transfer_marking, "t_enqueue_push", 1);
self.transfer_marking = gate.post_marking;
let entry = SyncOutboxEntry {
transfer_id,
delivery_id: delivery_id.clone(),
target_node_id: target_node_id.to_string(),
status: "in_flight".to_string(),
attempt_count: 0,
records,
transitions,
last_error: None,
};
self.outbox.insert(delivery_id, entry.clone());
entry
}
pub fn receive_transfer(
&mut self,
transfer_id: &str,
records: &[RecordFrame],
) -> Result<bool, (String, String)> {
if self.committed_transfers.contains(transfer_id) {
return Ok(true);
}
for frame in records {
unframe_record(frame, "blake3")?;
}
for frame in records {
let _ = self.admit_record_frame(frame);
}
self.committed_transfers.insert(transfer_id.to_string());
Ok(false)
}
pub fn dispose(&mut self) {
self.is_disposed = true;
}
}
impl Drop for MCardSyncEngine {
fn drop(&mut self) {
self.dispose();
}
}