@feltdb/core 0.7.3 → 0.8.0

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

@@ -51,9 +51,11 @@ use feltdb::distributed_transactions::{
     CausalCapacity, DistributedTransactionExecutor, ReceiveOutcome, ReplicationMessage,
     SubmitOutcome,
 };
-use feltdb::replication_protocol::ProtocolTransport;
-use feltdb::replica_acknowledgements::{AcknowledgementStore, ReclamationEvidence, ReplicaAcknowledgement};
+use feltdb::replica_acknowledgements::{
+    AcknowledgementStore, ReclamationEvidence, ReplicaAcknowledgement,
+};
 use feltdb::replica_membership::MembershipStore;
+use feltdb::replication_protocol::ProtocolTransport;
 use feltdb::state_hash::StateHash;
 use feltdb::tcp_transport::TcpTransport;
 use feltdb::transactions::{
@@ -127,7 +129,11 @@ fn deliver(
         Ok(ReceiveOutcome::AlreadyKnown) => {
             json!({ "envelope": key, "outcome": "already_known" })
         }
-        Ok(ReceiveOutcome::CapacityDeferred { missing, pending_entries, pending_bytes }) => {
+        Ok(ReceiveOutcome::CapacityDeferred {
+            missing,
+            pending_entries,
+            pending_bytes,
+        }) => {
             // Durable, but not buffered. The caller's obligation is to stop
             // reading from this peer; the envelope is admitted from the log
             // once the backlog drains.
@@ -178,16 +184,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut max_pending_entries: Option<usize> = None;
     let mut max_pending_bytes: Option<usize> = None;
     let mut authority_priority: u32 = 0;
+    let mut heartbeat_interval_ms: u64 = 1_000;
+    let mut heartbeat_failure_threshold: u32 = 5;
 
     let mut index = 1;
     while index < args.len() {
         match args[index].as_str() {
             "--node-id" => {
                 index += 1;
-                node_id = args
-                    .get(index)
-                    .ok_or("--node-id requires a value")?
-                    .clone();
+                node_id = args.get(index).ok_or("--node-id requires a value")?.clone();
             }
             "--data" => {
                 index += 1;
@@ -197,11 +202,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             }
             "--send" => {
                 index += 1;
-                send_specs.push(parse_link(args.get(index).ok_or("--send requires PEER=ADDR")?)?);
+                send_specs.push(parse_link(
+                    args.get(index).ok_or("--send requires PEER=ADDR")?,
+                )?);
             }
             "--recv" => {
                 index += 1;
-                recv_specs.push(parse_link(args.get(index).ok_or("--recv requires PEER=ADDR")?)?);
+                recv_specs.push(parse_link(
+                    args.get(index).ok_or("--recv requires PEER=ADDR")?,
+                )?);
             }
             // The bound is settable so an acceptance test can reach it through
             // the production path. Filling the shipping default would mean
@@ -237,6 +246,22 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     .parse::<u32>()
                     .map_err(|e| format!("--authority-priority: {e}"))?;
             }
+            "--heartbeat-interval-ms" => {
+                index += 1;
+                heartbeat_interval_ms = args
+                    .get(index)
+                    .ok_or("--heartbeat-interval-ms requires a value")?
+                    .parse::<u64>()
+                    .map_err(|e| format!("--heartbeat-interval-ms: {e}"))?;
+            }
+            "--heartbeat-failure-threshold" => {
+                index += 1;
+                heartbeat_failure_threshold = args
+                    .get(index)
+                    .ok_or("--heartbeat-failure-threshold requires a value")?
+                    .parse::<u32>()
+                    .map_err(|e| format!("--heartbeat-failure-threshold: {e}"))?;
+            }
             other => return Err(format!("unknown argument {other}").into()),
         }
         index += 1;
@@ -282,7 +307,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // recover its previous role. The cluster ID is set by the first `authority-claim`
     // command, so it starts as the node's own ID.
     let authority = Arc::new(Mutex::new(
-        AuthorityStore::open(
+        AuthorityStore::open_with_failure_detector(
             data_dir
                 .as_ref()
                 .map(|dir| dir.join("authority.json"))
@@ -290,13 +315,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             &node_id, // cluster_id defaults to node_id until set
             &node_id,
             authority_priority,
+            heartbeat_interval_ms,
+            heartbeat_failure_threshold,
         )
         .map_err(|e| e.to_string())?,
     ));
 
     let initial_state = StateHash::from_hex("0".repeat(64));
-    let mut executor =
-        DistributedTransactionExecutor::with_log(node_id.clone(), initial_state.clone(), log_path.clone())?;
+    let mut executor = DistributedTransactionExecutor::with_log(
+        node_id.clone(),
+        initial_state.clone(),
+        log_path.clone(),
+    )?;
 
     // The bound is set before recovery, not after, because recovery restores
     // the backlog and has to respect the same limit the live path does.
@@ -338,7 +368,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // missed an operation observably divergent. It lives beside the executor
     // under one lock so a local commit and an arriving replication cannot
     // interleave and chain onto a parent that is already stale.
-    let core = Arc::new(Mutex::new((executor, StateVersion::new(VectorClock::new(), "0".repeat(64)))));
+    let recovered_version = executor
+        .get_replica_state(&node_id)
+        .map(|replica| StateVersion::new(replica.vector_clock, replica.state_hash.to_string()))
+        .unwrap_or_else(|| StateVersion::new(VectorClock::new(), "0".repeat(64)));
+    let core = Arc::new(Mutex::new((executor, recovered_version)));
     let should_exit = Arc::new(AtomicBool::new(false));
     // Per-peer delivery hold.
     //
@@ -367,7 +401,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .into_iter()
         .map(|(peer, addr)| {
             let transport = TcpTransport::new("127.0.0.1:0".to_string());
-            SendLink { peer, addr, control: Arc::new(Mutex::new(transport.clone())), io: transport }
+            SendLink {
+                peer,
+                addr,
+                control: Arc::new(Mutex::new(transport.clone())),
+                io: transport,
+            }
         })
         .collect();
 
@@ -375,7 +414,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .into_iter()
         .map(|(peer, addr)| {
             let transport = TcpTransport::new(addr.clone());
-            RecvLink { peer, addr, control: Arc::new(Mutex::new(transport.clone())), io: transport }
+            RecvLink {
+                peer,
+                addr,
+                control: Arc::new(Mutex::new(transport.clone())),
+                io: transport,
+            }
         })
         .collect();
 
@@ -509,8 +553,35 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         };
 
         match verb {
-            "execute-tx" => {
-                let record = if argument.is_empty() { "item".to_string() } else { argument };
+            "execute-tx" | "authority-write" => {
+                let record = if verb == "authority-write" {
+                    let mut parts = argument.splitn(2, ' ');
+                    let token = parts.next().and_then(|value| value.parse::<u64>().ok());
+                    let record = parts.next().unwrap_or("item").to_string();
+                    let validation = match token {
+                        Some(token) => authority
+                            .lock()
+                            .await
+                            .validate_quorum_write(FencingToken(token), 2),
+                        None => Err(feltdb::authority_failover::AuthorityError::StaleToken {
+                            provided: FencingToken(0),
+                            current: authority.lock().await.state().current_token(),
+                        }),
+                    };
+                    if let Err(error) = validation {
+                        println!(
+                            "AUTHORITY_WRITE_REJECTED {}",
+                            json!({ "record": record, "reason": error.to_string() })
+                        );
+                        io::stdout().flush().ok();
+                        continue;
+                    }
+                    record
+                } else if argument.is_empty() {
+                    "item".to_string()
+                } else {
+                    argument
+                };
 
                 let mut fields = HashMap::new();
                 fields.insert("record".to_string(), json!(record.clone()));
@@ -854,7 +925,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 let (frontier, marks) = {
                     let guard = core.lock().await;
                     let (executor, _) = &*guard;
-                    (executor.causal_frontier().clone(), executor.origin_sequence_high_water())
+                    (
+                        executor.causal_frontier().clone(),
+                        executor.origin_sequence_high_water(),
+                    )
                 };
                 let view: Vec<String> = membership
                     .get_members()
@@ -1083,27 +1157,30 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "list-operations" => {
                 let guard = core.lock().await;
                 let (executor, _) = &*guard;
-                
+
                 // Get all operations from the log
                 let mut all_ops = Vec::new();
                 let mut applied_ops = Vec::new();
                 let pending_ops = executor.pending_causal_keys();
                 let deferred_ops = executor.deferred_causal_keys();
-                
+
                 if let Some(ref log) = executor.operation_log {
                     if let Ok(envelopes) = log.load_all() {
                         for env in &envelopes {
-                            let key = format!("{}:{}", env.envelope_id.originating_node, env.envelope_id.sequence);
+                            let key = format!(
+                                "{}:{}",
+                                env.envelope_id.originating_node, env.envelope_id.sequence
+                            );
                             all_ops.push(key.clone());
                         }
                     }
                 }
-                
+
                 // Get applied operations from the barrier
                 for key in executor.causal_barrier.applied_keys() {
                     applied_ops.push(key.to_string());
                 }
-                
+
                 println!(
                     "OPERATIONS {}",
                     json!({
@@ -1120,23 +1197,26 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "operation-inventory" => {
                 let guard = core.lock().await;
                 let (executor, _) = &*guard;
-                
+
                 // Get all operations from the log
                 let mut operations = json!({
                     "applied": [],
                     "pending": [],
                     "deferred": [],
                 });
-                
+
                 if let Some(ref log) = executor.operation_log {
                     if let Ok(envelopes) = log.load_all() {
                         let applied_keys = executor.causal_barrier.applied_keys();
                         let pending_keys = executor.pending_causal_keys();
                         let deferred_keys = executor.deferred_causal_keys();
-                        
+
                         for env in &envelopes {
-                            let key = format!("{}:{}", env.envelope_id.originating_node, env.envelope_id.sequence);
-                            
+                            let key = format!(
+                                "{}:{}",
+                                env.envelope_id.originating_node, env.envelope_id.sequence
+                            );
+
                             if applied_keys.contains(&key) {
                                 operations["applied"].as_array_mut().unwrap().push(json!({
                                     "id": key,
@@ -1159,7 +1239,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                         }
                     }
                 }
-                
+
                 println!("INVENTORY {}", operations);
                 io::stdout().flush().ok();
             }
@@ -1198,7 +1278,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                             })
                         );
                     }
-                    Ok(ClaimResult::Rejected { current_authority, current_token }) => {
+                    Ok(ClaimResult::Rejected {
+                        current_authority,
+                        current_token,
+                    }) => {
                         println!(
                             "AUTHORITY_REJECTED {}",
                             json!({
@@ -1230,11 +1313,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "authority-accept" => {
                 let mut parts = argument.split_whitespace();
                 let authority_node = parts.next().unwrap_or_default().to_string();
-                let token_value: u64 = parts
-                    .next()
-                    .unwrap_or("0")
-                    .parse()
-                    .unwrap_or(0);
+                let token_value: u64 = parts.next().unwrap_or("0").parse().unwrap_or(0);
                 let token = FencingToken(token_value);
 
                 let mut guard = authority.lock().await;
@@ -1265,7 +1344,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 let operations_applied = {
                     let core_guard = core.lock().await;
                     let (executor, _) = &*core_guard;
-                    executor.get_replica_state(&node_id).map(|r| r.operations_applied).unwrap_or(0)
+                    executor
+                        .get_replica_state(&node_id)
+                        .map(|r| r.operations_applied)
+                        .unwrap_or(0)
                 };
                 println!(
                     "AUTHORITY {}",
@@ -1291,7 +1373,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 let from_node = parts.next().unwrap_or_default().to_string();
 
                 if from_node.is_empty() {
-                    println!("ERROR {}", json!({ "reason": "heartbeat requires NODE_ID" }));
+                    println!(
+                        "ERROR {}",
+                        json!({ "reason": "heartbeat requires NODE_ID" })
+                    );
                 } else {
                     let mut guard = authority.lock().await;
                     guard.heartbeat(&from_node);
@@ -1377,7 +1462,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             }
 
             _ => {
-                println!("ERROR {}", json!({ "reason": format!("unknown command {verb}") }));
+                println!(
+                    "ERROR {}",
+                    json!({ "reason": format!("unknown command {verb}") })
+                );
                 io::stdout().flush().ok();
             }
         }

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

@@ -7,7 +7,6 @@
 /// - DistributedExecutor: Orchestrates consistency semantics
 ///
 /// Invariant: All replicas converge to identical state_hash for same operations
-
 use crate::causal_dependency_barrier::CausalDependencyBarrier;
 use crate::convergence::VectorClock;
 use crate::durable_operation_log::OperationLog;
@@ -136,11 +135,7 @@ impl ReplicaState {
     }
 
     /// Update replica state after transaction
-    pub fn apply_transaction(
-        &mut self,
-        envelope: &TransactionEnvelope,
-        new_state_hash: StateHash,
-    ) {
+    pub fn apply_transaction(&mut self, envelope: &TransactionEnvelope, new_state_hash: StateHash) {
         self.vector_clock.merge(&envelope.vector_clock);
         self.vector_clock.increment(&self.node_id);
         self.state_hash = new_state_hash;
@@ -276,7 +271,10 @@ impl CausalCapacity {
 
     /// A bound small enough to be reached by a test through the real path.
     pub fn new(max_pending_entries: usize, max_pending_bytes: usize) -> Self {
-        Self { max_pending_entries, max_pending_bytes }
+        Self {
+            max_pending_entries,
+            max_pending_bytes,
+        }
     }
 }
 
@@ -393,8 +391,12 @@ impl DistributedTransactionExecutor {
     /// source `next_origin_sequence` is recovered from.
     pub fn origin_sequence_high_water(&self) -> std::collections::BTreeMap<String, u64> {
         let mut marks = std::collections::BTreeMap::new();
-        let Some(ref log) = self.operation_log else { return marks };
-        let Ok(envelopes) = log.load_all() else { return marks };
+        let Some(ref log) = self.operation_log else {
+            return marks;
+        };
+        let Ok(envelopes) = log.load_all() else {
+            return marks;
+        };
         for envelope in envelopes {
             let entry = marks
                 .entry(envelope.envelope_id.originating_node.clone())
@@ -516,7 +518,9 @@ impl DistributedTransactionExecutor {
 
     /// The size local work would contribute, measured before it is executed.
     fn operations_bytes(operations: &[Operation]) -> usize {
-        serde_json::to_string(operations).map(|json| json.len()).unwrap_or(0)
+        serde_json::to_string(operations)
+            .map(|json| json.len())
+            .unwrap_or(0)
     }
 
     /// Execute local work unconditionally.
@@ -582,8 +586,10 @@ impl DistributedTransactionExecutor {
         // Step 6: A locally executed operation is applied, so it advances the
         // frontier exactly as a replicated one does. Own writes are always
         // causally eligible: they are built on the frontier they advance.
-        self.causal_barrier
-            .record_applied(&Self::barrier_key(&envelope.envelope_id), &envelope.vector_clock);
+        self.causal_barrier.record_applied(
+            &Self::barrier_key(&envelope.envelope_id),
+            &envelope.vector_clock,
+        );
 
         Ok(envelope)
     }
@@ -712,7 +718,9 @@ impl DistributedTransactionExecutor {
     /// per-operation constant, so a large envelope consumes its actual byte
     /// count.
     fn envelope_bytes(envelope: &TransactionEnvelope) -> usize {
-        serde_json::to_string(envelope).map(|json| json.len()).unwrap_or(0)
+        serde_json::to_string(envelope)
+            .map(|json| json.len())
+            .unwrap_or(0)
     }
 
     /// Apply one envelope and advance the applied frontier.
@@ -741,8 +749,10 @@ impl DistributedTransactionExecutor {
 
         // The frontier advances here and only here, so it describes what has
         // been successfully applied rather than what was claimed or received.
-        self.causal_barrier
-            .record_applied(&Self::barrier_key(&envelope.envelope_id), &envelope.vector_clock);
+        self.causal_barrier.record_applied(
+            &Self::barrier_key(&envelope.envelope_id),
+            &envelope.vector_clock,
+        );
 
         Ok(state_hash)
     }
@@ -816,16 +826,14 @@ impl DistributedTransactionExecutor {
             return Ok(0);
         }
         let by_key = self.log_by_key()?;
-        let mut keys: Vec<String> = self
-            .deferred
-            .iter()
-            .map(Self::barrier_key)
-            .collect();
+        let mut keys: Vec<String> = self.deferred.iter().map(Self::barrier_key).collect();
         keys.sort();
 
         let mut admitted = 0;
         for key in keys {
-            let Some(envelope) = by_key.get(&key).cloned() else { continue };
+            let Some(envelope) = by_key.get(&key).cloned() else {
+                continue;
+            };
             let dependencies = Self::dependencies_of(&envelope);
             let payload_bytes = Self::envelope_bytes(&envelope);
 
@@ -888,9 +896,7 @@ impl DistributedTransactionExecutor {
             .clocks
             .iter()
             .filter(|(node, required)| frontier.get(node) < **required)
-            .map(|(node, required)| {
-                format!("{}@{} (have {})", node, required, frontier.get(node))
-            })
+            .map(|(node, required)| format!("{}@{} (have {})", node, required, frontier.get(node)))
             .collect();
         missing.sort();
         missing
@@ -1021,11 +1027,7 @@ impl DistributedTransactionExecutor {
             return true;
         }
 
-        let first_hash = self
-            .replicas
-            .values()
-            .next()
-            .map(|r| r.state_hash.clone());
+        let first_hash = self.replicas.values().next().map(|r| r.state_hash.clone());
 
         if let Some(first) = first_hash {
             self.replicas.values().all(|r| r.state_hash == first)
@@ -1122,6 +1124,27 @@ impl DistributedTransactionExecutor {
             );
         }
 
+        // Restore the observable local replica state from the same applied
+        // subset. Recovery previously rebuilt the barrier and canonical data
+        // but left this counter and clock at their constructor values, making
+        // a fully recovered node report that it had applied zero operations.
+        let applied_keys = self.causal_barrier.applied_keys();
+        let operations_applied = envelopes
+            .iter()
+            .filter(|envelope| applied_keys.contains(&Self::barrier_key(&envelope.envelope_id)))
+            .map(|envelope| envelope.operations.len() as u64)
+            .sum();
+        let recovered_clock = self.causal_barrier.get_frontier().clone();
+        let recovered_hash = self
+            .canonical_state()
+            .map(|state| state.hash())
+            .unwrap_or_else(|_| StateHash::from_hex("0".repeat(64)));
+        if let Some(local) = self.replicas.get_mut(&self.local_node_id) {
+            local.vector_clock = recovered_clock;
+            local.operations_applied = operations_applied;
+            local.state_hash = recovered_hash;
+        }
+
         // Identity is recovered from the same log, and this is the half that
         // was missing: the causal frontier was already rebuilt here, so a
         // restarted origin came back knowing its causal position and not its
@@ -1201,7 +1224,10 @@ mod tests {
 
     #[test]
     fn test_replica_state_creation() {
-        let state = ReplicaState::new("node1".to_string(), StateHash::from_hex("hash0".to_string()));
+        let state = ReplicaState::new(
+            "node1".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         assert_eq!(state.node_id, "node1");
         assert_eq!(state.operations_applied, 0);
@@ -1224,7 +1250,10 @@ mod tests {
             StateHash::from_hex("hash0".to_string()),
         );
 
-        executor.register_replica("node2".to_string(), StateHash::from_hex("hash0".to_string()));
+        executor.register_replica(
+            "node2".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         assert!(executor.replicas.contains_key("node2"));
     }
@@ -1247,8 +1276,14 @@ mod tests {
             StateHash::from_hex("hash0".to_string()),
         );
 
-        executor.register_replica("node2".to_string(), StateHash::from_hex("hash0".to_string()));
-        executor.register_replica("node3".to_string(), StateHash::from_hex("hash0".to_string()));
+        executor.register_replica(
+            "node2".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
+        executor.register_replica(
+            "node3".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         assert!(executor.check_convergence());
     }
@@ -1260,7 +1295,10 @@ mod tests {
             StateHash::from_hex("hash0".to_string()),
         );
 
-        executor.register_replica("node2".to_string(), StateHash::from_hex("hash1".to_string()));
+        executor.register_replica(
+            "node2".to_string(),
+            StateHash::from_hex("hash1".to_string()),
+        );
 
         assert!(!executor.check_convergence());
     }

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

@@ -246,7 +246,8 @@ use serde_json::Value;
 use sha2::{Digest, Sha256};
 use std::any::type_name;
 use std::collections::hash_map::DefaultHasher;
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::ops::Bound::{Excluded, Unbounded};
 use std::fmt::{Display, Formatter};
 use std::fs::{self, OpenOptions};
 use std::hash::{Hash, Hasher};
@@ -315,7 +316,7 @@ pub struct FeltDb {
 #[allow(dead_code)] // Reserved runtime subsystems are initialized before their public APIs land.
 struct Inner {
     path: PathBuf,
-    rows: HashMap<String, HashMap<String, StoredRow>>,
+    rows: HashMap<String, BTreeMap<String, StoredRow>>,
     key_counters: HashMap<String, u64>,
     query_count_by_type: HashMap<String, usize>,
     adaptive_indexes: HashSet<String>,
@@ -1721,6 +1722,23 @@ impl FeltDb {
             .unwrap_or_default())
     }
 
+    /// Traverse one collection in immutable record-key order without materializing it.
+    pub fn list_collection_page(&self, capability: &str, after: Option<&str>, limit: usize) -> Result<Vec<StoredRow>> {
+        let inner = self.inner.lock().expect("lock poisoned");
+        let Some(rows) = inner.rows.get(capability) else { return Ok(vec![]) };
+        let values: Box<dyn Iterator<Item = &StoredRow>> = match after {
+            Some(key) => Box::new(rows.range::<str, _>((Excluded(key), Unbounded)).map(|(_, row)| row)),
+            None => Box::new(rows.values()),
+        };
+        Ok(values.filter(|row| !row.deleted).take(limit).cloned().collect())
+    }
+
+    /// Fetch one live collection record without materializing collection state.
+    pub fn get_collection_record(&self, capability: &str, key: &str) -> Result<Option<StoredRow>> {
+        let inner = self.inner.lock().expect("lock poisoned");
+        Ok(inner.rows.get(capability).and_then(|rows| rows.get(key)).filter(|row| !row.deleted).cloned())
+    }
+
     /// Subscribe to canonical mutation events.
     pub fn subscribe_changes(&self) -> broadcast::Receiver<ChangeEvent> {
         self.event_tx.subscribe()

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

@@ -1,10 +1,10 @@
+use serde_json::Value;
 use std::path::PathBuf;
 use std::{
     collections::HashMap,
     sync::{atomic::AtomicU64, Arc},
     time::Instant,
 };
-use serde_json::Value;
 
 #[derive(Clone)]
 pub struct BoundedQueryCursor {
@@ -16,34 +16,22 @@ pub struct BoundedQueryCursor {
     pub created_at: u64,
 }
 
+use crate::{
+    application_contract::ApplicationContractStore, artifacts::ArtifactStore, audit::AuditLog,
+    auth::KeyStore, causal::CausalStore, clock::LeaseClock, cluster::ClusterStore,
+    connections::ConnectionStore, content::ContentStore, identity::IdentityStore,
+    leases::LeaseStore, metrics::Metrics, portable_bundle::BundleStore, principals::PrincipalStore,
+    providers::ProviderStore, releases::ReleaseStore, sessions::SessionVerifier,
+    tenancy::TenancyStore,
+};
 use feltdb::{
-    FeltDb,
     application::ApplicationStore,
+    application_runtime::RuntimeStore,
     authorization::{GrantSigner, GrantStore},
     sync_contract::SyncStore,
-    workload::WorkloadStore,
     worker_mesh::WorkerMeshStore,
-    application_runtime::RuntimeStore,
-};
-use crate::{
-    artifacts::ArtifactStore,
-    audit::AuditLog,
-    auth::KeyStore,
-    causal::CausalStore,
-    cluster::ClusterStore,
-    connections::ConnectionStore,
-    content::ContentStore,
-    identity::IdentityStore,
-    leases::LeaseStore,
-    metrics::Metrics,
-    portable_bundle::BundleStore,
-    principals::PrincipalStore,
-    providers::ProviderStore,
-    releases::ReleaseStore,
-    sessions::SessionVerifier,
-    tenancy::TenancyStore,
-    application_contract::ApplicationContractStore,
-    clock::LeaseClock,
+    workload::WorkloadStore,
+    FeltDb,
 };
 
 #[derive(Clone)]