@feltdb/core 0.8.3 → 0.8.5

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

@@ -32,10 +32,10 @@
 /// 2. Allow callers to retry safely
 /// 3. Maintain state correctness
 /// 4. Show measurable rejection rate with clear retry guidance
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use feltdb::{
-    convergence::VectorClock, submission::{SubmissionManager, SubmissionMetrics},
+    convergence::VectorClock,
+    submission::{SubmissionManager, SubmissionMetrics},
     transactions::{Operation, OperationCommand, OperationId, StateVersion},
 };
 use std::collections::HashMap;
@@ -75,7 +75,13 @@ impl SeededRng {
     }
 }
 
-fn generate_operation(rng: &mut SeededRng, op_id: u64, seq: u64, node: &str, client_id: usize) -> Operation {
+fn generate_operation(
+    rng: &mut SeededRng,
+    op_id: u64,
+    seq: u64,
+    node: &str,
+    client_id: usize,
+) -> Operation {
     let record_id = format!("rec_{}", rng.next_range(0, 99));
     let _is_write = rng.next_f64() >= 0.7; // 70% reads, 30% writes
 
@@ -131,7 +137,7 @@ enum OutcomeType {
 struct SubmissionRecord {
     outcome_type: OutcomeType,
     first_attempt_latency_us: u64,
-    admission_latency_us: u64,  // Time to final accepted/rejected outcome
+    admission_latency_us: u64, // Time to final accepted/rejected outcome
     retry_attempts: usize,
     eventually_accepted: bool,
 }
@@ -158,7 +164,10 @@ struct ProductionAdmissionResult {
 impl ProductionAdmissionResult {
     fn from_records(records: &[SubmissionRecord], _wall_clock_ms: f64) -> Self {
         let total = records.len();
-        let first_attempt_accepted = records.iter().filter(|r| r.outcome_type == OutcomeType::Accepted && r.retry_attempts == 0).count();
+        let first_attempt_accepted = records
+            .iter()
+            .filter(|r| r.outcome_type == OutcomeType::Accepted && r.retry_attempts == 0)
+            .count();
         let first_attempt_rejected = total - first_attempt_accepted;
         let eventually_accepted = records.iter().filter(|r| r.eventually_accepted).count();
         let permanently_rejected = total - eventually_accepted;
@@ -170,7 +179,8 @@ impl ProductionAdmissionResult {
             0.0
         };
 
-        let mut first_attempt_latencies: Vec<u64> = records.iter().map(|r| r.first_attempt_latency_us).collect();
+        let mut first_attempt_latencies: Vec<u64> =
+            records.iter().map(|r| r.first_attempt_latency_us).collect();
         first_attempt_latencies.sort_unstable();
 
         let p50_first = if !first_attempt_latencies.is_empty() {
@@ -189,7 +199,8 @@ impl ProductionAdmissionResult {
             0
         };
 
-        let mut admission_latencies: Vec<u64> = records.iter().map(|r| r.admission_latency_us).collect();
+        let mut admission_latencies: Vec<u64> =
+            records.iter().map(|r| r.admission_latency_us).collect();
         admission_latencies.sort_unstable();
 
         let p50_admission = if !admission_latencies.is_empty() {
@@ -332,13 +343,25 @@ fn gate_14a_production_admission_revalidation(c: &mut Criterion) {
     println!("\n═════════════════════════════════════════════════════════════");
     println!("GATE 14A REVALIDATION: PRODUCTION ADMISSION CONTRACT");
     println!("═════════════════════════════════════════════════════════════");
-    println!("\nFROZEN WORKLOAD: {} ops/client, deterministic seed={}", OPERATIONS_PER_CLIENT, RANDOM_SEED);
+    println!(
+        "\nFROZEN WORKLOAD: {} ops/client, deterministic seed={}",
+        OPERATIONS_PER_CLIENT, RANDOM_SEED
+    );
     println!("RETRY POLICY: ProductionRetryPolicy::standard() (4 attempts, 700µs budget)");
     println!("MEASUREMENT: First-attempt vs eventual acceptance with retry metrics\n");
 
-    println!("{:<8} {:<12} {:<12} {:<12} {:<12} {:<12}", "Writers", "1st Accept%", "Retry Amp.", "P99 1st", "P99 Admit", "Eventually");
-    println!("{:<8} {:<12} {:<12} {:<12} {:<12} {:<12}", "       ", "             ", "          ", "Attempt", "Complete", "Accepted%");
-    println!("{:-<8} {:-<12} {:-<12} {:-<12} {:-<12} {:-<12}", "", "", "", "", "", "");
+    println!(
+        "{:<8} {:<12} {:<12} {:<12} {:<12} {:<12}",
+        "Writers", "1st Accept%", "Retry Amp.", "P99 1st", "P99 Admit", "Eventually"
+    );
+    println!(
+        "{:<8} {:<12} {:<12} {:<12} {:<12} {:<12}",
+        "       ", "             ", "          ", "Attempt", "Complete", "Accepted%"
+    );
+    println!(
+        "{:-<8} {:-<12} {:-<12} {:-<12} {:-<12} {:-<12}",
+        "", "", "", "", "", ""
+    );
 
     let mut all_verified = true;
 
@@ -374,22 +397,52 @@ fn gate_14a_production_admission_revalidation(c: &mut Criterion) {
     println!("\nDetailed metrics (8-writer case):");
     if let Some(result) = results_by_concurrency.get(&8) {
         println!("  Operations attempted:       {}", result.total_operations);
-        println!("  First-attempt accepted:     {} ({:.1}%)", result.first_attempt_accepted,
-            (result.first_attempt_accepted as f64 / result.total_operations as f64) * 100.0);
-        println!("  First-attempt rejected:     {} ({:.1}%)", result.first_attempt_rejected,
-            (result.first_attempt_rejected as f64 / result.total_operations as f64) * 100.0);
-        println!("  Eventually accepted:        {} ({:.1}%)", result.eventually_accepted,
-            (result.eventually_accepted as f64 / result.total_operations as f64) * 100.0);
-        println!("  Permanently rejected:       {}", result.permanently_rejected);
-        println!("  Total retry attempts:       {}", result.total_retry_attempts);
-        println!("  Retry amplification:        {:.3} retries/operation", result.retry_amplification);
-        println!("  First-attempt P50 latency:  {}µs", result.p50_first_attempt_latency_us);
-        println!("  First-attempt P99 latency:  {}µs", result.p99_first_attempt_latency_us);
-        println!("  End-to-end P99 latency:     {}µs", result.p99_admission_latency_us);
+        println!(
+            "  First-attempt accepted:     {} ({:.1}%)",
+            result.first_attempt_accepted,
+            (result.first_attempt_accepted as f64 / result.total_operations as f64) * 100.0
+        );
+        println!(
+            "  First-attempt rejected:     {} ({:.1}%)",
+            result.first_attempt_rejected,
+            (result.first_attempt_rejected as f64 / result.total_operations as f64) * 100.0
+        );
+        println!(
+            "  Eventually accepted:        {} ({:.1}%)",
+            result.eventually_accepted,
+            (result.eventually_accepted as f64 / result.total_operations as f64) * 100.0
+        );
+        println!(
+            "  Permanently rejected:       {}",
+            result.permanently_rejected
+        );
+        println!(
+            "  Total retry attempts:       {}",
+            result.total_retry_attempts
+        );
+        println!(
+            "  Retry amplification:        {:.3} retries/operation",
+            result.retry_amplification
+        );
+        println!(
+            "  First-attempt P50 latency:  {}µs",
+            result.p50_first_attempt_latency_us
+        );
+        println!(
+            "  First-attempt P99 latency:  {}µs",
+            result.p99_first_attempt_latency_us
+        );
+        println!(
+            "  End-to-end P99 latency:     {}µs",
+            result.p99_admission_latency_us
+        );
     }
 
-    println!("\n{}", if all_verified { "✓" } else { "✗" } );
-    println!("CONTRACT VERIFICATION: {}", if all_verified { "PASSED" } else { "FAILED" });
+    println!("\n{}", if all_verified { "✓" } else { "✗" });
+    println!(
+        "CONTRACT VERIFICATION: {}",
+        if all_verified { "PASSED" } else { "FAILED" }
+    );
 
     if all_verified {
         println!("\nKEY FINDINGS:");

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

@@ -23,13 +23,12 @@
 /// - Throughput (ops/sec)
 /// - Final state consistency check
 /// - State hash determinism
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use feltdb::Operation;
 use serde_json::json;
-use std::sync::Arc;
-use std::time::{Instant, Duration};
 use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
 
 // ============================================================================
 // FROZEN WORKLOAD DEFINITION
@@ -147,11 +146,7 @@ struct AdmissionContractResult {
 }
 
 impl AdmissionContractResult {
-    fn new(
-        outcomes: &[OperationRecord],
-        ingested_count: usize,
-        wall_clock_ms: f64,
-    ) -> Self {
+    fn new(outcomes: &[OperationRecord], ingested_count: usize, wall_clock_ms: f64) -> Self {
         let successful = outcomes
             .iter()
             .filter(|r| r.outcome != OperationOutcome::Rejected)
@@ -340,12 +335,17 @@ fn gate_14a_rc2_admission_contract(c: &mut Criterion) {
     println!("\n───────────────────────────────────────────────────────────────");
 
     // Collect results indexed by [retry_budget][concurrency]
-    let mut all_results: HashMap<usize, HashMap<usize, AdmissionContractResult>> =
-        HashMap::new();
+    let mut all_results: HashMap<usize, HashMap<usize, AdmissionContractResult>> = HashMap::new();
 
     for &retry_budget in RETRY_BUDGETS {
-        println!("\nRETRY BUDGET: {}",
-            if retry_budget == 100 { "∞ (unlimited)".to_string() } else { retry_budget.to_string() });
+        println!(
+            "\nRETRY BUDGET: {}",
+            if retry_budget == 100 {
+                "∞ (unlimited)".to_string()
+            } else {
+                retry_budget.to_string()
+            }
+        );
         println!("┌────────────────────────────────────────────────────────────┐");
         println!(
             "│ {:6} │ {:8} │ {:8} │ {:7} │ {:7} │ {:7} │ Contract",
@@ -418,7 +418,10 @@ fn gate_14a_rc2_admission_contract(c: &mut Criterion) {
                 };
                 println!(
                     "{:15} │ {:7.1}% │ {:8} │ {:7.0} │ {:7.0}",
-                    budget_label, success_pct, result.rejected, result.p95_latency_us,
+                    budget_label,
+                    success_pct,
+                    result.rejected,
+                    result.p95_latency_us,
                     result.throughput_ops_per_sec
                 );
             }

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

@@ -14,13 +14,12 @@
 /// 2. Identify whether boundary is sharp (7 PASS, 8 FAIL) or probabilistic
 /// 3. Reproduce exact failing sequence for later instrumentation
 /// 4. Establish baseline for state-hash divergence analysis
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use feltdb::Operation;
 use serde_json::json;
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
-use std::collections::HashMap;
 
 // ============================================================================
 // FROZEN WORKLOAD (identical to Gate 14A)
@@ -208,7 +207,10 @@ fn gate_14a_rc_root_cause(c: &mut Criterion) {
 
         println!(
             "{:7} | {:6} | {:4} | {:4} | {:8} | {:6} | {:9}",
-            concurrency, TRIALS_PER_LEVEL, pass_count, fail_count,
+            concurrency,
+            TRIALS_PER_LEVEL,
+            pass_count,
+            fail_count,
             concurrency * OPERATIONS_PER_CLIENT,
             concurrency * OPERATIONS_PER_CLIENT - avg_missing,
             avg_missing
@@ -234,7 +236,10 @@ fn gate_14a_rc_root_cause(c: &mut Criterion) {
             pass_level, fail_level
         );
         println!("\n  This is a deterministic transition.");
-        println!("  Next: Investigate why exactly {} writers exceeds capacity.", fail_level);
+        println!(
+            "  Next: Investigate why exactly {} writers exceeds capacity.",
+            fail_level
+        );
     } else {
         println!("  ? PROBABILISTIC BOUNDARY (failures at multiple levels)");
         for (concurrency, pass, fail, missing) in &boundary_results {
@@ -262,7 +267,10 @@ fn gate_14a_rc_root_cause(c: &mut Criterion) {
     println!("  5. Instrument FeltDB internals to prove subsystem");
     println!("\nCURRENT HYPOTHESIS:");
     if let Some((_, fail_level)) = sharp_boundary {
-        println!("  Operation buffer or lock contention reaches limit at {} writers", fail_level);
+        println!(
+            "  Operation buffer or lock contention reaches limit at {} writers",
+            fail_level
+        );
     }
     println!("═══════════════════════════════════════════════════════════\n");
 

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

@@ -21,14 +21,13 @@
 ///   ✓ Improves p99 submission latency (or acceptable tradeoff)
 ///   ✓ Reduces rejection rate
 ///   ✓ Produces identical state (state_hash match)
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use feltdb::Operation;
 use serde_json::json;
-use std::sync::Arc;
 use std::collections::VecDeque;
-use std::time::{Instant, Duration};
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
 
 // ============================================================================
 // FROZEN WORKLOAD
@@ -396,7 +395,10 @@ fn gate_14a_sync1_queued_prototype(c: &mut Criterion) {
     println!("═══════════════════════════════════════════════════════════════════");
     println!("\nEXPERIMENT DESIGN:");
     println!("  Control:  Direct mutex acquisition (current)");
-    println!("  Candidate: Bounded queue ({}) + single worker", QUEUE_SIZE);
+    println!(
+        "  Candidate: Bounded queue ({}) + single worker",
+        QUEUE_SIZE
+    );
     println!("\nFROZEN WORKLOAD:");
     println!("  Operations per client: {}", OPERATIONS_PER_CLIENT);
     println!("  Concurrency: 1, 2, 4, 8, 16, 32, 64");
@@ -421,12 +423,10 @@ fn gate_14a_sync1_queued_prototype(c: &mut Criterion) {
 
     for &concurrency in CONCURRENCY_LEVELS {
         // Measure mutex (control)
-        let (mutex_metrics, mutex_hash) =
-            rt.block_on(measure_mutex_admission(concurrency));
+        let (mutex_metrics, mutex_hash) = rt.block_on(measure_mutex_admission(concurrency));
 
         // Measure queued (candidate)
-        let (queued_metrics, queued_hash) =
-            rt.block_on(measure_queued_admission(concurrency));
+        let (queued_metrics, queued_hash) = rt.block_on(measure_queued_admission(concurrency));
 
         // Verify state hash match
         let hash_match = mutex_hash == queued_hash;
@@ -438,7 +438,11 @@ fn gate_14a_sync1_queued_prototype(c: &mut Criterion) {
             mutex_metrics.p99_submission_latency_us,
             queued_metrics.throughput_ops_per_sec,
             queued_metrics.p99_submission_latency_us,
-            if hash_match { "✓ MATCH" } else { "✗ MISMATCH" }
+            if hash_match {
+                "✓ MATCH"
+            } else {
+                "✗ MISMATCH"
+            }
         );
 
         comparison_results.push((concurrency, mutex_metrics, queued_metrics, hash_match));
@@ -462,10 +466,7 @@ fn gate_14a_sync1_queued_prototype(c: &mut Criterion) {
                 * 100.0;
 
             println!("│ At 64 writers:");
-            println!(
-                "│   Mutex:  {:8.0} ops/sec",
-                mutex_m.throughput_ops_per_sec
-            );
+            println!("│   Mutex:  {:8.0} ops/sec", mutex_m.throughput_ops_per_sec);
             println!(
                 "│   Queued: {:8.0} ops/sec",
                 queued_m.throughput_ops_per_sec
@@ -478,8 +479,7 @@ fn gate_14a_sync1_queued_prototype(c: &mut Criterion) {
     println!("\n┌─ Latency Analysis ────────────────────────────────────────┐");
     for (concurrency, mutex_m, queued_m, _) in &comparison_results {
         if *concurrency == 64 {
-            let p99_improvement = ((mutex_m.p99_submission_latency_us
-                as f64
+            let p99_improvement = ((mutex_m.p99_submission_latency_us as f64
                 - queued_m.p99_submission_latency_us as f64)
                 / mutex_m.p99_submission_latency_us as f64)
                 * 100.0;
@@ -503,7 +503,10 @@ fn gate_14a_sync1_queued_prototype(c: &mut Criterion) {
             println!("│ At 64 writers:");
             println!("│   Mutex rejection:  {:.2}%", mutex_rejection);
             println!("│   Queued rejection: {:.2}%", queued_rejection);
-            println!("│   Improvement:      {:.2}pp", mutex_rejection - queued_rejection);
+            println!(
+                "│   Improvement:      {:.2}pp",
+                mutex_rejection - queued_rejection
+            );
         }
     }
     println!("└───────────────────────────────────────────────────────────┘");
@@ -534,24 +537,40 @@ fn gate_14a_sync1_queued_prototype(c: &mut Criterion) {
 
     // Check 1: Reduces contention (implied by throughput improvement at high concurrency)
     if throughput_improvement_64 > 5.0 {
-        println!("✓ Reduces contention: Throughput improved by {:.1}% at 64 writers", throughput_improvement_64);
+        println!(
+            "✓ Reduces contention: Throughput improved by {:.1}% at 64 writers",
+            throughput_improvement_64
+        );
         decision_points.push(true);
     } else if throughput_improvement_64 > -5.0 {
-        println!("~ Contention reduction unclear: {:.1}% change at 64 writers", throughput_improvement_64);
+        println!(
+            "~ Contention reduction unclear: {:.1}% change at 64 writers",
+            throughput_improvement_64
+        );
         decision_points.push(false);
     } else {
-        println!("✗ Increases contention: Throughput decreased by {:.1}% at 64 writers", throughput_improvement_64.abs());
+        println!(
+            "✗ Increases contention: Throughput decreased by {:.1}% at 64 writers",
+            throughput_improvement_64.abs()
+        );
         decision_points.push(false);
     }
 
     // Check 2: Sustainable throughput at high concurrency
-    if let Some((_, mutex_m, queued_m, _)) = comparison_results.iter().find(|(c, _, _, _)| *c == 64) {
+    if let Some((_, mutex_m, queued_m, _)) = comparison_results.iter().find(|(c, _, _, _)| *c == 64)
+    {
         let ratio = queued_m.throughput_ops_per_sec / mutex_m.throughput_ops_per_sec;
         if ratio > 1.0 {
-            println!("✓ Increases sustainable throughput: {:.2}x at 64 writers", ratio);
+            println!(
+                "✓ Increases sustainable throughput: {:.2}x at 64 writers",
+                ratio
+            );
             decision_points.push(true);
         } else {
-            println!("✗ Throughput reduced or unchanged: {:.2}x at 64 writers", ratio);
+            println!(
+                "✗ Throughput reduced or unchanged: {:.2}x at 64 writers",
+                ratio
+            );
             decision_points.push(false);
         }
     }

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

@@ -25,12 +25,11 @@
 /// Ratio = lock_wait_time / total_operation_time
 /// If ratio is high (lock dominates) → admission architecture is bottleneck
 /// If ratio is low (lock is cheap) → other subsystem is constrained
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use feltdb::Operation;
 use serde_json::json;
 use std::sync::Arc;
-use std::time::{Instant, Duration};
+use std::time::{Duration, Instant};
 
 // ============================================================================
 // FROZEN WORKLOAD DEFINITION
@@ -140,7 +139,7 @@ struct LockStatistics {
     p50_operation_latency_us: u64,
     p95_operation_latency_us: u64,
     p99_operation_latency_us: u64,
-    lock_wait_ratio: f64, // lock_wait_time / total_operation_time
+    lock_wait_ratio: f64,        // lock_wait_time / total_operation_time
     critical_section_ratio: f64, // lock_hold_time / total_operation_time
 }
 
@@ -375,26 +374,45 @@ fn gate_14a_sync_economics(c: &mut Criterion) {
         }
 
         // Average across trials
-        let avg_success: usize = trial_stats.iter().map(|s| s.successful_operations).sum::<usize>()
+        let avg_success: usize = trial_stats
+            .iter()
+            .map(|s| s.successful_operations)
+            .sum::<usize>()
+            / trial_stats.len();
+        let avg_rejected: usize = trial_stats
+            .iter()
+            .map(|s| s.rejected_operations)
+            .sum::<usize>()
             / trial_stats.len();
-        let avg_rejected: usize = trial_stats.iter().map(|s| s.rejected_operations).sum::<usize>()
+        let avg_attempts: usize = trial_stats
+            .iter()
+            .map(|s| s.total_acquisition_attempts)
+            .sum::<usize>()
             / trial_stats.len();
-        let avg_attempts: usize =
-            trial_stats.iter().map(|s| s.total_acquisition_attempts).sum::<usize>()
-                / trial_stats.len();
-        let avg_wait_ratio: f64 = trial_stats.iter().map(|s| s.lock_wait_ratio).sum::<f64>()
+        let avg_wait_ratio: f64 =
+            trial_stats.iter().map(|s| s.lock_wait_ratio).sum::<f64>() / trial_stats.len() as f64;
+        let avg_hold_ratio: f64 = trial_stats
+            .iter()
+            .map(|s| s.critical_section_ratio)
+            .sum::<f64>()
             / trial_stats.len() as f64;
-        let avg_hold_ratio: f64 = trial_stats.iter().map(|s| s.critical_section_ratio).sum::<f64>()
+        let avg_ops_per_acq: f64 = trial_stats
+            .iter()
+            .map(|s| s.ops_per_acquisition)
+            .sum::<f64>()
             / trial_stats.len() as f64;
-        let avg_ops_per_acq: f64 = trial_stats.iter().map(|s| s.ops_per_acquisition).sum::<f64>()
+        let avg_throughput: f64 = trial_stats
+            .iter()
+            .map(|s| s.throughput_ops_per_sec)
+            .sum::<f64>()
             / trial_stats.len() as f64;
-        let avg_throughput: f64 =
-            trial_stats.iter().map(|s| s.throughput_ops_per_sec).sum::<f64>()
-                / trial_stats.len() as f64;
 
         println!(
             "{:8} │ {:8} │ {:8} │ {:8} │ {:5.1}% │ {:5.1}% │ {:6.2} │ {:8.0}",
-            concurrency, avg_success, avg_rejected, avg_attempts,
+            concurrency,
+            avg_success,
+            avg_rejected,
+            avg_attempts,
             avg_wait_ratio * 100.0,
             avg_hold_ratio * 100.0,
             avg_ops_per_acq,