@feltdb/core 0.8.4 → 0.8.6

package/dist/create/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.8.4';
+export const FELTDB_PACKAGE_VERSION = '0.8.6';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;

package/dist/create/server-source/Cargo.lock

@@ -470,6 +470,12 @@ version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
 
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
 [[package]]
 name = "errno"
 version = "0.3.14"
@@ -501,6 +507,7 @@ dependencies = [
  "sha2",
  "tempfile",
  "tokio",
+ "wasmi",
 ]
 
 [[package]]
@@ -557,6 +564,12 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26b73573e6edcd2af0cdf47bd6cb58f0b3839491263c314eaad1ccf24430e1de"
 
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
 [[package]]
 name = "form_urlencoded"
 version = "1.2.2"
@@ -663,6 +676,21 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
@@ -886,6 +914,16 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "indexmap"
+version = "2.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+]
+
 [[package]]
 name = "ipnet"
 version = "2.12.1"
@@ -935,12 +973,24 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
 [[package]]
 name = "libc"
 version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -1585,6 +1635,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "spin"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e"
+
 [[package]]
 name = "spki"
 version = "0.7.3"
@@ -1601,6 +1657,16 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
+[[package]]
+name = "string-interner"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23de088478b31c349c9ba67816fa55d9355232d63c3afea8bf513e31f0f1d2c0"
+dependencies = [
+ "hashbrown 0.15.5",
+ "serde",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -1891,6 +1957,12 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"
@@ -2018,6 +2090,99 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-encoder"
+version = "0.258.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e974fe6821a8cf64575d51ea2194e2c8f77e7b66e9afe7419ce8a97f9ee0d251"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.258.0",
+]
+
+[[package]]
+name = "wasmi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78693fcdd618e0fc34af59c6b8efa9ac5d58c68df940beff4bedddb6acfe7c27"
+dependencies = [
+ "spin",
+ "wasmi_collections",
+ "wasmi_core",
+ "wasmi_ir",
+ "wasmparser 0.228.0",
+ "wat",
+]
+
+[[package]]
+name = "wasmi_collections"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a8be2aa467cf2d29e96ff759472c36eeb44a3c81c67fc9cb76c9a24c519c557"
+dependencies = [
+ "string-interner",
+]
+
+[[package]]
+name = "wasmi_core"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69372d5fda3ea3d1e0aa6603c7888110e0187e88ea17cd8fc2e2df0a0e1f37fa"
+dependencies = [
+ "libm",
+]
+
+[[package]]
+name = "wasmi_ir"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f17b774caa13c618c7244f1ee51fe23c5e7b8538a471fa46d9949779758aed6"
+dependencies = [
+ "wasmi_core",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.228.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4abf1132c1fdf747d56bbc1bb52152400c70f336870f968b85e89ea422198ae3"
+dependencies = [
+ "bitflags",
+ "indexmap",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.258.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9a61719f93a87b16d325921e251800c4833f8fab50fa21c7de73aed50086313"
+dependencies = [
+ "bitflags",
+ "indexmap",
+]
+
+[[package]]
+name = "wast"
+version = "258.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97f7defc7ecca8b19ac7f824598eadd0c53985ee00c74060d65051e9da5b58a1"
+dependencies = [
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder",
+]
+
+[[package]]
+name = "wat"
+version = "1.258.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7555c008cca87f2ac58d9f83ccda7e7b44611093ce28eb28f052e7c78024b9bf"
+dependencies = [
+ "wast",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.104"

package/dist/create/server-source/Cargo.toml

@@ -1,5 +1,14 @@
 [workspace]
 members = ["crates/feltdb", "crates/feltdb-server", "crates/feltdb-wasm"]
+# The deterministic contracts' WASM implementations are their own
+# dependency-free workspaces: they are only ever built for
+# wasm32-unknown-unknown, and a second implementation that inherited this
+# workspace's dependencies would stop being an independent one.
+exclude = [
+    "crates/feltdb-trigger-contract-wasm",
+    "crates/feltdb-state-diff-contract-wasm",
+    "crates/feltdb-state-conflict-contract-wasm",
+]
 resolver = "2"
 
 [workspace.package]

package/dist/create/server-source/crates/feltdb/Cargo.toml

@@ -21,6 +21,9 @@ tokio = { version = "1", features = ["net", "io-util", "rt-multi-thread"] }
 criterion = { version = "0.5", features = ["html_reports"] }
 sha2 = "0.10"
 tempfile = "3"
+# Host runtime for the deterministic-contract conformance suite only. It is a
+# test dependency: FeltDB does not execute WASM in production.
+wasmi = "2"
 
 [[bench]]
 name = "gate13_baseline"

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

@@ -11,11 +11,9 @@
 /// 4. Separate primitives from transaction benchmarks
 /// 5. 2D matrix: causal barrier vs buffer size × node count
 /// 6. Black box protection on all critical results
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
 use feltdb::{
-    CausalDependencyBarrier, ConsistencyContractEnforcer, CrashAtomicExecutor,
-    VectorClock,
+    CausalDependencyBarrier, ConsistencyContractEnforcer, CrashAtomicExecutor, VectorClock,
 };
 
 /// Helper: Create a vector clock with N nodes
@@ -179,10 +177,8 @@ fn benchmark_causal_barrier_buffer_scaling(c: &mut Criterion) {
                             let _ = barrier.receive_operation(format!("op_{}", i), vc);
                         }
 
-                        let result = barrier.receive_operation(
-                            format!("op_test"),
-                            black_box(required.clone()),
-                        );
+                        let result = barrier
+                            .receive_operation(format!("op_test"), black_box(required.clone()));
                         black_box(result)
                     });
                 },
@@ -282,8 +278,7 @@ fn benchmark_cost_of_correctness(c: &mut Criterion) {
         let mut barrier = CausalDependencyBarrier::new();
         let required = VectorClock::new();
         b.iter(|| {
-            let result =
-                barrier.receive_operation("op".to_string(), black_box(required.clone()));
+            let result = barrier.receive_operation("op".to_string(), black_box(required.clone()));
             black_box(result)
         });
     });
@@ -360,7 +355,10 @@ fn benchmark_readiness_frontier_satisfied(c: &mut Criterion) {
         for node_count in [2, 4, 8].iter() {
             group.throughput(Throughput::Elements(1));
             group.bench_function(
-                format!("frontier_satisfied_nodes{}_buffer{}", node_count, buffer_size),
+                format!(
+                    "frontier_satisfied_nodes{}_buffer{}",
+                    node_count, buffer_size
+                ),
                 |b| {
                     let required = make_vector_clock(*node_count);
                     validate_vector_clock(&required, *node_count);
@@ -375,14 +373,13 @@ fn benchmark_readiness_frontier_satisfied(c: &mut Criterion) {
                         for i in 0..*buffer_size {
                             let mut unrelated = VectorClock::new();
                             unrelated.increment(&format!("other_node_{}", i));
-                            let _ = barrier.receive_operation(format!("op_buffer_{}", i), unrelated);
+                            let _ =
+                                barrier.receive_operation(format!("op_buffer_{}", i), unrelated);
                         }
 
                         // Now test readiness check on satisfied requirement
-                        let result = barrier.receive_operation(
-                            "op_test".to_string(),
-                            black_box(required.clone()),
-                        );
+                        let result = barrier
+                            .receive_operation("op_test".to_string(), black_box(required.clone()));
                         black_box(result)
                     });
                 },
@@ -403,7 +400,10 @@ fn benchmark_readiness_frontier_satisfied_corrected(c: &mut Criterion) {
         for node_count in [2, 4, 8].iter() {
             group.throughput(Throughput::Elements(1));
             group.bench_function(
-                format!("frontier_satisfied_corrected_nodes{}_buffer{}", node_count, buffer_size),
+                format!(
+                    "frontier_satisfied_corrected_nodes{}_buffer{}",
+                    node_count, buffer_size
+                ),
                 |b| {
                     let required = make_vector_clock(*node_count);
                     validate_vector_clock(&required, *node_count);
@@ -418,7 +418,8 @@ fn benchmark_readiness_frontier_satisfied_corrected(c: &mut Criterion) {
                             for i in 0..*buffer_size {
                                 let mut unrelated = VectorClock::new();
                                 unrelated.increment(&format!("other_node_{}", i));
-                                let _ = barrier.receive_operation(format!("op_buffer_{}", i), unrelated);
+                                let _ = barrier
+                                    .receive_operation(format!("op_buffer_{}", i), unrelated);
                             }
 
                             barrier
@@ -473,10 +474,8 @@ fn benchmark_readiness_frontier_missing(c: &mut Criterion) {
                         }
 
                         // Test readiness check on unsatisfied requirement
-                        let result = barrier.receive_operation(
-                            "op_test".to_string(),
-                            black_box(required.clone()),
-                        );
+                        let result = barrier
+                            .receive_operation("op_test".to_string(), black_box(required.clone()));
                         black_box(result)
                     });
                 },
@@ -495,29 +494,32 @@ fn benchmark_frontier_advancement_release(c: &mut Criterion) {
 
     for pending_count in [10, 100].iter() {
         group.throughput(Throughput::Elements(*pending_count as u64));
-        group.bench_function(format!("frontier_advancement_release_{}_pending", pending_count), |b| {
-            let mut required = VectorClock::new();
-            required.increment("node_a");
-            required.increment("node_a");  // {node_a: 2}
-            validate_vector_clock(&required, 1);
+        group.bench_function(
+            format!("frontier_advancement_release_{}_pending", pending_count),
+            |b| {
+                let mut required = VectorClock::new();
+                required.increment("node_a");
+                required.increment("node_a"); // {node_a: 2}
+                validate_vector_clock(&required, 1);
 
-            b.iter(|| {
-                let mut barrier = CausalDependencyBarrier::new();
+                b.iter(|| {
+                    let mut barrier = CausalDependencyBarrier::new();
 
-                // Pre-buffer N operations waiting for {node_a: 2}
-                for i in 0..*pending_count {
-                    let _ = barrier.receive_operation(format!("op_{}", i), required.clone());
-                }
+                    // Pre-buffer N operations waiting for {node_a: 2}
+                    for i in 0..*pending_count {
+                        let _ = barrier.receive_operation(format!("op_{}", i), required.clone());
+                    }
 
-                // Advance frontier to {node_a: 2}, which releases all pending
-                let mut satisfying = VectorClock::new();
-                satisfying.increment("node_a");
-                satisfying.increment("node_a");
+                    // Advance frontier to {node_a: 2}, which releases all pending
+                    let mut satisfying = VectorClock::new();
+                    satisfying.increment("node_a");
+                    satisfying.increment("node_a");
 
-                barrier.advance_frontier(black_box(&satisfying));
-                black_box(barrier.get_pending_operations())
-            });
-        });
+                    barrier.advance_frontier(black_box(&satisfying));
+                    black_box(barrier.get_pending_operations())
+                });
+            },
+        );
     }
 
     group.finish();
@@ -556,10 +558,8 @@ fn benchmark_causal_pathological_workload(c: &mut Criterion) {
 
             // Now test: incoming operation with already-satisfied requirement
             // This should be fast if frontier check is sufficient
-            let result = barrier.receive_operation(
-                "test_op".to_string(),
-                black_box(required.clone()),
-            );
+            let result =
+                barrier.receive_operation("test_op".to_string(), black_box(required.clone()));
             black_box(result)
         });
     });

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

@@ -9,7 +9,6 @@
 /// - Outcome C: Repeated advances cause O(m²) pathological rescanning
 ///
 /// Only Outcome C justifies architectural changes to release mechanism.
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
 use feltdb::{CausalDependencyBarrier, VectorClock};
 
@@ -44,11 +43,10 @@ fn benchmark_release_single_scan(c: &mut Criterion) {
                         for i in 0..*pending_size {
                             let mut required = VectorClock::new();
                             // Each requires increasing timestamp: A:1000, A:1001, etc.
-                            required.clocks.insert("node_a".to_string(), (1000 + i) as u64);
-                            let _ = barrier.receive_operation(
-                                format!("pending_{}", i),
-                                required,
-                            );
+                            required
+                                .clocks
+                                .insert("node_a".to_string(), (1000 + i) as u64);
+                            let _ = barrier.receive_operation(format!("pending_{}", i), required);
                         }
                         barrier
                     },
@@ -97,10 +95,7 @@ fn benchmark_release_selectivity(c: &mut Criterion) {
                             let mut required = VectorClock::new();
                             // Frontier will be at A:2000, these require A:100
                             required.clocks.insert("node_a".to_string(), 100);
-                            let _ = barrier.receive_operation(
-                                format!("ready_{}", i),
-                                required,
-                            );
+                            let _ = barrier.receive_operation(format!("ready_{}", i), required);
                         }
 
                         // Add blocked operations (frontier won't satisfy them yet)
@@ -108,10 +103,7 @@ fn benchmark_release_selectivity(c: &mut Criterion) {
                             let mut required = VectorClock::new();
                             // These require A:5000, frontier will only be at A:2000
                             required.clocks.insert("node_a".to_string(), 5000);
-                            let _ = barrier.receive_operation(
-                                format!("blocked_{}", i),
-                                required,
-                            );
+                            let _ = barrier.receive_operation(format!("blocked_{}", i), required);
                         }
                         barrier
                     },
@@ -146,7 +138,7 @@ fn benchmark_release_selectivity(c: &mut Criterion) {
 /// - Bad: entries_examined ≈ 50,000,000 (each advance scans remaining operations)
 fn benchmark_release_pathological_repeated(c: &mut Criterion) {
     let mut group = c.benchmark_group("gate13_release_pathological_repeated");
-    group.sample_size(5);  // Fewer samples for large workload
+    group.sample_size(5); // Fewer samples for large workload
     group.measurement_time(std::time::Duration::from_secs(30));
 
     // Note: Using 1000 instead of 10000 to keep benchmark runtime reasonable
@@ -166,10 +158,7 @@ fn benchmark_release_pathological_repeated(c: &mut Criterion) {
                         let mut required = VectorClock::new();
                         // Each requires A:(i+1)
                         required.clocks.insert("node_a".to_string(), (i + 1) as u64);
-                        let _ = barrier.receive_operation(
-                            format!("seq_{}", i),
-                            required,
-                        );
+                        let _ = barrier.receive_operation(format!("seq_{}", i), required);
                     }
                     barrier
                 },
@@ -221,12 +210,11 @@ fn benchmark_release_mixed_advances(c: &mut Criterion) {
 
                             // Distribute dependencies: some low, some high
                             let dependency_level = ((i * 997) % 1000) as u64 + 1;
-                            required.clocks.insert("node_a".to_string(), dependency_level);
+                            required
+                                .clocks
+                                .insert("node_a".to_string(), dependency_level);
 
-                            let _ = barrier.receive_operation(
-                                format!("mixed_{}", i),
-                                required,
-                            );
+                            let _ = barrier.receive_operation(format!("mixed_{}", i), required);
                         }
                         barrier
                     },

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

@@ -24,8 +24,7 @@
 ///
 /// This is a FROZEN baseline. No further causal barrier optimization until Gate 14
 /// demonstrates that the causal release path has become a system bottleneck.
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput, BenchmarkId};
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use feltdb::{CausalDependencyBarrier, VectorClock};
 use std::time::Instant;
 
@@ -51,10 +50,9 @@ fn populate_pending_operations(
     for i in 0..count {
         let mut required = create_vector_clock_with_nodes(node_count);
         // Make each operation depend on a node that hasn't been reached yet
-        required.clocks.insert(
-            format!("node_{}", node_count % 2),
-            (node_count * 10) as u64,
-        );
+        required
+            .clocks
+            .insert(format!("node_{}", node_count % 2), (node_count * 10) as u64);
         let _ = barrier.receive_operation(format!("op_{}", i), required);
     }
 }
@@ -246,10 +244,8 @@ fn benchmark_index_maintenance_cost(c: &mut Criterion) {
                 let required = create_vector_clock_with_nodes(nodes);
                 b.iter(|| {
                     let mut barrier = CausalDependencyBarrier::new();
-                    let _ = barrier.receive_operation(
-                        "op_test".to_string(),
-                        black_box(required.clone()),
-                    );
+                    let _ = barrier
+                        .receive_operation("op_test".to_string(), black_box(required.clone()));
                     black_box(barrier.get_dependency_index().entry_count())
                 });
             },
@@ -291,9 +287,7 @@ fn benchmark_vector_clock_cost(c: &mut Criterion) {
             |b, &nodes| {
                 let clock1 = create_vector_clock_with_nodes(nodes);
                 let clock2 = create_vector_clock_with_nodes(nodes);
-                b.iter(|| {
-                    black_box(black_box(&clock1).happens_before(black_box(&clock2)))
-                });
+                b.iter(|| black_box(black_box(&clock1).happens_before(black_box(&clock2))));
             },
         );
     }

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

@@ -14,7 +14,6 @@
 ///   throughput_1000_ops       1.583       1.590      +0.4%     ×1.15       PASS
 ///   ...
 ///   RESULT: PASS (all metrics within acceptable regression)
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
@@ -52,8 +51,8 @@ impl RegressionResult {
         baseline_metric: &BaselineMetric,
         current_value: f64,
     ) -> Self {
-        let change_pct = ((current_value - baseline_metric.baseline) / baseline_metric.baseline)
-            * 100.0;
+        let change_pct =
+            ((current_value - baseline_metric.baseline) / baseline_metric.baseline) * 100.0;
 
         let (passes_threshold, status) = if baseline_metric.direction == "higher_is_better" {
             // For throughput/performance: lower is regression
@@ -112,7 +111,8 @@ pub fn check_regression(
 
     for (metric_name, baseline_metric) in &baseline.metrics {
         if let Some(&current_value) = measurements.get(metric_name) {
-            let result = RegressionResult::from_measurement(metric_name, baseline_metric, current_value);
+            let result =
+                RegressionResult::from_measurement(metric_name, baseline_metric, current_value);
             results.push(result);
         }
     }
@@ -130,10 +130,7 @@ pub fn check_regression(
 }
 
 /// Format regression report
-pub fn format_report(
-    baseline: &RegressionBaseline,
-    results: &[RegressionResult],
-) -> String {
+pub fn format_report(baseline: &RegressionBaseline, results: &[RegressionResult]) -> String {
     let mut report = format!("Gate 13 Redux Regression Report\n");
     report.push_str("───────────────────────────────\n");
     report.push_str(&format!("Baseline: {}\n", baseline.git_commit));
@@ -165,9 +162,15 @@ pub fn format_report(
 
     report.push('\n');
     if failed == 0 {
-        report.push_str(&format!("RESULT: PASS ({}/{} metrics within acceptable regression)\n", passed, total));
+        report.push_str(&format!(
+            "RESULT: PASS ({}/{} metrics within acceptable regression)\n",
+            passed, total
+        ));
     } else {
-        report.push_str(&format!("RESULT: FAIL ({}/{} metrics exceeded regression threshold)\n", failed, total));
+        report.push_str(&format!(
+            "RESULT: FAIL ({}/{} metrics exceeded regression threshold)\n",
+            failed, total
+        ));
     }
 
     report

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

@@ -24,13 +24,12 @@
 ///
 /// CONCURRENCY LEVELS: 1, 2, 4, 8, 16, 32, 64
 /// TRIALS PER LEVEL: 5 (to detect consistent failures)
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use feltdb::Operation;
 use serde_json::json;
-use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::time::{Instant, Duration};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
 
 // ============================================================================
 // FROZEN WORKLOAD DEFINITION
@@ -226,11 +225,11 @@ fn analyze_outcomes(
     ingested_count: usize,
     wall_clock_ms: f64,
 ) -> (
-    f64,     // throughput ops/sec (successful only)
-    f64,     // p95 latency
-    f64,     // retry rate %
-    f64,     // error rate %
-    bool,    // correctness pass
+    f64,  // throughput ops/sec (successful only)
+    f64,  // p95 latency
+    f64,  // retry rate %
+    f64,  // error rate %
+    bool, // correctness pass
 ) {
     let successful = outcomes
         .iter()
@@ -295,7 +294,11 @@ fn gate_14a_concurrent_writer_scaling(c: &mut Criterion) {
     println!("\nFROZEN WORKLOAD:");
     println!("  Operations per client: {}", OPERATIONS_PER_CLIENT);
     println!("  Record count: {}", RECORD_COUNT);
-    println!("  Read/write ratio: {:.0}% reads, {:.0}% writes", READ_WRITE_RATIO * 100.0, (1.0 - READ_WRITE_RATIO) * 100.0);
+    println!(
+        "  Read/write ratio: {:.0}% reads, {:.0}% writes",
+        READ_WRITE_RATIO * 100.0,
+        (1.0 - READ_WRITE_RATIO) * 100.0
+    );
     println!("  Random seed: {}", RANDOM_SEED);
     println!("  Trials per concurrency level: {}", TRIALS_PER_LEVEL);
     println!("\nDIAGNOSTIC FOCUS:");