clm-kernel 0.0.20

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
pub mod codec;
pub mod outbox_ops;
pub mod petri;
pub mod service;
pub mod validation;
pub mod types;
pub mod open_petri_net;
pub mod open_petri_pullback;
pub mod open_petri_catalyst;
pub mod sheaf_spectral_oracle;

pub use codec::*;
pub use petri::*;
pub use service::*;
pub use types::*;
pub use open_petri_net::*;
pub use open_petri_pullback::*;
pub use sheaf_spectral_oracle::*;

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::{BTreeMap, BTreeSet};

    #[test]
    fn sync_p_invariants_hold() {
        assert!(verify_p_invariant(
            LIFECYCLE_PLACES,
            &lifecycle_transitions(),
            &[1, 1, 1, 1]
        ));
        assert!(verify_p_invariant(
            TRANSFER_PLACES,
            &transfer_transitions(),
            &[1, 1, 1, 1]
        ));
    }

    #[test]
    fn sync_chunked_base64_and_record_verification() {
        for len in [0usize, 1, 2, 3, 12287, 12288, 12289] {
            let data: Vec<u8> = (0..len).map(|i| ((i * 31 + 7) & 0xff) as u8).collect();
            let enc = bytes_to_base64(&data);
            let dec = base64_to_bytes(&enc).expect("valid base64");
            assert_eq!(dec, data);
        }
        let content = b"sync-contract-v1-payload".to_vec();
        let hex_digest = blake3::hash(&content).to_hex().to_string();
        let rec = MCardRecord {
            hash: hex_digest.clone(),
            content,
            g_time: "blake3|2026-10-23T00:00:00.000Z|UTC".to_string(),
        };
        let frame = frame_record(&rec);
        let (unframed, q_hash) = unframe_record(&frame, "blake3").expect("verified");
        assert_eq!(q_hash, format!("blake3:{hex_digest}"));
        assert_eq!(unframed.content, rec.content);
    }

    #[test]
    fn sync_page_cursor_and_engine_lifecycle() {
        let mut recs = Vec::new();
        for i in 0..5 {
            let bytes = format!("record-{i}").into_bytes();
            let h = blake3::hash(&bytes).to_hex().to_string();
            recs.push(MCardRecord {
                hash: h,
                content: bytes,
                g_time: "blake3|2026-10-23T00:00:00.000Z|UTC".to_string(),
            });
        }
        let known = BTreeSet::new();
        let page1 = frame_record_page(&recs, &known, None, 2, MAX_SYNC_PAGE_BYTES);
        assert_eq!(page1.records.len(), 2);
        assert!(page1.has_more);
        let page2 = frame_record_page(&recs, &known, page1.next_cursor.as_ref(), 2, MAX_SYNC_PAGE_BYTES);
        assert_eq!(page2.records.len(), 2);
        assert!(page2.has_more);
        let page3 = frame_record_page(&recs, &known, page2.next_cursor.as_ref(), 2, MAX_SYNC_PAGE_BYTES);
        assert_eq!(page3.records.len(), 1);
        assert!(!page3.has_more);

        let mut engine = MCardSyncEngine::new("node-1");
        let mut clock = BTreeMap::new();
        clock.insert("node-1".to_string(), 1);
        let payload = TransitionPayload {
            kind: "CREATE".to_string(),
            handle: "workspace/doc.md".to_string(),
            to_handle: None,
            from: None,
            to: Some(format!("blake3:{}", recs[0].hash)),
            meta: None,
            source_ref: None,
            branch_ref: None,
            clock,
            author: "did:clm:agent:test".to_string(),
        };
        let gate = engine.apply_transition("t_create", &payload, &[frame_record(&recs[0])]);
        assert!(gate.enabled);
        assert_eq!(gate.post_marking.get("p_active"), Some(&1));

        let q0 = format!("blake3:{}", recs[0].hash);
        let q1 = format!("blake3:{}", recs[1].hash);
        let mut clock2 = BTreeMap::new();
        clock2.insert("node-1".to_string(), 2);
        let seed_payload = TransitionPayload {
            kind: "SEED".to_string(),
            handle: "catalog/sample.md".to_string(),
            to_handle: None,
            from: None,
            to: Some(q0.clone()),
            meta: None,
            source_ref: Some(q0.clone()),
            branch_ref: None,
            clock: clock2.clone(),
            author: "did:clm:agent:test".to_string(),
        };
        let seed_gate = engine.apply_transition("t_seed", &seed_payload, &[frame_record(&recs[0])]);
        assert!(seed_gate.enabled);
        assert_eq!(seed_gate.post_marking.get("p_active"), Some(&1));

        let fork_payload = TransitionPayload {
            kind: "FORK".to_string(),
            handle: "catalog/sample.md".to_string(),
            to_handle: Some("workspace/sample.md".to_string()),
            from: Some(q0.clone()),
            to: Some(q0.clone()),
            meta: None,
            source_ref: Some(q0.clone()),
            branch_ref: None,
            clock: clock2.clone(),
            author: "did:clm:agent:test".to_string(),
        };
        let fork_gate = engine.apply_transition("t_fork", &fork_payload, &[]);
        assert!(fork_gate.enabled);

        let pin_payload = TransitionPayload {
            kind: "PIN".to_string(),
            handle: "catalog/sample.md".to_string(),
            to_handle: None,
            from: Some(q0.clone()),
            to: Some(q0.clone()),
            meta: None,
            source_ref: None,
            branch_ref: None,
            clock: clock2.clone(),
            author: "did:clm:agent:test".to_string(),
        };
        assert!(engine.apply_transition("t_pin", &pin_payload, &[]).enabled);

        let branch_payload = TransitionPayload {
            kind: "CONFLICT_BRANCH".to_string(),
            handle: "workspace/doc.md".to_string(),
            to_handle: None,
            from: Some(q0),
            to: Some(q1),
            meta: None,
            source_ref: None,
            branch_ref: Some("branch:conflict-1".to_string()),
            clock: clock2,
            author: "did:clm:agent:test".to_string(),
        };
        let branch_gate = engine.apply_transition("t_conflict_branch", &branch_payload, &[frame_record(&recs[1])]);
        assert!(branch_gate.enabled);
        assert_eq!(branch_gate.post_marking.get("p_conflict_quarantine"), Some(&1));
        assert_eq!(CHANGE_CALCULUS.len(), 10);
    }

    #[test]
    fn legacy_sync_api_remains_compatible() {
        use crate::crdt::{CrdtLog, VectorClock};

        let mut vc1 = VectorClock::new();
        vc1.increment("node-a");
        let mut vc2 = VectorClock::new();
        vc2.increment("node-b");
        let merged = vc1.merge(&vc2);
        assert_eq!(merged.entries.get("node-a"), Some(&1));
        assert_eq!(merged.entries.get("node-b"), Some(&1));

        let log_a = CrdtLog::new("node-a");
        assert_eq!(log_a.node_id, "node-a");
    }
}