clm_rust_core/layer2/sync/
mod.rs1pub 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}