@feltdb/core 0.8.4 → 0.8.5

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

@@ -173,7 +173,10 @@ fn lease_is_checked_with_the_server_clock_inside_cas() {
             current_epoch: 3,
         }
     );
-    assert_eq!(db.get_value(expired_key).unwrap().unwrap()["value"], "before");
+    assert_eq!(
+        db.get_value(expired_key).unwrap().unwrap()["value"],
+        "before"
+    );
 
     drop(db);
     let _ = fs::remove_file(path);

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

@@ -7,7 +7,6 @@
 /// - Node health (operations applied, crash count)
 /// - Recovery metrics (duration, type)
 /// - Operation status (acknowledged, committed, diverged, lost)
-
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};

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

@@ -5,7 +5,6 @@
 ///
 /// This is the core Gate 1 test: does operation-specific merge
 /// semantics guarantee convergence despite arbitrary delivery order?
-
 use crate::operation_log::MemoryOperationLog;
 use crate::permutation_scheduler::{OperationSchedule, PermutationScheduler};
 use crate::replay_fuzzing::ReplayFuzzer;
@@ -201,7 +200,7 @@ impl ConvergenceAggregation {
 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 {

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

@@ -169,7 +169,10 @@ impl TransactionRecord {
 
     /// Records touched by this transaction, for conflict detection.
     pub fn touched_keys(&self) -> HashSet<(String, String)> {
-        self.operations.iter().map(|operation| operation.key()).collect()
+        self.operations
+            .iter()
+            .map(|operation| operation.key())
+            .collect()
     }
 }
 
@@ -177,12 +180,18 @@ impl TransactionRecord {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum RejectionReason {
     /// A precondition did not hold. Carries the operation index and a reason.
-    PreconditionFailed { operation_index: usize, detail: String },
+    PreconditionFailed {
+        operation_index: usize,
+        detail: String,
+    },
     /// The transaction contained no operations.
     Empty,
     /// The transaction writes the same record twice, so its outcome would
     /// depend on operation order rather than on the transaction as a whole.
-    ConflictingWritesWithinTransaction { collection: String, record_id: String },
+    ConflictingWritesWithinTransaction {
+        collection: String,
+        record_id: String,
+    },
 }
 
 /// The outcome of applying a record to derived state.
@@ -265,7 +274,10 @@ impl AtomicTransactionLog {
     /// Read the log without modifying it.
     pub fn read_log(path: &Path) -> Result<RecoveryReport, std::io::Error> {
         if !path.exists() {
-            return Ok(RecoveryReport { committed: Vec::new(), discarded_tail: None });
+            return Ok(RecoveryReport {
+                committed: Vec::new(),
+                discarded_tail: None,
+            });
         }
 
         let reader = BufReader::new(File::open(path)?);
@@ -286,7 +298,9 @@ impl AtomicTransactionLog {
             }
             line_number += 1;
             let terminated = buffer.ends_with(b"\n");
-            let text = String::from_utf8_lossy(&buffer).trim_end_matches('\n').to_string();
+            let text = String::from_utf8_lossy(&buffer)
+                .trim_end_matches('\n')
+                .to_string();
             entries.push((line_number, text, terminated));
         }
 
@@ -311,21 +325,28 @@ impl AtomicTransactionLog {
                 // An unterminated, unparseable, or checksum-failing final entry
                 // is a transaction that was still being written when the
                 // process died. It never committed.
-                defect = Some(LogDefect::TornTail { bytes: text.len() + usize::from(terminated) });
+                defect = Some(LogDefect::TornTail {
+                    bytes: text.len() + usize::from(terminated),
+                });
             } else {
                 return Err(std::io::Error::new(
                     std::io::ErrorKind::InvalidData,
                     format!(
                         "transaction log corrupted at line {}: {}",
                         number,
-                        parsed.err().map(|error| error.to_string())
+                        parsed
+                            .err()
+                            .map(|error| error.to_string())
                             .unwrap_or_else(|| "checksum mismatch".to_string())
                     ),
                 ));
             }
         }
 
-        Ok(RecoveryReport { committed, discarded_tail: defect })
+        Ok(RecoveryReport {
+            committed,
+            discarded_tail: defect,
+        })
     }
 
     /// Commit a record: one write, one fsync. This is the atomic commit point.
@@ -420,7 +441,11 @@ pub struct TransactionExecutor {
 
 impl TransactionExecutor {
     pub fn new() -> Self {
-        Self { state: CanonicalState::new(), applied: HashSet::new(), applied_order: Vec::new() }
+        Self {
+            state: CanonicalState::new(),
+            applied: HashSet::new(),
+            applied_order: Vec::new(),
+        }
     }
 
     pub fn state(&self) -> &CanonicalState {
@@ -455,8 +480,12 @@ impl TransactionExecutor {
         }
 
         for (index, operation) in record.operations.iter().enumerate() {
-            let Some(precondition) = &operation.precondition else { continue };
-            let current = self.state.get_record(&operation.collection, &operation.record_id);
+            let Some(precondition) = &operation.precondition else {
+                continue;
+            };
+            let current = self
+                .state
+                .get_record(&operation.collection, &operation.record_id);
             let failure = match (precondition, current) {
                 (Precondition::MustExist, None) => Some("record does not exist".to_string()),
                 (Precondition::MustNotExist, Some(_)) => Some("record already exists".to_string()),
@@ -467,7 +496,10 @@ impl TransactionExecutor {
                 _ => None,
             };
             if let Some(detail) = failure {
-                return Err(RejectionReason::PreconditionFailed { operation_index: index, detail });
+                return Err(RejectionReason::PreconditionFailed {
+                    operation_index: index,
+                    detail,
+                });
             }
         }
 
@@ -486,8 +518,11 @@ impl TransactionExecutor {
         // Preflight succeeded, so every mutation below is known to be legal.
         // Staging them first keeps the mutation phase free of any decision that
         // could fail half-way through.
-        let staged: Vec<(&TransactionOperation, ())> =
-            record.operations.iter().map(|operation| (operation, ())).collect();
+        let staged: Vec<(&TransactionOperation, ())> = record
+            .operations
+            .iter()
+            .map(|operation| (operation, ()))
+            .collect();
         for (operation, ()) in staged {
             match &operation.op {
                 TransactionOp::Set(value) => self.state.set_record(
@@ -526,11 +561,14 @@ impl TransactionExecutor {
             .iter()
             .filter(|operation| match &operation.op {
                 TransactionOp::Set(value) => {
-                    self.state.get_record(&operation.collection, &operation.record_id) == Some(value)
-                }
-                TransactionOp::Delete => {
-                    self.state.get_record(&operation.collection, &operation.record_id).is_none()
+                    self.state
+                        .get_record(&operation.collection, &operation.record_id)
+                        == Some(value)
                 }
+                TransactionOp::Delete => self
+                    .state
+                    .get_record(&operation.collection, &operation.record_id)
+                    .is_none(),
             })
             .count()
     }
@@ -554,12 +592,29 @@ pub struct TransactionalNode {
 
 impl TransactionalNode {
     /// Start a node, recovering derived state from the durable log.
-    pub fn open<P: AsRef<Path>>(path: P, node_id: &str) -> Result<(Self, RecoveryReport), std::io::Error> {
+    pub fn open<P: AsRef<Path>>(
+        path: P,
+        node_id: &str,
+    ) -> Result<(Self, RecoveryReport), std::io::Error> {
         let (log, report) = AtomicTransactionLog::open(path)?;
         let mut executor = TransactionExecutor::new();
         executor.recover(&report.committed);
-        let next_sequence = report.committed.iter().map(|record| record.sequence).max().unwrap_or(0) + 1;
-        Ok((Self { log, executor, node_id: node_id.to_string(), next_sequence }, report))
+        let next_sequence = report
+            .committed
+            .iter()
+            .map(|record| record.sequence)
+            .max()
+            .unwrap_or(0)
+            + 1;
+        Ok((
+            Self {
+                log,
+                executor,
+                node_id: node_id.to_string(),
+                next_sequence,
+            },
+            report,
+        ))
     }
 
     pub fn state(&self) -> &CanonicalState {
@@ -574,8 +629,17 @@ impl TransactionalNode {
         &mut self.log
     }
 
-    pub fn build(&mut self, transaction_id: &str, operations: Vec<TransactionOperation>) -> TransactionRecord {
-        let record = TransactionRecord::new(transaction_id, &self.node_id, self.next_sequence, operations);
+    pub fn build(
+        &mut self,
+        transaction_id: &str,
+        operations: Vec<TransactionOperation>,
+    ) -> TransactionRecord {
+        let record = TransactionRecord::new(
+            transaction_id,
+            &self.node_id,
+            self.next_sequence,
+            operations,
+        );
         self.next_sequence += 1;
         record
     }
@@ -585,7 +649,11 @@ impl TransactionalNode {
     /// A rejected transaction is never written to the log, so a failed
     /// precondition leaves no trace in durable state.
     pub fn commit(&mut self, record: &TransactionRecord) -> Result<ApplyOutcome, std::io::Error> {
-        if self.executor.applied_transactions().contains(&record.transaction_id) {
+        if self
+            .executor
+            .applied_transactions()
+            .contains(&record.transaction_id)
+        {
             return Ok(ApplyOutcome::AlreadyApplied);
         }
         if let Err(reason) = self.executor.preflight(record) {
@@ -640,14 +708,23 @@ impl TransactionalNode {
     /// Applying a replicated transaction is the same all-or-nothing path, and
     /// a transaction already applied here is ignored, so duplicate delivery is
     /// safe.
-    pub fn accept_replicated(&mut self, record: &TransactionRecord) -> Result<ApplyOutcome, std::io::Error> {
+    pub fn accept_replicated(
+        &mut self,
+        record: &TransactionRecord,
+    ) -> Result<ApplyOutcome, std::io::Error> {
         if !record.verify_checksum() {
-            return Ok(ApplyOutcome::Rejected(RejectionReason::PreconditionFailed {
-                operation_index: 0,
-                detail: "replicated record failed its integrity check".to_string(),
-            }));
+            return Ok(ApplyOutcome::Rejected(
+                RejectionReason::PreconditionFailed {
+                    operation_index: 0,
+                    detail: "replicated record failed its integrity check".to_string(),
+                },
+            ));
         }
-        if self.executor.applied_transactions().contains(&record.transaction_id) {
+        if self
+            .executor
+            .applied_transactions()
+            .contains(&record.transaction_id)
+        {
             return Ok(ApplyOutcome::AlreadyApplied);
         }
         if let Err(reason) = self.executor.preflight(record) {

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

@@ -7,11 +7,10 @@
 /// - Rejected operations tracking
 /// - Index health metrics
 /// - Recovery state visibility
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::sync::Arc;
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ReplicationLagMetric {
@@ -102,7 +101,13 @@ impl ObservabilityManager {
         }
     }
 
-    pub fn record_replication_lag(&mut self, source: String, target: String, lag_ms: u64, pending: u64) {
+    pub fn record_replication_lag(
+        &mut self,
+        source: String,
+        target: String,
+        lag_ms: u64,
+        pending: u64,
+    ) {
         let now = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap_or_default()
@@ -250,7 +255,8 @@ impl ObservabilityManager {
     }
 
     pub fn record_operation_throughput(&self, ops_per_sec: u64) {
-        self.operation_throughput.store(ops_per_sec, Ordering::Relaxed);
+        self.operation_throughput
+            .store(ops_per_sec, Ordering::Relaxed);
     }
 
     pub fn get_health_report(&self) -> HealthReport {
@@ -259,7 +265,8 @@ impl ObservabilityManager {
             .unwrap_or_default()
             .as_secs();
 
-        let overall_status = if self.convergence_status
+        let overall_status = if self
+            .convergence_status
             .values()
             .all(|c| c.diverged_peers.is_empty())
         {
@@ -273,7 +280,13 @@ impl ObservabilityManager {
             overall_status: overall_status.to_string(),
             replication_lag: self.replication_lags.values().cloned().collect(),
             convergence: self.convergence_status.values().cloned().collect(),
-            rejected_operations: self.rejected_operations.iter().rev().take(100).cloned().collect(),
+            rejected_operations: self
+                .rejected_operations
+                .iter()
+                .rev()
+                .take(100)
+                .cloned()
+                .collect(),
             index_health: self.index_health.values().cloned().collect(),
             recovery_states: self.recovery_states.values().cloned().collect(),
             query_latency_p99: self.query_latency_p99.load(Ordering::Relaxed),

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

@@ -5,7 +5,6 @@
 /// to declare how it converges under concurrent application.
 ///
 /// This registry is the foundation of operation-specific CRDT semantics.
-
 use std::collections::HashMap;
 
 /// Conflict classification for an operation
@@ -40,13 +39,13 @@ pub enum ConvergenceSemantic {
 #[derive(Clone, Debug)]
 pub struct OperationAlgebra {
     pub operation_type: String,
-    pub read_set_bound: String,                // "single_record", "multiple_records", etc
-    pub write_set_bound: String,               // "single_record", "multiple_records", etc
+    pub read_set_bound: String, // "single_record", "multiple_records", etc
+    pub write_set_bound: String, // "single_record", "multiple_records", etc
     pub conflict_type: ConflictType,
     pub convergence_semantic: ConvergenceSemantic,
     pub merge_function_description: String,
-    pub commutativity_proof: Option<String>,   // Reference to commutative algebra proof
-    pub determinism_proof: Option<String>,     // Reference to determinism proof
+    pub commutativity_proof: Option<String>, // Reference to commutative algebra proof
+    pub determinism_proof: Option<String>,   // Reference to determinism proof
 }
 
 impl OperationAlgebra {
@@ -70,7 +69,11 @@ impl OperationAlgebra {
         }
     }
 
-    pub fn with_proofs(mut self, commutativity: Option<String>, determinism: Option<String>) -> Self {
+    pub fn with_proofs(
+        mut self,
+        commutativity: Option<String>,
+        determinism: Option<String>,
+    ) -> Self {
         self.commutativity_proof = commutativity;
         self.determinism_proof = determinism;
         self
@@ -249,7 +252,8 @@ impl OperationAlgebraRegistry {
 
     /// Register an operation algebra
     pub fn register(&mut self, algebra: OperationAlgebra) {
-        self.algebras.insert(algebra.operation_type.clone(), algebra);
+        self.algebras
+            .insert(algebra.operation_type.clone(), algebra);
     }
 
     /// Look up algebra for operation type
@@ -390,10 +394,7 @@ mod tests {
             ConvergenceSemantic::StrictlyCommutative,
             "test merge",
         )
-        .with_proofs(
-            Some("proof1".to_string()),
-            Some("proof2".to_string()),
-        );
+        .with_proofs(Some("proof1".to_string()), Some("proof2".to_string()));
 
         assert!(algebra.commutativity_proof.is_some());
         assert!(algebra.determinism_proof.is_some());

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

@@ -3,8 +3,7 @@
 /// Append-only log storing all executed operations for durability, replay, and recovery.
 /// Operations are immutable once appended; the log is the authoritative source for
 /// what has been executed in the system.
-
-use crate::transactions::{OperationId, Operation, StateVersion};
+use crate::transactions::{Operation, OperationId, StateVersion};
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 
@@ -39,7 +38,10 @@ impl MemoryOperationLog {
         let mut entries = self.entries.lock().unwrap();
         let mut by_id = self.by_id.lock().unwrap();
 
-        let op_id_key = format!("{}:{}", operation.operation_id.node_id, operation.operation_id.sequence);
+        let op_id_key = format!(
+            "{}:{}",
+            operation.operation_id.node_id, operation.operation_id.sequence
+        );
 
         if by_id.contains_key(&op_id_key) {
             return Err(format!("Operation already logged: {}", op_id_key));
@@ -125,7 +127,10 @@ impl MemoryOperationLog {
 
         let removed: Vec<_> = entries.drain(truncate_at as usize..).collect();
         for entry in removed {
-            let op_id_key = format!("{}:{}", entry.operation_id.node_id, entry.operation_id.sequence);
+            let op_id_key = format!(
+                "{}:{}",
+                entry.operation_id.node_id, entry.operation_id.sequence
+            );
             by_id.remove(&op_id_key);
         }
 

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

@@ -25,8 +25,16 @@ mod tests {
     fn user_order_audit() -> Vec<AtomicMutation> {
         vec![
             mutation("users", "users:u1", json!({ "id": "u1", "name": "Ada" })),
-            mutation("orders", "orders:o1", json!({ "id": "o1", "user": "u1", "total": 42 })),
-            mutation("audit", "audit:a1", json!({ "id": "a1", "event": "order.created" })),
+            mutation(
+                "orders",
+                "orders:o1",
+                json!({ "id": "o1", "user": "u1", "total": 42 }),
+            ),
+            mutation(
+                "audit",
+                "audit:a1",
+                json!({ "id": "a1", "event": "order.created" }),
+            ),
         ]
     }
 
@@ -42,7 +50,8 @@ mod tests {
     }
 
     #[test]
-    fn a_cross_collection_transaction_commits_every_operation() -> Result<(), Box<dyn std::error::Error>> {
+    fn a_cross_collection_transaction_commits_every_operation(
+    ) -> Result<(), Box<dyn std::error::Error>> {
         let dir = TempDir::new()?;
         let path = dir.path().join("app.log");
         let db = FeltDb::open(&path)?;
@@ -65,12 +74,17 @@ mod tests {
         }
 
         let reopened = FeltDb::open(&path)?;
-        assert_eq!(visible_count(&reopened), 3, "every row must recover together");
+        assert_eq!(
+            visible_count(&reopened),
+            3,
+            "every row must recover together"
+        );
         Ok(())
     }
 
     #[test]
-    fn a_failed_precondition_leaves_no_operation_applied() -> Result<(), Box<dyn std::error::Error>> {
+    fn a_failed_precondition_leaves_no_operation_applied() -> Result<(), Box<dyn std::error::Error>>
+    {
         let dir = TempDir::new()?;
         let path = dir.path().join("app.log");
         let db = FeltDb::open(&path)?;
@@ -82,8 +96,12 @@ mod tests {
             expected_version: Some(7),
         }];
 
-        let outcome = db.apply_atomic_transaction("tx-bad", None, &preconditions, &user_order_audit(), None);
-        assert!(outcome.is_err(), "a failed precondition must reject the transaction");
+        let outcome =
+            db.apply_atomic_transaction("tx-bad", None, &preconditions, &user_order_audit(), None);
+        assert!(
+            outcome.is_err(),
+            "a failed precondition must reject the transaction"
+        );
 
         assert_eq!(visible_count(&db), 0, "no operation may be applied");
         drop(db);
@@ -102,7 +120,10 @@ mod tests {
         let first = db.apply_atomic_transaction("tx-1", None, &[], &user_order_audit(), None)?;
         assert!(!first.duplicate);
         let second = db.apply_atomic_transaction("tx-1", None, &[], &user_order_audit(), None)?;
-        assert!(second.duplicate, "the same transaction id must not apply twice");
+        assert!(
+            second.duplicate,
+            "the same transaction id must not apply twice"
+        );
         assert_eq!(visible_count(&db), 3);
         Ok(())
     }
@@ -118,8 +139,12 @@ mod tests {
         }
 
         let reopened = FeltDb::open(&path)?;
-        let replayed = reopened.apply_atomic_transaction("tx-stable", None, &[], &user_order_audit(), None)?;
-        assert!(replayed.duplicate, "identity must be restored so redelivery stays idempotent");
+        let replayed =
+            reopened.apply_atomic_transaction("tx-stable", None, &[], &user_order_audit(), None)?;
+        assert!(
+            replayed.duplicate,
+            "identity must be restored so redelivery stays idempotent"
+        );
         assert_eq!(visible_count(&reopened), 3);
         Ok(())
     }
@@ -132,8 +157,8 @@ mod tests {
     /// intact. Refusing to open at all would turn a normal crash into an
     /// outage.
     #[test]
-    fn a_torn_transaction_record_is_discarded_and_the_store_still_opens()
-    -> Result<(), Box<dyn std::error::Error>> {
+    fn a_torn_transaction_record_is_discarded_and_the_store_still_opens(
+    ) -> Result<(), Box<dyn std::error::Error>> {
         let dir = TempDir::new()?;
         let path = dir.path().join("app.log");
 
@@ -154,7 +179,11 @@ mod tests {
         let recovered = FeltDb::open(&path).map_err(|error| {
             format!("a torn tail must not stop the store from opening: {error}")
         })?;
-        assert_eq!(visible_count(&recovered), 3, "committed history must survive");
+        assert_eq!(
+            visible_count(&recovered),
+            3,
+            "committed history must survive"
+        );
         Ok(())
     }
 
@@ -178,7 +207,11 @@ mod tests {
                 "tx-2",
                 None,
                 &[],
-                &[mutation("users", "users:u2", json!({ "id": "u2", "name": "Grace" }))],
+                &[mutation(
+                    "users",
+                    "users:u2",
+                    json!({ "id": "u2", "name": "Grace" }),
+                )],
                 None,
             )?;
         }
@@ -193,8 +226,15 @@ mod tests {
         drop(file);
 
         let recovered = FeltDb::open(&path)?;
-        assert_eq!(visible_count(&recovered), 3, "the committed transaction survives");
-        assert!(!present(&recovered, "users:u2"), "a torn transaction must apply nothing");
+        assert_eq!(
+            visible_count(&recovered),
+            3,
+            "the committed transaction survives"
+        );
+        assert!(
+            !present(&recovered, "users:u2"),
+            "a torn transaction must apply nothing"
+        );
         Ok(())
     }
 
@@ -245,9 +285,16 @@ mod tests {
         }
 
         let reopened = FeltDb::open(&path)?;
-        assert!(present(&reopened, "users:solo"), "single writes must still recover");
+        assert!(
+            present(&reopened, "users:solo"),
+            "single writes must still recover"
+        );
         assert!(present(&reopened, "users:solo2"));
-        assert_eq!(visible_count(&reopened), 3, "transaction rows recover alongside them");
+        assert_eq!(
+            visible_count(&reopened),
+            3,
+            "transaction rows recover alongside them"
+        );
         Ok(())
     }