clm-kernel 0.0.11

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
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(&current);
                    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(&current, 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();
    }
}