@feltdb/core 0.8.4 → 0.8.5

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

@@ -24,7 +24,6 @@
 ///             READY
 ///                 ↓
 ///             APPLIED
-
 use crate::convergence::VectorClock;
 use std::collections::HashMap;
 
@@ -74,7 +73,7 @@ pub enum OperationState {
     /// Operation is waiting for causal dependencies to be satisfied
     WaitingForDependencies {
         required_clock: VectorClock,
-        missing_dependencies: Vec<String>,  // human-readable list
+        missing_dependencies: Vec<String>, // human-readable list
     },
     /// All dependencies satisfied, ready to apply
     Ready,
@@ -284,7 +283,10 @@ impl CausalDependencyBarrier {
         let mut to_ready = Vec::new();
 
         for (op_id, pending_op) in self.pending.iter() {
-            if !self.local_frontier.happens_before(&pending_op.required_dependencies) {
+            if !self
+                .local_frontier
+                .happens_before(&pending_op.required_dependencies)
+            {
                 to_ready.push(op_id.clone());
                 newly_ready.push(op_id.clone());
             }
@@ -346,7 +348,10 @@ impl CausalDependencyBarrier {
         let mut to_ready = Vec::new();
         for op_id in candidates {
             if let Some(pending_op) = self.pending.get(&op_id) {
-                if !self.local_frontier.happens_before(&pending_op.required_dependencies) {
+                if !self
+                    .local_frontier
+                    .happens_before(&pending_op.required_dependencies)
+                {
                     to_ready.push(op_id.clone());
                     newly_ready.push(op_id);
                 }
@@ -386,10 +391,7 @@ impl CausalDependencyBarrier {
         for (node, required_ts) in &required.clocks {
             let current_ts = self.local_frontier.get(node);
             if current_ts < *required_ts {
-                missing.push(format!(
-                    "{}:{} (have {})",
-                    node, required_ts, current_ts
-                ));
+                missing.push(format!("{}:{} (have {})", node, required_ts, current_ts));
             }
         }
 
@@ -609,7 +611,8 @@ impl CausalDependencyBarrier {
     #[cfg(test)]
     fn index_operation(&mut self, op_id: &str, required: &VectorClock) {
         for (node, timestamp) in &required.clocks {
-            self.dependency_index.waiters
+            self.dependency_index
+                .waiters
                 .entry((node.clone(), *timestamp))
                 .or_insert_with(Vec::new)
                 .push(op_id.to_string());
@@ -620,7 +623,11 @@ impl CausalDependencyBarrier {
     #[cfg(test)]
     fn unindex_operation(&mut self, op_id: &str, required: &VectorClock) {
         for (node, timestamp) in &required.clocks {
-            if let Some(waiters) = self.dependency_index.waiters.get_mut(&(node.clone(), *timestamp)) {
+            if let Some(waiters) = self
+                .dependency_index
+                .waiters
+                .get_mut(&(node.clone(), *timestamp))
+            {
                 waiters.retain(|id| id != op_id);
             }
         }
@@ -705,7 +712,7 @@ mod tests {
 
             // Advance frontier to satisfy requirement
             barrier.advance_frontier(&required);
-            barrier.clear_metrics();  // Reset metrics after setup
+            barrier.clear_metrics(); // Reset metrics after setup
 
             // Pre-fill buffer with unrelated operations
             for i in 0..buffer_size {
@@ -713,14 +720,11 @@ mod tests {
                 unrelated.increment(&format!("other_{}", i));
                 let _ = barrier.receive_operation(format!("op_buffer_{}", i), unrelated);
             }
-            barrier.clear_metrics();  // Reset metrics after filling
+            barrier.clear_metrics(); // Reset metrics after filling
 
             // Critical test: receive satisfied operation
             // Expected: Should be ready, metrics should show frontier check not buffer scan
-            let result = barrier.receive_operation(
-                "op_test".to_string(),
-                required.clone(),
-            );
+            let result = barrier.receive_operation("op_test".to_string(), required.clone());
 
             let metrics = barrier.metrics();
 
@@ -778,10 +782,13 @@ mod tests {
 
         let mut required = VectorClock::new();
         required.increment("node_a");
-        required.increment("node_a");  // {node_a: 2}
+        required.increment("node_a"); // {node_a: 2}
 
         let result = barrier.receive_operation("op1".to_string(), required);
-        assert!(matches!(result, ReceiveResult::BufferedWaitingForDependencies { .. }));
+        assert!(matches!(
+            result,
+            ReceiveResult::BufferedWaitingForDependencies { .. }
+        ));
         assert_eq!(barrier.get_pending_operations().len(), 1);
     }
 
@@ -792,10 +799,13 @@ mod tests {
         // Operation requires {node_a: 2}
         let mut required = VectorClock::new();
         required.increment("node_a");
-        required.increment("node_a");  // {node_a: 2}
+        required.increment("node_a"); // {node_a: 2}
 
         let result = barrier.receive_operation("op1".to_string(), required);
-        assert!(matches!(result, ReceiveResult::BufferedWaitingForDependencies { .. }));
+        assert!(matches!(
+            result,
+            ReceiveResult::BufferedWaitingForDependencies { .. }
+        ));
         assert_eq!(barrier.get_pending_operations().len(), 1);
 
         // Advance frontier to satisfy dependency
@@ -817,14 +827,17 @@ mod tests {
 
         // Op2 depends on Op1 having been applied
         // Op1 has no dependencies
-        let op1_required = VectorClock::new();  // Op1 requires nothing
+        let op1_required = VectorClock::new(); // Op1 requires nothing
 
         let mut op2_required = VectorClock::new();
-        op2_required.increment("node_a");  // Op2 requires {node_a: 1}
+        op2_required.increment("node_a"); // Op2 requires {node_a: 1}
 
         // Receive Op2 before Op1
         let result = barrier.receive_operation("op2".to_string(), op2_required.clone());
-        assert!(matches!(result, ReceiveResult::BufferedWaitingForDependencies { .. }));
+        assert!(matches!(
+            result,
+            ReceiveResult::BufferedWaitingForDependencies { .. }
+        ));
 
         // Receive Op1 (which has no dependencies)
         let result = barrier.receive_operation("op1".to_string(), op1_required.clone());
@@ -864,7 +877,7 @@ mod tests {
         barrier.receive_operation("op1".to_string(), op1_clock.clone());
 
         // All should be buffered except Op1 (which can apply immediately)
-        assert_eq!(barrier.get_pending_operations().len(), 2);  // Op2 and Op3
+        assert_eq!(barrier.get_pending_operations().len(), 2); // Op2 and Op3
 
         // Apply Op1
         let mut apply_clock = VectorClock::new();
@@ -1051,7 +1064,7 @@ mod tests {
         // Trigger full-scan directly: should see all 10 items
         let mut partial = VectorClock::new();
         partial.increment("node_a");
-        partial.increment("node_a");  // Only {node_a: 2}, not enough for requirement
+        partial.increment("node_a"); // Only {node_a: 2}, not enough for requirement
         {
             let current = barrier.get_frontier().clone();
             barrier.get_prev_frontier_mut().clone_from(&current);
@@ -1077,7 +1090,7 @@ mod tests {
         let mut more_partial = VectorClock::new();
         more_partial.increment("node_a");
         more_partial.increment("node_a");
-        more_partial.increment("node_a");  // Only {node_a: 3}, still not enough
+        more_partial.increment("node_a"); // Only {node_a: 3}, still not enough
         {
             let current = barrier.get_frontier().clone();
             barrier.get_prev_frontier_mut().clone_from(&current);
@@ -1120,14 +1133,20 @@ mod tests {
         a3_required.increment("node_a");
         a3_required.increment("node_a");
         let result_a3 = barrier.receive_operation("A3".to_string(), a3_required.clone());
-        assert!(matches!(result_a3, ReceiveResult::BufferedWaitingForDependencies { .. }));
+        assert!(matches!(
+            result_a3,
+            ReceiveResult::BufferedWaitingForDependencies { .. }
+        ));
 
         // A2: requires {node_a: 2}
         let mut a2_required = VectorClock::new();
         a2_required.increment("node_a");
         a2_required.increment("node_a");
         let result_a2 = barrier.receive_operation("A2".to_string(), a2_required.clone());
-        assert!(matches!(result_a2, ReceiveResult::BufferedWaitingForDependencies { .. }));
+        assert!(matches!(
+            result_a2,
+            ReceiveResult::BufferedWaitingForDependencies { .. }
+        ));
 
         // Now frontier is only {node_a: 1}, both A2 and A3 are buffered
         assert_eq!(barrier.get_pending_operations().len(), 2);
@@ -1143,7 +1162,10 @@ mod tests {
         let pending = barrier.get_pending_operations();
         assert_eq!(pending.len(), 1);
         assert_eq!(pending[0].operation_id, "A3");
-        assert!(matches!(pending[0].state, OperationState::WaitingForDependencies { .. }));
+        assert!(matches!(
+            pending[0].state,
+            OperationState::WaitingForDependencies { .. }
+        ));
 
         // Apply A3 with {node_a: 3}
         let mut a3_contribution = VectorClock::new();
@@ -1167,16 +1189,19 @@ mod tests {
         let mut a5_required = VectorClock::new();
         a5_required.increment("B");
         a5_required.increment("B");
-        a5_required.increment("B");  // {B: 3}
+        a5_required.increment("B"); // {B: 3}
         for _ in 0..7 {
             a5_required.increment("C");
-        }  // {C: 7}
+        } // {C: 7}
         a5_required.increment("D");
-        a5_required.increment("D");  // {D: 2}
+        a5_required.increment("D"); // {D: 2}
 
         // Try to receive A5 before any dependencies
         let result = barrier.receive_operation("A5".to_string(), a5_required.clone());
-        assert!(matches!(result, ReceiveResult::BufferedWaitingForDependencies { .. }));
+        assert!(matches!(
+            result,
+            ReceiveResult::BufferedWaitingForDependencies { .. }
+        ));
 
         // Partially satisfy: apply B3
         let mut b3_clock = VectorClock::new();
@@ -1245,7 +1270,10 @@ mod tests {
         b3_required.increment("B");
         b3_required.increment("B");
         let result_b3 = barrier.receive_operation("B3".to_string(), b3_required.clone());
-        assert!(matches!(result_b3, ReceiveResult::BufferedWaitingForDependencies { .. }));
+        assert!(matches!(
+            result_b3,
+            ReceiveResult::BufferedWaitingForDependencies { .. }
+        ));
 
         // At this point:
         // - applied_frontier[B] = 1 (only B1 applied)
@@ -1258,7 +1286,10 @@ mod tests {
         a5_required.increment("B");
         a5_required.increment("B");
         let result_a5 = barrier.receive_operation("A5".to_string(), a5_required.clone());
-        assert!(matches!(result_a5, ReceiveResult::BufferedWaitingForDependencies { .. }));
+        assert!(matches!(
+            result_a5,
+            ReceiveResult::BufferedWaitingForDependencies { .. }
+        ));
 
         // NOW apply B3
         barrier.apply_operation("B3", &b3_required);
@@ -1285,7 +1316,10 @@ mod tests {
 
         for i in 0..5 {
             let result = barrier.receive_operation(format!("op_{}", i), required.clone());
-            assert!(matches!(result, ReceiveResult::BufferedWaitingForDependencies { .. }));
+            assert!(matches!(
+                result,
+                ReceiveResult::BufferedWaitingForDependencies { .. }
+            ));
         }
 
         assert_eq!(barrier.get_pending_operations().len(), 5);
@@ -1470,12 +1504,18 @@ mod tests {
         barrier.receive_operation("op_a3".to_string(), req_a3);
 
         // Verify index is correct
-        let a1_waiters = barrier.dependency_index.waiters.get(&("node_a".to_string(), 1))
+        let a1_waiters = barrier
+            .dependency_index
+            .waiters
+            .get(&("node_a".to_string(), 1))
             .map(|w| w.clone())
             .unwrap_or_default();
         assert!(a1_waiters.contains(&"op_a1".to_string()));
 
-        let a2_waiters = barrier.dependency_index.waiters.get(&("node_a".to_string(), 2))
+        let a2_waiters = barrier
+            .dependency_index
+            .waiters
+            .get(&("node_a".to_string(), 2))
             .map(|w| w.clone())
             .unwrap_or_default();
         assert!(a2_waiters.contains(&"op_a2".to_string()));
@@ -1487,7 +1527,8 @@ mod tests {
 
         // Check which operations are Ready
         let pending = barrier.get_pending_operations();
-        let ready: Vec<_> = pending.iter()
+        let ready: Vec<_> = pending
+            .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .map(|p| p.operation_id.clone())
             .collect();
@@ -1498,7 +1539,8 @@ mod tests {
         assert!(ready.contains(&"op_a2".to_string()));
 
         // op_a3 should still be Waiting (needs A:3)
-        let waiting: Vec<_> = pending.iter()
+        let waiting: Vec<_> = pending
+            .iter()
             .filter(|p| matches!(p.state, OperationState::WaitingForDependencies { .. }))
             .map(|p| p.operation_id.clone())
             .collect();
@@ -1518,9 +1560,13 @@ mod tests {
         // Add 20 operations with varied dependencies
         for i in 0..20 {
             let mut required = VectorClock::new();
-            required.clocks.insert("node_a".to_string(), ((i % 5) + 1) as u64);
+            required
+                .clocks
+                .insert("node_a".to_string(), ((i % 5) + 1) as u64);
             if i % 3 == 0 {
-                required.clocks.insert("node_b".to_string(), ((i / 3) + 1) as u64);
+                required
+                    .clocks
+                    .insert("node_b".to_string(), ((i / 3) + 1) as u64);
             }
             barrier.receive_operation(format!("op_{}", i), required);
         }
@@ -1530,11 +1576,16 @@ mod tests {
             for (node, ts) in &pending_op.required_dependencies.clocks {
                 let key = (node.clone(), *ts);
                 assert!(
-                    barrier.dependency_index.waiters.get(&key)
+                    barrier
+                        .dependency_index
+                        .waiters
+                        .get(&key)
                         .map(|waiters| waiters.contains(op_id))
                         .unwrap_or(false),
                     "Operation {} not found in index for ({}, {})",
-                    op_id, node, ts
+                    op_id,
+                    node,
+                    ts
                 );
             }
         }
@@ -1551,11 +1602,12 @@ mod tests {
         let result = barrier.receive_operation("op_1".to_string(), required.clone());
 
         // Verify it's indexed
-        assert!(
-            barrier.dependency_index.waiters.get(&("node_a".to_string(), 1))
-                .map(|w| w.contains(&"op_1".to_string()))
-                .unwrap_or(false)
-        );
+        assert!(barrier
+            .dependency_index
+            .waiters
+            .get(&("node_a".to_string(), 1))
+            .map(|w| w.contains(&"op_1".to_string()))
+            .unwrap_or(false));
 
         // Apply operation (moving it from pending to applied)
         barrier.apply_operation("op_1", &required);
@@ -1580,12 +1632,18 @@ mod tests {
         barrier.receive_operation("op_dup".to_string(), required.clone());
 
         // Should be indexed exactly once for (node_a, 5)
-        let waiters_at_5 = barrier.dependency_index.waiters.get(&("node_a".to_string(), 5))
+        let waiters_at_5 = barrier
+            .dependency_index
+            .waiters
+            .get(&("node_a".to_string(), 5))
             .map(|w| w.iter().filter(|id| id == &"op_dup").count())
             .unwrap_or(0);
 
         // VectorClock naturally deduplicates, so should only appear once
-        assert_eq!(waiters_at_5, 1, "Operation should appear once per unique dependency");
+        assert_eq!(
+            waiters_at_5, 1,
+            "Operation should appear once per unique dependency"
+        );
     }
 
     #[test]
@@ -1601,15 +1659,24 @@ mod tests {
         barrier.receive_operation("op_multi".to_string(), required);
 
         // Should be findable via any dependency
-        assert!(barrier.dependency_index.waiters.get(&("node_a".to_string(), 2))
+        assert!(barrier
+            .dependency_index
+            .waiters
+            .get(&("node_a".to_string(), 2))
             .map(|w| w.contains(&"op_multi".to_string()))
             .unwrap_or(false));
 
-        assert!(barrier.dependency_index.waiters.get(&("node_b".to_string(), 3))
+        assert!(barrier
+            .dependency_index
+            .waiters
+            .get(&("node_b".to_string(), 3))
             .map(|w| w.contains(&"op_multi".to_string()))
             .unwrap_or(false));
 
-        assert!(barrier.dependency_index.waiters.get(&("node_c".to_string(), 1))
+        assert!(barrier
+            .dependency_index
+            .waiters
+            .get(&("node_c".to_string(), 1))
             .map(|w| w.contains(&"op_multi".to_string()))
             .unwrap_or(false));
     }
@@ -1639,11 +1706,13 @@ mod tests {
 
         // Check which operations are Ready vs still Waiting
         let pending = barrier.get_pending_operations();
-        let ready_ops: Vec<_> = pending.iter()
+        let ready_ops: Vec<_> = pending
+            .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .map(|p| p.operation_id.clone())
             .collect();
-        let waiting_ops: Vec<_> = pending.iter()
+        let waiting_ops: Vec<_> = pending
+            .iter()
             .filter(|p| matches!(p.state, OperationState::WaitingForDependencies { .. }))
             .map(|p| p.operation_id.clone())
             .collect();
@@ -1675,7 +1744,10 @@ mod tests {
         barrier.receive_operation("op_2".to_string(), req_2);
 
         // Index should have entries
-        assert!(barrier.dependency_index.waiters.get(&("node_a".to_string(), 1))
+        assert!(barrier
+            .dependency_index
+            .waiters
+            .get(&("node_a".to_string(), 1))
             .map(|w| w.contains(&"op_1".to_string()))
             .unwrap_or(false));
 
@@ -1700,7 +1772,9 @@ mod tests {
         // Add mix of operations
         for i in 0..5 {
             let mut required = VectorClock::new();
-            required.clocks.insert("node_a".to_string(), ((i % 3) + 1) as u64);
+            required
+                .clocks
+                .insert("node_a".to_string(), ((i % 3) + 1) as u64);
             barrier.receive_operation(format!("op_{}", i), required);
         }
 
@@ -1708,11 +1782,16 @@ mod tests {
         for (op_id, pending_op) in &barrier.pending {
             for (node, ts) in &pending_op.required_dependencies.clocks {
                 assert!(
-                    barrier.dependency_index.waiters.get(&(node.clone(), *ts))
+                    barrier
+                        .dependency_index
+                        .waiters
+                        .get(&(node.clone(), *ts))
                         .map(|w| w.contains(op_id))
                         .unwrap_or(false),
                     "Operation {} not indexed for ({}, {})",
-                    op_id, node, ts
+                    op_id,
+                    node,
+                    ts
                 );
             }
         }
@@ -1726,7 +1805,10 @@ mod tests {
         for (op_id, pending_op) in &barrier.pending {
             for (node, ts) in &pending_op.required_dependencies.clocks {
                 assert!(
-                    barrier.dependency_index.waiters.get(&(node.clone(), *ts))
+                    barrier
+                        .dependency_index
+                        .waiters
+                        .get(&(node.clone(), *ts))
                         .map(|w| w.contains(op_id))
                         .unwrap_or(false),
                     "Remaining operation {} should still be in index",
@@ -1761,7 +1843,9 @@ mod tests {
             let mut rng_seed = hasher.finish();
 
             fn next_rng(seed: &mut u64) -> u64 {
-                *seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+                *seed = seed
+                    .wrapping_mul(6364136223846793005)
+                    .wrapping_add(1442695040888963407);
                 *seed
             }
 
@@ -1836,12 +1920,16 @@ mod tests {
                 barrier_opt.clear_metrics();
 
                 // Reference
-                barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+                barrier_ref
+                    .prev_frontier
+                    .clone_from(&barrier_ref.local_frontier);
                 barrier_ref.local_frontier.merge(advance);
                 let _ref_ready = barrier_ref.check_unblocked_operations_full_scan();
 
                 // Optimized
-                barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+                barrier_opt
+                    .prev_frontier
+                    .clone_from(&barrier_opt.local_frontier);
                 barrier_opt.local_frontier.merge(advance);
                 let _opt_ready = barrier_opt.check_unblocked_operations_indexed();
 
@@ -1863,7 +1951,9 @@ mod tests {
                             assert!(
                                 waiters.contains(op_id),
                                 "Seed {}: Operation {} not in index for {:?}",
-                                seed, op_id, key
+                                seed,
+                                op_id,
+                                key
                             );
                         }
                     }
@@ -1890,20 +1980,26 @@ mod tests {
         let mut frontier = VectorClock::new();
         frontier.clocks.insert("node_a".to_string(), 5);
 
-        barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+        barrier_ref
+            .prev_frontier
+            .clone_from(&barrier_ref.local_frontier);
         barrier_ref.local_frontier.merge(&frontier);
         barrier_ref.check_unblocked_operations_full_scan();
 
-        barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+        barrier_opt
+            .prev_frontier
+            .clone_from(&barrier_opt.local_frontier);
         barrier_opt.local_frontier.merge(&frontier);
         barrier_opt.check_unblocked_operations_indexed();
 
         // Both should have released all 10
-        let ref_ready = barrier_ref.get_pending_operations()
+        let ref_ready = barrier_ref
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
-        let opt_ready = barrier_opt.get_pending_operations()
+        let opt_ready = barrier_opt
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
@@ -1929,20 +2025,26 @@ mod tests {
         let mut frontier = VectorClock::new();
         frontier.clocks.insert("node_a".to_string(), 7);
 
-        barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+        barrier_ref
+            .prev_frontier
+            .clone_from(&barrier_ref.local_frontier);
         barrier_ref.local_frontier.merge(&frontier);
         barrier_ref.check_unblocked_operations_full_scan();
 
-        barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+        barrier_opt
+            .prev_frontier
+            .clone_from(&barrier_opt.local_frontier);
         barrier_opt.local_frontier.merge(&frontier);
         barrier_opt.check_unblocked_operations_indexed();
 
         // Both should have released op_1 through op_7
-        let ref_ready = barrier_ref.get_pending_operations()
+        let ref_ready = barrier_ref
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
-        let opt_ready = barrier_opt.get_pending_operations()
+        let opt_ready = barrier_opt
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
@@ -1967,19 +2069,25 @@ mod tests {
         let mut frontier = VectorClock::new();
         frontier.clocks.insert("node_a".to_string(), 5);
 
-        barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+        barrier_ref
+            .prev_frontier
+            .clone_from(&barrier_ref.local_frontier);
         barrier_ref.local_frontier.merge(&frontier);
         barrier_ref.check_unblocked_operations_full_scan();
 
-        barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+        barrier_opt
+            .prev_frontier
+            .clone_from(&barrier_opt.local_frontier);
         barrier_opt.local_frontier.merge(&frontier);
         barrier_opt.check_unblocked_operations_indexed();
 
-        let ref_ready = barrier_ref.get_pending_operations()
+        let ref_ready = barrier_ref
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
-        let opt_ready = barrier_opt.get_pending_operations()
+        let opt_ready = barrier_opt
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
@@ -1997,11 +2105,15 @@ mod tests {
         let mut frontier = VectorClock::new();
         frontier.clocks.insert("node_a".to_string(), 10);
 
-        barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+        barrier_ref
+            .prev_frontier
+            .clone_from(&barrier_ref.local_frontier);
         barrier_ref.local_frontier.merge(&frontier);
         let ref_ready = barrier_ref.check_unblocked_operations_full_scan();
 
-        barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+        barrier_opt
+            .prev_frontier
+            .clone_from(&barrier_opt.local_frontier);
         barrier_opt.local_frontier.merge(&frontier);
         let opt_ready = barrier_opt.check_unblocked_operations_indexed();
 
@@ -2016,7 +2128,8 @@ mod tests {
 
         for i in 0..50 {
             let mut req = VectorClock::new();
-            req.clocks.insert("node_a".to_string(), ((i % 10) + 1) as u64);
+            req.clocks
+                .insert("node_a".to_string(), ((i % 10) + 1) as u64);
             barrier.receive_operation(format!("op_{}", i), req);
         }
 
@@ -2047,7 +2160,8 @@ mod tests {
         // Build up some state
         for i in 0..20 {
             let mut req = VectorClock::new();
-            req.clocks.insert("node_a".to_string(), ((i % 5) + 1) as u64);
+            req.clocks
+                .insert("node_a".to_string(), ((i % 5) + 1) as u64);
             barrier1.receive_operation(format!("op_{}", i), req);
         }
 
@@ -2060,14 +2174,10 @@ mod tests {
 
         let mut barrier2 = CausalDependencyBarrier::new();
         for pending_op in pending_snapshot {
-            barrier2.pending.insert(
-                pending_op.operation_id.clone(),
-                pending_op.clone(),
-            );
-            barrier2.index_operation(
-                &pending_op.operation_id,
-                &pending_op.required_dependencies,
-            );
+            barrier2
+                .pending
+                .insert(pending_op.operation_id.clone(), pending_op.clone());
+            barrier2.index_operation(&pending_op.operation_id, &pending_op.required_dependencies);
         }
 
         // Verify index is equivalent
@@ -2105,11 +2215,15 @@ mod tests {
         let mut frontier = VectorClock::new();
         frontier.clocks.insert("node_a".to_string(), 5);
 
-        barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+        barrier_ref
+            .prev_frontier
+            .clone_from(&barrier_ref.local_frontier);
         barrier_ref.local_frontier.merge(&frontier);
         let _ref_ready = barrier_ref.check_unblocked_operations_full_scan();
 
-        barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+        barrier_opt
+            .prev_frontier
+            .clone_from(&barrier_opt.local_frontier);
         barrier_opt.local_frontier.merge(&frontier);
         let _opt_ready = barrier_opt.check_unblocked_operations_indexed();
 
@@ -2120,8 +2234,13 @@ mod tests {
         assert_eq!(ref_pending.len(), opt_pending.len());
 
         for ref_op in ref_pending.iter() {
-            let opt_op = opt_pending.iter().find(|op| op.operation_id == ref_op.operation_id)
-                .expect(&format!("Operation {} missing in optimized", ref_op.operation_id));
+            let opt_op = opt_pending
+                .iter()
+                .find(|op| op.operation_id == ref_op.operation_id)
+                .expect(&format!(
+                    "Operation {} missing in optimized",
+                    ref_op.operation_id
+                ));
 
             assert_eq!(
                 std::mem::discriminant(&ref_op.state),
@@ -2155,20 +2274,26 @@ mod tests {
         partial.clocks.insert("node_b".to_string(), 1);
         partial.clocks.insert("node_c".to_string(), 1);
 
-        barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+        barrier_ref
+            .prev_frontier
+            .clone_from(&barrier_ref.local_frontier);
         barrier_ref.local_frontier.merge(&partial);
         barrier_ref.check_unblocked_operations_full_scan();
 
-        barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+        barrier_opt
+            .prev_frontier
+            .clone_from(&barrier_opt.local_frontier);
         barrier_opt.local_frontier.merge(&partial);
         barrier_opt.check_unblocked_operations_indexed();
 
         // op_all_three should still be waiting
-        let ref_waiting = barrier_ref.get_pending_operations()
+        let ref_waiting = barrier_ref
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::WaitingForDependencies { .. }))
             .count();
-        let opt_waiting = barrier_opt.get_pending_operations()
+        let opt_waiting = barrier_opt
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::WaitingForDependencies { .. }))
             .count();
@@ -2182,20 +2307,26 @@ mod tests {
         full.clocks.insert("node_b".to_string(), 3);
         full.clocks.insert("node_c".to_string(), 2);
 
-        barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+        barrier_ref
+            .prev_frontier
+            .clone_from(&barrier_ref.local_frontier);
         barrier_ref.local_frontier.merge(&full);
         barrier_ref.check_unblocked_operations_full_scan();
 
-        barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+        barrier_opt
+            .prev_frontier
+            .clone_from(&barrier_opt.local_frontier);
         barrier_opt.local_frontier.merge(&full);
         barrier_opt.check_unblocked_operations_indexed();
 
         // Now op_all_three should be ready
-        let ref_ready = barrier_ref.get_pending_operations()
+        let ref_ready = barrier_ref
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
-        let opt_ready = barrier_opt.get_pending_operations()
+        let opt_ready = barrier_opt
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
@@ -2226,21 +2357,27 @@ mod tests {
                 frontier.clocks.insert(n.to_string(), ts);
             }
 
-            barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+            barrier_ref
+                .prev_frontier
+                .clone_from(&barrier_ref.local_frontier);
             barrier_ref.local_frontier.merge(&frontier);
             barrier_ref.check_unblocked_operations_full_scan();
 
-            barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+            barrier_opt
+                .prev_frontier
+                .clone_from(&barrier_opt.local_frontier);
             barrier_opt.local_frontier.merge(&frontier);
             barrier_opt.check_unblocked_operations_indexed();
         }
 
         // Both should have released all 5 operations
-        let ref_ready = barrier_ref.get_pending_operations()
+        let ref_ready = barrier_ref
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
-        let opt_ready = barrier_opt.get_pending_operations()
+        let opt_ready = barrier_opt
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
@@ -2268,20 +2405,26 @@ mod tests {
         let mut frontier = VectorClock::new();
         frontier.clocks.insert("node_a".to_string(), 25);
 
-        barrier_ref.prev_frontier.clone_from(&barrier_ref.local_frontier);
+        barrier_ref
+            .prev_frontier
+            .clone_from(&barrier_ref.local_frontier);
         barrier_ref.local_frontier.merge(&frontier);
         barrier_ref.check_unblocked_operations_full_scan();
 
-        barrier_opt.prev_frontier.clone_from(&barrier_opt.local_frontier);
+        barrier_opt
+            .prev_frontier
+            .clone_from(&barrier_opt.local_frontier);
         barrier_opt.local_frontier.merge(&frontier);
         barrier_opt.check_unblocked_operations_indexed();
 
         // Both should release exactly 25 operations
-        let ref_ready = barrier_ref.get_pending_operations()
+        let ref_ready = barrier_ref
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
-        let opt_ready = barrier_opt.get_pending_operations()
+        let opt_ready = barrier_opt
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
@@ -2314,11 +2457,13 @@ mod tests {
         barrier_opt.advance_frontier(&frontier);
 
         // All operations should be ready
-        let ref_ready = barrier_ref.get_pending_operations()
+        let ref_ready = barrier_ref
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
-        let opt_ready = barrier_opt.get_pending_operations()
+        let opt_ready = barrier_opt
+            .get_pending_operations()
             .iter()
             .filter(|p| matches!(p.state, OperationState::Ready))
             .count();
@@ -2342,7 +2487,9 @@ mod tests {
             for (op_id, pending_op) in &barrier.pending {
                 let mut found = false;
                 for (node, ts) in &pending_op.required_dependencies.clocks {
-                    if let Some(waiters) = barrier.dependency_index.waiters.get(&(node.clone(), *ts)) {
+                    if let Some(waiters) =
+                        barrier.dependency_index.waiters.get(&(node.clone(), *ts))
+                    {
                         if waiters.contains(op_id) {
                             found = true;
                             break;
@@ -2378,7 +2525,9 @@ mod tests {
                     assert!(
                         new_ts >= *prev_ts,
                         "Frontier regressed for {} from {} to {}",
-                        node, prev_ts, new_ts
+                        node,
+                        prev_ts,
+                        new_ts
                     );
                 }
 
@@ -2408,7 +2557,10 @@ mod tests {
                 for pending_op in barrier.get_pending_operations() {
                     if matches!(pending_op.state, OperationState::Ready) {
                         seen_ready.insert(pending_op.operation_id.clone());
-                    } else if matches!(pending_op.state, OperationState::WaitingForDependencies { .. }) {
+                    } else if matches!(
+                        pending_op.state,
+                        OperationState::WaitingForDependencies { .. }
+                    ) {
                         assert!(
                             !seen_ready.contains(&pending_op.operation_id),
                             "Operation {} regressed from Ready to Waiting",