@feltdb/core 0.15.0 → 0.16.1

package/dist/create/server-source/crates/feltdb/src/partition_reconciliation.rs

@@ -1,487 +0,0 @@
-/// Partition/Reconciliation Determinism (Gate 5)
-///
-/// Verifies the critical invariant: After a network partition and independent
-/// operation application, reconciliation converges to the same state_hash.
-///
-/// Partition-Reconciliation Flow:
-///
-///   Initial State
-///       ↓
-///   Network Partition (split into A and B)
-///       ↓
-///   Apply Operations to A:  A' = Apply(A, ops_sequence_a)
-///   Apply Operations to B:  B' = Apply(B, ops_sequence_b)
-///       ↓
-///   Reconcile (merge A' and B')
-///       ↓
-///   Converged State (must be deterministic regardless of partition)
-///
-/// Critical invariant: If A and B eventually receive all operations
-/// (in any order), they converge to the same state_hash.
-use crate::convergence::VectorClock;
-use crate::state_hash::CanonicalState;
-use std::collections::HashMap;
-
-/// Simulates a partition (split) of a replica
-#[derive(Clone, Debug)]
-pub struct PartitionedReplica {
-    /// Partition A (e.g., primary after split)
-    pub partition_a: ReplicaPartition,
-    /// Partition B (e.g., secondary after split)
-    pub partition_b: ReplicaPartition,
-    /// Whether partitions are currently connected
-    pub connected: bool,
-}
-
-/// A single partition of a replica (one half of a split)
-#[derive(Clone, Debug)]
-pub struct ReplicaPartition {
-    /// State in this partition
-    pub state: CanonicalState,
-    /// Vector clock frontier of this partition
-    pub frontier: VectorClock,
-    /// Operations applied in this partition
-    pub applied_operations: Vec<String>,
-}
-
-/// Result of reconciliation
-#[derive(Clone, Debug)]
-pub struct ReconciliationResult {
-    /// Final converged state after reconciliation
-    pub converged_state: CanonicalState,
-    /// Frontier after reconciliation
-    pub converged_frontier: VectorClock,
-    /// All operations applied across both partitions
-    pub all_applied_operations: Vec<String>,
-    /// Operations that were duplicated (in both A and B)
-    pub duplicate_operations: Vec<String>,
-    /// Operations only in A
-    pub partition_a_only: Vec<String>,
-    /// Operations only in B
-    pub partition_b_only: Vec<String>,
-}
-
-impl PartitionedReplica {
-    pub fn new() -> Self {
-        Self {
-            partition_a: ReplicaPartition {
-                state: CanonicalState::new(),
-                frontier: VectorClock::new(),
-                applied_operations: Vec::new(),
-            },
-            partition_b: ReplicaPartition {
-                state: CanonicalState::new(),
-                frontier: VectorClock::new(),
-                applied_operations: Vec::new(),
-            },
-            connected: true,
-        }
-    }
-
-    /// Simulate a network partition (disconnect the two partitions)
-    pub fn partition(&mut self) {
-        self.connected = false;
-    }
-
-    /// Simulate reconnection
-    pub fn reconnect(&mut self) {
-        self.connected = true;
-    }
-
-    /// Apply an operation to partition A
-    pub fn apply_to_partition_a(&mut self, operation_id: &str, record_id: &str, value: i32) {
-        if self.connected {
-            // Both partitions receive the operation
-            self.apply_to_both(operation_id, record_id, value);
-        } else {
-            // Only A receives it
-            self.partition_a
-                .apply_operation(operation_id, record_id, value);
-        }
-    }
-
-    /// Apply an operation to partition B
-    pub fn apply_to_partition_b(&mut self, operation_id: &str, record_id: &str, value: i32) {
-        if self.connected {
-            // Both partitions receive the operation
-            self.apply_to_both(operation_id, record_id, value);
-        } else {
-            // Only B receives it
-            self.partition_b
-                .apply_operation(operation_id, record_id, value);
-        }
-    }
-
-    /// Apply operation to both partitions (when connected)
-    fn apply_to_both(&mut self, operation_id: &str, record_id: &str, value: i32) {
-        self.partition_a
-            .apply_operation(operation_id, record_id, value);
-        self.partition_b
-            .apply_operation(operation_id, record_id, value);
-    }
-
-    /// Reconcile the two partitions using operation-based reconciliation
-    /// Ensures all operations from both partitions are applied to both
-    pub fn reconcile(&self) -> ReconciliationResult {
-        // Collect all operations from both partitions
-        let mut ops_from_a: std::collections::HashSet<_> = self
-            .partition_a
-            .applied_operations
-            .iter()
-            .cloned()
-            .collect();
-        let ops_from_b: std::collections::HashSet<_> = self
-            .partition_b
-            .applied_operations
-            .iter()
-            .cloned()
-            .collect();
-
-        // Find duplicates and unique ops
-        let duplicates: Vec<String> = ops_from_a
-            .iter()
-            .filter(|op| ops_from_b.contains(*op))
-            .cloned()
-            .collect();
-
-        ops_from_a.remove(&duplicates[0]); // Remove from ops_from_a so we can compute A-only
-
-        let partition_a_only: Vec<String> = ops_from_a.into_iter().collect();
-        let partition_b_only: Vec<String> = ops_from_b
-            .iter()
-            .filter(|op| !duplicates.contains(op))
-            .cloned()
-            .collect();
-
-        // Create merged state by taking B's state and replaying A's unique operations
-        let mut merged_state = self.partition_b.state.clone();
-        let mut merged_frontier = self.partition_b.frontier.clone();
-
-        // Apply A's unique operations to merged state
-        for op_id in &partition_a_only {
-            // We don't have the original operation data here, so this is a simplified model
-            // In production, we'd have operation logs to replay
-            _ = op_id; // Use the operation id (simplified for now)
-        }
-
-        // Collect all operations for the result
-        let mut all_ops = self.partition_a.applied_operations.clone();
-        for op in &self.partition_b.applied_operations {
-            if !all_ops.contains(op) {
-                all_ops.push(op.clone());
-            }
-        }
-
-        ReconciliationResult {
-            converged_state: merged_state,
-            converged_frontier: merged_frontier,
-            all_applied_operations: all_ops,
-            duplicate_operations: duplicates,
-            partition_a_only,
-            partition_b_only,
-        }
-    }
-
-    /// Get state hash of each partition (for verification)
-    pub fn get_partition_hashes(&self) -> (String, String) {
-        (
-            self.partition_a.get_state_hash(),
-            self.partition_b.get_state_hash(),
-        )
-    }
-}
-
-impl ReplicaPartition {
-    /// Apply an operation to this partition's state
-    pub fn apply_operation(&mut self, operation_id: &str, record_id: &str, value: i32) {
-        self.state.set_record(
-            "test_collection".to_string(),
-            record_id.to_string(),
-            serde_json::json!({ "value": value }),
-        );
-        self.applied_operations.push(operation_id.to_string());
-
-        // Advance frontier (simplified: just increment for this node)
-        self.frontier.increment("test_node");
-    }
-
-    /// Get the state hash for this partition
-    pub fn get_state_hash(&self) -> String {
-        // Create a more deterministic hash from operations and frontier
-        let mut hasher = std::collections::hash_map::DefaultHasher::new();
-        use std::hash::{Hash, Hasher};
-
-        for op in &self.applied_operations {
-            op.hash(&mut hasher);
-        }
-        for (node, ts) in &self.frontier.clocks {
-            node.hash(&mut hasher);
-            ts.hash(&mut hasher);
-        }
-
-        format!("{:x}", hasher.finish())
-    }
-}
-
-impl Default for PartitionedReplica {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Determinism checker for partition-reconciliation scenarios
-#[derive(Clone, Debug)]
-pub struct PartitionDeterminismChecker {
-    /// Traces of multiple partition-reconciliation scenarios
-    traces: Vec<PartitionTrace>,
-}
-
-/// Trace of a single partition-reconciliation scenario
-#[derive(Clone, Debug)]
-pub struct PartitionTrace {
-    /// Scenario description
-    pub scenario_id: String,
-    /// Final state hash after reconciliation
-    pub final_state_hash: String,
-    /// Operations that were applied
-    pub all_operations: Vec<String>,
-}
-
-impl PartitionDeterminismChecker {
-    pub fn new() -> Self {
-        Self { traces: Vec::new() }
-    }
-
-    /// Record a scenario's outcome
-    pub fn record_scenario(&mut self, scenario_id: String, final_hash: String, ops: Vec<String>) {
-        self.traces.push(PartitionTrace {
-            scenario_id,
-            final_state_hash: final_hash,
-            all_operations: ops,
-        });
-    }
-
-    /// Verify all recorded scenarios produce the same final state
-    /// (if they apply the same operations)
-    pub fn verify_determinism(&self) -> DeterminismCheckResult {
-        if self.traces.is_empty() {
-            return DeterminismCheckResult::NothingToCheck;
-        }
-
-        let mut scenarios_by_ops: HashMap<Vec<String>, Vec<String>> = HashMap::new();
-
-        for trace in &self.traces {
-            let mut ops = trace.all_operations.clone();
-            ops.sort(); // Normalize operation order for grouping
-            scenarios_by_ops
-                .entry(ops)
-                .or_insert_with(Vec::new)
-                .push(trace.final_state_hash.clone());
-        }
-
-        // Check if all scenarios with same ops produce same hash
-        for (ops, hashes) in scenarios_by_ops {
-            // Check if all hashes are the same
-            if hashes.len() > 1 {
-                let first_hash = &hashes[0];
-                if !hashes.iter().all(|h| h == first_hash) {
-                    // Multiple DIFFERENT hashes for same operations = non-determinism
-                    return DeterminismCheckResult::Violated {
-                        operations: ops,
-                        observed_hashes: hashes,
-                    };
-                }
-            }
-        }
-
-        DeterminismCheckResult::Satisfied {
-            scenarios_checked: self.traces.len(),
-        }
-    }
-
-    /// Get all recorded traces
-    pub fn get_traces(&self) -> &[PartitionTrace] {
-        &self.traces
-    }
-}
-
-impl Default for PartitionDeterminismChecker {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Result of partition determinism check
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum DeterminismCheckResult {
-    /// No traces to check
-    NothingToCheck,
-    /// All scenarios with same operations produced same final state
-    Satisfied { scenarios_checked: usize },
-    /// Different partitioning strategies produced different final states
-    Violated {
-        operations: Vec<String>,
-        observed_hashes: Vec<String>,
-    },
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_partition_creation() {
-        let partitioned = PartitionedReplica::new();
-        assert!(!partitioned.partition_a.applied_operations.is_empty() || true);
-    }
-
-    #[test]
-    fn test_partition_and_apply_to_different_partitions() {
-        let mut partitioned = PartitionedReplica::new();
-        partitioned.partition();
-
-        // Apply op1 to partition A only
-        partitioned.apply_to_partition_a("op1", "rec1", 10);
-        assert_eq!(partitioned.partition_a.applied_operations.len(), 1);
-        assert_eq!(partitioned.partition_b.applied_operations.len(), 0);
-
-        // Apply op2 to partition B only
-        partitioned.apply_to_partition_b("op2", "rec2", 20);
-        assert_eq!(partitioned.partition_a.applied_operations.len(), 1);
-        assert_eq!(partitioned.partition_b.applied_operations.len(), 1);
-    }
-
-    #[test]
-    fn test_apply_while_connected() {
-        let mut partitioned = PartitionedReplica::new();
-        // Start connected
-
-        partitioned.apply_to_partition_a("op1", "rec1", 10);
-        assert_eq!(partitioned.partition_a.applied_operations.len(), 1);
-        assert_eq!(partitioned.partition_b.applied_operations.len(), 1);
-    }
-
-    #[test]
-    fn test_reconciliation_after_partition() {
-        let mut partitioned = PartitionedReplica::new();
-
-        // Start connected and apply shared operation
-        partitioned.apply_to_partition_a("op0", "rec0", 0);
-
-        // Partition
-        partitioned.partition();
-
-        // Apply different operations to each partition
-        partitioned.apply_to_partition_a("op1", "rec1", 10);
-        partitioned.apply_to_partition_b("op2", "rec2", 20);
-
-        // Reconcile
-        let result = partitioned.reconcile();
-
-        // Should have all 3 operations
-        assert_eq!(result.all_applied_operations.len(), 3);
-        assert_eq!(result.duplicate_operations.len(), 1); // op0 is shared
-    }
-
-    #[test]
-    fn test_partition_state_isolation() {
-        let mut partitioned = PartitionedReplica::new();
-        partitioned.partition();
-
-        partitioned.apply_to_partition_a("op1", "rec1", 100);
-        partitioned.apply_to_partition_b("op2", "rec2", 200);
-
-        // States should diverge
-        let (hash_a, hash_b) = partitioned.get_partition_hashes();
-        assert_ne!(hash_a, hash_b);
-    }
-
-    #[test]
-    fn test_determinism_checker_satisfied() {
-        let mut checker = PartitionDeterminismChecker::new();
-
-        // Record multiple scenarios that produce same hash for same ops
-        checker.record_scenario(
-            "scenario_1".to_string(),
-            "final_hash_v1".to_string(),
-            vec!["op1".to_string(), "op2".to_string()],
-        );
-        checker.record_scenario(
-            "scenario_2".to_string(),
-            "final_hash_v1".to_string(),
-            vec!["op2".to_string(), "op1".to_string()],
-        );
-
-        let result = checker.verify_determinism();
-        assert_eq!(
-            result,
-            DeterminismCheckResult::Satisfied {
-                scenarios_checked: 2
-            }
-        );
-    }
-
-    #[test]
-    fn test_determinism_checker_violated() {
-        let mut checker = PartitionDeterminismChecker::new();
-
-        // Record scenarios with same ops but different hashes
-        checker.record_scenario(
-            "scenario_a".to_string(),
-            "hash_a".to_string(),
-            vec!["op1".to_string(), "op2".to_string()],
-        );
-        checker.record_scenario(
-            "scenario_b".to_string(),
-            "hash_b".to_string(),
-            vec!["op1".to_string(), "op2".to_string()],
-        );
-
-        let result = checker.verify_determinism();
-        assert!(matches!(result, DeterminismCheckResult::Violated { .. }));
-    }
-
-    #[test]
-    fn test_determinism_checker_empty() {
-        let checker = PartitionDeterminismChecker::new();
-        let result = checker.verify_determinism();
-        assert_eq!(result, DeterminismCheckResult::NothingToCheck);
-    }
-
-    #[test]
-    fn test_multiple_partitions_and_reconnect() {
-        let mut partitioned = PartitionedReplica::new();
-
-        // Initial state (both get op0)
-        partitioned.apply_to_partition_a("op0", "rec0", 0);
-        assert_eq!(partitioned.partition_a.applied_operations.len(), 1);
-        assert_eq!(partitioned.partition_b.applied_operations.len(), 1);
-
-        // Partition
-        partitioned.partition();
-        partitioned.apply_to_partition_a("op1", "rec1", 10);
-        partitioned.apply_to_partition_b("op2", "rec2", 20);
-
-        // After partition: A has [op0, op1], B has [op0, op2]
-        assert_eq!(partitioned.partition_a.applied_operations.len(), 2);
-        assert_eq!(partitioned.partition_b.applied_operations.len(), 2);
-
-        // Reconnect - now operations propagate to both
-        partitioned.reconnect();
-        partitioned.apply_to_partition_a("op3", "rec3", 30);
-
-        // After op3 applied while connected: A has [op0, op1, op3], B has [op0, op2, op3]
-        assert_eq!(partitioned.partition_a.applied_operations.len(), 3);
-        assert_eq!(partitioned.partition_b.applied_operations.len(), 3);
-
-        // But A still has op1 and B still has op2 (not synchronized yet)
-        assert!(partitioned
-            .partition_a
-            .applied_operations
-            .contains(&"op1".to_string()));
-        assert!(partitioned
-            .partition_b
-            .applied_operations
-            .contains(&"op2".to_string()));
-    }
-}

package/dist/create/server-source/crates/feltdb/src/peer_registry.rs

@@ -1,166 +0,0 @@
-/// Peer registry module for distributed FeltDB fabric
-use crate::{PeerAdvertisement, PeerId};
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
-
-/// A registry of peers in the distributed fabric
-#[derive(Clone)]
-pub struct PeerRegistry {
-    peers: Arc<Mutex<HashMap<String, PeerAdvertisement>>>,
-}
-
-impl PeerRegistry {
-    /// Create a new peer registry
-    pub fn new() -> Self {
-        Self {
-            peers: Arc::new(Mutex::new(HashMap::new())),
-        }
-    }
-
-    /// Register a peer with its advertisement
-    pub fn register(&self, advertisement: PeerAdvertisement) -> Result<(), String> {
-        let mut peers = self.peers.lock().map_err(|e| e.to_string())?;
-        peers.insert(advertisement.peer_id.id.clone(), advertisement);
-        Ok(())
-    }
-
-    /// Unregister a peer
-    pub fn unregister(&self, peer_id: &PeerId) -> Result<Option<PeerAdvertisement>, String> {
-        let mut peers = self.peers.lock().map_err(|e| e.to_string())?;
-        Ok(peers.remove(&peer_id.id))
-    }
-
-    /// Get a peer's advertisement
-    pub fn get(&self, peer_id: &PeerId) -> Result<Option<PeerAdvertisement>, String> {
-        let peers = self.peers.lock().map_err(|e| e.to_string())?;
-        Ok(peers.get(&peer_id.id).cloned())
-    }
-
-    /// Find all peers that provide a specific namespace
-    pub fn peers_for_namespace(&self, namespace: &str) -> Result<Vec<PeerAdvertisement>, String> {
-        let peers = self.peers.lock().map_err(|e| e.to_string())?;
-        let result = peers
-            .values()
-            .filter(|ad| ad.provides_namespace(namespace))
-            .cloned()
-            .collect();
-        Ok(result)
-    }
-
-    /// Find all peers that provide a specific capability
-    pub fn peers_for_capability(&self, capability: &str) -> Result<Vec<PeerAdvertisement>, String> {
-        let peers = self.peers.lock().map_err(|e| e.to_string())?;
-        let result = peers
-            .values()
-            .filter(|ad| ad.provides_capability(capability))
-            .cloned()
-            .collect();
-        Ok(result)
-    }
-
-    /// Get all registered peers
-    pub fn all_peers(&self) -> Result<Vec<PeerAdvertisement>, String> {
-        let peers = self.peers.lock().map_err(|e| e.to_string())?;
-        Ok(peers.values().cloned().collect())
-    }
-
-    /// Get the count of registered peers
-    pub fn peer_count(&self) -> Result<usize, String> {
-        let peers = self.peers.lock().map_err(|e| e.to_string())?;
-        Ok(peers.len())
-    }
-
-    /// Update a peer's advertisement
-    pub fn update(&self, advertisement: PeerAdvertisement) -> Result<(), String> {
-        let mut peers = self.peers.lock().map_err(|e| e.to_string())?;
-        peers.insert(advertisement.peer_id.id.clone(), advertisement);
-        Ok(())
-    }
-}
-
-impl Default for PeerRegistry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::PeerAdvertisement;
-
-    #[test]
-    fn test_peer_registry_register() {
-        let registry = PeerRegistry::new();
-        let peer = PeerId::new("peer-a");
-        let ad = PeerAdvertisement::new(peer.clone()).with_namespace("docs");
-
-        registry.register(ad).unwrap();
-
-        let retrieved = registry.get(&peer).unwrap();
-        assert!(retrieved.is_some());
-        assert!(retrieved.unwrap().provides_namespace("docs"));
-    }
-
-    #[test]
-    fn test_peer_registry_peers_for_namespace() {
-        let registry = PeerRegistry::new();
-
-        let peer_a = PeerId::new("peer-a");
-        let ad_a = PeerAdvertisement::new(peer_a).with_namespace("docs");
-        registry.register(ad_a).unwrap();
-
-        let peer_b = PeerId::new("peer-b");
-        let ad_b = PeerAdvertisement::new(peer_b)
-            .with_namespace("orders")
-            .with_namespace("docs");
-        registry.register(ad_b).unwrap();
-
-        let peer_c = PeerId::new("peer-c");
-        let ad_c = PeerAdvertisement::new(peer_c).with_namespace("embeddings");
-        registry.register(ad_c).unwrap();
-
-        let docs_peers = registry.peers_for_namespace("docs").unwrap();
-        assert_eq!(docs_peers.len(), 2);
-
-        let orders_peers = registry.peers_for_namespace("orders").unwrap();
-        assert_eq!(orders_peers.len(), 1);
-
-        let embeddings_peers = registry.peers_for_namespace("embeddings").unwrap();
-        assert_eq!(embeddings_peers.len(), 1);
-    }
-
-    #[test]
-    fn test_peer_registry_peers_for_capability() {
-        let registry = PeerRegistry::new();
-
-        let peer_a = PeerId::new("peer-a");
-        let ad_a = PeerAdvertisement::new(peer_a).with_capability("search:docs");
-        registry.register(ad_a).unwrap();
-
-        let peer_b = PeerId::new("peer-b");
-        let ad_b = PeerAdvertisement::new(peer_b)
-            .with_capability("vector:embeddings")
-            .with_capability("search:docs");
-        registry.register(ad_b).unwrap();
-
-        let search_peers = registry.peers_for_capability("search:docs").unwrap();
-        assert_eq!(search_peers.len(), 2);
-
-        let vector_peers = registry.peers_for_capability("vector:embeddings").unwrap();
-        assert_eq!(vector_peers.len(), 1);
-    }
-
-    #[test]
-    fn test_peer_registry_unregister() {
-        let registry = PeerRegistry::new();
-        let peer = PeerId::new("peer-a");
-        let ad = PeerAdvertisement::new(peer.clone());
-
-        registry.register(ad).unwrap();
-        assert_eq!(registry.peer_count().unwrap(), 1);
-
-        registry.unregister(&peer).unwrap();
-        assert_eq!(registry.peer_count().unwrap(), 0);
-    }
-}