@feltdb/core 0.8.4 → 0.8.5

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

@@ -20,7 +20,9 @@ mod phase_7_1_release_economics {
             // Fill with blocked operations
             for i in 0..*pending_size {
                 let mut required = VectorClock::new();
-                required.clocks.insert("node_a".to_string(), (1000 + i) as u64);
+                required
+                    .clocks
+                    .insert("node_a".to_string(), (1000 + i) as u64);
                 let _ = barrier.receive_operation(format!("pending_{}", i), required);
             }
 
@@ -34,7 +36,10 @@ mod phase_7_1_release_economics {
             let metrics = barrier.metrics();
             println!(
                 "Pending={:5} | Cost={:?} | Entries examined={} | Released={}",
-                pending_size, elapsed, metrics.pending_entries_examined, metrics.operations_released
+                pending_size,
+                elapsed,
+                metrics.pending_entries_examined,
+                metrics.operations_released
             );
         }
     }
@@ -74,14 +79,19 @@ mod phase_7_1_release_economics {
 
             let metrics = barrier.metrics();
             let released_pct = if metrics.pending_entries_examined > 0 {
-                (metrics.operations_released as f64 / metrics.pending_entries_examined as f64) * 100.0
+                (metrics.operations_released as f64 / metrics.pending_entries_examined as f64)
+                    * 100.0
             } else {
                 0.0
             };
 
             println!(
                 "Ready%={:3} | Cost={:?} | Examined={:3} | Released={:3} | Ratio={:.1}%",
-                ready_percent, elapsed, metrics.pending_entries_examined, metrics.operations_released, released_pct
+                ready_percent,
+                elapsed,
+                metrics.pending_entries_examined,
+                metrics.operations_released,
+                released_pct
             );
         }
     }
@@ -102,7 +112,10 @@ mod phase_7_1_release_economics {
             let _ = barrier.receive_operation(format!("seq_{}", i), required);
         }
 
-        println!("Initial pending: {}", barrier.get_pending_operations().len());
+        println!(
+            "Initial pending: {}",
+            barrier.get_pending_operations().len()
+        );
 
         // Advance frontier multiple times
         let start = Instant::now();
@@ -137,7 +150,10 @@ mod phase_7_1_release_economics {
 
         // Analysis
         if total_entries_examined > 500 {
-            println!("⚠️  WARNING: Examined {} entries for 100 pending (10 advances)", total_entries_examined);
+            println!(
+                "⚠️  WARNING: Examined {} entries for 100 pending (10 advances)",
+                total_entries_examined
+            );
             println!("   Expected if O(m): ~100-200");
             println!("   This suggests possible rescanning behavior");
         } else {
@@ -159,7 +175,9 @@ mod phase_7_1_release_economics {
             for i in 0..*pending_size {
                 let mut required = VectorClock::new();
                 let dependency_level = ((i * 997) % 1000) as u64 + 1;
-                required.clocks.insert("node_a".to_string(), dependency_level);
+                required
+                    .clocks
+                    .insert("node_a".to_string(), dependency_level);
                 let _ = barrier.receive_operation(format!("mixed_{}", i), required);
             }
 

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

@@ -7,7 +7,6 @@
 /// - Execution interleaving
 ///
 /// Verifies final state matches deterministic reference model.
-
 use crate::convergence::VectorClock;
 use crate::state_hash::StateHash;
 use crate::transactions::*;
@@ -71,7 +70,9 @@ impl ConcurrencyFuzzer {
 
     /// Generate random transaction
     fn generate_transaction(&mut self, id: usize) -> FuzzedTransaction {
-        let num_ops = self.rng.gen_range(1..=self.config.max_operations_per_transaction);
+        let num_ops = self
+            .rng
+            .gen_range(1..=self.config.max_operations_per_transaction);
         let mut write_set = HashSet::new();
         let mut read_set = HashSet::new();
         let mut operations = Vec::new();
@@ -82,10 +83,7 @@ impl ConcurrencyFuzzer {
         let base_version = StateVersion::new(vc.clone(), format!("genesis_{}", id));
 
         for op_idx in 0..num_ops {
-            let record_id = format!(
-                "rec_{}",
-                self.rng.gen_range(0..self.config.max_records)
-            );
+            let record_id = format!("rec_{}", self.rng.gen_range(0..self.config.max_records));
             let value = self.rng.gen_range(0..1000);
 
             let op_id = OperationId::new("fuzzer".to_string(), ((id * 100) + op_idx) as u64);
@@ -109,10 +107,7 @@ impl ConcurrencyFuzzer {
 
             // Randomly add read dependencies
             if self.rng.gen_bool(0.3) {
-                let read_record = format!(
-                    "rec_{}",
-                    self.rng.gen_range(0..self.config.max_records)
-                );
+                let read_record = format!("rec_{}", self.rng.gen_range(0..self.config.max_records));
                 op = op.with_read_set(vec![StateDependency::new(
                     "fuzzing".to_string(),
                     read_record.clone(),
@@ -190,10 +185,7 @@ impl ConcurrencyFuzzer {
         let conflict_graph = Self::compute_conflict_graph(workload);
         let total_conflicts: usize = conflict_graph.iter().map(|(_, v)| v.len()).sum::<usize>() / 2; // Each edge counted twice
 
-        let concurrent_transactions = workload
-            .iter()
-            .filter(|t| t.operations.len() > 1)
-            .count();
+        let concurrent_transactions = workload.iter().filter(|t| t.operations.len() > 1).count();
         let sequential_transactions = total_transactions - concurrent_transactions;
 
         FuzzingStats {
@@ -422,6 +414,9 @@ mod tests {
             .filter(|(tx1, tx2)| tx1.write_set != tx2.write_set)
             .count();
 
-        assert!(diff_count > 0, "Different seeds should produce different workloads");
+        assert!(
+            diff_count > 0,
+            "Different seeds should produce different workloads"
+        );
     }
 }

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

@@ -18,7 +18,6 @@
 /// 3. Consensus-Required Operations
 ///    - Must serialize through consensus (strong ordering)
 ///    - Examples: Transfer (requires mutual exclusion)
-
 use crate::operation_algebra::{ConflictType, ConvergenceSemantic, OperationAlgebra};
 use std::collections::HashMap;
 
@@ -245,9 +244,7 @@ pub enum NoDowngradeVerificationResult {
         operations_checked: usize,
     },
     /// Silent downgrade detected
-    DowngradeDetected {
-        reason: String,
-    },
+    DowngradeDetected { reason: String },
 }
 
 /// Consensus requirement checker
@@ -307,9 +304,7 @@ pub enum ConsensusEnforcementResult {
     /// No consensus operations
     NoConsensusOps,
     /// Consensus requirement satisfied
-    Satisfied {
-        consensus_operations: usize,
-    },
+    Satisfied { consensus_operations: usize },
     /// Consensus requirement violated
     Violated {
         operations_requiring_consensus: Vec<String>,
@@ -399,10 +394,7 @@ mod tests {
         let semantic = ConvergenceSemantic::DeterministicMerge;
 
         let result = enforcer.verify_no_downgrade(&semantic);
-        assert_eq!(
-            result,
-            NoDowngradeVerificationResult::NoOperations
-        );
+        assert_eq!(result, NoDowngradeVerificationResult::NoOperations);
     }
 
     #[test]

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

@@ -18,7 +18,6 @@
 /// Never:
 ///   - state reflects op but dedup missing (double-apply on retry)
 ///   - dedup has op but state wasn't mutated (phantom operation)
-
 use crate::state_hash::CanonicalState;
 use std::collections::HashSet;
 
@@ -37,7 +36,7 @@ pub enum CrashBoundaryPoint {
 #[derive(Clone, Debug)]
 pub struct CrashAtomicExecutor {
     state: CanonicalState,
-    dedup_set: HashSet<String>,  // OperationId set
+    dedup_set: HashSet<String>, // OperationId set
 }
 
 impl CrashAtomicExecutor {
@@ -57,7 +56,10 @@ impl CrashAtomicExecutor {
     ) -> Result<(), String> {
         // Check for duplicate before applying
         if self.dedup_set.contains(operation_id) {
-            return Err(format!("Operation {} already applied (dedup hit)", operation_id));
+            return Err(format!(
+                "Operation {} already applied (dedup hit)",
+                operation_id
+            ));
         }
 
         // Simulate state mutation
@@ -114,7 +116,11 @@ impl CrashAtomicExecutor {
     pub fn recover(&self, crash_state: &CrashRecoveryState) -> RecoveryDecision {
         let in_dedup = self.dedup_set.contains(&crash_state.operation_id);
 
-        match (crash_state.state_mutated, crash_state.dedup_persisted, in_dedup) {
+        match (
+            crash_state.state_mutated,
+            crash_state.dedup_persisted,
+            in_dedup,
+        ) {
             // State mutated, dedup persisted → fully applied, don't retry
             (true, true, true) => RecoveryDecision::AlreadyApplied,
 
@@ -266,7 +272,10 @@ mod tests {
         ));
 
         let decision = executor.recover(&crash_state);
-        assert!(matches!(decision, RecoveryDecision::PartiallyApplied { .. }));
+        assert!(matches!(
+            decision,
+            RecoveryDecision::PartiallyApplied { .. }
+        ));
     }
 
     #[test]

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

@@ -2,7 +2,6 @@
 ///
 /// Simulates crashes at persistence boundaries to verify recovery behavior.
 /// Tests that recovery always produces valid state (pre-crash or post-crash, never partial).
-
 use crate::convergence::VectorClock;
 use crate::operation_log::MemoryOperationLog;
 use crate::state_hash::{CanonicalState, StateHash};
@@ -34,17 +33,11 @@ pub struct ExecutionCheckpoint {
 #[derive(Clone, Debug)]
 pub enum RecoveryResult {
     /// State is in a valid pre-transaction state
-    ValidPre {
-        checkpoint: ExecutionCheckpoint,
-    },
+    ValidPre { checkpoint: ExecutionCheckpoint },
     /// State is in a valid post-transaction state
-    ValidPost {
-        checkpoint: ExecutionCheckpoint,
-    },
+    ValidPost { checkpoint: ExecutionCheckpoint },
     /// State is corrupted or indeterminate
-    Invalid {
-        reason: String,
-    },
+    Invalid { reason: String },
 }
 
 /// Crash injection test harness
@@ -69,7 +62,11 @@ impl CrashInjectionTester {
 
     /// Simulate crash before operation log append
     pub fn crash_before_operation_append(&self, operation: &Operation) -> RecoveryResult {
-        assert_eq!(self.operation_log.size(), 0, "Operation should not be logged yet");
+        assert_eq!(
+            self.operation_log.size(),
+            0,
+            "Operation should not be logged yet"
+        );
         assert_eq!(
             self.transition_store.size(),
             0,
@@ -88,7 +85,9 @@ impl CrashInjectionTester {
 
     /// Simulate crash after operation log append (before transition)
     pub fn crash_after_operation_append(&self, operation: &Operation) -> RecoveryResult {
-        let op_appended = self.operation_log.contains_operation_id(&operation.operation_id);
+        let op_appended = self
+            .operation_log
+            .contains_operation_id(&operation.operation_id);
 
         if !op_appended {
             return RecoveryResult::Invalid {
@@ -114,9 +113,7 @@ impl CrashInjectionTester {
 
     /// Simulate crash after state transition recorded
     pub fn crash_after_transition_recorded(&self, transaction_id: &str) -> RecoveryResult {
-        let transition = self
-            .transition_store
-            .get_by_transaction_id(transaction_id);
+        let transition = self.transition_store.get_by_transaction_id(transaction_id);
 
         if transition.is_none() {
             return RecoveryResult::Invalid {
@@ -279,16 +276,11 @@ mod tests {
             let mut vc = VectorClock::new();
             vc.increment("node1");
 
-            let from_version = crate::transactions::StateVersion::new(
-                vc.clone(),
-                prev_hash.clone(),
-            );
+            let from_version =
+                crate::transactions::StateVersion::new(vc.clone(), prev_hash.clone());
 
             vc.increment("node1");
-            let to_version = crate::transactions::StateVersion::new(
-                vc,
-                format!("hash{}", i),
-            );
+            let to_version = crate::transactions::StateVersion::new(vc, format!("hash{}", i));
 
             let op = create_test_operation(i);
             let transition = StateTransition::new(
@@ -298,7 +290,10 @@ mod tests {
                 ConsistencyContract::local(),
             );
 
-            tester.transition_store.record_transition(transition).unwrap();
+            tester
+                .transition_store
+                .record_transition(transition)
+                .unwrap();
             prev_hash = format!("hash{}", i);
         }
 
@@ -327,7 +322,8 @@ mod tests {
 
         let mut vc2 = VectorClock::new();
         vc2.increment("node1");
-        let from_version2 = crate::transactions::StateVersion::new(vc2.clone(), "hash_broken".to_string());
+        let from_version2 =
+            crate::transactions::StateVersion::new(vc2.clone(), "hash_broken".to_string());
 
         vc2.increment("node1");
         let to_version2 = crate::transactions::StateVersion::new(vc2, "hash2".to_string());

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

@@ -3,7 +3,6 @@
 /// Comprehensive tests verifying that the transaction system can recover from
 /// partial failures and crashes. Tests scenarios where operations are logged but
 /// transitions not persisted, and vice versa.
-
 use crate::convergence::VectorClock;
 use crate::operation_log::MemoryOperationLog;
 use crate::state_transition_store::MemoryStateTransitionStore;
@@ -68,7 +67,12 @@ mod crash_recovery {
 
         let op_ids: Vec<_> = (1..=5)
             .map(|i| {
-                let op = create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
+                let op = create_test_operation(
+                    i,
+                    base_version.clone(),
+                    &format!("rec{}", i),
+                    i as i32 * 10,
+                );
                 let op_id = op.operation_id.clone();
                 log.append(op).unwrap();
                 op_id
@@ -176,7 +180,8 @@ mod crash_recovery {
         let base_version = create_version(1, "hash0");
 
         for i in 1..=10 {
-            let op = create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
+            let op =
+                create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
             log.append(op).unwrap();
         }
 
@@ -256,12 +261,8 @@ mod crash_recovery {
         assert!(log.contains_operation_id(&op_id));
 
         let ops = vec![create_test_operation(2, base_version.clone(), "rec2", 200)];
-        let transition = StateTransition::new(
-            base_version,
-            ops,
-            to_version,
-            ConsistencyContract::local(),
-        );
+        let transition =
+            StateTransition::new(base_version, ops, to_version, ConsistencyContract::local());
 
         store.record_transition(transition).unwrap();
         assert_eq!(store.size(), 1);
@@ -275,7 +276,8 @@ mod crash_recovery {
         let base_version = create_version(1, "hash0");
 
         for i in 1..=5 {
-            let op = create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
+            let op =
+                create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
             log.append(op.clone()).unwrap();
 
             let to_version = create_version(i as u64 + 1, &format!("hash{}", i));
@@ -304,7 +306,8 @@ mod crash_recovery {
         let base_version = create_version(1, "hash0");
 
         for i in 1..=10 {
-            let op = create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
+            let op =
+                create_test_operation(i, base_version.clone(), &format!("rec{}", i), i as i32 * 10);
             log.append(op).unwrap();
         }
 

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

@@ -55,7 +55,12 @@ mod tests {
     /// Build an envelope with an explicitly chosen envelope sequence and an
     /// explicitly chosen causal clock, so the two counters can be moved
     /// independently -- which is exactly what a restart of the origin does.
-    fn envelope(origin: &str, sequence: u64, clock: &[(&str, u64)], payload: &str) -> TransactionEnvelope {
+    fn envelope(
+        origin: &str,
+        sequence: u64,
+        clock: &[(&str, u64)],
+        payload: &str,
+    ) -> TransactionEnvelope {
         let mut fields = HashMap::new();
         fields.insert("record".to_string(), serde_json::json!(payload));
         let operation = Operation::new(
@@ -112,7 +117,12 @@ mod tests {
         for position in 1..=5u64 {
             let outcome = executor
                 .receive_replicated(
-                    message(envelope("A", position, &[("A", position)], &format!("r{position}"))),
+                    message(envelope(
+                        "A",
+                        position,
+                        &[("A", position)],
+                        &format!("r{position}"),
+                    )),
                     zero_version(),
                 )
                 .expect("receive");
@@ -143,7 +153,10 @@ mod tests {
 
         // B's envelope claims to have seen A through position 5.
         let outcome = executor
-            .receive_replicated(message(envelope("B", 1, &[("A", 5), ("B", 1)], "b1")), zero_version())
+            .receive_replicated(
+                message(envelope("B", 1, &[("A", 5), ("B", 1)], "b1")),
+                zero_version(),
+            )
             .expect("receive");
 
         assert!(
@@ -164,7 +177,12 @@ mod tests {
         for position in 1..=3u64 {
             executor
                 .receive_replicated(
-                    message(envelope("A", position, &[("A", position)], &format!("a{position}"))),
+                    message(envelope(
+                        "A",
+                        position,
+                        &[("A", position)],
+                        &format!("a{position}"),
+                    )),
                     zero_version(),
                 )
                 .expect("receive");
@@ -173,7 +191,10 @@ mod tests {
 
         // B has seen A through 3, which this replica has too.
         executor
-            .receive_replicated(message(envelope("B", 1, &[("A", 3), ("B", 1)], "b1")), zero_version())
+            .receive_replicated(
+                message(envelope("B", 1, &[("A", 3), ("B", 1)], "b1")),
+                zero_version(),
+            )
             .expect("receive");
 
         assert_eq!(
@@ -193,12 +214,27 @@ mod tests {
 
         // Two origins, interleaved, plus an out-of-order arrival that is held
         // and later released -- so the applied set is not simply arrival order.
-        executor.receive_replicated(message(envelope("A", 1, &[("A", 1)], "a1")), zero_version()).unwrap();
-        executor.receive_replicated(message(envelope("A", 3, &[("A", 3)], "a3")), zero_version()).unwrap();
-        executor.receive_replicated(message(envelope("A", 2, &[("A", 2)], "a2")), zero_version()).unwrap();
-        executor.receive_replicated(message(envelope("B", 1, &[("A", 3), ("B", 1)], "b1")), zero_version()).unwrap();
+        executor
+            .receive_replicated(message(envelope("A", 1, &[("A", 1)], "a1")), zero_version())
+            .unwrap();
+        executor
+            .receive_replicated(message(envelope("A", 3, &[("A", 3)], "a3")), zero_version())
+            .unwrap();
+        executor
+            .receive_replicated(message(envelope("A", 2, &[("A", 2)], "a2")), zero_version())
+            .unwrap();
+        executor
+            .receive_replicated(
+                message(envelope("B", 1, &[("A", 3), ("B", 1)], "b1")),
+                zero_version(),
+            )
+            .unwrap();
 
-        assert_eq!(executor.pending_causal_count(), 0, "everything was released");
+        assert_eq!(
+            executor.pending_causal_count(),
+            0,
+            "everything was released"
+        );
         assert_eq!(executor.causal_frontier().get("A"), 3);
         assert_eq!(executor.causal_frontier().get("B"), 1);
 
@@ -206,7 +242,12 @@ mod tests {
         // frontier already covers its clock position. So a frontier test would
         // answer "already applied" for all of them.
         let frontier = executor.causal_frontier().clone();
-        let log = executor.operation_log.as_ref().expect("log").load_all().expect("load");
+        let log = executor
+            .operation_log
+            .as_ref()
+            .expect("log")
+            .load_all()
+            .expect("load");
         for envelope in &log {
             let origin = &envelope.originating_node;
             let position = envelope.vector_clock.get(origin);
@@ -238,7 +279,12 @@ mod tests {
             for position in 1..=3u64 {
                 executor
                     .receive_replicated(
-                        message(envelope("A", position, &[("A", position)], &format!("a{position}"))),
+                        message(envelope(
+                            "A",
+                            position,
+                            &[("A", position)],
+                            &format!("a{position}"),
+                        )),
                         zero_version(),
                     )
                     .expect("receive");
@@ -253,13 +299,21 @@ mod tests {
         .expect("executor");
         recovered.load_from_disk(path).expect("recover");
 
-        assert_eq!(recovered.causal_frontier().get("A"), 3, "the frontier is rebuilt from the log");
+        assert_eq!(
+            recovered.causal_frontier().get("A"),
+            3,
+            "the frontier is rebuilt from the log"
+        );
 
         // A retransmission of an already-applied operation after the restart.
         let again = recovered
             .receive_replicated(message(envelope("A", 2, &[("A", 2)], "a2")), zero_version())
             .expect("receive");
-        assert_eq!(again, ReceiveOutcome::AlreadyKnown, "a duplicate after restart is refused");
+        assert_eq!(
+            again,
+            ReceiveOutcome::AlreadyKnown,
+            "a duplicate after restart is refused"
+        );
     }
 
     // ---------------------------------------------------------------------
@@ -273,13 +327,22 @@ mod tests {
         for position in 1..=200u64 {
             executor
                 .receive_replicated(
-                    message(envelope("A", position, &[("A", position)], &format!("a{position}"))),
+                    message(envelope(
+                        "A",
+                        position,
+                        &[("A", position)],
+                        &format!("a{position}"),
+                    )),
                     zero_version(),
                 )
                 .expect("receive");
         }
 
-        assert_eq!(executor.pending_causal_count(), 0, "the bounded population is empty");
+        assert_eq!(
+            executor.pending_causal_count(),
+            0,
+            "the bounded population is empty"
+        );
         assert_eq!(executor.deferred_causal_count(), 0);
         assert_eq!(
             executor.envelopes_seen.len(),
@@ -322,7 +385,10 @@ mod tests {
 
         // Before the origin restarts: A's first operation, sequence 1, clock 1.
         let first = executor
-            .receive_replicated(message(envelope("A", 1, &[("A", 1)], "before")), zero_version())
+            .receive_replicated(
+                message(envelope("A", 1, &[("A", 1)], "before")),
+                zero_version(),
+            )
             .expect("receive");
         assert!(matches!(first, ReceiveOutcome::Applied { .. }));
 
@@ -347,7 +413,9 @@ mod tests {
         );
         let state = executor.canonical_state().expect("state");
         assert!(
-            !state.records.contains_key(&("items".to_string(), "after".to_string())),
+            !state
+                .records
+                .contains_key(&("items".to_string(), "after".to_string())),
             "and the write is simply absent: no error, no divergence signal, no retry"
         );
 
@@ -374,19 +442,32 @@ mod tests {
         // before it died.
         let (mut executor, _dir) = receiver();
         executor
-            .receive_replicated(message(envelope("A", 1, &[("A", 1)], "one")), zero_version())
+            .receive_replicated(
+                message(envelope("A", 1, &[("A", 1)], "one")),
+                zero_version(),
+            )
             .expect("receive");
 
         // Origin restarts after one operation and commits two more. Sequences
         // 1 and 2; clock positions 2 and 3.
         let dropped = executor
-            .receive_replicated(message(envelope("A", 1, &[("A", 2)], "two")), zero_version())
+            .receive_replicated(
+                message(envelope("A", 1, &[("A", 2)], "two")),
+                zero_version(),
+            )
             .expect("receive");
         let admitted = executor
-            .receive_replicated(message(envelope("A", 2, &[("A", 3)], "three")), zero_version())
+            .receive_replicated(
+                message(envelope("A", 2, &[("A", 3)], "three")),
+                zero_version(),
+            )
             .expect("receive");
 
-        assert_eq!(dropped, ReceiveOutcome::AlreadyKnown, "the first collides and is lost");
+        assert_eq!(
+            dropped,
+            ReceiveOutcome::AlreadyKnown,
+            "the first collides and is lost"
+        );
         assert!(
             matches!(admitted, ReceiveOutcome::PendingDependencies { .. }),
             "the second does not collide, is admitted, and is then held forever waiting on \