@feltdb/core 0.8.4 → 0.8.6

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

@@ -61,9 +61,17 @@ mod tests {
     /// Convergence validation result
     #[derive(Debug, PartialEq)]
     enum ConvergenceResult {
-        Converged { common_hash: String, rounds_needed: usize },
-        PartialConvergence { converged_nodes: Vec<NodeId>, diverged_nodes: Vec<NodeId> },
-        Diverged { hashes: HashMap<NodeId, String> },
+        Converged {
+            common_hash: String,
+            rounds_needed: usize,
+        },
+        PartialConvergence {
+            converged_nodes: Vec<NodeId>,
+            diverged_nodes: Vec<NodeId>,
+        },
+        Diverged {
+            hashes: HashMap<NodeId, String>,
+        },
     }
 
     /// Execute operations on a replica set under adversarial transport
@@ -80,7 +88,10 @@ mod tests {
         for (op_idx, op) in operations.iter().enumerate() {
             // Originating node applies operation
             let origin = nodes[op_idx % nodes.len()];
-            replicas.get_mut(&origin).unwrap().apply_operation(op.clone());
+            replicas
+                .get_mut(&origin)
+                .unwrap()
+                .apply_operation(op.clone());
 
             // Broadcast to other nodes
             for &target in nodes.iter().filter(|n| **n != origin) {
@@ -106,8 +117,10 @@ mod tests {
         }
 
         // Check convergence: all nodes should have same hash
-        let hashes: HashMap<NodeId, String> =
-            replicas.iter().map(|(n, r)| (*n, r.hash().to_string())).collect();
+        let hashes: HashMap<NodeId, String> = replicas
+            .iter()
+            .map(|(n, r)| (*n, r.hash().to_string()))
+            .collect();
 
         let unique_hashes: HashSet<&String> = hashes.values().collect();
 
@@ -124,15 +137,16 @@ mod tests {
     #[test]
     fn test_convergence_validator_commutative_ops_mesh() {
         let nodes = vec![NodeId(1), NodeId(2), NodeId(3)];
-        let ops = vec!["add:1".to_string(), "add:2".to_string(), "add:3".to_string()];
+        let ops = vec![
+            "add:1".to_string(),
+            "add:2".to_string(),
+            "add:3".to_string(),
+        ];
         let faults = vec![];
 
         let result = validate_convergence(nodes, ops, faults);
 
-        assert!(matches!(
-            result,
-            ConvergenceResult::Converged { .. }
-        ));
+        assert!(matches!(result, ConvergenceResult::Converged { .. }));
         println!("✅ Test 1: Commutative operations converged");
     }
 
@@ -150,10 +164,7 @@ mod tests {
         let result = validate_convergence(nodes, ops, faults);
 
         // Last write wins should be deterministic
-        assert!(matches!(
-            result,
-            ConvergenceResult::Converged { .. }
-        ));
+        assert!(matches!(result, ConvergenceResult::Converged { .. }));
         println!("✅ Test 2: Deterministic merge operations converged");
     }
 
@@ -190,10 +201,7 @@ mod tests {
 
         let result = validate_convergence(nodes, ops, faults);
 
-        assert!(matches!(
-            result,
-            ConvergenceResult::Converged { .. }
-        ));
+        assert!(matches!(result, ConvergenceResult::Converged { .. }));
         println!("✅ Test 3: Convergence after partition healing verified");
     }
 
@@ -212,10 +220,7 @@ mod tests {
         let result = validate_convergence(nodes, ops, faults);
 
         // In correct implementation, should converge
-        assert!(matches!(
-            result,
-            ConvergenceResult::Converged { .. }
-        ));
+        assert!(matches!(result, ConvergenceResult::Converged { .. }));
         println!("✅ Test 4: Convergence validator detection verified");
     }
 
@@ -306,10 +311,7 @@ mod tests {
         let result = validate_convergence(nodes, operations, faults);
 
         // Should converge despite many faults
-        assert!(matches!(
-            result,
-            ConvergenceResult::Converged { .. }
-        ));
+        assert!(matches!(result, ConvergenceResult::Converged { .. }));
         println!("✅ Test 7: No silent divergence under faults verified");
     }
 

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

@@ -6,11 +6,10 @@
 #[cfg(test)]
 mod tests {
     use crate::causal_dependency_barrier::CausalDependencyBarrier;
-    use crate::consistency_contract::{ConsistencyContractEnforcer, CommutativeVerificationResult};
+    use crate::consistency_contract::{CommutativeVerificationResult, ConsistencyContractEnforcer};
     use crate::convergence::VectorClock;
     use crate::persistence_reality::{
-        DurablePersistenceLayer, PersistenceCrashPoint, PersistenceContractVerifier,
-        RecoveryResult,
+        DurablePersistenceLayer, PersistenceContractVerifier, PersistenceCrashPoint, RecoveryResult,
     };
 
     #[test]
@@ -102,11 +101,15 @@ mod tests {
         let recovery = wal.recover();
 
         // Partition A's operation should survive
-        assert!(recovery.recovered_operations.contains(&"partition_a_op1".to_string()));
+        assert!(recovery
+            .recovered_operations
+            .contains(&"partition_a_op1".to_string()));
 
         // Partition B's operation was corrupted during crash
         // Should not silently appear in recovery
-        assert!(!recovery.recovered_operations.contains(&"partition_b_op1".to_string()));
+        assert!(!recovery
+            .recovered_operations
+            .contains(&"partition_b_op1".to_string()));
 
         println!("✅ Gates 5+7: Partition persistence verified");
     }
@@ -196,7 +199,9 @@ mod tests {
         );
 
         let recovery = wal.recover();
-        assert!(recovery.recovered_operations.contains(&"exactly_once_op".to_string()));
+        assert!(recovery
+            .recovered_operations
+            .contains(&"exactly_once_op".to_string()));
 
         // Critical: After recovery, duplicate application must be prevented
         let result = executor.apply_with_crash("exactly_once_op", "rec1", 99);
@@ -213,7 +218,10 @@ mod tests {
 
         // Gate 6: Record commutative operation
         let result = enforcer.verify_commutative("Increment", &[5, 10, 15]);
-        assert!(matches!(result, CommutativeVerificationResult::Satisfied { .. }));
+        assert!(matches!(
+            result,
+            CommutativeVerificationResult::Satisfied { .. }
+        ));
 
         // Gate 7: Simulate persistence
         let mut wal = DurablePersistenceLayer::new();
@@ -306,27 +314,37 @@ mod tests {
 
         let crash_points = vec![
             ("BeforeWrite", PersistenceCrashPoint::BeforeWrite),
-            ("AfterBufferBeforeFsync", PersistenceCrashPoint::AfterBufferBeforeFsync),
+            (
+                "AfterBufferBeforeFsync",
+                PersistenceCrashPoint::AfterBufferBeforeFsync,
+            ),
             ("DuringFsync", PersistenceCrashPoint::DuringFsync),
-            ("AfterFsyncBeforeReturn", PersistenceCrashPoint::AfterFsyncBeforeReturn),
-            ("AfterWriteReturns", PersistenceCrashPoint::AfterWriteReturns),
+            (
+                "AfterFsyncBeforeReturn",
+                PersistenceCrashPoint::AfterFsyncBeforeReturn,
+            ),
+            (
+                "AfterWriteReturns",
+                PersistenceCrashPoint::AfterWriteReturns,
+            ),
         ];
 
         let mut verifier = PersistenceContractVerifier::new();
 
         for (name, crash_point) in crash_points {
             let mut wal = DurablePersistenceLayer::new();
-            let result = wal.write_with_crash(
-                format!("op_{}", name),
-                vec![1, 2, 3],
-                crash_point,
-            );
+            let result = wal.write_with_crash(format!("op_{}", name), vec![1, 2, 3], crash_point);
 
             let recovery = wal.recover();
 
             // Only count as "written" if actually fsynced
-            let was_fsynced = matches!(result, crate::persistence_reality::WriteResult::Success { .. }) ||
-                matches!(result, crate::persistence_reality::WriteResult::Crashed { fsynced: true, .. });
+            let was_fsynced = matches!(
+                result,
+                crate::persistence_reality::WriteResult::Success { .. }
+            ) || matches!(
+                result,
+                crate::persistence_reality::WriteResult::Crashed { fsynced: true, .. }
+            );
 
             let written_count = if was_fsynced { 1 } else { 0 };
             let recovered_count = recovery.recovered_operations.len();

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

@@ -10,7 +10,9 @@ mod tests {
         DistributedTransactionExecutor, ReplicationMessage, TransactionEnvelope,
     };
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion};
+    use crate::transactions::{
+        ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion,
+    };
     use serde_json::json;
     use std::collections::HashMap;
     use std::sync::Arc;
@@ -131,7 +133,11 @@ mod tests {
         }
 
         /// Replicate a single operation from leader to all followers
-        fn replicate_operation(&self, envelope: TransactionEnvelope, seq: u64) -> Result<(), String> {
+        fn replicate_operation(
+            &self,
+            envelope: TransactionEnvelope,
+            seq: u64,
+        ) -> Result<(), String> {
             // Create replication message
             let message = ReplicationMessage::new(
                 envelope,

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

@@ -19,7 +19,9 @@ mod tests {
         DistributedTransactionExecutor, ReplicationMessage, TransactionEnvelope,
     };
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion};
+    use crate::transactions::{
+        ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion,
+    };
     use serde_json::json;
     use std::collections::HashMap;
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -161,15 +163,24 @@ mod tests {
         follower1.recover();
 
         // Follower1 can submit operations again
-        follower1.submit_operation(50).await.expect("recovery submit");
+        follower1
+            .submit_operation(50)
+            .await
+            .expect("recovery submit");
 
         let leader_ops = leader.operations_applied().await;
         let f1_ops = follower1.operations_applied().await;
         let f2_ops = follower2.operations_applied().await;
 
-        println!("Leader: {}, Follower1: {}, Follower2: {}", leader_ops, f1_ops, f2_ops);
+        println!(
+            "Leader: {}, Follower1: {}, Follower2: {}",
+            leader_ops, f1_ops, f2_ops
+        );
         assert_eq!(leader_ops, 50, "Leader should have 50 operations");
-        assert_eq!(f1_ops, 1, "Follower1 should have 1 operation after recovery");
+        assert_eq!(
+            f1_ops, 1,
+            "Follower1 should have 1 operation after recovery"
+        );
     }
 
     /// Phase 2a Test 2: Leader crash and recovery
@@ -192,7 +203,10 @@ mod tests {
         }
 
         let pre_crash_leader_ops = leader.operations_applied().await;
-        assert_eq!(pre_crash_leader_ops, 25, "Leader should have 25 pre-crash ops");
+        assert_eq!(
+            pre_crash_leader_ops, 25,
+            "Leader should have 25 pre-crash ops"
+        );
 
         // Crash leader
         leader.crash();
@@ -204,12 +218,18 @@ mod tests {
 
         // Leader can submit operations again
         for i in 25..50 {
-            leader.submit_operation(i).await.expect("leader post-recovery submit");
+            leader
+                .submit_operation(i)
+                .await
+                .expect("leader post-recovery submit");
         }
 
         let post_recovery_leader_ops = leader.operations_applied().await;
         println!("Post-recovery leader ops: {}", post_recovery_leader_ops);
-        assert_eq!(post_recovery_leader_ops, 50, "Leader should recover and accept new ops");
+        assert_eq!(
+            post_recovery_leader_ops, 50,
+            "Leader should recover and accept new ops"
+        );
     }
 
     /// Phase 2a Test 3: Concurrent crashes (leader + 1 follower)
@@ -236,7 +256,10 @@ mod tests {
         follower1.crash();
 
         // Only follower2 can operate
-        follower2.submit_operation(30).await.expect("follower2 operates during dual crash");
+        follower2
+            .submit_operation(30)
+            .await
+            .expect("follower2 operates during dual crash");
 
         // Recover both
         leader.recover();
@@ -244,14 +267,23 @@ mod tests {
 
         // All can operate again
         leader.submit_operation(30).await.expect("leader recovery");
-        follower1.submit_operation(31).await.expect("follower1 recovery");
-        follower2.submit_operation(32).await.expect("follower2 continues");
+        follower1
+            .submit_operation(31)
+            .await
+            .expect("follower1 recovery");
+        follower2
+            .submit_operation(32)
+            .await
+            .expect("follower2 continues");
 
         let leader_ops = leader.operations_applied().await;
         let f1_ops = follower1.operations_applied().await;
         let f2_ops = follower2.operations_applied().await;
 
-        println!("Post dual-crash - Leader: {}, F1: {}, F2: {}", leader_ops, f1_ops, f2_ops);
+        println!(
+            "Post dual-crash - Leader: {}, F1: {}, F2: {}",
+            leader_ops, f1_ops, f2_ops
+        );
         assert_eq!(leader_ops, 31, "Leader should recover");
         assert_eq!(f1_ops, 1, "Follower1 should recover");
         assert_eq!(f2_ops, 2, "Follower2 should continue");
@@ -281,13 +313,22 @@ mod tests {
 
             // Recover
             leader.recover();
-            leader.submit_operation(cycle * 100).await.expect("recovery submit");
+            leader
+                .submit_operation(cycle * 100)
+                .await
+                .expect("recovery submit");
 
             let post_recovery_ops = leader.operations_applied().await;
-            println!("Cycle {}: pre={}, post={}", cycle, pre_crash_ops, post_recovery_ops);
+            println!(
+                "Cycle {}: pre={}, post={}",
+                cycle, pre_crash_ops, post_recovery_ops
+            );
 
             // Should maintain state across crashes
-            assert!(post_recovery_ops > 0, "Should have operations after recovery");
+            assert!(
+                post_recovery_ops > 0,
+                "Should have operations after recovery"
+            );
         }
     }
 
@@ -322,7 +363,10 @@ mod tests {
 
         // Finish submitting
         for i in 10..20 {
-            leader.submit_operation(i).await.expect("post-recovery submit");
+            leader
+                .submit_operation(i)
+                .await
+                .expect("post-recovery submit");
         }
 
         let final_ops = leader.operations_applied().await;

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

@@ -20,7 +20,9 @@ mod tests {
         DistributedTransactionExecutor, ReplicationMessage, TransactionEnvelope,
     };
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion};
+    use crate::transactions::{
+        ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion,
+    };
     use serde_json::json;
     use std::collections::HashMap;
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -136,25 +138,49 @@ mod tests {
         }
 
         // Normal operation before partition
-        leader.submit_operation(0).await.expect("pre-partition submit");
-        assert_eq!(leader.operations_applied().await, 1, "Leader has 1 op pre-partition");
+        leader
+            .submit_operation(0)
+            .await
+            .expect("pre-partition submit");
+        assert_eq!(
+            leader.operations_applied().await,
+            1,
+            "Leader has 1 op pre-partition"
+        );
 
         // Partition leader
         leader.partition();
 
         // Followers can still operate independently
-        follower1.submit_operation(100).await.expect("follower1 operates");
-        follower2.submit_operation(200).await.expect("follower2 operates");
+        follower1
+            .submit_operation(100)
+            .await
+            .expect("follower1 operates");
+        follower2
+            .submit_operation(200)
+            .await
+            .expect("follower2 operates");
 
         // Leader isolated cannot reach followers
-        assert_eq!(leader.operations_applied().await, 1, "Leader still has 1 op");
+        assert_eq!(
+            leader.operations_applied().await,
+            1,
+            "Leader still has 1 op"
+        );
 
         // Heal partition
         leader.heal_partition();
 
         // Leader can operate again
-        leader.submit_operation(1).await.expect("post-partition submit");
-        assert_eq!(leader.operations_applied().await, 2, "Leader resumed after partition");
+        leader
+            .submit_operation(1)
+            .await
+            .expect("post-partition submit");
+        assert_eq!(
+            leader.operations_applied().await,
+            2,
+            "Leader resumed after partition"
+        );
 
         println!("Partition recovery successful");
     }
@@ -187,8 +213,14 @@ mod tests {
             }
         }
 
-        println!("Sent {} operations, {} successful deliveries", envelope_count, successful);
-        assert_eq!(successful, envelope_count, "Leader submits should all succeed locally");
+        println!(
+            "Sent {} operations, {} successful deliveries",
+            envelope_count, successful
+        );
+        assert_eq!(
+            successful, envelope_count,
+            "Leader submits should all succeed locally"
+        );
 
         // Test that operations persist despite loss
         let ops = leader.operations_applied().await;
@@ -231,8 +263,14 @@ mod tests {
 
         {
             let mut executor = leader.executor.lock().await;
-            executor.register_replica("slow_follower".to_string(), StateHash::from_hex("0".repeat(64)));
-            executor.register_replica("fast_follower".to_string(), StateHash::from_hex("0".repeat(64)));
+            executor.register_replica(
+                "slow_follower".to_string(),
+                StateHash::from_hex("0".repeat(64)),
+            );
+            executor.register_replica(
+                "fast_follower".to_string(),
+                StateHash::from_hex("0".repeat(64)),
+            );
         }
 
         // Leader submits 50 operations rapidly
@@ -245,11 +283,17 @@ mod tests {
 
         // Simulate slow node with delay (in production, this would be network latency)
         // Fast node catches up quickly
-        fast_follower.submit_operation(0).await.expect("fast follower");
+        fast_follower
+            .submit_operation(0)
+            .await
+            .expect("fast follower");
 
         // Slow node with simulated 1s delay would eventually catch up
         // For testing, we verify the mechanism works
-        slow_follower.submit_operation(0).await.expect("slow follower");
+        slow_follower
+            .submit_operation(0)
+            .await
+            .expect("slow follower");
 
         // Both followers should be able to process
         let fast_ops = fast_follower.operations_applied().await;
@@ -286,18 +330,27 @@ mod tests {
 
         // Follower1 (slow) eventually catches up
         for i in 0..30 {
-            follower1.submit_operation(1000 + i).await.expect("slow follower processes");
+            follower1
+                .submit_operation(1000 + i)
+                .await
+                .expect("slow follower processes");
         }
 
         // Heal follower2
         follower2.heal_partition();
-        follower2.submit_operation(2000).await.expect("follower2 recovers");
+        follower2
+            .submit_operation(2000)
+            .await
+            .expect("follower2 recovers");
 
         let leader_ops = leader.operations_applied().await;
         let f1_ops = follower1.operations_applied().await;
         let f2_ops = follower2.operations_applied().await;
 
-        println!("Combined issues - Leader: {}, F1: {}, F2: {}", leader_ops, f1_ops, f2_ops);
+        println!(
+            "Combined issues - Leader: {}, F1: {}, F2: {}",
+            leader_ops, f1_ops, f2_ops
+        );
 
         assert_eq!(leader_ops, 30, "Leader not affected by follower issues");
         assert_eq!(f1_ops, 30, "Slow follower recovered");

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

@@ -18,7 +18,9 @@ mod tests {
         DistributedTransactionExecutor, ReplicationMessage, TransactionEnvelope,
     };
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion};
+    use crate::transactions::{
+        ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion,
+    };
     use serde_json::json;
     use std::collections::HashMap;
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -204,7 +206,10 @@ mod tests {
         follower1.fail();
 
         // Follower2 is the last replica standing
-        follower2.submit_operation(100).await.expect("follower2 survives");
+        follower2
+            .submit_operation(100)
+            .await
+            .expect("follower2 survives");
 
         // Recovery
         leader.recover();
@@ -218,7 +223,10 @@ mod tests {
         let final_leader_ops = leader.operations_applied().await;
         let final_follower2_ops = follower2.operations_applied().await;
 
-        println!("Post-recovery: leader={}, follower2={}", final_leader_ops, final_follower2_ops);
+        println!(
+            "Post-recovery: leader={}, follower2={}",
+            final_leader_ops, final_follower2_ops
+        );
 
         assert_eq!(final_leader_ops, 50, "Leader recovered fully");
         assert_eq!(final_follower2_ops, 1, "Last replica survived");
@@ -234,8 +242,14 @@ mod tests {
         // All healthy, submit baseline
         for i in 0..10 {
             node_1.submit_operation(i).await.expect("node_1 baseline");
-            node_2.submit_operation(i + 100).await.expect("node_2 baseline");
-            node_3.submit_operation(i + 200).await.expect("node_3 baseline");
+            node_2
+                .submit_operation(i + 100)
+                .await
+                .expect("node_2 baseline");
+            node_3
+                .submit_operation(i + 200)
+                .await
+                .expect("node_3 baseline");
         }
 
         // Sequential cascade: failures propagate
@@ -257,7 +271,10 @@ mod tests {
         let ops_2 = node_2.operations_applied().await;
         let ops_3 = node_3.operations_applied().await;
 
-        println!("Sequential cascade recovery: N1={}, N2={}, N3={}", ops_1, ops_2, ops_3);
+        println!(
+            "Sequential cascade recovery: N1={}, N2={}, N3={}",
+            ops_1, ops_2, ops_3
+        );
 
         assert!(ops_1 > 0, "Node 1 recovered");
         assert!(ops_2 > 0, "Node 2 recovered");

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

@@ -16,7 +16,9 @@ mod tests {
         DistributedTransactionExecutor, ReplicationMessage, TransactionEnvelope,
     };
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion};
+    use crate::transactions::{
+        ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion,
+    };
     use serde_json::json;
     use std::collections::HashMap;
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -78,7 +80,11 @@ mod tests {
         }
 
         /// Submit operation if not crashed
-        fn submit_operation(&self, op_idx: u64, crash_point: CrashPoint) -> Result<TransactionEnvelope, String> {
+        fn submit_operation(
+            &self,
+            op_idx: u64,
+            crash_point: CrashPoint,
+        ) -> Result<TransactionEnvelope, String> {
             if self.is_crashed.load(Ordering::Relaxed) {
                 return Err("Node is crashed".to_string());
             }
@@ -375,7 +381,10 @@ mod tests {
             assert!(!result.data_loss);
             assert!(!result.divergence);
 
-            println!("✓ {:?}: {} operations, {} crashes", point, result.operations_tested, result.crashes);
+            println!(
+                "✓ {:?}: {} operations, {} crashes",
+                point, result.operations_tested, result.crashes
+            );
         }
     }