use crate::sheaf::Marking;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[cfg(feature = "native")]
use crate::archive::{ArchiveManifest, ArchiveFileEntry};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[derive(Default)]
pub enum PartialSharingMode {
ContentOnly,
ContentAndExecution,
#[default]
FullSovereign,
}
impl PartialSharingMode {
pub fn from_str(s: &str) -> Self {
match s {
"content_only" => PartialSharingMode::ContentOnly,
"content_and_execution" => PartialSharingMode::ContentAndExecution,
_ => PartialSharingMode::FullSovereign,
}
}
}
#[cfg(feature = "native")]
pub fn compute_manifest_delta(
local_manifest: &ArchiveManifest,
peer_manifest: &ArchiveManifest,
) -> Vec<ArchiveFileEntry> {
let local_hashes: std::collections::HashSet<&str> = local_manifest
.files
.iter()
.map(|f| f.sha256.as_str())
.collect();
peer_manifest
.files
.iter()
.filter(|f| !local_hashes.contains(f.sha256.as_str()))
.cloned()
.collect()
}
#[cfg(feature = "native")]
pub fn merge_gset_cards(
target_db: &str,
clm_root: &str,
incoming_cards: &[(String, String, String)], sharing_mode: PartialSharingMode,
) -> Result<usize, String> {
let mut count = 0;
for (hash, content, g_time) in incoming_cards {
let db_clean = target_db.to_lowercase();
if sharing_mode == PartialSharingMode::ContentOnly && !db_clean.contains("content_memory") {
continue;
}
if sharing_mode == PartialSharingMode::ContentAndExecution
&& !db_clean.contains("content_memory")
&& !db_clean.contains("execution_log")
{
continue;
}
if target_db.contains('/') || target_db.ends_with(".db") {
let path = std::path::Path::new(target_db);
if let Ok(conn) = rusqlite::Connection::open(path) {
let _ = conn.execute(
"CREATE TABLE IF NOT EXISTS card (hash TEXT PRIMARY KEY, content TEXT, g_time TEXT);",
[],
);
if let Ok(inserted) = conn.execute(
"INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?1, ?2, ?3);",
rusqlite::params![hash, content, g_time],
) {
count += inserted;
}
}
} else {
let _ = crate::db::setter_card_batch(target_db, clm_root, hash, content, g_time);
count += 1;
}
}
Ok(count)
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct VectorClock {
pub entries: HashMap<String, u64>,
}
impl VectorClock {
pub fn new() -> Self {
Self::default()
}
pub fn increment(&mut self, node_id: &str) {
let counter = self.entries.entry(node_id.to_string()).or_insert(0);
*counter += 1;
}
pub fn merge(&self, other: &VectorClock) -> VectorClock {
let mut entries = self.entries.clone();
for (node, counter) in &other.entries {
let current = entries.entry(node.clone()).or_insert(0);
*current = (*current).max(*counter);
}
VectorClock { entries }
}
pub fn happened_before(&self, other: &VectorClock) -> bool {
let mut all_le = true;
let mut any_lt = false;
for (node, self_counter) in &self.entries {
let other_counter = other.entries.get(node).copied().unwrap_or(0);
if *self_counter > other_counter {
all_le = false;
}
if *self_counter < other_counter {
any_lt = true;
}
}
if other.entries.keys().any(|k| !self.entries.contains_key(k)) {
any_lt = true;
}
all_le && any_lt
}
pub fn is_concurrent_with(&self, other: &VectorClock) -> bool {
!self.happened_before(other) && !other.happened_before(self)
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LearningEvent {
pub vcard_hash: String,
pub pcard_hash: String,
pub marking_delta: Marking,
pub agent_did: String,
pub timestamp: String,
pub vector_clock: VectorClock,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CrdtLog {
pub events: Vec<LearningEvent>,
pub clock: VectorClock,
pub node_id: String,
}
impl CrdtLog {
pub fn new(node_id: &str) -> Self {
Self {
events: Vec::new(),
clock: VectorClock::new(),
node_id: node_id.to_string(),
}
}
pub fn append(&mut self, mut event: LearningEvent) {
self.clock.increment(&self.node_id);
event.vector_clock = self.clock.clone();
self.events.push(event);
}
pub fn merge(&mut self, other: &CrdtLog) {
self.clock = self.clock.merge(&other.clock);
for event in &other.events {
if !self.events.iter().any(|e| e.vcard_hash == event.vcard_hash) {
self.events.push(event.clone());
}
}
self.events
.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
}
pub fn concurrent_pairs(&self) -> Vec<(&LearningEvent, &LearningEvent)> {
let mut pairs = Vec::new();
for i in 0..self.events.len() {
for j in (i + 1)..self.events.len() {
if self.events[i]
.vector_clock
.is_concurrent_with(&self.events[j].vector_clock)
{
pairs.push((&self.events[i], &self.events[j]));
}
}
}
pairs
}
}
#[cfg(any(feature = "native", feature = "db"))]
pub fn persist_learning_event(
conn: &rusqlite::Connection,
event: &LearningEvent,
node_id: &str,
) -> Result<(), String> {
let vc_json = serde_json::to_string(&event.vector_clock)
.map_err(|e| format!("Failed to serialize vector_clock: {}", e))?;
let marking_json = serde_json::to_string(&event.marking_delta)
.map_err(|e| format!("Failed to serialize marking_delta: {}", e))?;
conn.execute(
"INSERT OR IGNORE INTO learning_event \
(vcard_hash, pcard_hash, agent_did, timestamp, vector_clock, marking_delta, node_id, synced_at) \
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
rusqlite::params![
event.vcard_hash,
event.pcard_hash,
event.agent_did,
event.timestamp,
vc_json,
marking_json,
node_id,
chrono::Utc::now().to_rfc3339(),
],
).map_err(|e| format!("Failed to persist learning event: {}", e))?;
Ok(())
}
#[cfg(any(feature = "native", feature = "db"))]
pub fn load_learning_events(
conn: &rusqlite::Connection,
since: Option<&str>,
) -> Result<Vec<LearningEvent>, String> {
let mut events = Vec::new();
let sql = if since.is_some() {
"SELECT vcard_hash, pcard_hash, agent_did, timestamp, vector_clock, marking_delta \
FROM learning_event WHERE timestamp > ?1 ORDER BY timestamp ASC"
} else {
"SELECT vcard_hash, pcard_hash, agent_did, timestamp, vector_clock, marking_delta \
FROM learning_event ORDER BY timestamp ASC"
};
let mut stmt = conn.prepare(sql)
.map_err(|e| format!("Failed to prepare query: {}", e))?;
let map_row = |row: &rusqlite::Row| -> rusqlite::Result<(String, String, String, String, String, String)> {
Ok((
row.get(0)?,
row.get(1)?,
row.get(2)?,
row.get(3)?,
row.get(4)?,
row.get(5)?,
))
};
let rows = if let Some(since_ts) = since {
stmt.query_map(rusqlite::params![since_ts], map_row)
.map_err(|e| format!("Failed to query learning events: {}", e))?
} else {
stmt.query_map(rusqlite::params![], map_row)
.map_err(|e| format!("Failed to query learning events: {}", e))?
};
for row in rows {
let (vcard_hash, pcard_hash, agent_did, timestamp, vc_json, marking_json) = row
.map_err(|e| format!("Failed to read row: {}", e))?;
let vector_clock: VectorClock = serde_json::from_str(&vc_json)
.map_err(|e| format!("Failed to deserialize vector_clock: {}", e))?;
let marking_delta: Marking = serde_json::from_str(&marking_json)
.map_err(|e| format!("Failed to deserialize marking_delta: {}", e))?;
events.push(LearningEvent {
vcard_hash,
pcard_hash,
agent_did,
timestamp,
vector_clock,
marking_delta,
});
}
Ok(events)
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncReport {
pub events_merged: usize,
pub events_appended: usize,
pub conflicts: Vec<String>,
}
#[cfg(any(feature = "native", feature = "db"))]
pub fn sync_learning_events(
local: &mut CrdtLog,
remote: &CrdtLog,
conn: &rusqlite::Connection,
) -> Result<SyncReport, String> {
let local_count_before = local.events.len();
local.merge(remote);
let events_appended = local.events.len() - local_count_before;
let conflicts: Vec<String> = local
.concurrent_pairs()
.iter()
.map(|(a, b)| {
format!(
"concurrent events: {} vs {} (vclock: {:?} vs {:?})",
a.vcard_hash, b.vcard_hash, a.vector_clock, b.vector_clock
)
})
.collect();
let events_merged = remote.events.len();
for event in &local.events {
persist_learning_event(conn, event, &local.node_id)?;
}
Ok(SyncReport {
events_merged,
events_appended,
conflicts,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
fn test_vector_clock_happened_before() {
let mut a = VectorClock::new();
a.increment("n1");
a.increment("n1");
let mut b = a.clone();
b.increment("n1");
assert!(a.happened_before(&b));
assert!(!b.happened_before(&a));
}
#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
fn test_vector_clock_concurrent() {
let mut a = VectorClock::new();
a.increment("n1");
let mut b = VectorClock::new();
b.increment("n2");
assert!(a.is_concurrent_with(&b));
}
#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
fn test_crdt_log_merge_idempotent() {
let mut log_a = CrdtLog::new("a");
log_a.append(LearningEvent {
vcard_hash: "h1".to_string(),
pcard_hash: "p1".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:a".to_string(),
timestamp: "t1".to_string(),
vector_clock: VectorClock::new(),
});
let mut log_b = CrdtLog::new("b");
log_b.merge(&log_a);
assert_eq!(log_b.events.len(), 1);
log_b.merge(&log_a);
assert_eq!(log_b.events.len(), 1);
}
#[cfg_attr(not(target_arch = "wasm32"), test)]
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
fn test_crdt_log_detects_concurrent_events() {
let mut log_a = CrdtLog::new("a");
log_a.append(LearningEvent {
vcard_hash: "h1".to_string(),
pcard_hash: "p1".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:a".to_string(),
timestamp: "t1".to_string(),
vector_clock: VectorClock::new(),
});
let mut log_b = CrdtLog::new("b");
log_b.append(LearningEvent {
vcard_hash: "h2".to_string(),
pcard_hash: "p2".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:b".to_string(),
timestamp: "t2".to_string(),
vector_clock: VectorClock::new(),
});
let mut merged = CrdtLog::new("local");
merged.merge(&log_a);
merged.merge(&log_b);
assert_eq!(merged.concurrent_pairs().len(), 1);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn test_crdt_db_schema_creates_learning_event_table() {
let conn = rusqlite::Connection::open_in_memory().unwrap();
conn.execute_batch(
"CREATE TABLE IF NOT EXISTS learning_event (
vcard_hash TEXT PRIMARY KEY,
pcard_hash TEXT NOT NULL,
agent_did TEXT NOT NULL,
timestamp TEXT NOT NULL,
vector_clock TEXT NOT NULL,
marking_delta TEXT NOT NULL,
node_id TEXT NOT NULL,
synced_at TEXT
);",
).unwrap();
let table_exists: bool = conn
.query_row(
"SELECT count(*) FROM sqlite_master WHERE type='table' AND name='learning_event';",
[],
|row| row.get(0),
)
.unwrap_or(0) > 0;
assert!(table_exists, "learning_event table should exist");
}
#[cfg(any(feature = "native", feature = "db"))]
#[test]
fn test_crdt_db_persist_and_load_learning_event() {
let conn = rusqlite::Connection::open_in_memory().unwrap();
conn.execute_batch(
"CREATE TABLE IF NOT EXISTS learning_event (
vcard_hash TEXT PRIMARY KEY,
pcard_hash TEXT NOT NULL,
agent_did TEXT NOT NULL,
timestamp TEXT NOT NULL,
vector_clock TEXT NOT NULL,
marking_delta TEXT NOT NULL,
node_id TEXT NOT NULL,
synced_at TEXT
);",
).unwrap();
let event = LearningEvent {
vcard_hash: "vcard-hash-1".to_string(),
pcard_hash: "pcard-hash-1".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:node-a".to_string(),
timestamp: "2026-07-16T10:00:00Z".to_string(),
vector_clock: VectorClock::new(),
};
persist_learning_event(&conn, &event, "node-a").unwrap();
let loaded = load_learning_events(&conn, None).unwrap();
assert_eq!(loaded.len(), 1);
assert_eq!(loaded[0].vcard_hash, "vcard-hash-1");
assert_eq!(loaded[0].pcard_hash, "pcard-hash-1");
assert_eq!(loaded[0].agent_did, "did:key:node-a");
}
#[cfg(any(feature = "native", feature = "db"))]
#[test]
fn test_crdt_db_persist_is_idempotent() {
let conn = rusqlite::Connection::open_in_memory().unwrap();
conn.execute_batch(
"CREATE TABLE IF NOT EXISTS learning_event (
vcard_hash TEXT PRIMARY KEY,
pcard_hash TEXT NOT NULL,
agent_did TEXT NOT NULL,
timestamp TEXT NOT NULL,
vector_clock TEXT NOT NULL,
marking_delta TEXT NOT NULL,
node_id TEXT NOT NULL,
synced_at TEXT
);",
).unwrap();
let event = LearningEvent {
vcard_hash: "vcard-dup".to_string(),
pcard_hash: "pcard-1".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:a".to_string(),
timestamp: "t1".to_string(),
vector_clock: VectorClock::new(),
};
persist_learning_event(&conn, &event, "node-a").unwrap();
persist_learning_event(&conn, &event, "node-a").unwrap();
let loaded = load_learning_events(&conn, None).unwrap();
assert_eq!(loaded.len(), 1, "duplicate persist should be idempotent");
}
#[cfg(any(feature = "native", feature = "db"))]
#[test]
fn test_crdt_db_load_returns_vector_clock_order() {
let conn = rusqlite::Connection::open_in_memory().unwrap();
conn.execute_batch(
"CREATE TABLE IF NOT EXISTS learning_event (
vcard_hash TEXT PRIMARY KEY,
pcard_hash TEXT NOT NULL,
agent_did TEXT NOT NULL,
timestamp TEXT NOT NULL,
vector_clock TEXT NOT NULL,
marking_delta TEXT NOT NULL,
node_id TEXT NOT NULL,
synced_at TEXT
);",
).unwrap();
let event_b = LearningEvent {
vcard_hash: "vcard-b".to_string(),
pcard_hash: "pcard-b".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:b".to_string(),
timestamp: "2026-07-16T12:00:00Z".to_string(),
vector_clock: VectorClock::new(),
};
let event_a = LearningEvent {
vcard_hash: "vcard-a".to_string(),
pcard_hash: "pcard-a".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:a".to_string(),
timestamp: "2026-07-16T10:00:00Z".to_string(),
vector_clock: VectorClock::new(),
};
persist_learning_event(&conn, &event_b, "node-b").unwrap();
persist_learning_event(&conn, &event_a, "node-a").unwrap();
let loaded = load_learning_events(&conn, None).unwrap();
assert_eq!(loaded.len(), 2);
assert_eq!(loaded[0].vcard_hash, "vcard-a");
assert_eq!(loaded[1].vcard_hash, "vcard-b");
}
#[cfg(any(feature = "native", feature = "db"))]
#[test]
fn test_crdt_sync_merges_and_persists() {
let conn = rusqlite::Connection::open_in_memory().unwrap();
conn.execute_batch(
"CREATE TABLE IF NOT EXISTS learning_event (
vcard_hash TEXT PRIMARY KEY,
pcard_hash TEXT NOT NULL,
agent_did TEXT NOT NULL,
timestamp TEXT NOT NULL,
vector_clock TEXT NOT NULL,
marking_delta TEXT NOT NULL,
node_id TEXT NOT NULL,
synced_at TEXT
);",
).unwrap();
let mut local = CrdtLog::new("node-local");
local.append(LearningEvent {
vcard_hash: "vcard-local".to_string(),
pcard_hash: "pcard-1".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:local".to_string(),
timestamp: "t1".to_string(),
vector_clock: VectorClock::new(),
});
let mut remote = CrdtLog::new("node-remote");
remote.append(LearningEvent {
vcard_hash: "vcard-remote".to_string(),
pcard_hash: "pcard-2".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:remote".to_string(),
timestamp: "t2".to_string(),
vector_clock: VectorClock::new(),
});
let report = sync_learning_events(&mut local, &remote, &conn).unwrap();
assert_eq!(report.events_merged, 1);
assert_eq!(report.events_appended, 1);
assert_eq!(local.events.len(), 2);
let loaded = load_learning_events(&conn, None).unwrap();
assert_eq!(loaded.len(), 2);
}
#[cfg(any(feature = "native", feature = "db"))]
#[test]
fn test_crdt_sync_survives_restart() {
let tmp_dir = std::env::temp_dir();
let db_path = tmp_dir.join("clm_crdt_restart_test.db");
let _ = std::fs::remove_file(&db_path);
{
let conn = rusqlite::Connection::open(&db_path).unwrap();
conn.execute_batch(
"CREATE TABLE IF NOT EXISTS learning_event (
vcard_hash TEXT PRIMARY KEY,
pcard_hash TEXT NOT NULL,
agent_did TEXT NOT NULL,
timestamp TEXT NOT NULL,
vector_clock TEXT NOT NULL,
marking_delta TEXT NOT NULL,
node_id TEXT NOT NULL,
synced_at TEXT
);",
).unwrap();
let event = LearningEvent {
vcard_hash: "vcard-restart".to_string(),
pcard_hash: "pcard-1".to_string(),
marking_delta: Marking::new(),
agent_did: "did:key:restart".to_string(),
timestamp: "t-restart".to_string(),
vector_clock: VectorClock::new(),
};
persist_learning_event(&conn, &event, "node-restart").unwrap();
}
{
let conn = rusqlite::Connection::open(&db_path).unwrap();
let loaded = load_learning_events(&conn, None).unwrap();
assert_eq!(loaded.len(), 1);
assert_eq!(loaded[0].vcard_hash, "vcard-restart");
}
let _ = std::fs::remove_file(&db_path);
}
#[cfg(feature = "native")]
#[test]
fn test_manifest_delta_compute() {
let manifest_local = ArchiveManifest {
archive_id: "archive:local".to_string(),
g_time: "t1".to_string(),
files: vec![
ArchiveFileEntry { path: "f1.txt".to_string(), sha256: "hash1".to_string(), size: 10, mode: 0o644 },
ArchiveFileEntry { path: "f2.txt".to_string(), sha256: "hash2".to_string(), size: 20, mode: 0o644 },
],
top_level_vcard_hash: None,
archiver_did: None,
compression: None,
};
let manifest_peer = ArchiveManifest {
archive_id: "archive:peer".to_string(),
g_time: "t2".to_string(),
files: vec![
ArchiveFileEntry { path: "f1.txt".to_string(), sha256: "hash1".to_string(), size: 10, mode: 0o644 },
ArchiveFileEntry { path: "f3.txt".to_string(), sha256: "hash3".to_string(), size: 30, mode: 0o644 },
],
top_level_vcard_hash: None,
archiver_did: None,
compression: None,
};
let delta = compute_manifest_delta(&manifest_local, &manifest_peer);
assert_eq!(delta.len(), 1);
assert_eq!(delta[0].path, "f3.txt");
assert_eq!(delta[0].sha256, "hash3");
}
}