@feltdb/core 0.8.4 → 0.8.5

package/dist/create/server-source/crates/feltdb/benches/phase_7_1_3_crossover_analysis.rs

@@ -8,8 +8,7 @@
 /// - Frontier advances: 1, 10, 100
 ///
 /// Output: CSV table suitable for crossover curve analysis
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 use feltdb::causal_dependency_barrier::CausalDependencyBarrier;
 use feltdb::convergence::VectorClock;
 use std::fs::File;
@@ -65,7 +64,11 @@ impl CrossoverMetrics {
             self.ix_index_entries,
             self.speedup,
             self.winner,
-            if self.winner == 'I' { "INDEXED" } else { "FULL_SCAN" }
+            if self.winner == 'I' {
+                "INDEXED"
+            } else {
+                "FULL_SCAN"
+            }
         )
     }
 }
@@ -86,7 +89,8 @@ fn generate_workload(
     let mut operations = Vec::new();
     for i in 0..workload.pending_size {
         let mut required = VectorClock::new();
-        let release_threshold = (workload.pending_size as f64 * workload.release_selectivity) as usize;
+        let release_threshold =
+            (workload.pending_size as f64 * workload.release_selectivity) as usize;
         let ts = if i < release_threshold {
             10 // Will be released when frontier advances to 10
         } else {
@@ -185,7 +189,13 @@ fn measure_indexed(
         candidates_discovered = barrier.get_dependency_index().waiters.len() as u64;
     }
 
-    (latency_ns, candidates_discovered, candidates_examined, ops_released, candidates_discovered)
+    (
+        latency_ns,
+        candidates_discovered,
+        candidates_examined,
+        ops_released,
+        candidates_discovered,
+    )
 }
 
 /// Phase 7.1.3: Crossover Matrix Benchmark
@@ -201,8 +211,10 @@ fn benchmark_crossover_matrix(c: &mut Criterion) {
     let mut results = Vec::new();
 
     println!("\n=== Phase 7.1.3: Crossover Analysis ===");
-    println!("{:>7} {:>3} {:>5} {:>10} {:>12} {:>12} {:>7}",
-        "Pending", "Adv", "Sel%", "FS (µs)", "IX (µs)", "Speedup", "Winner");
+    println!(
+        "{:>7} {:>3} {:>5} {:>10} {:>12} {:>12} {:>7}",
+        "Pending", "Adv", "Sel%", "FS (µs)", "IX (µs)", "Speedup", "Winner"
+    );
 
     for pending in &pending_sizes {
         for advances in &advance_counts {
@@ -216,7 +228,8 @@ fn benchmark_crossover_matrix(c: &mut Criterion) {
                 let (ops, advs) = generate_workload(&workload, 42);
 
                 // Measure both paths
-                let (fs_latency, fs_examined, fs_released) = measure_full_scan(&workload, &ops, &advs);
+                let (fs_latency, fs_examined, fs_released) =
+                    measure_full_scan(&workload, &ops, &advs);
                 let (ix_latency, ix_discovered, ix_examined, ix_released, ix_entries) =
                     measure_indexed(&workload, &ops, &advs);
 
@@ -231,9 +244,20 @@ fn benchmark_crossover_matrix(c: &mut Criterion) {
                 let fs_us = fs_latency as f64 / 1000.0;
                 let ix_us = ix_latency as f64 / 1000.0;
 
-                println!("{:>7} {:>3} {:>5.0} {:>10.1} {:>12.1} {:>12.2}x {}",
-                    pending, advances, selectivity * 100.0, fs_us, ix_us, speedup,
-                    if winner == 'I' { "INDEXED" } else { "FULL_SCAN" });
+                println!(
+                    "{:>7} {:>3} {:>5.0} {:>10.1} {:>12.1} {:>12.2}x {}",
+                    pending,
+                    advances,
+                    selectivity * 100.0,
+                    fs_us,
+                    ix_us,
+                    speedup,
+                    if winner == 'I' {
+                        "INDEXED"
+                    } else {
+                        "FULL_SCAN"
+                    }
+                );
 
                 let metrics = CrossoverMetrics {
                     pending: *pending,
@@ -254,15 +278,21 @@ fn benchmark_crossover_matrix(c: &mut Criterion) {
                 results.push(metrics);
 
                 // Criterion benchmarks for regression gates
-                let bench_name = format!("pending_{}_adv_{}_sel_{:.0}pct",
-                    pending, advances, selectivity * 100.0);
+                let bench_name = format!(
+                    "pending_{}_adv_{}_sel_{:.0}pct",
+                    pending,
+                    advances,
+                    selectivity * 100.0
+                );
 
                 group.bench_with_input(
                     BenchmarkId::new("full_scan", &bench_name),
                     &workload,
                     |b, w| {
                         let (ops, advs) = generate_workload(w, 42);
-                        b.iter(|| measure_full_scan(black_box(w), black_box(&ops), black_box(&advs)));
+                        b.iter(|| {
+                            measure_full_scan(black_box(w), black_box(&ops), black_box(&advs))
+                        });
                     },
                 );
 
@@ -282,7 +312,8 @@ fn benchmark_crossover_matrix(c: &mut Criterion) {
 
     // Write results to CSV for analysis
     if let Ok(mut file) = File::create("target/phase_7_1_3_crossover.csv") {
-        let _ = writeln!(file,
+        let _ =
+            writeln!(file,
             "pending,advances,selectivity_pct,fs_latency_ns,fs_entries_examined,fs_ops_released,\
              ix_latency_ns,ix_candidates_discovered,ix_candidates_examined,ix_ops_released,\
              ix_index_entries,speedup,winner,winner_name");

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

@@ -2,7 +2,6 @@
 ///
 /// Defines explicit, machine-readable submission semantics.
 /// Never silently drops operations. Rejection is explicit and retryable.
-
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
@@ -12,9 +11,7 @@ pub enum SubmissionOutcome {
     /// Operation accepted for processing
     /// Operations are accepted in order but may not yet be committed.
     /// Caller should wait for CommitAck before assuming durability.
-    Accepted {
-        operation_id: u64,
-    },
+    Accepted { operation_id: u64 },
 
     /// Operation rejected due to backpressure
     /// Caller should retry with backoff
@@ -103,11 +100,11 @@ impl ProductionRetryPolicy {
         ProductionRetryPolicy {
             max_attempts: 4,
             backoff_sequence: vec![
-                0,        // Attempt 1: no backoff (immediate)
-                100,      // Attempt 2: 100µs
-                200,      // Attempt 3: 200µs
-                400,      // Attempt 4: 400µs
-                // Total: 700µs of bounded admission attempts
+                0,   // Attempt 1: no backoff (immediate)
+                100, // Attempt 2: 100µs
+                200, // Attempt 3: 200µs
+                400, // Attempt 4: 400µs
+                     // Total: 700µs of bounded admission attempts
             ],
         }
     }
@@ -117,9 +114,7 @@ impl ProductionRetryPolicy {
     pub fn stress_test() -> Self {
         ProductionRetryPolicy {
             max_attempts: 10,
-            backoff_sequence: vec![
-                0, 50, 100, 150, 200, 250, 300, 350, 400, 450,
-            ],
+            backoff_sequence: vec![0, 50, 100, 150, 200, 250, 300, 350, 400, 450],
         }
     }
 
@@ -168,9 +163,7 @@ mod tests {
 
     #[test]
     fn outcome_accessors_work() {
-        let accepted = SubmissionOutcome::Accepted {
-            operation_id: 123,
-        };
+        let accepted = SubmissionOutcome::Accepted { operation_id: 123 };
         assert!(accepted.is_accepted());
         assert!(!accepted.is_rejected());
 

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

@@ -38,7 +38,10 @@ mod tests {
                 record_id: "rec1".to_string(),
                 fields: {
                     let mut m = HashMap::new();
-                    m.insert("field".to_string(), serde_json::json!(format!("value_{}", seq)));
+                    m.insert(
+                        "field".to_string(),
+                        serde_json::json!(format!("value_{}", seq)),
+                    );
                     m
                 },
             },
@@ -62,7 +65,11 @@ mod tests {
                 assert!(true, "Operation explicitly accepted");
             }
             SubmissionOutcome::Rejected(ref reason) => {
-                assert!(true, "Operation explicitly rejected with reason: {:?}", reason);
+                assert!(
+                    true,
+                    "Operation explicitly rejected with reason: {:?}",
+                    reason
+                );
             }
         }
     }
@@ -101,7 +108,10 @@ mod tests {
 
         let op1 = create_operation("node1", 1);
         let outcome1 = submitter.submit(op1.clone());
-        assert!(outcome1.is_accepted(), "First submission should be accepted");
+        assert!(
+            outcome1.is_accepted(),
+            "First submission should be accepted"
+        );
 
         let outcome2 = submitter.submit(op1);
         assert!(outcome2.is_rejected(), "Duplicate should be rejected");
@@ -110,7 +120,10 @@ mod tests {
             SubmissionOutcome::Rejected(RejectionReason::DuplicateDetected {
                 original_operation_id,
             }) => {
-                assert_eq!(original_operation_id, 1, "Should identify original operation ID");
+                assert_eq!(
+                    original_operation_id, 1,
+                    "Should identify original operation ID"
+                );
             }
             _ => panic!("Expected DuplicateDetected rejection reason"),
         }
@@ -130,8 +143,14 @@ mod tests {
                 retry_after_us,
                 suggested_backoff_ms,
             } => {
-                assert!(retry_after_us > 0, "retry_after_us should guide backoff strategy");
-                assert!(suggested_backoff_ms > 0, "suggested_backoff_ms should guide backoff");
+                assert!(
+                    retry_after_us > 0,
+                    "retry_after_us should guide backoff strategy"
+                );
+                assert!(
+                    suggested_backoff_ms > 0,
+                    "suggested_backoff_ms should guide backoff"
+                );
             }
             _ => panic!("Expected AdmissionBackpressure"),
         }
@@ -159,7 +178,10 @@ mod tests {
             RejectionReason::DuplicateDetected {
                 original_operation_id,
             } => {
-                assert_eq!(original_operation_id, 42, "Should identify original operation");
+                assert_eq!(
+                    original_operation_id, 42,
+                    "Should identify original operation"
+                );
             }
             _ => panic!("Expected DuplicateDetected"),
         }
@@ -279,7 +301,10 @@ mod tests {
         let policy = ProductionRetryPolicy::standard();
 
         // Verify bounded policy constraints
-        assert!(policy.max_attempts < 100, "max_attempts should be reasonable");
+        assert!(
+            policy.max_attempts < 100,
+            "max_attempts should be reasonable"
+        );
         assert!(
             policy.backoff_sequence.len() <= policy.max_attempts,
             "backoff sequence length should not exceed max_attempts"
@@ -353,7 +378,11 @@ mod tests {
 
         let elapsed = start.elapsed();
 
-        assert_eq!(accepted + rejected, 1000, "Every operation must get an outcome");
+        assert_eq!(
+            accepted + rejected,
+            1000,
+            "Every operation must get an outcome"
+        );
         assert_eq!(rejected, 0, "Under normal load, no rejections expected");
         println!(
             "Processed 1000 operations in {:.2}ms ({:.0} ops/sec)",
@@ -398,7 +427,10 @@ mod tests {
 
         // First cycle: all should be accepted
         assert_eq!(accepted_by_cycle[0], 20, "First cycle should accept all");
-        assert_eq!(duplicates_by_cycle[0], 0, "First cycle should have no duplicates");
+        assert_eq!(
+            duplicates_by_cycle[0], 0,
+            "First cycle should have no duplicates"
+        );
 
         // Subsequent cycles: all should be duplicates
         for cycle in 1..5 {
@@ -464,9 +496,7 @@ mod tests {
 
     #[test]
     fn contract_outcome_accessors_are_correct() {
-        let accepted = SubmissionOutcome::Accepted {
-            operation_id: 42,
-        };
+        let accepted = SubmissionOutcome::Accepted { operation_id: 42 };
         assert!(accepted.is_accepted());
         assert!(!accepted.is_rejected());
 

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

@@ -9,7 +9,6 @@
 ///   send → maybe delay → maybe duplicate → maybe drop → eventually deliver
 ///
 /// FeltDB must converge itself. Simulator cannot help.
-
 use std::collections::{HashMap, VecDeque};
 
 /// Reproducible fault seed
@@ -44,32 +43,17 @@ pub enum LinkState {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NetworkEvent {
     /// Delay a message by N ticks
-    Delay {
-        message_id: MessageId,
-        ticks: u64,
-    },
+    Delay { message_id: MessageId, ticks: u64 },
     /// Drop a message permanently
-    Drop {
-        message_id: MessageId,
-    },
+    Drop { message_id: MessageId },
     /// Duplicate a message
-    Duplicate {
-        message_id: MessageId,
-    },
+    Duplicate { message_id: MessageId },
     /// Partition a directional link
-    Partition {
-        from: NodeId,
-        to: NodeId,
-    },
+    Partition { from: NodeId, to: NodeId },
     /// Heal a directional link
-    Heal {
-        from: NodeId,
-        to: NodeId,
-    },
+    Heal { from: NodeId, to: NodeId },
     /// Reorder messages on a connection
-    Reorder {
-        connection: ConnectionId,
-    },
+    Reorder { connection: ConnectionId },
 }
 
 /// Deterministic network schedule (fully reproducible from seed)
@@ -125,11 +109,13 @@ impl ConnectivityMatrix {
     }
 
     pub fn partition(&mut self, from: NodeId, to: NodeId) {
-        self.links.insert(ConnectionId { from, to }, LinkState::Partitioned);
+        self.links
+            .insert(ConnectionId { from, to }, LinkState::Partitioned);
     }
 
     pub fn heal(&mut self, from: NodeId, to: NodeId) {
-        self.links.insert(ConnectionId { from, to }, LinkState::Connected);
+        self.links
+            .insert(ConnectionId { from, to }, LinkState::Connected);
     }
 
     pub fn get_state(&self, from: NodeId, to: NodeId) -> LinkState {
@@ -326,10 +312,7 @@ impl ReplicationTransport for AdversarialTransport {
 
     fn apply_fault(&mut self, event: NetworkEvent) {
         match event {
-            NetworkEvent::Delay {
-                message_id,
-                ticks,
-            } => {
+            NetworkEvent::Delay { message_id, ticks } => {
                 // Find message and delay delivery
                 for msg in &mut self.in_flight {
                     if msg.id == message_id {
@@ -438,10 +421,7 @@ mod tests {
         let n2 = NodeId(2);
 
         // Partition n1 → n2
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n2,
-        });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
 
         // Message should be dropped
         let _msg_id = transport.send(n1, n2, vec![1, 2, 3]);
@@ -489,9 +469,7 @@ mod tests {
         let msg_id = transport.send(n1, n2, vec![1, 2, 3]);
 
         // Duplicate the message
-        transport.apply_fault(NetworkEvent::Duplicate {
-            message_id: msg_id,
-        });
+        transport.apply_fault(NetworkEvent::Duplicate { message_id: msg_id });
 
         transport.tick();
         let messages = transport.receive(n2);
@@ -510,9 +488,7 @@ mod tests {
 
         let msg_id = transport.send(n1, n2, vec![1, 2, 3]);
 
-        transport.apply_fault(NetworkEvent::Drop {
-            message_id: msg_id,
-        });
+        transport.apply_fault(NetworkEvent::Drop { message_id: msg_id });
 
         transport.tick();
         let messages = transport.receive(n2);
@@ -528,10 +504,7 @@ mod tests {
         let n2 = NodeId(2);
 
         // Partition n1 → n2 only (asymmetric)
-        transport.apply_fault(NetworkEvent::Partition {
-            from: n1,
-            to: n2,
-        });
+        transport.apply_fault(NetworkEvent::Partition { from: n1, to: n2 });
 
         // n1 → n2 blocked
         let _msg_id = transport.send(n1, n2, vec![1, 2, 3]);

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

@@ -85,11 +85,13 @@ impl IndexAnalytics {
         if operation == "read" {
             let old_avg = metric.avg_query_time_ms;
             metric.reads += 1;
-            metric.avg_query_time_ms = (old_avg * (metric.reads - 1) as f64 + time_ms) / metric.reads as f64;
+            metric.avg_query_time_ms =
+                (old_avg * (metric.reads - 1) as f64 + time_ms) / metric.reads as f64;
         } else {
             let old_avg = metric.avg_write_time_ms;
             metric.writes += 1;
-            metric.avg_write_time_ms = (old_avg * (metric.writes - 1) as f64 + time_ms) / metric.writes as f64;
+            metric.avg_write_time_ms =
+                (old_avg * (metric.writes - 1) as f64 + time_ms) / metric.writes as f64;
         }
 
         metric.last_used_at = current_time_ms();
@@ -142,13 +144,21 @@ impl IndexAnalytics {
 
     pub fn get_slowest_queries(&self, limit: usize) -> Vec<QueryTrace> {
         let mut traces = self.query_traces.clone();
-        traces.sort_by(|a, b| b.execution_time_ms.partial_cmp(&a.execution_time_ms).unwrap_or(std::cmp::Ordering::Equal));
+        traces.sort_by(|a, b| {
+            b.execution_time_ms
+                .partial_cmp(&a.execution_time_ms)
+                .unwrap_or(std::cmp::Ordering::Equal)
+        });
         traces.truncate(limit);
         traces
     }
 
     pub fn get_frequent_fields(&self, limit: usize) -> Vec<(String, u64)> {
-        let mut fields: Vec<_> = self.field_query_count.iter().map(|(k, v)| (k.clone(), *v)).collect();
+        let mut fields: Vec<_> = self
+            .field_query_count
+            .iter()
+            .map(|(k, v)| (k.clone(), *v))
+            .collect();
         fields.sort_by(|a, b| b.1.cmp(&a.1));
         fields.truncate(limit);
         fields
@@ -182,11 +192,7 @@ impl IndexAnalytics {
         }
     }
 
-    pub fn generate_report(
-        &self,
-        collection_name: &str,
-        period: &str,
-    ) -> PerformanceReport {
+    pub fn generate_report(&self, collection_name: &str, period: &str) -> PerformanceReport {
         let now = current_time_ms();
         let cutoff = match period {
             "hourly" => now - 3_600_000,
@@ -201,20 +207,31 @@ impl IndexAnalytics {
             .cloned()
             .collect();
 
-        let indexed_queries = recent_traces.iter().filter(|t| t.index_used.is_some()).count();
+        let indexed_queries = recent_traces
+            .iter()
+            .filter(|t| t.index_used.is_some())
+            .count();
         let full_scans = recent_traces.len() - indexed_queries;
 
         let avg_query_time = if recent_traces.is_empty() {
             0.0
         } else {
-            recent_traces.iter().map(|t| t.execution_time_ms).sum::<f64>() / recent_traces.len() as f64
+            recent_traces
+                .iter()
+                .map(|t| t.execution_time_ms)
+                .sum::<f64>()
+                / recent_traces.len() as f64
         };
 
         let slowest_query = if recent_traces.is_empty() {
             None
         } else {
             let mut traces = recent_traces.clone();
-            traces.sort_by(|a, b| b.execution_time_ms.partial_cmp(&a.execution_time_ms).unwrap_or(std::cmp::Ordering::Equal));
+            traces.sort_by(|a, b| {
+                b.execution_time_ms
+                    .partial_cmp(&a.execution_time_ms)
+                    .unwrap_or(std::cmp::Ordering::Equal)
+            });
             traces.first().cloned()
         };
 
@@ -267,7 +284,10 @@ impl IndexAnalytics {
                     rec_type: "create_index".to_string(),
                     priority: "high".to_string(),
                     index_name: None,
-                    reason: format!("Field '{}' scanned {:.0} rows per query", field, avg_scanned_per_query),
+                    reason: format!(
+                        "Field '{}' scanned {:.0} rows per query",
+                        field, avg_scanned_per_query
+                    ),
                     expected_speedup: Some(avg_scanned_per_query / 10.0),
                     estimated_roi: None,
                 });
@@ -283,7 +303,10 @@ impl IndexAnalytics {
                     rec_type: "drop_index".to_string(),
                     priority: "low".to_string(),
                     index_name: Some(metric.name.clone()),
-                    reason: format!("Index has {:.1}% hit rate and unused for 24h", metric.hit_rate * 100.0),
+                    reason: format!(
+                        "Index has {:.1}% hit rate and unused for 24h",
+                        metric.hit_rate * 100.0
+                    ),
                     expected_speedup: None,
                     estimated_roi: Some(-0.01),
                 });
@@ -307,7 +330,11 @@ impl IndexAnalytics {
                     rec_type: "create_index".to_string(),
                     priority: "medium".to_string(),
                     index_name: None,
-                    reason: format!("Fields '{}' queried together in {} queries", fields.replace('|', ", "), count),
+                    reason: format!(
+                        "Fields '{}' queried together in {} queries",
+                        fields.replace('|', ", "),
+                        count
+                    ),
                     expected_speedup: Some(5.0),
                     estimated_roi: None,
                 });
@@ -326,7 +353,9 @@ impl IndexAnalytics {
             if priority_cmp == std::cmp::Ordering::Equal {
                 let speedup_a = a.expected_speedup.unwrap_or(0.0);
                 let speedup_b = b.expected_speedup.unwrap_or(0.0);
-                speedup_b.partial_cmp(&speedup_a).unwrap_or(std::cmp::Ordering::Equal)
+                speedup_b
+                    .partial_cmp(&speedup_a)
+                    .unwrap_or(std::cmp::Ordering::Equal)
             } else {
                 priority_cmp
             }
@@ -368,7 +397,14 @@ impl AutoTuner {
             return false;
         }
 
-        let key = format!("{}:{}", recommendation.rec_type, recommendation.index_name.as_ref().unwrap_or(&recommendation.reason));
+        let key = format!(
+            "{}:{}",
+            recommendation.rec_type,
+            recommendation
+                .index_name
+                .as_ref()
+                .unwrap_or(&recommendation.reason)
+        );
         if self.applied_recommendations.contains(&key) {
             return false;
         }
@@ -386,13 +422,23 @@ impl AutoTuner {
             return false;
         }
 
-        let key = format!("{}:{}", recommendation.rec_type, recommendation.index_name.as_ref().unwrap_or(&recommendation.reason));
+        let key = format!(
+            "{}:{}",
+            recommendation.rec_type,
+            recommendation
+                .index_name
+                .as_ref()
+                .unwrap_or(&recommendation.reason)
+        );
         self.applied_recommendations.insert(key);
         true
     }
 
     /// Get recommendations that are ready for auto-apply.
-    pub fn get_auto_applicable_recommendations(&self, report: &PerformanceReport) -> Vec<TuningRecommendation> {
+    pub fn get_auto_applicable_recommendations(
+        &self,
+        report: &PerformanceReport,
+    ) -> Vec<TuningRecommendation> {
         report
             .recommendations
             .iter()