@feltdb/core 0.8.4 → 0.8.5

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

@@ -3,7 +3,6 @@
 /// Generates multiple orderings of the same operation set to test
 /// whether independent nodes converge to identical state regardless
 /// of message delivery order.
-
 use crate::transactions::Operation;
 use rand::seq::SliceRandom;
 use rand::SeedableRng;
@@ -30,7 +29,10 @@ pub struct OperationSchedule {
 
 impl OperationSchedule {
     pub fn new(strategy: ScheduleStrategy, operations: Vec<Operation>) -> Self {
-        Self { strategy, operations }
+        Self {
+            strategy,
+            operations,
+        }
     }
 
     pub fn id(&self) -> String {
@@ -78,7 +80,10 @@ impl PermutationScheduler {
     /// Generate a comprehensive test set:
     /// - All deterministic permutations
     /// - N random permutations
-    pub fn comprehensive_schedules(operations: &[Operation], random_count: usize) -> Vec<OperationSchedule> {
+    pub fn comprehensive_schedules(
+        operations: &[Operation],
+        random_count: usize,
+    ) -> Vec<OperationSchedule> {
         let mut schedules = Self::deterministic_schedules(operations);
         schedules.extend(Self::random_schedules(operations, random_count));
         schedules
@@ -115,7 +120,7 @@ impl PermutationScheduler {
 mod tests {
     use super::*;
     use crate::convergence::VectorClock;
-    use crate::transactions::{OperationId, OperationCommand, StateVersion};
+    use crate::transactions::{OperationCommand, OperationId, StateVersion};
     use std::collections::HashMap;
 
     fn create_test_operation(seq: u64, collection: &str, record_id: &str, value: i32) -> Operation {
@@ -165,7 +170,10 @@ mod tests {
 
         // All should be RandomSeed variants
         for schedule in &schedules {
-            assert!(matches!(schedule.strategy, ScheduleStrategy::RandomSeed { .. }));
+            assert!(matches!(
+                schedule.strategy,
+                ScheduleStrategy::RandomSeed { .. }
+            ));
         }
     }
 
@@ -181,8 +189,16 @@ mod tests {
 
         // Same seed should produce same order
         for i in 0..3 {
-            let ops1: Vec<u64> = schedules1[i].operations.iter().map(|o| o.operation_id.sequence).collect();
-            let ops2: Vec<u64> = schedules2[i].operations.iter().map(|o| o.operation_id.sequence).collect();
+            let ops1: Vec<u64> = schedules1[i]
+                .operations
+                .iter()
+                .map(|o| o.operation_id.sequence)
+                .collect();
+            let ops2: Vec<u64> = schedules2[i]
+                .operations
+                .iter()
+                .map(|o| o.operation_id.sequence)
+                .collect();
             assert_eq!(ops1, ops2);
         }
     }
@@ -222,7 +238,11 @@ mod tests {
 
         for schedule in &schedules {
             assert_eq!(schedule.operations.len(), 3);
-            let seq: Vec<u64> = schedule.operations.iter().map(|o| o.operation_id.sequence).collect();
+            let seq: Vec<u64> = schedule
+                .operations
+                .iter()
+                .map(|o| o.operation_id.sequence)
+                .collect();
             assert!(seq.contains(&1));
             assert!(seq.contains(&2));
             assert!(seq.contains(&3));
@@ -240,7 +260,11 @@ mod tests {
         let schedules = PermutationScheduler::deterministic_schedules(&ops);
         let original = &schedules[0];
 
-        let seq: Vec<u64> = original.operations.iter().map(|o| o.operation_id.sequence).collect();
+        let seq: Vec<u64> = original
+            .operations
+            .iter()
+            .map(|o| o.operation_id.sequence)
+            .collect();
         assert_eq!(seq, vec![1, 2, 3]);
     }
 
@@ -255,7 +279,11 @@ mod tests {
         let schedules = PermutationScheduler::deterministic_schedules(&ops);
         let reversed = &schedules[1];
 
-        let seq: Vec<u64> = reversed.operations.iter().map(|o| o.operation_id.sequence).collect();
+        let seq: Vec<u64> = reversed
+            .operations
+            .iter()
+            .map(|o| o.operation_id.sequence)
+            .collect();
         assert_eq!(seq, vec![3, 2, 1]);
     }
 }

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

@@ -5,7 +5,6 @@
 ///   process writes → crash → restart → recover
 ///
 /// Critical test: Same data after arbitrary crash/recovery cycles.
-
 use std::collections::HashMap;
 
 /// Point at which to inject a crash during persistence
@@ -26,7 +25,7 @@ pub enum PersistenceCrashPoint {
 /// Write-ahead log entry (simplified)
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct WALEntry {
-    pub lsn: u64,  // Log sequence number
+    pub lsn: u64, // Log sequence number
     pub operation_id: String,
     pub data: Vec<u8>,
     pub checksum: u32,
@@ -178,7 +177,10 @@ impl DurablePersistenceLayer {
 
     /// Simulate disk corruption: flip random bytes
     pub fn corrupt_tail(&mut self, num_entries_affected: usize) {
-        let start = self.committed_log.len().saturating_sub(num_entries_affected);
+        let start = self
+            .committed_log
+            .len()
+            .saturating_sub(num_entries_affected);
         for entry in &mut self.committed_log[start..] {
             if !entry.data.is_empty() {
                 entry.data[0] ^= 0xFF; // Flip all bits in first byte
@@ -229,7 +231,9 @@ impl Default for DurablePersistenceLayer {
 /// Result of a write operation
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum WriteResult {
-    Success { lsn: u64 },
+    Success {
+        lsn: u64,
+    },
     Crashed {
         written_to_buffer: bool,
         fsynced: bool,
@@ -321,7 +325,10 @@ impl PersistenceContractVerifier {
             if scenario.corrupted_count > 0 {
                 // If corruption occurred, it should be detected or entry dropped
                 // (not silently included in recovered)
-                let expected_max = scenario.written_operations.len().saturating_sub(scenario.corrupted_count);
+                let expected_max = scenario
+                    .written_operations
+                    .len()
+                    .saturating_sub(scenario.corrupted_count);
                 if scenario.recovered_operations.len() > expected_max {
                     corrupted_undetected += 1;
                 }
@@ -353,7 +360,9 @@ impl Default for PersistenceContractVerifier {
 /// Result of fsync durability verification
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum FsyncDurabilityResult {
-    Satisfied { scenarios_checked: usize },
+    Satisfied {
+        scenarios_checked: usize,
+    },
     Violated {
         scenario: String,
         written: usize,
@@ -400,13 +409,7 @@ mod tests {
             PersistenceCrashPoint::AfterFsyncBeforeReturn,
         );
 
-        assert!(matches!(
-            result,
-            WriteResult::Crashed {
-                fsynced: true,
-                ..
-            }
-        ));
+        assert!(matches!(result, WriteResult::Crashed { fsynced: true, .. }));
         assert_eq!(wal.get_log().len(), 1);
     }
 
@@ -524,7 +527,10 @@ mod tests {
         );
 
         let result = verifier.verify_corruption_detection();
-        assert!(matches!(result, CorruptionDetectionResult::Satisfied { .. }));
+        assert!(matches!(
+            result,
+            CorruptionDetectionResult::Satisfied { .. }
+        ));
     }
 
     #[test]