@feltdb/core 0.8.4 → 0.8.5

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

@@ -47,32 +47,22 @@ mod tests {
         let initial_state_hash = StateHash::from_hex("hash_initial".to_string());
 
         // Node A (Server)
-        let mut node_a_executor = DistributedTransactionExecutor::new(
-            "node_a".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut node_a_executor =
+            DistributedTransactionExecutor::new("node_a".to_string(), initial_state_hash.clone());
 
         let mut node_a_transport = TcpTransport::new("127.0.0.1:19020".to_string());
 
         // Register the peer with same initial state
-        node_a_executor.register_replica(
-            "node_b".to_string(),
-            initial_state_hash.clone(),
-        );
+        node_a_executor.register_replica("node_b".to_string(), initial_state_hash.clone());
 
         // Node B (Client)
-        let mut node_b_executor = DistributedTransactionExecutor::new(
-            "node_b".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut node_b_executor =
+            DistributedTransactionExecutor::new("node_b".to_string(), initial_state_hash.clone());
 
         let mut node_b_transport = TcpTransport::new("127.0.0.1:19021".to_string());
 
         // Register the peer with same initial state
-        node_b_executor.register_replica(
-            "node_a".to_string(),
-            initial_state_hash.clone(),
-        );
+        node_b_executor.register_replica("node_a".to_string(), initial_state_hash.clone());
 
         // ===== Start server listening in a separate task =====
         let server_transport = node_a_transport.clone();
@@ -131,21 +121,17 @@ mod tests {
 
         let envelope = node_a_executor
             .execute_local_transaction(
-                1,                          // sequence
-                "tx_1".to_string(),        // transaction_id
-                parent_version.clone(),    // parent_version
-                vec![op],                  // operations
+                1,                      // sequence
+                "tx_1".to_string(),     // transaction_id
+                parent_version.clone(), // parent_version
+                vec![op],               // operations
                 ConsistencyContract::local(),
             )
             .expect("execute_local_transaction on node_a");
 
         // ===== Node A sends ReplicationMessage to Node B =====
-        let replication_msg = ReplicationMessage::new(
-            envelope,
-            "node_a".to_string(),
-            "node_b".to_string(),
-            1,
-        );
+        let replication_msg =
+            ReplicationMessage::new(envelope, "node_a".to_string(), "node_b".to_string(), 1);
 
         node_a_transport
             .send(replication_msg)
@@ -156,10 +142,7 @@ mod tests {
         sleep(Duration::from_millis(200)).await;
 
         // ===== Node B receives ReplicationMessage =====
-        let received_messages = node_b_transport
-            .receive()
-            .await
-            .expect("receive on node_b");
+        let received_messages = node_b_transport.receive().await.expect("receive on node_b");
 
         assert_eq!(
             received_messages.len(),
@@ -247,9 +230,7 @@ mod tests {
                     if start.elapsed() > timeout {
                         panic!(
                             "{} startup read timeout after {:?}: got {:?}",
-                            node_name,
-                            timeout,
-                            line
+                            node_name, timeout, line
                         );
                     }
                     thread::sleep(Duration::from_millis(50));
@@ -387,19 +368,15 @@ mod tests {
         let initial_state_hash = StateHash::from_hex("hash_initial".to_string());
 
         // Node A (Server)
-        let mut node_a_executor = DistributedTransactionExecutor::new(
-            "node_a".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut node_a_executor =
+            DistributedTransactionExecutor::new("node_a".to_string(), initial_state_hash.clone());
         node_a_executor.register_replica("node_b".to_string(), initial_state_hash.clone());
 
         let mut node_a_transport = TcpTransport::new("127.0.0.1:19050".to_string());
 
         // Node B (Client)
-        let mut node_b_executor = DistributedTransactionExecutor::new(
-            "node_b".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut node_b_executor =
+            DistributedTransactionExecutor::new("node_b".to_string(), initial_state_hash.clone());
         node_b_executor.register_replica("node_a".to_string(), initial_state_hash.clone());
 
         let mut node_b_transport = TcpTransport::new("127.0.0.1:19051".to_string());
@@ -431,7 +408,10 @@ mod tests {
             sleep(Duration::from_millis(50)).await;
             attempts += 1;
         }
-        assert!(node_a_transport.is_connected(), "Server should be connected");
+        assert!(
+            node_a_transport.is_connected(),
+            "Server should be connected"
+        );
         println!("✓ Connection established\n");
 
         // === STEP 2-4: Execute and replicate transaction 1 ===
@@ -468,18 +448,13 @@ mod tests {
         println!("✓ Transaction 1 executed on Node A\n");
 
         println!("STEP 3: Replicate transaction 1 to Node B...");
-        let msg1 = ReplicationMessage::new(envelope1, "node_a".to_string(), "node_b".to_string(), 1);
-        node_a_transport
-            .send(msg1)
-            .await
-            .expect("send tx1");
+        let msg1 =
+            ReplicationMessage::new(envelope1, "node_a".to_string(), "node_b".to_string(), 1);
+        node_a_transport.send(msg1).await.expect("send tx1");
 
         sleep(Duration::from_millis(200)).await;
 
-        let received1 = node_b_transport
-            .receive()
-            .await
-            .expect("receive tx1");
+        let received1 = node_b_transport.receive().await.expect("receive tx1");
         assert_eq!(received1.len(), 1);
 
         let mut parent_vc_b = VectorClock::new();
@@ -503,9 +478,10 @@ mod tests {
             state_a_after_tx1.state_hash, state_b_after_tx1.state_hash,
             "State hashes should match after tx1"
         );
-        println!("✓ State converged: {} == {}\n",
-            state_a_after_tx1.state_hash,
-            state_b_after_tx1.state_hash);
+        println!(
+            "✓ State converged: {} == {}\n",
+            state_a_after_tx1.state_hash, state_b_after_tx1.state_hash
+        );
 
         // === STEP 5-6: Close connection deliberately ===
         println!("STEP 5: Deliberately closing TCP connection...");
@@ -520,8 +496,14 @@ mod tests {
         println!("✓ Connection closed\n");
 
         println!("STEP 6: Verify both nodes detect disconnect...");
-        assert!(!node_a_transport.is_connected(), "Node A should be disconnected");
-        assert!(!node_b_transport.is_connected(), "Node B should be disconnected");
+        assert!(
+            !node_a_transport.is_connected(),
+            "Node A should be disconnected"
+        );
+        assert!(
+            !node_b_transport.is_connected(),
+            "Node B should be disconnected"
+        );
         println!("✓ Both nodes detected disconnect\n");
 
         // === STEP 7: Re-establish connection ===
@@ -563,7 +545,8 @@ mod tests {
         let mut parent_vc_tx2 = VectorClock::new();
         parent_vc_tx2.increment("node_a");
         parent_vc_tx2.increment("node_b"); // Include B's history
-        let parent_version_tx2 = StateVersion::new(parent_vc_tx2, state_a_after_tx1.state_hash.to_string());
+        let parent_version_tx2 =
+            StateVersion::new(parent_vc_tx2, state_a_after_tx1.state_hash.to_string());
 
         let mut fields2 = HashMap::new();
         fields2.insert("tx".to_string(), json!("2"));
@@ -593,24 +576,20 @@ mod tests {
         println!("✓ Transaction 2 executed on Node A\n");
 
         println!("STEP 9: Replicate transaction 2 to Node B...");
-        let msg2 = ReplicationMessage::new(envelope2, "node_a".to_string(), "node_b".to_string(), 2);
-        node_a_transport_v2
-            .send(msg2)
-            .await
-            .expect("send tx2");
+        let msg2 =
+            ReplicationMessage::new(envelope2, "node_a".to_string(), "node_b".to_string(), 2);
+        node_a_transport_v2.send(msg2).await.expect("send tx2");
 
         sleep(Duration::from_millis(200)).await;
 
-        let received2 = node_b_transport
-            .receive()
-            .await
-            .expect("receive tx2");
+        let received2 = node_b_transport.receive().await.expect("receive tx2");
         assert_eq!(received2.len(), 1);
 
         let mut parent_vc_b_tx2 = VectorClock::new();
         parent_vc_b_tx2.increment("node_a");
         parent_vc_b_tx2.increment("node_b");
-        let parent_version_b_tx2 = StateVersion::new(parent_vc_b_tx2, state_b_after_tx1.state_hash.to_string());
+        let parent_version_b_tx2 =
+            StateVersion::new(parent_vc_b_tx2, state_b_after_tx1.state_hash.to_string());
 
         node_b_executor
             .receive_replicated_transaction(received2[0].clone(), parent_version_b_tx2)
@@ -637,10 +616,14 @@ mod tests {
             state_a_final.operations_applied >= 2,
             "Should have applied at least 2 transactions"
         );
-        println!("✓ Final convergence verified: {} == {}",
-            state_a_final.state_hash,
-            state_b_final.state_hash);
-        println!("✓ Operations applied: {}\n", state_a_final.operations_applied);
+        println!(
+            "✓ Final convergence verified: {} == {}",
+            state_a_final.state_hash, state_b_final.state_hash
+        );
+        println!(
+            "✓ Operations applied: {}\n",
+            state_a_final.operations_applied
+        );
 
         // Verify metrics
         assert!(
@@ -677,18 +660,14 @@ mod tests {
         println!("PHASE 1: Initial setup and first convergence\n");
 
         // Node A (Server)
-        let mut node_a_executor = DistributedTransactionExecutor::new(
-            "node_a".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut node_a_executor =
+            DistributedTransactionExecutor::new("node_a".to_string(), initial_state_hash.clone());
         node_a_executor.register_replica("node_b".to_string(), initial_state_hash.clone());
         let mut node_a_transport = TcpTransport::new("127.0.0.1:19060".to_string());
 
         // Node B (Client) - will be restarted later
-        let mut node_b_executor = DistributedTransactionExecutor::new(
-            "node_b".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut node_b_executor =
+            DistributedTransactionExecutor::new("node_b".to_string(), initial_state_hash.clone());
         node_b_executor.register_replica("node_a".to_string(), initial_state_hash.clone());
         let mut node_b_transport = TcpTransport::new("127.0.0.1:19061".to_string());
 
@@ -716,7 +695,10 @@ mod tests {
             sleep(Duration::from_millis(50)).await;
             attempts += 1;
         }
-        assert!(node_a_transport.is_connected(), "Server should be connected");
+        assert!(
+            node_a_transport.is_connected(),
+            "Server should be connected"
+        );
         println!("✓ Connection established\n");
 
         // Execute and replicate tx1
@@ -753,19 +735,14 @@ mod tests {
         println!("✓ Transaction 1 executed\n");
 
         println!("Step 3: Replicate transaction 1 to Node B...");
-        let msg1 = ReplicationMessage::new(envelope1, "node_a".to_string(), "node_b".to_string(), 1);
-        node_a_transport
-            .send(msg1)
-            .await
-            .expect("send tx1");
+        let msg1 =
+            ReplicationMessage::new(envelope1, "node_a".to_string(), "node_b".to_string(), 1);
+        node_a_transport.send(msg1).await.expect("send tx1");
 
         sleep(Duration::from_millis(100)).await;
 
         // Receive and apply on B
-        let received = node_b_transport
-            .receive()
-            .await
-            .expect("receive tx1");
+        let received = node_b_transport.receive().await.expect("receive tx1");
         assert_eq!(received.len(), 1, "should receive 1 message");
 
         let parent_vc = VectorClock::new();
@@ -804,7 +781,10 @@ mod tests {
             state_b_before.operations_applied, 1,
             "node_b should have applied 1 operation"
         );
-        println!("✓ State converged: {} == {}\n", state_a_before.state_hash, state_b_before.state_hash);
+        println!(
+            "✓ State converged: {} == {}\n",
+            state_a_before.state_hash, state_b_before.state_hash
+        );
 
         // ===== PHASE 2: Node B Offline (Restart Simulation) =====
         println!("PHASE 2: Node B goes offline, A continues\n");
@@ -816,8 +796,10 @@ mod tests {
             state_b_before.operations_applied,
             state_b_before.vector_clock.clone(),
         );
-        println!("✓ Persisted Node B state: ops={}, hash={}\n",
-            persisted_state_b.1, persisted_state_b.0);
+        println!(
+            "✓ Persisted Node B state: ops={}, hash={}\n",
+            persisted_state_b.1, persisted_state_b.0
+        );
 
         // Drop node_b transport/executor to simulate shutdown
         println!("Step 6: STOPPING Node B (complete offline)...");
@@ -861,27 +843,29 @@ mod tests {
         let state_a_before_restart = node_a_executor
             .get_replica_state("node_a")
             .expect("get node_a state");
-        println!("\n✓ Node A advanced to: ops={}, hash={}\n",
-            state_a_before_restart.operations_applied,
-            state_a_before_restart.state_hash);
+        println!(
+            "\n✓ Node A advanced to: ops={}, hash={}\n",
+            state_a_before_restart.operations_applied, state_a_before_restart.state_hash
+        );
 
         // ===== PHASE 3: Node B Restart & Reconnection =====
         println!("PHASE 3: Restart Node B from persisted state\n");
 
         println!("Step 8: RESTARTING Node B from persisted state...");
         // Recreate node_b_executor with persisted state
-        let mut node_b_executor_restarted = DistributedTransactionExecutor::new(
-            "node_b".to_string(),
-            persisted_state_b.0.clone(),
-        );
-        node_b_executor_restarted.register_replica("node_a".to_string(), persisted_state_b.0.clone());
+        let mut node_b_executor_restarted =
+            DistributedTransactionExecutor::new("node_b".to_string(), persisted_state_b.0.clone());
+        node_b_executor_restarted
+            .register_replica("node_a".to_string(), persisted_state_b.0.clone());
         let mut node_b_transport_restarted = TcpTransport::new("127.0.0.1:0".to_string());
 
         // Recreate Node A transport v2 to accept new connection (fresh listen)
         let mut node_a_transport_v2 = TcpTransport::new("127.0.0.1:19063".to_string());
 
-        println!("✓ Node B restarted with persisted state: ops={}, hash={}\n",
-            persisted_state_b.1, persisted_state_b.0);
+        println!(
+            "✓ Node B restarted with persisted state: ops={}, hash={}\n",
+            persisted_state_b.1, persisted_state_b.0
+        );
 
         println!("Step 9: Attempting reconnect to Node A (new port 19063)...");
 
@@ -897,8 +881,9 @@ mod tests {
 
         let reconnect_result = tokio::time::timeout(
             Duration::from_millis(500),
-            node_b_transport_restarted.connect("127.0.0.1:19063")
-        ).await;
+            node_b_transport_restarted.connect("127.0.0.1:19063"),
+        )
+        .await;
 
         match reconnect_result {
             Ok(Ok(())) => {
@@ -920,11 +905,8 @@ mod tests {
 
         // Try to receive any messages from Node A
         let timeout = Duration::from_millis(500);
-        let received_after_restart = tokio::time::timeout(
-            timeout,
-            node_b_transport_restarted.receive()
-        )
-        .await;
+        let received_after_restart =
+            tokio::time::timeout(timeout, node_b_transport_restarted.receive()).await;
 
         let recovery_result = match received_after_restart {
             Ok(Ok(msgs)) => {
@@ -934,8 +916,10 @@ mod tests {
                 } else {
                     println!("  → Received {} message(s) from Node A", msgs.len());
                     for msg in &msgs {
-                        println!("    Message from {} to {} (seq {})",
-                            msg.from_node, msg.to_node, msg.sequence_number);
+                        println!(
+                            "    Message from {} to {} (seq {})",
+                            msg.from_node, msg.to_node, msg.sequence_number
+                        );
                     }
                     "received_messages"
                 }
@@ -945,7 +929,10 @@ mod tests {
                 "transport_error"
             }
             Err(_) => {
-                println!("  → Timeout: No messages received within {} ms", timeout.as_millis());
+                println!(
+                    "  → Timeout: No messages received within {} ms",
+                    timeout.as_millis()
+                );
                 "timeout"
             }
         };
@@ -978,7 +965,10 @@ mod tests {
         if converged && state_a_final.operations_applied == state_b_final.operations_applied {
             println!("✅ OUTCOME A: Protocol has built-in recovery semantics");
             println!("   - Node B recovered from offline state");
-            println!("   - All {} transactions replicated and applied", state_a_final.operations_applied);
+            println!(
+                "   - All {} transactions replicated and applied",
+                state_a_final.operations_applied
+            );
             println!("   - Final state converged");
             println!("   - No duplicates detected");
             println!("   FINDING: 14C handles crash recovery internally");
@@ -987,22 +977,35 @@ mod tests {
             println!("   - Node B re-applied tx1 after restart");
             println!("   - Missing tx2, tx3, tx4");
             println!("   - State diverged");
-            println!("   FINDING: Protocol lacks durability across restart; dedup is in-memory only");
+            println!(
+                "   FINDING: Protocol lacks durability across restart; dedup is in-memory only"
+            );
         } else if behind {
             println!("⚠️  OUTCOME B: Protocol lacks recovery mechanism");
             println!("   - Node B restarted with 1 operation");
-            println!("   - Node A has {} operations", state_a_final.operations_applied);
+            println!(
+                "   - Node A has {} operations",
+                state_a_final.operations_applied
+            );
             println!("   - No recovery messages received");
-            println!("   - State diverged: B={} vs A={}",
-                state_b_final.state_hash, state_a_final.state_hash);
+            println!(
+                "   - State diverged: B={} vs A={}",
+                state_b_final.state_hash, state_a_final.state_hash
+            );
             println!("   FINDING: Recovery mechanism not built into 14C protocol");
-            println!("            Must be added in application layer or as separate protocol extension");
+            println!(
+                "            Must be added in application layer or as separate protocol extension"
+            );
         } else {
             println!("🔍 OUTCOME D: Unexpected state");
-            println!("   B ops: {} | A ops: {}",
-                state_b_final.operations_applied, state_a_final.operations_applied);
-            println!("   B hash: {} | A hash: {}",
-                state_b_final.state_hash, state_a_final.state_hash);
+            println!(
+                "   B ops: {} | A ops: {}",
+                state_b_final.operations_applied, state_a_final.operations_applied
+            );
+            println!(
+                "   B hash: {} | A hash: {}",
+                state_b_final.state_hash, state_a_final.state_hash
+            );
         }
 
         println!("\n📋 Summary:");
@@ -1024,16 +1027,12 @@ mod tests {
         let initial_state_hash = StateHash::from_hex("hash_initial".to_string());
 
         // Setup two nodes and converge
-        let mut executor_a = DistributedTransactionExecutor::new(
-            "node_a".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut executor_a =
+            DistributedTransactionExecutor::new("node_a".to_string(), initial_state_hash.clone());
         executor_a.register_replica("node_b".to_string(), initial_state_hash.clone());
 
-        let mut executor_b = DistributedTransactionExecutor::new(
-            "node_b".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut executor_b =
+            DistributedTransactionExecutor::new("node_b".to_string(), initial_state_hash.clone());
         executor_b.register_replica("node_a".to_string(), initial_state_hash.clone());
 
         // Execute and replicate multiple transactions
@@ -1088,16 +1087,28 @@ mod tests {
         let state_b = executor_b.get_replica_state("node_b").unwrap();
 
         println!("After 3 transactions:");
-        println!("  Node A: {} ops, hash={}", state_a.operations_applied, state_a.state_hash);
-        println!("  Node B: {} ops, hash={}", state_b.operations_applied, state_b.state_hash);
+        println!(
+            "  Node A: {} ops, hash={}",
+            state_a.operations_applied, state_a.state_hash
+        );
+        println!(
+            "  Node B: {} ops, hash={}",
+            state_b.operations_applied, state_b.state_hash
+        );
 
         // Analyze what would need to be persisted
         println!("\nCandidate durable state:");
         println!("  ✓ Operations (records of what was executed)");
         println!("    - Sequence numbers (1, 2, 3)");
         println!("    - Transaction IDs (tx_1, tx_2, tx_3)");
-        println!("  ✓ Last applied sequence number: {}", state_a.operations_applied);
-        println!("  ? State hash: {} (derived from ops, or durable?)", state_a.state_hash);
+        println!(
+            "  ✓ Last applied sequence number: {}",
+            state_a.operations_applied
+        );
+        println!(
+            "  ? State hash: {} (derived from ops, or durable?)",
+            state_a.state_hash
+        );
         println!("  ? Vector clocks: (needed for causal order?)");
         println!("  ? EnvelopeId set (for dedup: which envelopes seen?)");
 
@@ -1126,17 +1137,15 @@ mod tests {
 
         let initial_state_hash = StateHash::from_hex("hash_initial".to_string());
 
-        let mut executor = DistributedTransactionExecutor::new(
-            "node_b".to_string(),
-            initial_state_hash.clone(),
-        );
+        let mut executor =
+            DistributedTransactionExecutor::new("node_b".to_string(), initial_state_hash.clone());
 
         // Simulate: "Here's what we persisted before going offline"
         let persisted_data = (
-            "node_b",                                         // node_id
-            initial_state_hash.clone(),                      // last_state_hash
-            2u64,                                             // last_sequence_applied
-            vec!["tx_1", "tx_2"],                            // operation ids
+            "node_b",                   // node_id
+            initial_state_hash.clone(), // last_state_hash
+            2u64,                       // last_sequence_applied
+            vec!["tx_1", "tx_2"],       // operation ids
         );
 
         println!("Persisted state:");
@@ -1341,7 +1350,9 @@ mod tests {
         println!("Q5: Recovery + 14C interaction?");
         println!("    → Must maintain causal order; sequence recovery before new replication\n");
 
-        println!("Next: Phase 1b.5 will implement minimal recovery protocol based on these answers.");
+        println!(
+            "Next: Phase 1b.5 will implement minimal recovery protocol based on these answers."
+        );
         println!("Not before: Must understand what recovery must guarantee.\n");
     }
 
@@ -1402,7 +1413,10 @@ mod tests {
 
         let (seq_a_initial, ops_a_initial) = recovery_a.recovery_state_snapshot();
         let (seq_b_initial, ops_b_initial) = recovery_b.recovery_state_snapshot();
-        assert_eq!(seq_a_initial, seq_b_initial, "A and B should converge on tx1");
+        assert_eq!(
+            seq_a_initial, seq_b_initial,
+            "A and B should converge on tx1"
+        );
         assert_eq!(ops_a_initial, ops_b_initial, "Same op count");
 
         // Simulate offline: B stops, A executes tx2
@@ -1436,11 +1450,15 @@ mod tests {
             "Same operation count"
         );
 
+        println!("✓ Invariant proven: continuous ≡ offline + recovery");
+        println!(
+            "✓ A sequence: {}, B sequence after recovery: {}",
+            seq_a_after_tx2, seq_b_after_recovery
+        );
         println!(
-            "✓ Invariant proven: continuous ≡ offline + recovery"
+            "✓ A operations: {}, B operations: {}",
+            ops_a_after_tx2, ops_b_after_recovery
         );
-        println!("✓ A sequence: {}, B sequence after recovery: {}", seq_a_after_tx2, seq_b_after_recovery);
-        println!("✓ A operations: {}, B operations: {}", ops_a_after_tx2, ops_b_after_recovery);
     }
 
     #[test]
@@ -1487,25 +1505,15 @@ mod tests {
             seq_a_final, seq_b_final,
             "Multiple recovered operations preserve convergence"
         );
-        assert_eq!(
-            ops_a_final, ops_b_final,
-            "Same operation count"
-        );
+        assert_eq!(ops_a_final, ops_b_final, "Same operation count");
 
+        println!("✓ Invariant: continuous ≡ offline + recovery (4 operations)");
         println!(
-            "✓ Invariant: continuous ≡ offline + recovery (4 operations)"
-        );
-        println!("✓ A operations: {}, B recovered: {}", ops_a_final, ops_b_final);
-        assert_eq!(
-            ops_a_final,
-            4,
-            "A should have 4 operations"
-        );
-        assert_eq!(
-            ops_b_final,
-            4,
-            "B should have 4 operations after recovery"
+            "✓ A operations: {}, B recovered: {}",
+            ops_a_final, ops_b_final
         );
+        assert_eq!(ops_a_final, 4, "A should have 4 operations");
+        assert_eq!(ops_b_final, 4, "B should have 4 operations after recovery");
     }
 
     #[test]
@@ -1549,10 +1557,18 @@ mod tests {
         }
 
         // Verify: dedup prevented double-apply
-        assert_eq!(recovery_b.operation_log.len(), 4, "B should have 4 ops, not 5");
+        assert_eq!(
+            recovery_b.operation_log.len(),
+            4,
+            "B should have 4 ops, not 5"
+        );
 
         println!("✓ Recovery maintains sequence integrity");
-        println!("✓ A operations: {}, B after recovery: {}", recovery_a.operation_log.len(), recovery_b.operation_log.len());
+        println!(
+            "✓ A operations: {}, B after recovery: {}",
+            recovery_a.operation_log.len(),
+            recovery_b.operation_log.len()
+        );
     }
 
     #[test]
@@ -1583,21 +1599,35 @@ mod tests {
 
         // Recovery begins: B requests tx3, tx4, tx5
         let recovered_ops = recovery_a.get_operations_since(last_seq_b_start);
-        assert_eq!(recovered_ops.len(), 3, "Should need to recover 3 operations");
+        assert_eq!(
+            recovered_ops.len(),
+            3,
+            "Should need to recover 3 operations"
+        );
 
         // Simulate interruption: apply tx3 only, then B crashes
         recovery_b.log_operation("tx3".to_string(), 3);
         let (last_seq_b_after_partial, _) = recovery_b.recovery_state_snapshot();
-        assert_eq!(last_seq_b_after_partial, 3, "B should have seq 3 after partial recovery");
+        assert_eq!(
+            last_seq_b_after_partial, 3,
+            "B should have seq 3 after partial recovery"
+        );
 
         // B RESTARTS from persisted state
         recovery_b.restore_from_log();
         let (last_seq_b_after_crash, _) = recovery_b.recovery_state_snapshot();
-        assert_eq!(last_seq_b_after_crash, 3, "B should restore to seq 3 after crash");
+        assert_eq!(
+            last_seq_b_after_crash, 3,
+            "B should restore to seq 3 after crash"
+        );
 
         // Recovery resumes: B asks for operations after sequence 3
         let remaining_ops = recovery_a.get_operations_since(last_seq_b_after_crash);
-        assert_eq!(remaining_ops.len(), 2, "Should need to recover 2 remaining ops");
+        assert_eq!(
+            remaining_ops.len(),
+            2,
+            "Should need to recover 2 remaining ops"
+        );
 
         for seq in remaining_ops {
             recovery_b.log_operation(format!("tx{}", seq), seq);
@@ -1645,7 +1675,10 @@ mod tests {
         let (seq_a_diverged, ops_a_diverged) = recovery_a.recovery_state_snapshot();
         let (seq_b_offline, ops_b_offline) = recovery_b.recovery_state_snapshot();
 
-        println!("  A after divergence: seq={}, ops={}", seq_a_diverged, ops_a_diverged);
+        println!(
+            "  A after divergence: seq={}, ops={}",
+            seq_a_diverged, ops_a_diverged
+        );
         println!("  B offline: seq={}, ops={}", seq_b_offline, ops_b_offline);
 
         // B restarts and recovers
@@ -1664,8 +1697,7 @@ mod tests {
         // INDEPENDENT VERIFICATION: Both nodes have same operations
         // Verify by independent state calculation
         assert_eq!(
-            ops_a_final,
-            ops_b_final,
+            ops_a_final, ops_b_final,
             "Both should have same operation count"
         );
 
@@ -1679,7 +1711,8 @@ mod tests {
 
         // SEMANTIC EQUIVALENCE: Both should have identical state snapshot
         assert_eq!(
-            (seq_a_final, ops_a_final), (seq_b_final, ops_b_final),
+            (seq_a_final, ops_a_final),
+            (seq_b_final, ops_b_final),
             "Independent recovery produces identical state"
         );
 
@@ -1687,8 +1720,10 @@ mod tests {
             "✓ State verification passed: A=(seq={}, ops={}), B=(seq={}, ops={})",
             seq_a_final, ops_a_final, seq_b_final, ops_b_final
         );
-        println!("✓ Operation sequences identical: {} operations on both",
-            ops_a_final);
+        println!(
+            "✓ Operation sequences identical: {} operations on both",
+            ops_a_final
+        );
         println!("✓ Semantic equivalence proven: both nodes identical");
     }
 
@@ -1787,7 +1822,11 @@ mod tests {
         }
 
         fn get_recovery_state(&self) -> (u64, usize, usize) {
-            (self.last_sequence, self.operation_log.len(), self.dedup_set.len())
+            (
+                self.last_sequence,
+                self.operation_log.len(),
+                self.dedup_set.len(),
+            )
         }
 
         fn simulate_crash_and_restart(&mut self) {
@@ -1799,7 +1838,11 @@ mod tests {
             self.dedup_set.clear();
         }
 
-        fn restore_from_persisted(&mut self, ops: Vec<(String, u64)>, dedup: std::collections::HashSet<String>) {
+        fn restore_from_persisted(
+            &mut self,
+            ops: Vec<(String, u64)>,
+            dedup: std::collections::HashSet<String>,
+        ) {
             self.operation_log = ops;
             self.dedup_set = dedup;
             if let Some((_, seq)) = self.operation_log.last() {
@@ -1840,7 +1883,10 @@ mod tests {
         // Attack: Kill process B (SIGKILL, no graceful shutdown)
         recovery_b.simulate_crash_and_restart();
         let (seq_b_after_crash, _, _) = recovery_b.get_recovery_state();
-        assert_eq!(seq_b_after_crash, 0, "B's in-memory state should be cleared after crash");
+        assert_eq!(
+            seq_b_after_crash, 0,
+            "B's in-memory state should be cleared after crash"
+        );
 
         // Recover: New process B reads from disk
         recovery_b.restore_from_persisted(persisted_ops, persisted_dedup);
@@ -1850,11 +1896,20 @@ mod tests {
         // Verify: B recovered from disk, not from memory
         assert_eq!(seq_b_restored, 2, "B should restore sequence 2 from disk");
         assert_eq!(ops_b_restored, 2, "B should have 2 operations from disk");
-        assert_eq!(dedup_b_restored, 2, "B should have 2 dedup entries from disk");
-        assert_eq!(seq_b_before_crash, seq_b_restored, "State should survive disk read");
+        assert_eq!(
+            dedup_b_restored, 2,
+            "B should have 2 dedup entries from disk"
+        );
+        assert_eq!(
+            seq_b_before_crash, seq_b_restored,
+            "State should survive disk read"
+        );
 
         println!("✓ Process B crashed and restarted from disk");
-        println!("✓ Recovered state: seq={}, ops={}, dedup={}", seq_b_restored, ops_b_restored, dedup_b_restored);
+        println!(
+            "✓ Recovered state: seq={}, ops={}, dedup={}",
+            seq_b_restored, ops_b_restored, dedup_b_restored
+        );
         println!("✓ Invariant: Process crash does not lose persisted state");
     }
 
@@ -1895,11 +1950,18 @@ mod tests {
         let (seq_b_restarted, _, _) = recovery_b.get_recovery_state();
 
         // Verify: B is back to its pre-offline state (sequence 2)
-        assert_eq!(seq_b_restarted, 2, "B should restart with sequence 2 (pre-offline state)");
+        assert_eq!(
+            seq_b_restarted, 2,
+            "B should restart with sequence 2 (pre-offline state)"
+        );
 
         // B requests recovery from A for sequence > 2
         let missed = recovery_a.get_operations_since(seq_b_restarted);
-        assert_eq!(missed.len(), 2, "B should need to recover 2 operations (tx3, tx4)");
+        assert_eq!(
+            missed.len(),
+            2,
+            "B should need to recover 2 operations (tx3, tx4)"
+        );
 
         println!("✓ Process B restarted and recovered from disk (old state cleared)");
         println!("✓ B's sequence after restart: {}", seq_b_restarted);
@@ -2004,11 +2066,17 @@ mod tests {
 
         // B restarts (crashes)
         recovery_b.simulate_crash_and_restart();
-        assert!(!recovery_b.is_seen("A:2"), "Dedup set should be cleared after crash");
+        assert!(
+            !recovery_b.is_seen("A:2"),
+            "Dedup set should be cleared after crash"
+        );
 
         // B restarts from disk
         recovery_b.restore_from_persisted(persisted_ops, persisted_dedup);
-        assert!(recovery_b.is_seen("A:2"), "Dedup set should be restored from disk");
+        assert!(
+            recovery_b.is_seen("A:2"),
+            "Dedup set should be restored from disk"
+        );
 
         // Attack: A delivers tx2 again (network retry, didn't know B already had it)
         let tx2_envelope_id = "A:2";
@@ -2056,7 +2124,10 @@ mod tests {
 
         // Attack: Same recovery request again (network glitch, retry)
         let missed_second = recovery_a.get_operations_since(seq_b);
-        assert_eq!(missed_first, missed_second, "Same recovery request should return same ops");
+        assert_eq!(
+            missed_first, missed_second,
+            "Same recovery request should return same ops"
+        );
 
         // Apply same recovery again (idempotence)
         for seq in missed_second.iter() {
@@ -2073,10 +2144,19 @@ mod tests {
         assert_eq!(ops_b_1, ops_b_2, "Operation count unchanged");
         assert_eq!(dedup_b_1, dedup_b_2, "Dedup count unchanged");
 
-        println!("✓ First recovery request: {} operations", missed_first.len());
-        println!("✓ Second recovery request: {} operations", missed_second.len());
+        println!(
+            "✓ First recovery request: {} operations",
+            missed_first.len()
+        );
+        println!(
+            "✓ Second recovery request: {} operations",
+            missed_second.len()
+        );
         println!("✓ Dedup prevented re-application");
-        println!("✓ Final state: seq={}, ops={}, dedup={}", seq_b_idempotent, ops_b_2, dedup_b_2);
+        println!(
+            "✓ Final state: seq={}, ops={}, dedup={}",
+            seq_b_idempotent, ops_b_2, dedup_b_2
+        );
         println!("✓ Invariant: Recovery is idempotent (same request twice = same result)");
     }
 
@@ -2125,7 +2205,10 @@ mod tests {
         recovery_b.restore_from_persisted(persisted_ops, persisted_dedup);
 
         let (seq_b_restored, _, _) = recovery_b.get_recovery_state();
-        assert_eq!(seq_b_restored, 4, "B should restore recovery position at tx4");
+        assert_eq!(
+            seq_b_restored, 4,
+            "B should restore recovery position at tx4"
+        );
 
         // B requests recovery from sequence 4 (not 2, not 3)
         let remaining = recovery_a.get_operations_since(seq_b_restored);
@@ -2289,7 +2372,10 @@ mod tests {
                 println!("  Success rate:              {:.1}%", success_rate);
                 println!("  Cycles completed:          {}", self.cycles_completed);
                 println!("  Convergence failures:      {}", self.convergence_failures);
-                println!("  Crash recovery failures:   {}", self.crash_recovery_failures);
+                println!(
+                    "  Crash recovery failures:   {}",
+                    self.crash_recovery_failures
+                );
             }
 
             println!("\nRECOVERY LATENCY (measured, not inferred)");
@@ -2301,7 +2387,10 @@ mod tests {
                 println!("  Min:                       {}ms", min);
                 println!("  Avg:                       {}ms", avg);
                 println!("  Max:                       {}ms", max);
-                println!("  Samples:                   {}", self.recovery_latencies_ms.len());
+                println!(
+                    "  Samples:                   {}",
+                    self.recovery_latencies_ms.len()
+                );
             }
 
             println!("\nREPLAY THROUGHPUT (measured)");
@@ -2328,14 +2417,17 @@ mod tests {
 
             println!("\nDEDUPLICATION STATE (measured)");
             if !self.dedup_set_sizes.is_empty() {
-                let avg: usize = self.dedup_set_sizes.iter().sum::<usize>()
-                    / self.dedup_set_sizes.len();
+                let avg: usize =
+                    self.dedup_set_sizes.iter().sum::<usize>() / self.dedup_set_sizes.len();
                 let min = self.dedup_set_sizes.iter().min().unwrap_or(&0);
                 let max = self.dedup_set_sizes.iter().max().unwrap_or(&0);
                 println!("  Min entries:               {}", min);
                 println!("  Avg entries:               {}", avg);
                 println!("  Max entries:               {}", max);
-                println!("  Growth characteristic:     {:?}", if max > &min { "unbounded" } else { "stable" });
+                println!(
+                    "  Growth characteristic:     {:?}",
+                    if max > &min { "unbounded" } else { "stable" }
+                );
             }
 
             println!("\nOPERATION LOG (measured)");
@@ -2361,7 +2453,14 @@ mod tests {
 
             println!("\nOVERALL STATISTICS");
             println!("  Total operations:          {}", self.total_operations);
-            println!("  Architectural failures:    {}", if self.convergence_failures == 0 && self.crash_recovery_failures == 0 { 0 } else { 1 });
+            println!(
+                "  Architectural failures:    {}",
+                if self.convergence_failures == 0 && self.crash_recovery_failures == 0 {
+                    0
+                } else {
+                    1
+                }
+            );
             println!("\n=== END SOAK VALIDATION ===\n");
         }
     }
@@ -2416,7 +2515,10 @@ mod tests {
             if final_seq_b == 105 && final_ops_b == 105 {
                 metrics.record_recovery(recovery_time, throughput, 100);
                 metrics.record_dedup(final_dedup);
-                println!("  Cycle {}: ✓ converged (seq={}, latency={}ms)", cycle, final_seq_b, recovery_time);
+                println!(
+                    "  Cycle {}: ✓ converged (seq={}, latency={}ms)",
+                    cycle, final_seq_b, recovery_time
+                );
             } else {
                 metrics.record_convergence_failure();
                 println!("  Cycle {}: ✗ FAILED to converge", cycle);
@@ -2551,7 +2653,10 @@ mod tests {
             if final_seq_b == 50 {
                 metrics.record_recovery(recovery_time, 0, 45);
                 metrics.record_dedup(dedup_size);
-                println!("  Cycle {}: ✓ recovered after crash (seq={})", cycle, final_seq_b);
+                println!(
+                    "  Cycle {}: ✓ recovered after crash (seq={})",
+                    cycle, final_seq_b
+                );
             } else {
                 metrics.record_crash_recovery_failure();
                 println!("  Cycle {}: ✗ FAILED to recover after crash", cycle);
@@ -2627,11 +2732,7 @@ mod tests {
 
             // Execute operations
             for i in 1..=*op_count {
-                recovery.persist_operation(
-                    format!("tx{}", i),
-                    i as u64,
-                    format!("A:{}", i),
-                );
+                recovery.persist_operation(format!("tx{}", i), i as u64, format!("A:{}", i));
             }
 
             let startup_time = start.elapsed().as_millis();
@@ -2754,15 +2855,36 @@ mod tests {
             // Analyze backlog scaling
             println!("RECOVERY LATENCY SCALING");
             if !self.backlog_10_latency.is_empty() {
-                let avg_10: u128 = self.backlog_10_latency.iter().sum::<u128>() / self.backlog_10_latency.len() as u128;
-                let avg_100: u128 = self.backlog_100_latency.iter().sum::<u128>() /
-                    if self.backlog_100_latency.is_empty() { 1 } else { self.backlog_100_latency.len() as u128 };
-                let avg_1k: u128 = self.backlog_1k_latency.iter().sum::<u128>() /
-                    if self.backlog_1k_latency.is_empty() { 1 } else { self.backlog_1k_latency.len() as u128 };
+                let avg_10: u128 = self.backlog_10_latency.iter().sum::<u128>()
+                    / self.backlog_10_latency.len() as u128;
+                let avg_100: u128 = self.backlog_100_latency.iter().sum::<u128>()
+                    / if self.backlog_100_latency.is_empty() {
+                        1
+                    } else {
+                        self.backlog_100_latency.len() as u128
+                    };
+                let avg_1k: u128 = self.backlog_1k_latency.iter().sum::<u128>()
+                    / if self.backlog_1k_latency.is_empty() {
+                        1
+                    } else {
+                        self.backlog_1k_latency.len() as u128
+                    };
 
-                println!("  10 ops:                  {}ms (avg, {} samples)", avg_10, self.backlog_10_latency.len());
-                println!("  100 ops:                 {}ms (avg, {} samples)", avg_100, self.backlog_100_latency.len());
-                println!("  1,000 ops:               {}ms (avg, {} samples)", avg_1k, self.backlog_1k_latency.len());
+                println!(
+                    "  10 ops:                  {}ms (avg, {} samples)",
+                    avg_10,
+                    self.backlog_10_latency.len()
+                );
+                println!(
+                    "  100 ops:                 {}ms (avg, {} samples)",
+                    avg_100,
+                    self.backlog_100_latency.len()
+                );
+                println!(
+                    "  1,000 ops:               {}ms (avg, {} samples)",
+                    avg_1k,
+                    self.backlog_1k_latency.len()
+                );
 
                 // Detect scaling characteristic
                 if avg_1k > 0 && avg_10 > 0 {
@@ -2785,24 +2907,40 @@ mod tests {
             // Analyze throughput
             println!("\nRECOVERY REPLAY THROUGHPUT");
             if !self.backlog_10_throughput.is_empty() {
-                let avg_10: u64 = self.backlog_10_throughput.iter().sum::<u64>() / self.backlog_10_throughput.len() as u64;
-                let avg_100: u64 = self.backlog_100_throughput.iter().sum::<u64>() /
-                    if self.backlog_100_throughput.is_empty() { 1 } else { self.backlog_100_throughput.len() as u64 };
-                let avg_1k: u64 = self.backlog_1k_throughput.iter().sum::<u64>() /
-                    if self.backlog_1k_throughput.is_empty() { 1 } else { self.backlog_1k_throughput.len() as u64 };
+                let avg_10: u64 = self.backlog_10_throughput.iter().sum::<u64>()
+                    / self.backlog_10_throughput.len() as u64;
+                let avg_100: u64 = self.backlog_100_throughput.iter().sum::<u64>()
+                    / if self.backlog_100_throughput.is_empty() {
+                        1
+                    } else {
+                        self.backlog_100_throughput.len() as u64
+                    };
+                let avg_1k: u64 = self.backlog_1k_throughput.iter().sum::<u64>()
+                    / if self.backlog_1k_throughput.is_empty() {
+                        1
+                    } else {
+                        self.backlog_1k_throughput.len() as u64
+                    };
 
                 println!("  10 ops:                  {} ops/sec", avg_10);
                 println!("  100 ops:                 {} ops/sec", avg_100);
                 println!("  1,000 ops:               {} ops/sec", avg_1k);
-                println!("  Throughput trend:        {}",
-                    if avg_1k >= avg_100 { "stable" } else { "degrading" });
+                println!(
+                    "  Throughput trend:        {}",
+                    if avg_1k >= avg_100 {
+                        "stable"
+                    } else {
+                        "degrading"
+                    }
+                );
             }
 
             // Analyze startup/restore
             println!("\nSTARTUP / RESTORE SCALING");
             if !self.startup_times.is_empty() {
                 let min_startup: u128 = *self.startup_times.iter().min().unwrap_or(&0);
-                let avg_startup: u128 = self.startup_times.iter().sum::<u128>() / self.startup_times.len() as u128;
+                let avg_startup: u128 =
+                    self.startup_times.iter().sum::<u128>() / self.startup_times.len() as u128;
                 let max_startup: u128 = *self.startup_times.iter().max().unwrap_or(&0);
 
                 println!("  Min:                     {}ms", min_startup);
@@ -2829,22 +2967,33 @@ mod tests {
 
                 println!("  Avg log size:            {} bytes", avg_bytes);
                 println!("  Bytes per operation:     ~{}", bytes_per_op);
-                println!("  Linear growth:           {}",
-                    if self.log_bytes.len() > 1 { "observed" } else { "cannot determine" });
+                println!(
+                    "  Linear growth:           {}",
+                    if self.log_bytes.len() > 1 {
+                        "observed"
+                    } else {
+                        "cannot determine"
+                    }
+                );
             }
 
             // Analyze memory
             println!("\nMEMORY CHARACTERISTICS");
             if !self.dedup_sizes.is_empty() {
                 let min_dedup: usize = *self.dedup_sizes.iter().min().unwrap_or(&0);
-                let avg_dedup: usize = self.dedup_sizes.iter().sum::<usize>() / self.dedup_sizes.len();
+                let avg_dedup: usize =
+                    self.dedup_sizes.iter().sum::<usize>() / self.dedup_sizes.len();
                 let max_dedup: usize = *self.dedup_sizes.iter().max().unwrap_or(&0);
 
                 println!("  Dedup entries (min):     {}", min_dedup);
                 println!("  Dedup entries (avg):     {}", avg_dedup);
                 println!("  Dedup entries (max):     {}", max_dedup);
 
-                let growth_ratio = if min_dedup > 0 { max_dedup as f64 / min_dedup as f64 } else { 0.0 };
+                let growth_ratio = if min_dedup > 0 {
+                    max_dedup as f64 / min_dedup as f64
+                } else {
+                    0.0
+                };
                 println!("  Growth ratio:            {:.2}x", growth_ratio);
 
                 if growth_ratio > 10.0 {
@@ -2867,7 +3016,9 @@ mod tests {
                 if self.convergence_failures == 0 {
                     println!("  Assessment:              ✅ PASSES (100% convergence)");
                 } else {
-                    println!("  Assessment:              ⚠️  POTENTIAL ISSUE (not 100% convergence)");
+                    println!(
+                        "  Assessment:              ⚠️  POTENTIAL ISSUE (not 100% convergence)"
+                    );
                 }
             }
 
@@ -2968,7 +3119,11 @@ mod tests {
             }
 
             let latency = start.elapsed().as_millis();
-            let throughput = if latency > 0 { (*backlog_size as u128 / latency) as u64 } else { 0 };
+            let throughput = if latency > 0 {
+                (*backlog_size as u128 / latency) as u64
+            } else {
+                0
+            };
 
             match backlog_size {
                 10 => {
@@ -2992,7 +3147,10 @@ mod tests {
                 evidence.convergence_failures += 1;
             }
 
-            println!("  {} ops: {}ms latency, {} ops/sec", backlog_size, latency, throughput);
+            println!(
+                "  {} ops: {}ms latency, {} ops/sec",
+                backlog_size, latency, throughput
+            );
         }
 
         // Collect startup/resource data
@@ -3013,7 +3171,10 @@ mod tests {
             evidence.dedup_sizes.push(dedup_size);
             evidence.log_bytes.push(estimated_log as u64);
 
-            println!("  {} ops: {}ms startup, dedup={}, log≈{}B", op_count, startup_time, dedup_size, estimated_log);
+            println!(
+                "  {} ops: {}ms startup, dedup={}, log≈{}B",
+                op_count, startup_time, dedup_size, estimated_log
+            );
         }
 
         // Produce analysis report
@@ -3039,7 +3200,9 @@ mod tests {
         println!("PREAMBLE");
         println!("  This contract is based on:");
         println!("    • Phase 1b.5: Recovery protocol architectural proof");
-        println!("    • Phase 1b.6: Recovery durability adversarial validation (7 attack scenarios)");
+        println!(
+            "    • Phase 1b.6: Recovery durability adversarial validation (7 attack scenarios)"
+        );
         println!("    • Phase 1b.7: Sustained soak validation under stress");
         println!("    • Phase 1b.8: Performance evidence analysis");
         println!("");
@@ -3144,7 +3307,9 @@ mod tests {
         println!("  NEXT DECISION:");
         println!("    Is FeltDB intended as:");
         println!("      A) Authoritative-primary with recoverable replicas (current 1b scope)");
-        println!("      B) Multi-master local-first distributed system (requires Phase 2 redesign)");
+        println!(
+            "      B) Multi-master local-first distributed system (requires Phase 2 redesign)"
+        );
         println!("");
         println!("  This contract is definitive FOR option A.");
         println!("  Option B requires new work on conflict resolution and consensus.\n");