Skip to main content

clm_rust_core/layer2/sync/
mod.rs

1pub mod codec;
2pub mod outbox_ops;
3pub mod petri;
4pub mod service;
5pub mod validation;
6pub mod types;
7pub mod open_petri_net;
8pub mod open_petri_pullback;
9pub mod open_petri_catalyst;
10pub mod sheaf_spectral_oracle;
11
12pub use codec::*;
13pub use petri::*;
14pub use service::*;
15pub use types::*;
16pub use open_petri_net::*;
17pub use open_petri_pullback::*;
18pub use sheaf_spectral_oracle::*;
19
20#[cfg(test)]
21mod tests {
22    use super::*;
23    use std::collections::{BTreeMap, BTreeSet};
24
25    #[test]
26    fn sync_p_invariants_hold() {
27        assert!(verify_p_invariant(
28            LIFECYCLE_PLACES,
29            &lifecycle_transitions(),
30            &[1, 1, 1, 1]
31        ));
32        assert!(verify_p_invariant(
33            TRANSFER_PLACES,
34            &transfer_transitions(),
35            &[1, 1, 1, 1]
36        ));
37    }
38
39    #[test]
40    fn sync_chunked_base64_and_record_verification() {
41        for len in [0usize, 1, 2, 3, 12287, 12288, 12289] {
42            let data: Vec<u8> = (0..len).map(|i| ((i * 31 + 7) & 0xff) as u8).collect();
43            let enc = bytes_to_base64(&data);
44            let dec = base64_to_bytes(&enc).expect("valid base64");
45            assert_eq!(dec, data);
46        }
47        let content = b"sync-contract-v1-payload".to_vec();
48        let hex_digest = blake3::hash(&content).to_hex().to_string();
49        let rec = MCardRecord {
50            hash: hex_digest.clone(),
51            content,
52            g_time: "blake3|2026-10-23T00:00:00.000Z|UTC".to_string(),
53        };
54        let frame = frame_record(&rec);
55        let (unframed, q_hash) = unframe_record(&frame, "blake3").expect("verified");
56        assert_eq!(q_hash, format!("blake3:{hex_digest}"));
57        assert_eq!(unframed.content, rec.content);
58    }
59
60    #[test]
61    fn sync_page_cursor_and_engine_lifecycle() {
62        let mut recs = Vec::new();
63        for i in 0..5 {
64            let bytes = format!("record-{i}").into_bytes();
65            let h = blake3::hash(&bytes).to_hex().to_string();
66            recs.push(MCardRecord {
67                hash: h,
68                content: bytes,
69                g_time: "blake3|2026-10-23T00:00:00.000Z|UTC".to_string(),
70            });
71        }
72        let known = BTreeSet::new();
73        let page1 = frame_record_page(&recs, &known, None, 2, MAX_SYNC_PAGE_BYTES);
74        assert_eq!(page1.records.len(), 2);
75        assert!(page1.has_more);
76        let page2 = frame_record_page(&recs, &known, page1.next_cursor.as_ref(), 2, MAX_SYNC_PAGE_BYTES);
77        assert_eq!(page2.records.len(), 2);
78        assert!(page2.has_more);
79        let page3 = frame_record_page(&recs, &known, page2.next_cursor.as_ref(), 2, MAX_SYNC_PAGE_BYTES);
80        assert_eq!(page3.records.len(), 1);
81        assert!(!page3.has_more);
82
83        let mut engine = MCardSyncEngine::new("node-1");
84        let mut clock = BTreeMap::new();
85        clock.insert("node-1".to_string(), 1);
86        let payload = TransitionPayload {
87            kind: "CREATE".to_string(),
88            handle: "workspace/doc.md".to_string(),
89            to_handle: None,
90            from: None,
91            to: Some(format!("blake3:{}", recs[0].hash)),
92            meta: None,
93            source_ref: None,
94            branch_ref: None,
95            clock,
96            author: "did:clm:agent:test".to_string(),
97        };
98        let gate = engine.apply_transition("t_create", &payload, &[frame_record(&recs[0])]);
99        assert!(gate.enabled);
100        assert_eq!(gate.post_marking.get("p_active"), Some(&1));
101
102        let q0 = format!("blake3:{}", recs[0].hash);
103        let q1 = format!("blake3:{}", recs[1].hash);
104        let mut clock2 = BTreeMap::new();
105        clock2.insert("node-1".to_string(), 2);
106        let seed_payload = TransitionPayload {
107            kind: "SEED".to_string(),
108            handle: "catalog/sample.md".to_string(),
109            to_handle: None,
110            from: None,
111            to: Some(q0.clone()),
112            meta: None,
113            source_ref: Some(q0.clone()),
114            branch_ref: None,
115            clock: clock2.clone(),
116            author: "did:clm:agent:test".to_string(),
117        };
118        let seed_gate = engine.apply_transition("t_seed", &seed_payload, &[frame_record(&recs[0])]);
119        assert!(seed_gate.enabled);
120        assert_eq!(seed_gate.post_marking.get("p_active"), Some(&1));
121
122        let fork_payload = TransitionPayload {
123            kind: "FORK".to_string(),
124            handle: "catalog/sample.md".to_string(),
125            to_handle: Some("workspace/sample.md".to_string()),
126            from: Some(q0.clone()),
127            to: Some(q0.clone()),
128            meta: None,
129            source_ref: Some(q0.clone()),
130            branch_ref: None,
131            clock: clock2.clone(),
132            author: "did:clm:agent:test".to_string(),
133        };
134        let fork_gate = engine.apply_transition("t_fork", &fork_payload, &[]);
135        assert!(fork_gate.enabled);
136
137        let pin_payload = TransitionPayload {
138            kind: "PIN".to_string(),
139            handle: "catalog/sample.md".to_string(),
140            to_handle: None,
141            from: Some(q0.clone()),
142            to: Some(q0.clone()),
143            meta: None,
144            source_ref: None,
145            branch_ref: None,
146            clock: clock2.clone(),
147            author: "did:clm:agent:test".to_string(),
148        };
149        assert!(engine.apply_transition("t_pin", &pin_payload, &[]).enabled);
150
151        let branch_payload = TransitionPayload {
152            kind: "CONFLICT_BRANCH".to_string(),
153            handle: "workspace/doc.md".to_string(),
154            to_handle: None,
155            from: Some(q0),
156            to: Some(q1),
157            meta: None,
158            source_ref: None,
159            branch_ref: Some("branch:conflict-1".to_string()),
160            clock: clock2,
161            author: "did:clm:agent:test".to_string(),
162        };
163        let branch_gate = engine.apply_transition("t_conflict_branch", &branch_payload, &[frame_record(&recs[1])]);
164        assert!(branch_gate.enabled);
165        assert_eq!(branch_gate.post_marking.get("p_conflict_quarantine"), Some(&1));
166        assert_eq!(CHANGE_CALCULUS.len(), 10);
167    }
168
169    #[test]
170    fn legacy_sync_api_remains_compatible() {
171        use crate::crdt::{CrdtLog, VectorClock};
172
173        let mut vc1 = VectorClock::new();
174        vc1.increment("node-a");
175        let mut vc2 = VectorClock::new();
176        vc2.increment("node-b");
177        let merged = vc1.merge(&vc2);
178        assert_eq!(merged.entries.get("node-a"), Some(&1));
179        assert_eq!(merged.entries.get("node-b"), Some(&1));
180
181        let log_a = CrdtLog::new("node-a");
182        assert_eq!(log_a.node_id, "node-a");
183    }
184}