@feltdb/core 0.8.3 → 0.8.5

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

@@ -7,7 +7,6 @@
 /// - Relationship access patterns
 /// - Materialized views and projections
 /// - Multi-key operations
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -142,7 +141,11 @@ impl ProductionAPI {
             .ok_or_else(|| format!("Resource not found: {}", id))
     }
 
-    pub fn read_many(&self, ids: &[&str], _options: ReadOptions) -> Result<Vec<StateValue>, String> {
+    pub fn read_many(
+        &self,
+        ids: &[&str],
+        _options: ReadOptions,
+    ) -> Result<Vec<StateValue>, String> {
         let mut results = Vec::new();
         for id in ids {
             if let Some(value) = self.state_store.get(*id) {
@@ -152,7 +155,11 @@ impl ProductionAPI {
         Ok(results)
     }
 
-    pub fn write(&mut self, mutation: Mutation, options: WriteOptions) -> Result<MutationResult, String> {
+    pub fn write(
+        &mut self,
+        mutation: Mutation,
+        options: WriteOptions,
+    ) -> Result<MutationResult, String> {
         if let Some(ref key) = options.idempotency_key {
             if let Some(existing) = self.state_store.get(&mutation.resource_id) {
                 return Ok(MutationResult {
@@ -177,7 +184,8 @@ impl ProductionAPI {
             updated_at: now,
         };
 
-        self.state_store.insert(mutation.resource_id.clone(), value.clone());
+        self.state_store
+            .insert(mutation.resource_id.clone(), value.clone());
 
         Ok(MutationResult {
             success: true,
@@ -209,7 +217,10 @@ impl ProductionAPI {
         Ok(results)
     }
 
-    pub fn transaction(&mut self, request: TransactionRequest) -> Result<TransactionResult, String> {
+    pub fn transaction(
+        &mut self,
+        request: TransactionRequest,
+    ) -> Result<TransactionResult, String> {
         self.transaction_id_counter += 1;
         let transaction_id = format!("tx-{}", self.transaction_id_counter);
 
@@ -246,13 +257,12 @@ impl ProductionAPI {
             .push(target);
     }
 
-    pub fn get_relationships(&self, query: RelationshipQuery) -> Result<RelationshipResult, String> {
+    pub fn get_relationships(
+        &self,
+        query: RelationshipQuery,
+    ) -> Result<RelationshipResult, String> {
         let key = format!("{}:{}", query.source_id, query.relationship);
-        let targets = self
-            .relationships
-            .get(&key)
-            .cloned()
-            .unwrap_or_default();
+        let targets = self.relationships.get(&key).cloned().unwrap_or_default();
 
         Ok(RelationshipResult {
             source_id: query.source_id,
@@ -359,8 +369,16 @@ mod tests {
     #[test]
     fn test_relationships() {
         let mut api = ProductionAPI::new();
-        api.add_relationship("user-1".to_string(), "follows".to_string(), "user-2".to_string());
-        api.add_relationship("user-1".to_string(), "follows".to_string(), "user-3".to_string());
+        api.add_relationship(
+            "user-1".to_string(),
+            "follows".to_string(),
+            "user-2".to_string(),
+        );
+        api.add_relationship(
+            "user-1".to_string(),
+            "follows".to_string(),
+            "user-3".to_string(),
+        );
 
         let result = api
             .get_relationships(RelationshipQuery {

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

@@ -0,0 +1,126 @@
+//! Test instrumentation for the collection read paths a bounded query can take.
+//!
+//! PR33 attributed sustained-workload degradation to bounded queries cloning an
+//! entire collection under the state mutex before predicate, ordering and limit
+//! were applied. PR34 removes that clone, and a benchmark alone cannot prove a
+//! clone is gone: a faster number is evidence of speed, not of mechanism.
+//!
+//! These counters therefore record *which traversal a read used*, so a test can
+//! assert that a bounded query never entered `FeltDb::list_collection`. They
+//! are process-global, monotonic, carry no record data, and are not part of the
+//! query contract: nothing in the query path reads them, and no query result
+//! depends on them. The HTTP surface only exposes them when a server is started
+//! with `FELTDB_QUERY_DIAGNOSTICS=1`.
+//!
+//! PR35 extends them with execution attribution. An index is an optimization, so
+//! "the query got faster" is not evidence that it was used; these counters say
+//! which execution a query actually took, how many candidates the index
+//! produced, and how many records the predicate had to evaluate. That last
+//! figure is the one the PR35 claim rests on: for a selective indexed query it
+//! must track the candidate count rather than the collection size.
+
+use std::sync::atomic::{AtomicU64, Ordering};
+
+static FULL_COLLECTION_MATERIALIZATIONS: AtomicU64 = AtomicU64::new(0);
+static FULL_COLLECTION_RECORDS_CLONED: AtomicU64 = AtomicU64::new(0);
+static COLLECTION_SCANS: AtomicU64 = AtomicU64::new(0);
+static SCAN_RECORDS_VISITED: AtomicU64 = AtomicU64::new(0);
+static SCAN_RECORDS_MATERIALIZED: AtomicU64 = AtomicU64::new(0);
+static QUERIES_TOTAL: AtomicU64 = AtomicU64::new(0);
+static QUERIES_SCAN: AtomicU64 = AtomicU64::new(0);
+static QUERIES_INDEXED: AtomicU64 = AtomicU64::new(0);
+static INDEX_HITS: AtomicU64 = AtomicU64::new(0);
+static INDEX_MISSES: AtomicU64 = AtomicU64::new(0);
+static INDEX_CANDIDATES_EXAMINED: AtomicU64 = AtomicU64::new(0);
+static RECORDS_PREDICATE_EVALUATED: AtomicU64 = AtomicU64::new(0);
+
+/// A point-in-time reading of the collection read counters.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct QueryExecutionCounters {
+    /// Calls to `FeltDb::list_collection`, which clones a whole collection.
+    pub full_collection_materializations: u64,
+    /// Records cloned by those calls.
+    pub full_collection_records_cloned: u64,
+    /// Calls to `FeltDb::query_collection`, which evaluates borrowed records.
+    pub collection_scans: u64,
+    /// Records a scan predicate observed, borrowed rather than cloned.
+    pub scan_records_visited: u64,
+    /// Records a scan actually cloned, which is at most the matching set.
+    pub scan_records_materialized: u64,
+    /// Collection reads that executed a query: `queries_scan + queries_indexed`.
+    pub queries_total: u64,
+    /// Queries answered by evaluating the predicate over the whole collection.
+    pub queries_scan: u64,
+    /// Queries answered from equality-index candidates.
+    pub queries_indexed: u64,
+    /// Queries for which at least one condition had an applicable index.
+    pub index_hits: u64,
+    /// Queries for which no condition had an applicable index, which fall back.
+    pub index_misses: u64,
+    /// Candidate record keys the index produced, after intersection.
+    pub index_candidates_examined: u64,
+    /// Records the predicate was actually evaluated against, on either path.
+    /// For a selective indexed query this tracks the candidate count; for a scan
+    /// it is the collection size.
+    pub records_predicate_evaluated: u64,
+}
+
+pub(crate) fn record_full_materialization(records: usize) {
+    FULL_COLLECTION_MATERIALIZATIONS.fetch_add(1, Ordering::Relaxed);
+    FULL_COLLECTION_RECORDS_CLONED.fetch_add(records as u64, Ordering::Relaxed);
+}
+
+pub(crate) fn record_scan(visited: usize, materialized: usize) {
+    COLLECTION_SCANS.fetch_add(1, Ordering::Relaxed);
+    SCAN_RECORDS_VISITED.fetch_add(visited as u64, Ordering::Relaxed);
+    SCAN_RECORDS_MATERIALIZED.fetch_add(materialized as u64, Ordering::Relaxed);
+    QUERIES_TOTAL.fetch_add(1, Ordering::Relaxed);
+    QUERIES_SCAN.fetch_add(1, Ordering::Relaxed);
+    // A scan evaluates the predicate against every record it visits. This is
+    // the O(N) figure PR35 exists to reduce, recorded on the same counter the
+    // indexed path reports to, so the two are directly comparable.
+    RECORDS_PREDICATE_EVALUATED.fetch_add(visited as u64, Ordering::Relaxed);
+}
+
+/// A query for which no condition had an applicable index, so it falls back.
+///
+/// This deliberately does not advance `queries_total`: the scan the caller is
+/// about to run records the query itself, and counting it here would report
+/// every fallback twice.
+pub(crate) fn record_index_miss() {
+    INDEX_MISSES.fetch_add(1, Ordering::Relaxed);
+}
+
+/// A query answered from index candidates.
+///
+/// `examined` is the candidate set after intersection, `evaluated` the records
+/// the predicate actually ran against, and `materialized` the matching set that
+/// was cloned. `evaluated` can be below `examined` only if an index entry has no
+/// record behind it, which would be a maintenance defect; the gap is visible
+/// here rather than hidden.
+pub(crate) fn record_indexed_query(examined: usize, evaluated: usize, materialized: usize) {
+    QUERIES_TOTAL.fetch_add(1, Ordering::Relaxed);
+    QUERIES_INDEXED.fetch_add(1, Ordering::Relaxed);
+    INDEX_HITS.fetch_add(1, Ordering::Relaxed);
+    INDEX_CANDIDATES_EXAMINED.fetch_add(examined as u64, Ordering::Relaxed);
+    RECORDS_PREDICATE_EVALUATED.fetch_add(evaluated as u64, Ordering::Relaxed);
+    SCAN_RECORDS_MATERIALIZED.fetch_add(materialized as u64, Ordering::Relaxed);
+}
+
+/// Read the counters. Monotonic since process start, so tests compare deltas.
+pub fn counters() -> QueryExecutionCounters {
+    QueryExecutionCounters {
+        full_collection_materializations: FULL_COLLECTION_MATERIALIZATIONS.load(Ordering::Relaxed),
+        full_collection_records_cloned: FULL_COLLECTION_RECORDS_CLONED.load(Ordering::Relaxed),
+        collection_scans: COLLECTION_SCANS.load(Ordering::Relaxed),
+        scan_records_visited: SCAN_RECORDS_VISITED.load(Ordering::Relaxed),
+        scan_records_materialized: SCAN_RECORDS_MATERIALIZED.load(Ordering::Relaxed),
+        queries_total: QUERIES_TOTAL.load(Ordering::Relaxed),
+        queries_scan: QUERIES_SCAN.load(Ordering::Relaxed),
+        queries_indexed: QUERIES_INDEXED.load(Ordering::Relaxed),
+        index_hits: INDEX_HITS.load(Ordering::Relaxed),
+        index_misses: INDEX_MISSES.load(Ordering::Relaxed),
+        index_candidates_examined: INDEX_CANDIDATES_EXAMINED.load(Ordering::Relaxed),
+        records_predicate_evaluated: RECORDS_PREDICATE_EVALUATED.load(Ordering::Relaxed),
+    }
+}

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

@@ -5,7 +5,6 @@
 /// - Latency contract enforcement
 /// - Performance degradation detection
 /// - Query optimization recommendations
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::time::{Duration, Instant};
@@ -156,7 +155,11 @@ impl QueryPerformanceTracker {
         for metric in &self.metrics {
             csv.push_str(&format!(
                 "{},{},{},{},{}\n",
-                metric.timestamp, metric.query_type, metric.duration_us, metric.index_name, metric.result_count
+                metric.timestamp,
+                metric.query_type,
+                metric.duration_us,
+                metric.index_name,
+                metric.result_count
             ));
         }
         csv
@@ -187,12 +190,7 @@ mod tests {
         std::thread::sleep(Duration::from_micros(50));
         let elapsed = timer.elapsed_us();
 
-        tracker.record_query(
-            "index_lookup".to_string(),
-            "idx_1".to_string(),
-            10,
-            elapsed,
-        );
+        tracker.record_query("index_lookup".to_string(), "idx_1".to_string(), 10, elapsed);
 
         let stats = tracker.get_stats("index_lookup").unwrap();
         assert_eq!(stats.count, 1);

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

@@ -8,7 +8,6 @@
 /// - After index deletion (rebuild index from scratch)
 ///
 /// All paths must converge to identical state_hash.
-
 use crate::operation_log::{MemoryOperationLog, OperationLogEntry};
 use crate::state_hash::{CanonicalState, StateHash};
 use crate::state_transition_store::MemoryStateTransitionStore;
@@ -46,7 +45,10 @@ pub struct ReplayFuzzer {
 }
 
 impl ReplayFuzzer {
-    pub fn new(operation_log: MemoryOperationLog, transition_store: MemoryStateTransitionStore) -> Self {
+    pub fn new(
+        operation_log: MemoryOperationLog,
+        transition_store: MemoryStateTransitionStore,
+    ) -> Self {
         Self {
             operation_log,
             transition_store,
@@ -99,9 +101,7 @@ impl ReplayFuzzer {
         let log_size = self.operation_log.size();
         if snapshot_at >= log_size {
             return ReplayPath {
-                scenario: ReplayScenario::AfterSnapshot {
-                    snapshot_at,
-                },
+                scenario: ReplayScenario::AfterSnapshot { snapshot_at },
                 final_state_hash: StateHash::from_hex("snapshot_beyond_log".to_string()),
                 operations_replayed: 0,
                 transitions_created: 0,

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

@@ -137,12 +137,16 @@ impl AcknowledgementStore {
     pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, AcknowledgementError> {
         let path = path.as_ref().to_path_buf();
         let acknowledgements = if path.exists() {
-            let bytes = std::fs::read(&path).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
+            let bytes =
+                std::fs::read(&path).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
             serde_json::from_slice(&bytes).map_err(|e| AcknowledgementError::Io(e.to_string()))?
         } else {
             BTreeMap::new()
         };
-        Ok(Self { path, acknowledgements })
+        Ok(Self {
+            path,
+            acknowledgements,
+        })
     }
 
     fn persist(&self) -> Result<(), AcknowledgementError> {
@@ -154,10 +158,12 @@ impl AcknowledgementStore {
             .map_err(|e| AcknowledgementError::Io(e.to_string()))?;
         {
             use std::io::Write;
-            let mut file =
-                std::fs::File::create(&temp).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
-            file.write_all(&bytes).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
-            file.sync_all().map_err(|e| AcknowledgementError::Io(e.to_string()))?;
+            let mut file = std::fs::File::create(&temp)
+                .map_err(|e| AcknowledgementError::Io(e.to_string()))?;
+            file.write_all(&bytes)
+                .map_err(|e| AcknowledgementError::Io(e.to_string()))?;
+            file.sync_all()
+                .map_err(|e| AcknowledgementError::Io(e.to_string()))?;
         }
         std::fs::rename(&temp, &self.path).map_err(|e| AcknowledgementError::Io(e.to_string()))?;
         if let Some(parent) = self.path.parent() {
@@ -227,7 +233,9 @@ impl AcknowledgementStore {
             // No required replicas at all. Still not a licence: a node with no
             // membership has not established that it is alone, it has
             // established nothing.
-            return ReclamationEvidence::Blocked { waiting_on: Vec::new() };
+            return ReclamationEvidence::Blocked {
+                waiting_on: Vec::new(),
+            };
         }
 
         let missing: Vec<String> = required
@@ -236,7 +244,9 @@ impl AcknowledgementStore {
             .cloned()
             .collect();
         if !missing.is_empty() {
-            return ReclamationEvidence::Blocked { waiting_on: missing };
+            return ReclamationEvidence::Blocked {
+                waiting_on: missing,
+            };
         }
 
         // The minimum over every required replica, component-wise. A frontier
@@ -259,7 +269,10 @@ impl AcknowledgementStore {
                 frontier.clocks.insert(origin, lowest);
             }
         }
-        ReclamationEvidence::SafeThrough { frontier, covered: required }
+        ReclamationEvidence::SafeThrough {
+            frontier,
+            covered: required,
+        }
     }
 }
 
@@ -328,12 +341,17 @@ mod tests {
     fn a_required_replica_with_no_acknowledgement_blocks() {
         let dir = tempfile::tempdir().unwrap();
         let mut acks = store(&dir);
-        acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"])).unwrap();
+        acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"]))
+            .unwrap();
 
         let evidence = acks.evidence(&["ra".into(), "rb".into(), "rc".into()]);
         match evidence {
             ReclamationEvidence::Blocked { waiting_on } => {
-                assert_eq!(waiting_on, vec!["ra", "rc"], "and it names who it waits for");
+                assert_eq!(
+                    waiting_on,
+                    vec!["ra", "rc"],
+                    "and it names who it waits for"
+                );
             }
             other => panic!("missing acknowledgement must block, got {other:?}"),
         }
@@ -347,7 +365,8 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
         let mut acks = store(&dir);
         acks.record(ack("ra", &[("A", 3)], &["ra", "rb"])).unwrap();
-        acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"])).unwrap();
+        acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"]))
+            .unwrap();
 
         let local = vec!["ra".to_string(), "rb".to_string()];
         assert_eq!(acks.required_union(&local), vec!["ra", "rb", "rc"]);
@@ -363,7 +382,10 @@ mod tests {
         // alone. It has established nothing, and nothing is what it may act on.
         let dir = tempfile::tempdir().unwrap();
         let acks = store(&dir);
-        assert!(matches!(acks.evidence(&[]), ReclamationEvidence::Blocked { .. }));
+        assert!(matches!(
+            acks.evidence(&[]),
+            ReclamationEvidence::Blocked { .. }
+        ));
     }
 
     #[test]
@@ -395,8 +417,10 @@ mod tests {
     fn the_safe_frontier_is_the_minimum_over_every_required_replica() {
         let dir = tempfile::tempdir().unwrap();
         let mut acks = store(&dir);
-        acks.record(ack("ra", &[("A", 9), ("B", 4)], &["ra", "rb"])).unwrap();
-        acks.record(ack("rb", &[("A", 5), ("B", 6)], &["ra", "rb"])).unwrap();
+        acks.record(ack("ra", &[("A", 9), ("B", 4)], &["ra", "rb"]))
+            .unwrap();
+        acks.record(ack("rb", &[("A", 5), ("B", 6)], &["ra", "rb"]))
+            .unwrap();
 
         match acks.evidence(&["ra".into(), "rb".into()]) {
             ReclamationEvidence::SafeThrough { frontier, covered } => {
@@ -415,7 +439,8 @@ mod tests {
         // anything is safe through.
         let dir = tempfile::tempdir().unwrap();
         let mut acks = store(&dir);
-        acks.record(ack("ra", &[("A", 4), ("C", 9)], &["ra", "rb"])).unwrap();
+        acks.record(ack("ra", &[("A", 4), ("C", 9)], &["ra", "rb"]))
+            .unwrap();
         acks.record(ack("rb", &[("A", 4)], &["ra", "rb"])).unwrap();
 
         match acks.evidence(&["ra".into(), "rb".into()]) {
@@ -437,7 +462,8 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
         {
             let mut acks = store(&dir);
-            acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"])).unwrap();
+            acks.record(ack("rb", &[("A", 3)], &["ra", "rb", "rc"]))
+                .unwrap();
         }
         let recovered = store(&dir);
         match recovered.evidence(&["ra".into(), "rb".into()]) {
@@ -464,7 +490,11 @@ mod tests {
 
         let recovered = store(&dir);
         assert_eq!(
-            recovered.get("rb").unwrap().origin_sequence_high_water.get("A"),
+            recovered
+                .get("rb")
+                .unwrap()
+                .origin_sequence_high_water
+                .get("A"),
             Some(&7),
         );
     }

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

@@ -146,19 +146,23 @@ impl MembershipStore {
     /// directory. Membership is what will later authorise deleting history, so
     /// it is written with the same care as the log it will authorise deleting.
     fn persist(&self) -> Result<(), MembershipError> {
-        let Some(cluster) = &self.cluster else { return Ok(()) };
+        let Some(cluster) = &self.cluster else {
+            return Ok(());
+        };
         if let Some(parent) = self.path.parent() {
             std::fs::create_dir_all(parent).map_err(|e| MembershipError::Io(e.to_string()))?;
         }
         let temp = self.path.with_extension("tmp");
-        let bytes = serde_json::to_vec_pretty(cluster)
-            .map_err(|e| MembershipError::Io(e.to_string()))?;
+        let bytes =
+            serde_json::to_vec_pretty(cluster).map_err(|e| MembershipError::Io(e.to_string()))?;
         {
             use std::io::Write;
-            let mut file = std::fs::File::create(&temp)
+            let mut file =
+                std::fs::File::create(&temp).map_err(|e| MembershipError::Io(e.to_string()))?;
+            file.write_all(&bytes)
+                .map_err(|e| MembershipError::Io(e.to_string()))?;
+            file.sync_all()
                 .map_err(|e| MembershipError::Io(e.to_string()))?;
-            file.write_all(&bytes).map_err(|e| MembershipError::Io(e.to_string()))?;
-            file.sync_all().map_err(|e| MembershipError::Io(e.to_string()))?;
         }
         std::fs::rename(&temp, &self.path).map_err(|e| MembershipError::Io(e.to_string()))?;
         if let Some(parent) = self.path.parent() {
@@ -435,7 +439,11 @@ mod tests {
         cluster.suspect_replica("rc").unwrap();
         cluster.mark_seen("rc").unwrap();
         let seen = cluster.get_members().into_iter().next().unwrap();
-        assert_eq!(seen.status, ReplicaStatus::Active, "contact reinstates a suspected replica");
+        assert_eq!(
+            seen.status,
+            ReplicaStatus::Active,
+            "contact reinstates a suspected replica"
+        );
         assert!(seen.last_seen_at_ms.is_some());
 
         cluster.remove_replica("rc").unwrap();
@@ -503,7 +511,10 @@ mod tests {
     fn membership_operations_need_a_cluster() {
         let dir = tempfile::tempdir().unwrap();
         let mut cluster = store(&dir);
-        assert!(matches!(cluster.join_replica("ra", "A"), Err(MembershipError::NoCluster)));
+        assert!(matches!(
+            cluster.join_replica("ra", "A"),
+            Err(MembershipError::NoCluster)
+        ));
         cluster.create_cluster("c1").unwrap();
         assert!(matches!(
             cluster.create_cluster("c2"),
@@ -523,7 +534,10 @@ mod tests {
         cluster.join_replica("ra", "A").unwrap();
         cluster.approve_replica("ra").unwrap();
         assert!(
-            matches!(cluster.approve_replica("ra"), Err(MembershipError::NotJoining(_))),
+            matches!(
+                cluster.approve_replica("ra"),
+                Err(MembershipError::NotJoining(_))
+            ),
             "approving twice is not a silent no-op"
         );
     }
@@ -648,7 +662,9 @@ mod tests {
         let mut cluster = MembershipStore::open(&path).unwrap();
         cluster.create_cluster("c1").unwrap();
         for index in 0..20 {
-            cluster.join_replica(&format!("r{index}"), &format!("N{index}")).unwrap();
+            cluster
+                .join_replica(&format!("r{index}"), &format!("N{index}"))
+                .unwrap();
             let observed = MembershipStore::open(&path).unwrap();
             assert_eq!(
                 observed.get_members().len(),
@@ -656,6 +672,9 @@ mod tests {
                 "every observation is of a complete cluster"
             );
         }
-        assert!(!path.with_extension("tmp").exists(), "no temp file is left at rest");
+        assert!(
+            !path.with_extension("tmp").exists(),
+            "no temp file is left at rest"
+        );
     }
 }

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

@@ -6,7 +6,6 @@
 /// - Routing messages from leader to followers
 /// - Acknowledgment tracking
 /// - Retry logic for lost messages
-
 use crate::distributed_transactions::ReplicationMessage;
 use std::collections::{HashMap, VecDeque};
 use std::sync::atomic::{AtomicU64, Ordering};
@@ -67,7 +66,10 @@ impl PeerReplicationQueue {
     }
 
     pub fn pending_count(&self) -> usize {
-        self.messages.iter().filter(|m| m.status == DeliveryStatus::Pending).count()
+        self.messages
+            .iter()
+            .filter(|m| m.status == DeliveryStatus::Pending)
+            .count()
     }
 
     pub fn next_pending(&mut self) -> Option<TrackedMessage> {
@@ -103,7 +105,8 @@ impl ReplicationManager {
 
     /// Register a peer to receive replication messages
     pub fn register_peer(&mut self, peer_id: String) {
-        self.peer_queues.insert(peer_id.clone(), PeerReplicationQueue::new(peer_id));
+        self.peer_queues
+            .insert(peer_id.clone(), PeerReplicationQueue::new(peer_id));
     }
 
     /// Enqueue a message for replication to all peers

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

@@ -2,7 +2,6 @@
 ///
 /// Decouples ReplicationMessage handling from transport details.
 /// Works with typed messages (ReplicationMessage) rather than raw bytes.
-
 use crate::distributed_transactions::ReplicationMessage;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
@@ -71,7 +70,8 @@ impl ProtocolMetrics {
 
     pub fn record_receive(&self, bytes: usize) {
         self.messages_received.fetch_add(1, Ordering::Relaxed);
-        self.bytes_received.fetch_add(bytes as u64, Ordering::Relaxed);
+        self.bytes_received
+            .fetch_add(bytes as u64, Ordering::Relaxed);
     }
 
     pub fn record_error(&self) {
@@ -79,7 +79,8 @@ impl ProtocolMetrics {
     }
 
     pub fn record_connection_state_change(&self) {
-        self.connection_state_changes.fetch_add(1, Ordering::Relaxed);
+        self.connection_state_changes
+            .fetch_add(1, Ordering::Relaxed);
     }
 
     pub fn get_messages_sent(&self) -> u64 {