@feltdb/core 0.8.3 → 0.8.5

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

@@ -13,7 +13,7 @@ mod tests {
     use crate::distributed_transactions::TransactionEnvelope;
     use crate::durable_operation_log::OperationLog;
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyLevel, ConsistencyContract};
+    use crate::transactions::{ConsistencyContract, ConsistencyLevel};
     use tempfile::TempDir;
 
     fn create_test_envelope(node: &str, sequence: u64) -> TransactionEnvelope {
@@ -68,8 +68,7 @@ mod tests {
     /// 2. Recover log from disk
     /// 3. Verify all 3 recovered in order
     #[test]
-    fn test_durable_log_multiple_envelopes_in_order(
-    ) -> Result<(), Box<dyn std::error::Error>> {
+    fn test_durable_log_multiple_envelopes_in_order() -> Result<(), Box<dyn std::error::Error>> {
         let temp_dir = TempDir::new()?;
         let log_path = temp_dir.path().join("operations.log");
 
@@ -89,8 +88,11 @@ mod tests {
 
             assert_eq!(loaded.len(), 3, "Should have recovered 3 envelopes");
             for (i, envelope) in loaded.iter().enumerate() {
-                assert_eq!(envelope.envelope_id.sequence, (i + 1) as u64,
-                    "Envelopes should be in order");
+                assert_eq!(
+                    envelope.envelope_id.sequence,
+                    (i + 1) as u64,
+                    "Envelopes should be in order"
+                );
             }
         }
 
@@ -110,7 +112,7 @@ mod tests {
 
         for seq in 1..=100 {
             let envelope = create_test_envelope("nodeA", seq);
-            log.append(&envelope)?;  // Each append must fsync
+            log.append(&envelope)?; // Each append must fsync
         }
 
         // Verify all 100 can be loaded (fsync guarantee)

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

@@ -13,7 +13,7 @@ mod tests {
     use crate::distributed_transactions::{DistributedTransactionExecutor, TransactionEnvelope};
     use crate::durable_dedup_set::DeduplicationSet;
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyLevel, ConsistencyContract};
+    use crate::transactions::{ConsistencyContract, ConsistencyLevel};
     use tempfile::TempDir;
 
     fn create_test_envelope(node: &str, sequence: u64) -> TransactionEnvelope {
@@ -79,12 +79,11 @@ mod tests {
 
         // Step 1 & 2: Create executor with log and simulate loading persisted state
         {
-            let executor =
-                DistributedTransactionExecutor::with_log(
-                    "nodeA".to_string(),
-                    StateHash::from_hex("state_v0".to_string()),
-                    Some(log_path.clone()),
-                )?;
+            let executor = DistributedTransactionExecutor::with_log(
+                "nodeA".to_string(),
+                StateHash::from_hex("state_v0".to_string()),
+                Some(log_path.clone()),
+            )?;
 
             // Verify executor has dedup set configured
             let node_id = executor.get_local_node_id();
@@ -93,12 +92,11 @@ mod tests {
 
         // Step 3: Create another executor and load from disk
         {
-            let mut executor =
-                DistributedTransactionExecutor::with_log(
-                    "nodeA".to_string(),
-                    StateHash::from_hex("state_v0".to_string()),
-                    Some(log_path.clone()),
-                )?;
+            let mut executor = DistributedTransactionExecutor::with_log(
+                "nodeA".to_string(),
+                StateHash::from_hex("state_v0".to_string()),
+                Some(log_path.clone()),
+            )?;
 
             // This should set up both operation log and dedup set
             let recovered = executor.load_from_disk(log_path)?;

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

@@ -144,12 +144,11 @@ mod tests {
         let log_path = temp_dir.path().join("operations.log");
 
         // Setup: Node A and B both have operations 1-3
-        let mut node_a =
-            DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let mut node_a = DistributedTransactionExecutor::with_log(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
 
         let node_b = DistributedTransactionExecutor::new(
             "nodeB".to_string(),
@@ -157,7 +156,10 @@ mod tests {
         );
 
         // Simulate: Both nodes have same state
-        node_a.register_replica("nodeB".to_string(), StateHash::from_hex("hash0".to_string()));
+        node_a.register_replica(
+            "nodeB".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         // Verify convergence
         assert!(node_a.check_convergence());
@@ -183,12 +185,11 @@ mod tests {
         let log_path = temp_dir.path().join("operations.log");
 
         // Setup: Node A (restarted, missing op), Node B (authoritative)
-        let mut node_a =
-            DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let mut node_a = DistributedTransactionExecutor::with_log(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
 
         let mut node_b = DistributedTransactionExecutor::new(
             "nodeB".to_string(),
@@ -196,8 +197,14 @@ mod tests {
         );
 
         // Register each other
-        node_a.register_replica("nodeB".to_string(), StateHash::from_hex("hash0".to_string()));
-        node_b.register_replica("nodeA".to_string(), StateHash::from_hex("hash0".to_string()));
+        node_a.register_replica(
+            "nodeB".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
+        node_b.register_replica(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         // Peer (B) has operation 1
         let missing_op = create_test_envelope("nodeB", 1);
@@ -222,20 +229,25 @@ mod tests {
         let temp_dir = TempDir::new()?;
         let log_path = temp_dir.path().join("operations.log");
 
-        let mut node_a =
-            DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let mut node_a = DistributedTransactionExecutor::with_log(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
 
         let mut node_b = DistributedTransactionExecutor::new(
             "nodeB".to_string(),
             StateHash::from_hex("hash0".to_string()),
         );
 
-        node_a.register_replica("nodeB".to_string(), StateHash::from_hex("hash0".to_string()));
-        node_b.register_replica("nodeA".to_string(), StateHash::from_hex("hash0".to_string()));
+        node_a.register_replica(
+            "nodeB".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
+        node_b.register_replica(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         // Peer has operations 1-5
         let missing_ops: Vec<_> = (1..=5)
@@ -261,12 +273,11 @@ mod tests {
         let temp_dir = TempDir::new()?;
         let log_path = temp_dir.path().join("operations.log");
 
-        let mut node_a =
-            DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let mut node_a = DistributedTransactionExecutor::with_log(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
 
         let node_b = DistributedTransactionExecutor::new(
             "nodeB".to_string(),
@@ -275,9 +286,7 @@ mod tests {
 
         // Pre-populate node_a's seen set to simulate prior durability
         let envelope = create_test_envelope("nodeB", 1);
-        node_a
-            .envelopes_seen
-            .insert(envelope.envelope_id.clone());
+        node_a.envelopes_seen.insert(envelope.envelope_id.clone());
 
         // Recovery tries to apply same envelope (duplicate)
         let mut recovery = RecoveryOrchestrator::new(node_a, "nodeB".to_string());
@@ -285,7 +294,10 @@ mod tests {
         recovery.apply_missing_operations(vec![envelope.clone()])?;
 
         // Should not error on duplicate—dedup handles it
-        assert!(recovery.executor.envelopes_seen.contains(&envelope.envelope_id));
+        assert!(recovery
+            .executor
+            .envelopes_seen
+            .contains(&envelope.envelope_id));
         recovery.finalize_recovery()?;
 
         assert_eq!(recovery.get_state(), RecoveryState::Ready);
@@ -303,12 +315,11 @@ mod tests {
         let log_path = temp_dir.path().join("operations.log");
 
         // First recovery attempt (simulated interruption)
-        let node_a_attempt1 =
-            DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let node_a_attempt1 = DistributedTransactionExecutor::with_log(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
 
         let node_b = DistributedTransactionExecutor::new(
             "nodeB".to_string(),
@@ -325,12 +336,11 @@ mod tests {
         recovery1.apply_missing_operations(ops[0..2].to_vec())?;
 
         // Second recovery attempt (after restart)
-        let mut node_a_attempt2 =
-            DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let mut node_a_attempt2 = DistributedTransactionExecutor::with_log(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
         node_a_attempt2
             .envelopes_seen
             .extend(recovery1.executor.envelopes_seen.clone());
@@ -355,12 +365,11 @@ mod tests {
         let temp_dir = TempDir::new()?;
         let log_path = temp_dir.path().join("operations.log");
 
-        let node_a =
-            DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let node_a = DistributedTransactionExecutor::with_log(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
 
         // No peer available - simulate peer_state being unavailable
         let mut recovery = RecoveryOrchestrator::new(node_a, "unavailable_peer".to_string());
@@ -398,16 +407,18 @@ mod tests {
         );
 
         // Create restarted node with same initial hash
-        let mut local =
-            DistributedTransactionExecutor::with_log(
-                "local".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let mut local = DistributedTransactionExecutor::with_log(
+            "local".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
 
         // Register each other with same state
         local.register_replica("peer".to_string(), StateHash::from_hex("hash0".to_string()));
-        peer.register_replica("local".to_string(), StateHash::from_hex("hash0".to_string()));
+        peer.register_replica(
+            "local".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         // Reconcile: Both have same state
         let mut recovery = RecoveryOrchestrator::new(local, "peer".to_string());
@@ -439,24 +450,22 @@ mod tests {
 
         // Phase 1: Initial execution and persistence
         {
-            let executor =
-                DistributedTransactionExecutor::with_log(
-                    "nodeA".to_string(),
-                    StateHash::from_hex("hash0".to_string()),
-                    Some(log_path.clone()),
-                )?;
+            let executor = DistributedTransactionExecutor::with_log(
+                "nodeA".to_string(),
+                StateHash::from_hex("hash0".to_string()),
+                Some(log_path.clone()),
+            )?;
 
             let _node_id = executor.get_local_node_id();
             assert_eq!(_node_id, "nodeA");
         }
 
         // Phase 2: "Crash" and restart
-        let mut recovered_executor =
-            DistributedTransactionExecutor::with_log(
-                "nodeA".to_string(),
-                StateHash::from_hex("hash0".to_string()),
-                Some(log_path.clone()),
-            )?;
+        let mut recovered_executor = DistributedTransactionExecutor::with_log(
+            "nodeA".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+            Some(log_path.clone()),
+        )?;
 
         // Phase 3: Load from disk (reconstruct dedup from operation log)
         let count = recovered_executor.load_from_disk(log_path)?;
@@ -468,8 +477,17 @@ mod tests {
             StateHash::from_hex("hash0".to_string()),
         );
 
-        recovered_executor
-            .register_replica("nodeB".to_string(), StateHash::from_hex("hash0".to_string()));
+        // The peer is registered at the state the recovered node actually
+        // holds, read back rather than restated. `load_from_disk` recomputes
+        // the local replica's hash from the replayed log, so a fabricated
+        // literal here would describe a peer that has diverged and the
+        // convergence check below would be asserting the opposite of what this
+        // test is about.
+        let recovered_hash = recovered_executor
+            .get_replica_state("nodeA")
+            .expect("the recovered node has a local replica")
+            .state_hash;
+        recovered_executor.register_replica("nodeB".to_string(), recovered_hash);
 
         let mut recovery = RecoveryOrchestrator::new(recovered_executor, "nodeB".to_string());
         recovery.reconcile_with_peer(&peer)?;

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

@@ -9,10 +9,10 @@
 
 #[cfg(test)]
 mod tests {
-    use crate::durable_operation_log::OperationLog;
     use crate::distributed_transactions::TransactionEnvelope;
+    use crate::durable_operation_log::OperationLog;
     use crate::state_hash::StateHash;
-    use crate::transactions::{ConsistencyLevel, ConsistencyContract};
+    use crate::transactions::{ConsistencyContract, ConsistencyLevel};
     use tempfile::TempDir;
 
     fn create_test_envelope(node: &str, sequence: u64) -> TransactionEnvelope {
@@ -95,7 +95,7 @@ mod tests {
             let mut log = OperationLog::new(&log_path)?;
             let envelope = create_test_envelope("nodeA", 1);
             log.append(&envelope)?; // fsync ensures this is durable
-            // ... hypothetical crash here ...
+                                    // ... hypothetical crash here ...
         }
 
         // Scenario B: Restart and recover

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

@@ -66,8 +66,15 @@ mod tests {
 
         // Verify all standard operations are registered
         let standard_ops = vec![
-            "SetField", "Increment", "AddToSet", "RemoveFromSet", "Create", "Delete", "Transfer",
-            "Append", "Noop",
+            "SetField",
+            "Increment",
+            "AddToSet",
+            "RemoveFromSet",
+            "Create",
+            "Delete",
+            "Transfer",
+            "Append",
+            "Noop",
         ];
 
         for op_type in &standard_ops {
@@ -125,7 +132,10 @@ mod tests {
             create_test_operation(3, "records", "rec3", 30),
         ];
         let schedules = PermutationScheduler::minimal_schedules(&ops);
-        println!("Gate 1: Generated {} permutation schedules", schedules.len());
+        println!(
+            "Gate 1: Generated {} permutation schedules",
+            schedules.len()
+        );
 
         // Integration insight:
         // - Gate 1 creates permutations
@@ -148,11 +158,14 @@ mod tests {
             "Increment should be commutative"
         );
         assert_eq!(
-            increment_algebra.merge_function_description, "Counter CRDT: sum(all_increments)"
+            increment_algebra.merge_function_description,
+            "Counter CRDT: sum(all_increments)"
         );
 
-        println!("✓ Increment declared as commutative (algebra: {})",
-                 increment_algebra.merge_function_description);
+        println!(
+            "✓ Increment declared as commutative (algebra: {})",
+            increment_algebra.merge_function_description
+        );
     }
 
     #[test]
@@ -165,7 +178,8 @@ mod tests {
         // SetField uses LWW (Last-Write-Wins) for determinism
         assert!(setfield_algebra.is_deterministic());
         assert_eq!(
-            setfield_algebra.merge_function_description, "LWW: max(timestamp, value)"
+            setfield_algebra.merge_function_description,
+            "LWW: max(timestamp, value)"
         );
 
         println!(
@@ -209,7 +223,9 @@ mod tests {
         // Test that convergence holds as operation count increases
         for op_count in [1, 3, 5, 10].iter() {
             let ops: Vec<_> = (1..=*op_count)
-                .map(|seq| create_test_operation(seq, "records", &format!("rec{}", seq), seq as i32 * 10))
+                .map(|seq| {
+                    create_test_operation(seq, "records", &format!("rec{}", seq), seq as i32 * 10)
+                })
                 .collect();
 
             let simulator = MultiNodeConvergenceSimulator::new(3);
@@ -263,8 +279,11 @@ mod tests {
         ];
         let simulator = MultiNodeConvergenceSimulator::new(3);
         let result = simulator.test_minimal_convergence(&ops);
-        println!("  ✓ {} nodes executed {} operations",
-                 result.node_results.len(), ops.len());
+        println!(
+            "  ✓ {} nodes executed {} operations",
+            result.node_results.len(),
+            ops.len()
+        );
         println!("  ✓ All converged to: {}", result.canonical_hash);
 
         println!("\nGate 2: Operation Algebra Declaration");
@@ -272,7 +291,10 @@ mod tests {
         let algebras = registry.all_algebras();
         println!("  ✓ {} operation types declared", algebras.len());
         for alg in algebras.iter().take(5) {
-            println!("    - {}: {:?}", alg.operation_type, alg.convergence_semantic);
+            println!(
+                "    - {}: {:?}",
+                alg.operation_type, alg.convergence_semantic
+            );
         }
 
         println!("\n✅ Phase 5 Foundation Established");

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

@@ -60,7 +60,10 @@ mod tests {
         // Gate 2: Increment is commutative
         let registry = OperationAlgebraRegistry::new();
         let increment_algebra = registry.get("Increment").unwrap();
-        assert!(increment_algebra.is_commutative(), "Gate 2: Increment not commutative");
+        assert!(
+            increment_algebra.is_commutative(),
+            "Gate 2: Increment not commutative"
+        );
 
         println!(
             "✅ Scenario 1: Basic Convergence (Gates 1,2,4,6) - {} nodes converged to {}",
@@ -128,9 +131,7 @@ mod tests {
             crate::crash_atomic_boundary::InvariantCheckResult::Satisfied
         ));
 
-        println!(
-            "✅ Scenario 3: Exactly-Once with Crash (Gates 3,4) - invariant satisfied"
-        );
+        println!("✅ Scenario 3: Exactly-Once with Crash (Gates 3,4) - invariant satisfied");
     }
 
     #[test]
@@ -267,8 +268,7 @@ mod tests {
 
         let mut barrier = CausalDependencyBarrier::new();
         let op_empty = VectorClock::new();
-        let recv_result =
-            barrier.receive_operation("op1".to_string(), op_empty);
+        let recv_result = barrier.receive_operation("op1".to_string(), op_empty);
         assert!(matches!(
             recv_result,
             crate::causal_dependency_barrier::ReceiveResult::ReadyToApply { .. }

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

@@ -57,18 +57,9 @@ mod tests {
         assert_eq!(transport.receive(n4).len(), 1);
 
         // Gate 9: Partition n1 from {n2, n3, n4}
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n2,
-        });
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n3,
-        });
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n4,
-        });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n3 });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n4 });
 
         // n1 tries to send but gets dropped by partition
         transport.send(n1, n2, b"during_partition".to_vec());
@@ -83,18 +74,9 @@ mod tests {
         assert_eq!(transport.receive(n4).len(), 1);
 
         // Gate 9: Heal partition
-        transport.apply_fault(NetworkEvent::Heal {
-            from: n1,
-            to: n2,
-        });
-        transport.apply_fault(NetworkEvent::Heal {
-            from: n1,
-            to: n3,
-        });
-        transport.apply_fault(NetworkEvent::Heal {
-            from: n1,
-            to: n4,
-        });
+        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n2 });
+        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n3 });
+        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n4 });
 
         // Now all nodes can communicate again
         transport.send(n1, n2, b"after_heal".to_vec());
@@ -121,10 +103,7 @@ mod tests {
         assert_eq!(transport.receive(n3).len(), 1);
 
         // Gate 9: Create asymmetric partition (n1→n2 broken but n2→n1 ok)
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n2,
-        });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
 
         // n1 can't reach n2
         transport.send(n1, n2, b"blocked".to_vec());
@@ -429,10 +408,7 @@ mod tests {
         });
 
         // And partition n1 from n3
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n3,
-        });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n3 });
 
         // Byzantine messages from n2 still deliver
         transport.tick();
@@ -466,20 +442,11 @@ mod tests {
         assert_eq!(transport.receive(n3).len(), 1);
 
         // Round 2-4: Cascade of partitions
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n2,
-        });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
         transport.tick();
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n3,
-        });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n3 });
         transport.tick();
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n2,
-            to: n3,
-        });
+        transport.apply_fault(NetworkEvent::Partition { from: n2, to: n3 });
         transport.tick();
 
         // All nodes isolated
@@ -488,10 +455,7 @@ mod tests {
         assert_eq!(transport.receive(n2).len(), 0);
 
         // Round 5-7: Heal partitions one by one
-        transport.apply_fault(NetworkEvent::Heal {
-            from: n1,
-            to: n2,
-        });
+        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n2 });
         transport.tick();
 
         // n1 ↔ n2 now connected
@@ -499,10 +463,7 @@ mod tests {
         transport.tick();
         assert_eq!(transport.receive(n2).len(), 1);
 
-        transport.apply_fault(NetworkEvent::Heal {
-            from: n2,
-            to: n3,
-        });
+        transport.apply_fault(NetworkEvent::Heal { from: n2, to: n3 });
         transport.tick();
 
         // n2 ↔ n3 now connected
@@ -510,10 +471,7 @@ mod tests {
         transport.tick();
         assert_eq!(transport.receive(n3).len(), 1);
 
-        transport.apply_fault(NetworkEvent::Heal {
-            from: n1,
-            to: n3,
-        });
+        transport.apply_fault(NetworkEvent::Heal { from: n1, to: n3 });
         transport.tick();
 
         // All fully connected again