cleaned up a bunch of (lack of) imports

crates/jacquard-repo/src/car/reader.rs

···
 //! Provides functions for reading CAR (Content Addressable aRchive) files into memory
 //! or streaming them for large repositories.
 
-use crate::error::Result;
+use crate::error::{RepoError, Result};
 use bytes::Bytes;
 use cid::Cid as IpldCid;
 use iroh_car::CarReader;
-use n0_future::stream::StreamExt;
+use n0_future::stream::{Stream, StreamExt};
 use std::collections::BTreeMap;
 use std::path::Path;
+use std::pin::Pin;
 use tokio::fs::File;
 
 /// Parsed CAR file data
···
 /// Returns BTreeMap of CID -> block data (sorted order for determinism).
 /// For large CAR files, consider using `stream_car()` instead.
 pub async fn read_car(path: impl AsRef<Path>) -> Result<BTreeMap<IpldCid, Bytes>> {
-    let file = File::open(path)
-        .await
-        .map_err(|e| crate::error::RepoError::io(e))?;
+    let file = File::open(path).await.map_err(|e| RepoError::io(e))?;
 
-    let reader = CarReader::new(file)
-        .await
-        .map_err(|e| crate::error::RepoError::car(e))?;
+    let reader = CarReader::new(file).await.map_err(|e| RepoError::car(e))?;
 
     let mut blocks = BTreeMap::new();
     let stream = reader.stream();
     n0_future::pin!(stream);
 
     while let Some(result) = stream.next().await {
-        let (cid, data) = result.map_err(|e| crate::error::RepoError::car_parse(e))?;
+        let (cid, data) = result.map_err(|e| RepoError::car_parse(e))?;
         blocks.insert(cid, Bytes::from(data));
     }
 
···
 ///
 /// Useful for checking roots without loading all blocks.
 pub async fn read_car_header(path: impl AsRef<Path>) -> Result<Vec<IpldCid>> {
-    let file = File::open(path)
-        .await
-        .map_err(|e| crate::error::RepoError::io(e))?;
+    let file = File::open(path).await.map_err(|e| RepoError::io(e))?;
 
-    let reader = CarReader::new(file)
-        .await
-        .map_err(|e| crate::error::RepoError::car(e))?;
+    let reader = CarReader::new(file).await.map_err(|e| RepoError::car(e))?;
 
     Ok(reader.header().roots().to_vec())
 }
···
 pub async fn parse_car_bytes(data: &[u8]) -> Result<ParsedCar> {
     let reader = CarReader::new(data)
         .await
-        .map_err(|e| crate::error::RepoError::car_parse(e))?;
+        .map_err(|e| RepoError::car_parse(e))?;
 
     let roots = reader.header().roots();
     let root = roots
         .first()
         .copied()
-        .ok_or_else(|| crate::error::RepoError::invalid("CAR file has no roots"))?;
+        .ok_or_else(|| RepoError::invalid("CAR file has no roots"))?;
 
     let mut blocks = BTreeMap::new();
     let stream = reader.stream();
     n0_future::pin!(stream);
 
     while let Some(result) = stream.next().await {
-        let (cid, data) = result.map_err(|e| crate::error::RepoError::car_parse(e))?;
+        let (cid, data) = result.map_err(|e| RepoError::car_parse(e))?;
         blocks.insert(cid, Bytes::from(data));
     }
 
···
 ///
 /// Useful for processing large CAR files incrementally.
 pub async fn stream_car(path: impl AsRef<Path>) -> Result<CarBlockStream> {
-    let file = File::open(path)
-        .await
-        .map_err(|e| crate::error::RepoError::io(e))?;
+    let file = File::open(path).await.map_err(|e| RepoError::io(e))?;
 
-    let reader = CarReader::new(file)
-        .await
-        .map_err(|e| crate::error::RepoError::car(e))?;
+    let reader = CarReader::new(file).await.map_err(|e| RepoError::car(e))?;
 
     let roots = reader.header().roots().to_vec();
     let stream = Box::pin(reader.stream());
···
 ///
 /// Iterates through CAR blocks without loading entire file into memory.
 pub struct CarBlockStream {
-    stream: std::pin::Pin<
-        Box<
-            dyn n0_future::stream::Stream<
-                    Item = std::result::Result<(IpldCid, Vec<u8>), iroh_car::Error>,
-                > + Send,
-        >,
+    stream: Pin<
+        Box<dyn Stream<Item = std::result::Result<(IpldCid, Vec<u8>), iroh_car::Error>> + Send>,
     >,
     roots: Vec<IpldCid>,
 }
···
     pub async fn next(&mut self) -> Result<Option<(IpldCid, Bytes)>> {
         match self.stream.next().await {
             Some(result) => {
-                let (cid, data) = result.map_err(|e| crate::error::RepoError::car_parse(e))?;
+                let (cid, data) = result.map_err(|e| RepoError::car_parse(e))?;
                 Ok(Some((cid, Bytes::from(data))))
             }
             None => Ok(None),

crates/jacquard-repo/src/car/writer.rs

···
 //!
 //! Provides functions for writing blocks to CAR (Content Addressable aRchive) files.
 
-use crate::error::Result;
+use crate::error::{RepoError, Result};
 use crate::mst::tree::Mst;
 use crate::storage::BlockStore;
 use bytes::Bytes;
···
     roots: Vec<IpldCid>,
     blocks: BTreeMap<IpldCid, Bytes>,
 ) -> Result<()> {
-    let file = File::create(path)
-        .await
-        .map_err(|e| crate::error::RepoError::io(e))?;
+    let file = File::create(path).await.map_err(|e| RepoError::io(e))?;
 
     let header = iroh_car::CarHeader::new_v1(roots);
     let mut writer = CarWriter::new(header, file);
···
         writer
             .write(cid, data.as_ref())
             .await
-            .map_err(|e| crate::error::RepoError::car(e))?;
+            .map_err(|e| RepoError::car(e))?;
     }
 
-    writer
-        .finish()
-        .await
-        .map_err(|e| crate::error::RepoError::car(e))?;
+    writer.finish().await.map_err(|e| RepoError::car(e))?;
 
     Ok(())
 }
···
 ///
 /// Like `write_car()` but writes to a `Vec<u8>` instead of a file.
 /// Useful for tests and proof generation.
-pub async fn write_car_bytes(
-    root: IpldCid,
-    blocks: BTreeMap<IpldCid, Bytes>,
-) -> Result<Vec<u8>> {
+pub async fn write_car_bytes(root: IpldCid, blocks: BTreeMap<IpldCid, Bytes>) -> Result<Vec<u8>> {
     let mut buffer = Vec::new();
     let header = iroh_car::CarHeader::new_v1(vec![root]);
     let mut writer = CarWriter::new(header, &mut buffer);
···
         writer
             .write(cid, data.as_ref())
             .await
-            .map_err(|e| crate::error::RepoError::car(e))?;
+            .map_err(|e| RepoError::car(e))?;
     }
 
-    writer
-        .finish()
-        .await
-        .map_err(|e| crate::error::RepoError::car(e))?;
+    writer.finish().await.map_err(|e| RepoError::car(e))?;
 
-    buffer.flush().await.map_err(|e| crate::error::RepoError::io(e))?;
+    buffer.flush().await.map_err(|e| RepoError::io(e))?;
 
     Ok(buffer)
 }
···
     commit_cid: IpldCid,
     mst: &Mst<S>,
 ) -> Result<()> {
-    let file = File::create(path)
-        .await
-        .map_err(|e| crate::error::RepoError::io(e))?;
+    let file = File::create(path).await.map_err(|e| RepoError::io(e))?;
 
     let header = iroh_car::CarHeader::new_v1(vec![commit_cid]);
     let mut writer = CarWriter::new(header, file);
···
     let commit_data = storage
         .get(&commit_cid)
         .await?
-        .ok_or_else(|| crate::error::RepoError::not_found("commit", &commit_cid))?;
+        .ok_or_else(|| RepoError::not_found("commit", &commit_cid))?;
 
     writer
         .write(commit_cid, &commit_data)
         .await
-        .map_err(|e| crate::error::RepoError::car(e))?;
+        .map_err(|e| RepoError::car(e))?;
 
     // Stream MST and record blocks
     mst.write_blocks_to_car(&mut writer).await?;
 
     // Finish writing
-    writer
-        .finish()
-        .await
-        .map_err(|e| crate::error::RepoError::car(e))?;
+    writer.finish().await.map_err(|e| RepoError::car(e))?;
 
     Ok(())
 }

crates/jacquard-repo/src/commit/firehose.rs

···
 //! which are DISTINCT from repository commit objects.
 
 use bytes::Bytes;
-use jacquard_common::IntoStatic;
-use jacquard_common::types::string::{Did, Tid};
+use jacquard_common::types::cid::CidLink;
+use jacquard_common::types::crypto::PublicKey;
+use jacquard_common::types::string::{Datetime, Did, Tid};
+use jacquard_common::{CowStr, IntoStatic};
 
 /// Firehose commit message (sync v1.0 and v1.1)
 ///
···
     pub since: Tid,
 
     /// Timestamp of when this message was originally broadcast
-    pub time: jacquard_common::types::string::Datetime,
+    pub time: Datetime,
 
     /// Repo commit object CID
     ///
     /// This CID points to the repository commit block (with did, version, data, rev, prev, sig).
     /// It must be the first entry in the CAR header 'roots' list.
     #[serde(borrow)]
-    pub commit: jacquard_common::types::cid::CidLink<'a>,
+    pub commit: CidLink<'a>,
 
     /// CAR file containing relevant blocks
     ///
···
     /// - Consumers must have previous repository state
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(borrow)]
-    pub prev_data: Option<jacquard_common::types::cid::CidLink<'a>>,
+    pub prev_data: Option<CidLink<'a>>,
 
     /// Blob CIDs referenced in this commit
     #[serde(borrow)]
-    pub blobs: Vec<jacquard_common::types::cid::CidLink<'a>>,
+    pub blobs: Vec<CidLink<'a>>,
 
     /// DEPRECATED: Replaced by #sync event and data limits
     ///
···
 pub struct RepoOp<'a> {
     /// Operation type: "create", "update", or "delete"
     #[serde(borrow)]
-    pub action: jacquard_common::CowStr<'a>,
+    pub action: CowStr<'a>,
 
     /// Collection/rkey path (e.g., "app.bsky.feed.post/abc123")
     #[serde(borrow)]
-    pub path: jacquard_common::CowStr<'a>,
+    pub path: CowStr<'a>,
 
     /// For creates and updates, the new record CID. For deletions, None (null).
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(borrow)]
-    pub cid: Option<jacquard_common::types::cid::CidLink<'a>>,
+    pub cid: Option<CidLink<'a>>,
 
     /// For updates and deletes, the previous record CID
     ///
···
     /// For creates, this field should not be defined.
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(borrow)]
-    pub prev: Option<jacquard_common::types::cid::CidLink<'a>>,
+    pub prev: Option<CidLink<'a>>,
 }
 
 impl IntoStatic for FirehoseCommit<'_> {
···
     }
 }
 
+use crate::car::parse_car_bytes;
 /// Validation functions for firehose commit messages
 ///
 /// These functions validate commits from the `com.atproto.sync.subscribeRepos` firehose.
-use crate::error::Result;
+use crate::error::{RepoError, Result};
 use crate::mst::Mst;
-use crate::storage::BlockStore;
+use crate::storage::{BlockStore, LayeredBlockStore, MemoryBlockStore};
 use cid::Cid as IpldCid;
 use std::sync::Arc;
 
···
         &self,
         prev_mst_root: Option<IpldCid>,
         prev_storage: Arc<S>,
-        pubkey: &jacquard_common::types::crypto::PublicKey<'_>,
+        pubkey: &PublicKey<'_>,
     ) -> Result<IpldCid> {
         // 1. Parse CAR blocks from the firehose message into temporary storage
-        let parsed = crate::car::parse_car_bytes(&self.blocks).await?;
-        let temp_storage = crate::storage::MemoryBlockStore::new_from_blocks(parsed.blocks);
+        let parsed = parse_car_bytes(&self.blocks).await?;
+        let temp_storage = MemoryBlockStore::new_from_blocks(parsed.blocks);
 
         // 2. Create layered storage: reads from temp first, then prev; writes to temp only
         // This avoids copying all previous MST blocks
-        let layered_storage =
-            crate::storage::LayeredBlockStore::new(temp_storage.clone(), prev_storage);
+        let layered_storage = LayeredBlockStore::new(temp_storage.clone(), prev_storage);
 
         // 3. Extract and verify commit object from temporary storage
         let commit_cid: IpldCid = self
             .commit
             .to_ipld()
-            .map_err(|e| crate::error::RepoError::invalid(format!("Invalid commit CID: {}", e)))?;
+            .map_err(|e| RepoError::invalid(format!("Invalid commit CID: {}", e)))?;
         let commit_bytes = temp_storage
             .get(&commit_cid)
             .await?
-            .ok_or_else(|| crate::error::RepoError::not_found("commit block", &commit_cid))?;
+            .ok_or_else(|| RepoError::not_found("commit block", &commit_cid))?;
 
         let commit = super::Commit::from_cbor(&commit_bytes)?;
 
         // Verify DID matches
         if commit.did().as_ref() != self.repo.as_ref() {
-            return Err(crate::error::RepoError::invalid_commit(format!(
+            return Err(RepoError::invalid_commit(format!(
                 "DID mismatch: commit has {}, message has {}",
                 commit.did(),
                 self.repo
···
         let computed_root = computed_mst.get_pointer().await?;
 
         if computed_root != expected_root {
-            return Err(crate::error::RepoError::invalid_commit(format!(
+            return Err(RepoError::invalid_commit(format!(
                 "MST root mismatch: expected {}, got {}",
                 expected_root, computed_root
             )));
···
     /// **Inductive property:** Can validate without any external state besides the blocks
     /// in this message. The `prev_data` field provides the starting MST root, and operations
     /// include `prev` CIDs for validation. All necessary blocks must be in the CAR bytes.
-    pub async fn validate_v1_1(
-        &self,
-        pubkey: &jacquard_common::types::crypto::PublicKey<'_>,
-    ) -> Result<IpldCid> {
+    pub async fn validate_v1_1(&self, pubkey: &PublicKey<'_>) -> Result<IpldCid> {
         // 1. Require prev_data for v1.1
         let prev_data_cid: IpldCid = self
             .prev_data
             .as_ref()
             .ok_or_else(|| {
-                crate::error::RepoError::invalid_commit(
-                    "Sync v1.1 validation requires prev_data field",
-                )
+                RepoError::invalid_commit("Sync v1.1 validation requires prev_data field")
             })?
             .to_ipld()
-            .map_err(|e| {
-                crate::error::RepoError::invalid(format!("Invalid prev_data CID: {}", e))
-            })?;
+            .map_err(|e| RepoError::invalid(format!("Invalid prev_data CID: {}", e)))?;
 
         // 2. Parse CAR blocks from the firehose message into temporary storage
-        let parsed = crate::car::parse_car_bytes(&self.blocks).await?;
-        let temp_storage = Arc::new(crate::storage::MemoryBlockStore::new_from_blocks(
-            parsed.blocks,
-        ));
+        let parsed = parse_car_bytes(&self.blocks).await?;
+        let temp_storage = Arc::new(MemoryBlockStore::new_from_blocks(parsed.blocks));
 
         // 3. Extract and verify commit object from temporary storage
         let commit_cid: IpldCid = self
             .commit
             .to_ipld()
-            .map_err(|e| crate::error::RepoError::invalid(format!("Invalid commit CID: {}", e)))?;
+            .map_err(|e| RepoError::invalid(format!("Invalid commit CID: {}", e)))?;
         let commit_bytes = temp_storage
             .get(&commit_cid)
             .await?
-            .ok_or_else(|| crate::error::RepoError::not_found("commit block", &commit_cid))?;
+            .ok_or_else(|| RepoError::not_found("commit block", &commit_cid))?;
 
         let commit = super::Commit::from_cbor(&commit_bytes)?;
 
         // Verify DID matches
         if commit.did().as_ref() != self.repo.as_ref() {
-            return Err(crate::error::RepoError::invalid_commit(format!(
+            return Err(RepoError::invalid_commit(format!(
                 "DID mismatch: commit has {}, message has {}",
                 commit.did(),
                 self.repo
···
         let computed_root = computed_mst.get_pointer().await?;
 
         if computed_root != expected_root {
-            return Err(crate::error::RepoError::invalid_commit(format!(
+            return Err(RepoError::invalid_commit(format!(
                 "MST root mismatch: expected {}, got {}",
                 expected_root, computed_root
             )));

crates/jacquard-repo/src/commit/proof.rs

···
 use crate::mst::Mst;
 use crate::storage::MemoryBlockStore;
 use cid::Cid as IpldCid;
+use jacquard_common::CowStr;
 use jacquard_common::types::string::Did;
 use smol_str::format_smolstr;
 use std::sync::Arc;
···
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RecordClaim<'a> {
     /// Collection NSID (e.g., "app.bsky.feed.post")
-    pub collection: jacquard_common::CowStr<'a>,
+    pub collection: CowStr<'a>,
 
     /// Record key (TID or other identifier)
-    pub rkey: jacquard_common::CowStr<'a>,
+    pub rkey: CowStr<'a>,
 
     /// Expected CID of the record
     /// - Some(cid): claiming record exists with this CID

crates/jacquard-repo/src/error.rs

···
 }
 
 /// Diff-specific errors
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
 pub enum DiffError {
     /// Too many operations
     #[error("Too many operations: {count} (max {max})")]

crates/jacquard-repo/src/mst/diff.rs

···
 //! MST diff calculation
 
 use std::collections::BTreeMap;
+use std::future::Future;
+use std::pin::Pin;
 
 use super::cursor::{CursorPosition, MstCursor};
 use super::tree::Mst;
-use crate::error::Result;
+use super::util::serialize_node_data;
+use crate::commit::firehose::RepoOp;
+use crate::error::{RepoError, Result};
+use crate::mst::NodeEntry;
 use crate::storage::BlockStore;
 use bytes::Bytes;
 use cid::Cid as IpldCid;
+use jacquard_common::types::cid::CidLink;
 use smol_str::SmolStr;
 
 /// Diff between two MST states
···
     /// The sync protocol has a 200 operation limit per commit.
     pub fn validate_limits(&self) -> Result<()> {
         if self.op_count() > 200 {
-            return Err(crate::error::RepoError::too_large(
+            return Err(RepoError::too_large(
                 "diff operation count",
                 self.op_count(),
                 200,
···
         &self,
         storage: &S,
     ) -> Result<std::collections::BTreeMap<IpldCid, bytes::Bytes>> {
-        use std::collections::BTreeMap;
-
         let mut blocks = BTreeMap::new();
 
         for cid in &self.new_leaf_cids {
···
     ///
     /// Returns operations in the format used by `com.atproto.sync.subscribeRepos`.
     /// All update/delete operations include prev CIDs for sync v1.1 validation.
-    pub fn to_repo_ops(&self) -> Vec<crate::commit::firehose::RepoOp<'_>> {
-        use jacquard_common::types::cid::CidLink;
-
+    pub fn to_repo_ops(&self) -> Vec<RepoOp<'_>> {
         let mut ops = Vec::with_capacity(self.op_count());
 
         // Add creates
         for (key, cid) in &self.creates {
-            ops.push(crate::commit::firehose::RepoOp {
+            ops.push(RepoOp {
                 action: "create".into(),
                 path: key.as_str().into(),
                 cid: Some(CidLink::from(*cid)),
···
 
         // Add updates
         for (key, new_cid, old_cid) in &self.updates {
-            ops.push(crate::commit::firehose::RepoOp {
+            ops.push(RepoOp {
                 action: "update".into(),
                 path: key.as_str().into(),
                 cid: Some(CidLink::from(*new_cid)),
···
 
         // Add deletes
         for (key, old_cid) in &self.deletes {
-            ops.push(crate::commit::firehose::RepoOp {
+            ops.push(RepoOp {
                 action: "delete".into(),
                 path: key.as_str().into(),
                 cid: None, // null for deletes
···
     old: &'a Mst<S>,
     new: &'a Mst<S>,
     diff: &'a mut MstDiff,
-) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send + 'a>> {
+) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
     Box::pin(async move {
         // If CIDs are equal, trees are identical - skip entire subtree
         let old_cid = old.get_pointer().await?;
···
 
     // Serialize the MST node
     let entries = tree.get_entries().await?;
-    let node_data = super::util::serialize_node_data(&entries).await?;
-    let cbor = serde_ipld_dagcbor::to_vec(&node_data)
-        .map_err(|e| crate::error::RepoError::serialization(e))?;
+    let node_data = serialize_node_data(&entries).await?;
+    let cbor = serde_ipld_dagcbor::to_vec(&node_data).map_err(|e| RepoError::serialization(e))?;
 
     // Track the serialized block
     diff.new_mst_blocks.insert(tree_cid, Bytes::from(cbor));
···
 fn track_added_tree<'a, S: BlockStore + Sync + 'static>(
     tree: &'a Mst<S>,
     diff: &'a mut MstDiff,
-) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send + 'a>> {
+) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
     Box::pin(async move {
-        use super::node::NodeEntry;
-
         // Serialize and track this MST node
         serialize_and_track_mst(tree, diff).await?;
 
···
 fn track_removed_tree<'a, S: BlockStore + Sync + 'static>(
     tree: &'a Mst<S>,
     diff: &'a mut MstDiff,
-) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send + 'a>> {
+) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
     Box::pin(async move {
-        use super::node::NodeEntry;
-
         // Track this MST node as removed
         let tree_cid = tree.get_pointer().await?;
         diff.removed_mst_blocks.push(tree_cid);
···
 fn track_removed_tree_all<'a, S: BlockStore + Sync + 'static>(
     tree: &'a Mst<S>,
     diff: &'a mut MstDiff,
-) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send + 'a>> {
+) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
     Box::pin(async move {
-        use super::node::NodeEntry;
-
         // Track this node as removed
         let tree_cid = tree.get_pointer().await?;
         diff.removed_mst_blocks.push(tree_cid);

crates/jacquard-repo/src/mst/node.rs

···
 use cid::Cid as IpldCid;
 use smol_str::SmolStr;
 
+use crate::{mst::Mst, storage::BlockStore};
+
 /// Entry in an MST node - either a subtree or a leaf
 ///
 /// This is the in-memory representation used for tree operations.
···
 ///
 /// The wire format (CBOR) is different - see `NodeData` and `TreeEntry`.
 #[derive(Clone)]
-pub enum NodeEntry<S: crate::storage::BlockStore> {
+pub enum NodeEntry<S> {
     /// Subtree reference
     ///
     /// Will be lazily loaded from storage when needed.
-    Tree(crate::mst::Mst<S>),
+    Tree(Mst<S>),
 
     /// Leaf node with key-value pair
     Leaf {
···
     },
 }
 
-impl<S: crate::storage::BlockStore> fmt::Debug for NodeEntry<S> {
+impl<S: BlockStore> fmt::Debug for NodeEntry<S> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             NodeEntry::Tree(t) => write!(f, "{:?}", t),
···
     }
 }
 
-impl<S: crate::storage::BlockStore> NodeEntry<S> {
+impl<S: BlockStore> NodeEntry<S> {
     /// Check if this is a tree entry
     pub fn is_tree(&self) -> bool {
         matches!(self, NodeEntry::Tree(_))

crates/jacquard-repo/src/mst/tree.rs

···
 /// - Layer = floor(leading_zeros / 2) for ~4 fanout
 /// - Deterministic and insertion-order independent
 #[derive(Clone)]
-pub struct Mst<S: BlockStore> {
+pub struct Mst<S> {
     /// Block storage for loading/saving nodes (shared via Arc)
     storage: Arc<S>,
 
···
     /// For nodes with no leaves, recursively checks subtrees.
     pub(crate) fn get_layer<'a>(
         &'a self,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<usize>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'a>> {
         Box::pin(async move {
             if let Some(layer) = self.layer {
                 return Ok(layer);
···
     pub fn get<'a>(
         &'a self,
         key: &'a str,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Option<IpldCid>>> + Send + 'a>>
-    {
+    ) -> Pin<Box<dyn Future<Output = Result<Option<IpldCid>>> + Send + 'a>> {
         Box::pin(async move {
             validate_key(key)?;
 
···
         &'a self,
         key: &'a str,
         cid: IpldCid,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Mst<S>>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<Mst<S>>> + Send + 'a>> {
         Box::pin(async move {
             validate_key(key)?;
 
···
     pub fn delete<'a>(
         &'a self,
         key: &'a str,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Mst<S>>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<Mst<S>>> + Send + 'a>> {
         Box::pin(async move {
             validate_key(key)?;
 
···
     fn delete_recurse<'a>(
         &'a self,
         key: &'a str,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Mst<S>>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<Mst<S>>> + Send + 'a>> {
         Box::pin(async move {
             let entries = self.get_entries().await?;
             let index = Self::find_gt_or_equal_leaf_index_in(&entries, key);
···
     }
 
     /// Trim top node if it only contains one subtree
-    fn trim_top(
-        self,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Mst<S>>> + Send>> {
+    fn trim_top(self) -> Pin<Box<dyn Future<Output = Result<Mst<S>>> + Send>> {
         Box::pin(async move {
             let entries = self.get_entries().await?;
 
···
     pub fn split_around<'a>(
         &'a self,
         key: &'a str,
-    ) -> std::pin::Pin<
-        Box<dyn std::future::Future<Output = Result<(Option<Mst<S>>, Option<Mst<S>>)>> + Send + 'a>,
-    > {
+    ) -> Pin<Box<dyn Future<Output = Result<(Option<Mst<S>>, Option<Mst<S>>)>> + Send + 'a>> {
         Box::pin(async move {
             let entries = self.get_entries().await?;
             let index = Self::find_gt_or_equal_leaf_index_in(&entries, key);
···
     pub fn append_merge<'a>(
         &'a self,
         to_merge: &'a Mst<S>,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Mst<S>>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<Mst<S>>> + Send + 'a>> {
         Box::pin(async move {
             // Check same layer
             let self_layer = self.get_layer().await?;
···
     /// Uses parallel traversal to collect leaves from independent subtrees concurrently.
     pub fn leaves<'a>(
         &'a self,
-    ) -> std::pin::Pin<
-        Box<
-            dyn std::future::Future<Output = Result<Vec<(smol_str::SmolStr, IpldCid)>>> + Send + 'a,
-        >,
-    > {
+    ) -> Pin<Box<dyn Future<Output = Result<Vec<(smol_str::SmolStr, IpldCid)>>> + Send + 'a>> {
         Box::pin(async move { collect_leaves_parallel(self.clone()).await })
     }
 
     /// Get all leaf entries sequentially (for benchmarking)
     pub fn leaves_sequential<'a>(
         &'a self,
-    ) -> std::pin::Pin<
-        Box<
-            dyn std::future::Future<Output = Result<Vec<(smol_str::SmolStr, IpldCid)>>> + Send + 'a,
-        >,
-    > {
+    ) -> Pin<Box<dyn Future<Output = Result<Vec<(smol_str::SmolStr, IpldCid)>>> + Send + 'a>> {
         Box::pin(async move {
             let mut result = Vec::new();
             self.collect_leaves_sequential(&mut result).await?;
···
     fn collect_leaves_sequential<'a>(
         &'a self,
         result: &'a mut Vec<(smol_str::SmolStr, IpldCid)>,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
         Box::pin(async move {
             let entries = self.get_entries().await?;
 
···
     /// Uses parallel traversal to collect blocks from independent subtrees concurrently.
     pub fn collect_blocks<'a>(
         &'a self,
-    ) -> std::pin::Pin<
+    ) -> Pin<
         Box<
-            dyn std::future::Future<
+            dyn Future<
                     Output = Result<(IpldCid, std::collections::BTreeMap<IpldCid, bytes::Bytes>)>,
                 > + Send
                 + 'a,
···
     /// Collect all blocks sequentially (for benchmarking)
     pub fn collect_blocks_sequential<'a>(
         &'a self,
-    ) -> std::pin::Pin<
+    ) -> Pin<
         Box<
-            dyn std::future::Future<
+            dyn Future<
                     Output = Result<(IpldCid, std::collections::BTreeMap<IpldCid, bytes::Bytes>)>,
                 > + Send
                 + 'a,
···
     pub fn cids_for_path<'a>(
         &'a self,
         key: &'a str,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Vec<IpldCid>>> + Send + 'a>>
-    {
+    ) -> Pin<Box<dyn Future<Output = Result<Vec<IpldCid>>> + Send + 'a>> {
         Box::pin(async move {
             validate_key(key)?;
 
···
         &'a self,
         writer: &'a mut iroh_car::CarWriter<W>,
         leaf_cids: &'a mut Vec<IpldCid>,
-    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
         Box::pin(async move {
             let pointer = self.get_pointer().await?;
 

crates/jacquard-repo/src/mst/util.rs

···
 //! MST utility functions
 
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+
 use super::node::{NodeData, NodeEntry, TreeEntry};
+use crate::Mst;
 use crate::error::{MstError, Result};
 use crate::storage::BlockStore;
 use bytes::Bytes;
···
 /// - `Tree` after `Leaf` → that leaf's `tree` pointer
 pub fn serialize_node_data<'a, S: BlockStore + Sync + 'static>(
     entries: &'a [NodeEntry<S>],
-) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<NodeData>> + Send + 'a>> {
+) -> Pin<Box<dyn Future<Output = Result<NodeData>> + Send + 'a>> {
     Box::pin(async move {
         let mut data = NodeData {
             left: None,
···
 /// - Each entry → `Leaf` with reconstructed full key
 /// - `tree` pointer → append `Tree` entry
 pub fn deserialize_node_data<S: BlockStore + Sync + 'static>(
-    storage: std::sync::Arc<S>,
+    storage: Arc<S>,
     data: &NodeData,
     layer: Option<usize>,
 ) -> Result<Vec<NodeEntry<S>>> {
-    use crate::mst::Mst;
-
     let mut entries = Vec::new();
 
     // Left pointer → prepend Tree

crates/jacquard-repo/src/repo.rs

···
 //! Optional convenience layer over MST primitives. Provides type-safe record operations,
 //! batch writes, commit creation, and CAR export.
 
-use crate::commit::Commit;
-use crate::error::Result;
-use crate::mst::Mst;
+use crate::commit::firehose::{FirehoseCommit, RepoOp};
+use crate::commit::{Commit, SigningKey};
+use crate::error::{RepoError, Result};
+use crate::mst::{Mst, MstDiff, RecordWriteOp};
 use crate::storage::BlockStore;
 use cid::Cid as IpldCid;
 use jacquard_common::IntoStatic;
-use jacquard_common::types::string::{Did, Nsid, RecordKey, Tid};
+use jacquard_common::types::cid::CidLink;
+use jacquard_common::types::recordkey::RecordKeyType;
+use jacquard_common::types::string::{Datetime, Did, Nsid, RecordKey, Tid};
 use jacquard_common::types::tid::Ticker;
+use smol_str::format_smolstr;
 use std::collections::BTreeMap;
 use std::path::Path;
 use std::sync::Arc;
···
     /// Previous MST root CID (for sync v1.1)
     pub prev_data: Option<IpldCid>,
 
-    /// All blocks to persist (MST nodes + record data + commit block)
-    ///
-    /// Includes:
-    /// - All new MST node blocks from `diff.new_mst_blocks`
-    /// - All new record data blocks (from creates + updates)
-    /// - The commit block itself
+    /// New blocks to persist (MST nodes + record data + commit block)
     pub blocks: BTreeMap<IpldCid, bytes::Bytes>,
 
     /// Relevant blocks for firehose (sync v1.1 inductive validation)
···
     /// - Includes "adjacent" blocks needed for operation inversion
     pub relevant_blocks: BTreeMap<IpldCid, bytes::Bytes>,
 
-    /// CIDs of blocks to delete from storage
-    ///
-    /// Contains CIDs that are no longer referenced by the current tree:
-    /// - Record CIDs from deleted records
-    /// - Old record CIDs from updated records
-    ///
-    /// **Note:** Actual deletion should consider whether previous commits still
-    /// reference these CIDs. A proper GC strategy might:
-    /// - Only delete if previous commits are also being GC'd
-    /// - Use reference counting across all retained commits
-    /// - Perform periodic reachability analysis
-    ///
-    /// For simple single-commit repos or when old commits are discarded, direct
-    /// deletion is safe.
+    /// CIDs of blocks to delete
     pub deleted_cids: Vec<IpldCid>,
 }
 
···
         &self,
         repo: &Did<'_>,
         seq: i64,
-        time: jacquard_common::types::string::Datetime,
-        ops: Vec<crate::commit::firehose::RepoOp<'static>>,
-        blobs: Vec<jacquard_common::types::cid::CidLink<'static>>,
-    ) -> Result<crate::commit::firehose::FirehoseCommit<'static>> {
-        use jacquard_common::types::cid::CidLink;
-
+        time: Datetime,
+        ops: Vec<RepoOp<'static>>,
+        blobs: Vec<CidLink<'static>>,
+    ) -> Result<FirehoseCommit<'static>> {
         // Convert relevant blocks to CAR format
         let blocks_car =
             crate::car::write_car_bytes(self.cid, self.relevant_blocks.clone()).await?;
 
-        Ok(crate::commit::firehose::FirehoseCommit {
+        Ok(FirehoseCommit {
             repo: repo.clone().into_static(),
             rev: self.rev.clone(),
             seq,
···
         let commit_bytes = storage
             .get(commit_cid)
             .await?
-            .ok_or_else(|| crate::error::RepoError::not_found("commit", commit_cid))?;
+            .ok_or_else(|| RepoError::not_found("commit", commit_cid))?;
 
         let commit = Commit::from_cbor(&commit_bytes)?;
         let mst_root = commit.data();
···
     }
 
     /// Get a record by collection and rkey
-    pub async fn get_record<T: jacquard_common::types::recordkey::RecordKeyType>(
+    pub async fn get_record<T: RecordKeyType>(
         &self,
         collection: &Nsid<'_>,
         rkey: &RecordKey<T>,
···
     }
 
     /// Create a record (error if exists)
-    pub async fn create_record<T: jacquard_common::types::recordkey::RecordKeyType>(
+    pub async fn create_record<T: RecordKeyType>(
         &mut self,
         collection: &Nsid<'_>,
         rkey: &RecordKey<T>,
···
         let key = format!("{}/{}", collection.as_ref(), rkey.as_ref());
 
         if self.mst.get(&key).await?.is_some() {
-            return Err(crate::error::RepoError::already_exists("record", &key));
+            return Err(RepoError::already_exists("record", &key));
         }
 
         self.mst = self.mst.add(&key, record_cid).await?;
···
     }
 
     /// Update a record (error if not exists, returns previous CID)
-    pub async fn update_record<T: jacquard_common::types::recordkey::RecordKeyType>(
+    pub async fn update_record<T: RecordKeyType>(
         &mut self,
         collection: &Nsid<'_>,
         rkey: &RecordKey<T>,
···
             .mst
             .get(&key)
             .await?
-            .ok_or_else(|| crate::error::RepoError::not_found("record", &key))?;
+            .ok_or_else(|| RepoError::not_found("record", &key))?;
 
         self.mst = self.mst.update(&key, record_cid).await?;
         Ok(old_cid)
     }
 
     /// Delete a record (error if not exists, returns deleted CID)
-    pub async fn delete_record<T: jacquard_common::types::recordkey::RecordKeyType>(
+    pub async fn delete_record<T: RecordKeyType>(
         &mut self,
         collection: &Nsid<'_>,
         rkey: &RecordKey<T>,
···
             .mst
             .get(&key)
             .await?
-            .ok_or_else(|| crate::error::RepoError::not_found("record", &key))?;
+            .ok_or_else(|| RepoError::not_found("record", &key))?;
 
         self.mst = self.mst.delete(&key).await?;
         Ok(old_cid)
     }
 
+    // TODO(cursor-based queries): Potential future API additions
+    //
+    // The current API is purely single-record CRUD. Cursor-based traversal (see mst/cursor.rs)
+    // would enable efficient collection/range queries:
+    //
+    // - list_collection(collection: &Nsid) -> Vec<(RecordKey, IpldCid)>
+    //   Enumerate all records in a collection via prefix search on "collection/"
+    //   Uses cursor.advance() + cursor.skip_subtree() to skip irrelevant branches
+    //
+    // - list_collection_range(collection: &Nsid, start: &Rkey, end: &Rkey) -> Vec<...>
+    //   Range query: advance to start key, collect until > end, skip subtrees outside range
+    //   Useful for pagination / time-bounded queries (since Rkeys are often TIDs)
+    //
+    // - list_all_collections() -> Vec<Nsid>
+    //   Walk tree, track collection prefixes, skip subtrees once prefix changes
+    //
+    // Current single-key get() is already optimal (O(log n) targeted lookup).
+    // But these bulk operations would benefit significantly from cursor's skip_subtree()
+    // to avoid traversing unrelated branches when searching lexicographically-organized data.
+
     /// Apply record write operations with inline data
     ///
     /// Serializes record data to DAG-CBOR, computes CIDs, stores data blocks,
     /// then applies write operations to the MST. Returns the diff for inspection.
     ///
     /// For creating commits with operations, use `create_commit()` instead.
-    pub async fn apply_record_writes(
-        &mut self,
-        ops: &[crate::mst::RecordWriteOp<'_>],
-    ) -> Result<crate::mst::MstDiff> {
-        use crate::mst::RecordWriteOp;
+    pub async fn apply_record_writes(&mut self, ops: &[RecordWriteOp<'_>]) -> Result<MstDiff> {
         use smol_str::format_smolstr;
 
         let mut updated_tree = self.mst.clone();
···
 
                     // Serialize record to DAG-CBOR
                     let cbor = serde_ipld_dagcbor::to_vec(record)
-                        .map_err(|e| crate::error::RepoError::serialization(e))?;
+                        .map_err(|e| RepoError::serialization(e))?;
 
                     // Compute CID and store data
                     let cid = self.storage.put(&cbor).await?;
···
 
                     // Serialize record to DAG-CBOR
                     let cbor = serde_ipld_dagcbor::to_vec(record)
-                        .map_err(|e| crate::error::RepoError::serialization(e))?;
+                        .map_err(|e| RepoError::serialization(e))?;
 
                     // Compute CID and store data
                     let cid = self.storage.put(&cbor).await?;
···
                     // Validate prev if provided
                     if let Some(prev_cid) = prev {
                         if &cid != prev_cid {
-                            return Err(crate::error::RepoError::invalid(format!(
+                            return Err(RepoError::invalid(format!(
                                 "Update prev CID mismatch for key {}: expected {}, got {}",
                                 key, prev_cid, cid
                             )));
···
                     let key = format_smolstr!("{}/{}", collection.as_ref(), rkey.as_ref());
 
                     // Check exists
-                    let current = self.mst.get(key.as_str()).await?.ok_or_else(|| {
-                        crate::error::RepoError::not_found("record", key.as_str())
-                    })?;
+                    let current = self
+                        .mst
+                        .get(key.as_str())
+                        .await?
+                        .ok_or_else(|| RepoError::not_found("record", key.as_str()))?;
 
                     // Validate prev if provided
                     if let Some(prev_cid) = prev {
                         if &current != prev_cid {
-                            return Err(crate::error::RepoError::invalid(format!(
+                            return Err(RepoError::invalid(format!(
                                 "Delete prev CID mismatch for key {}: expected {}, got {}",
                                 key, prev_cid, current
                             )));
···
     /// Returns `(ops, CommitData)` - ops are needed for `to_firehose_commit()`.
     pub async fn create_commit<K>(
         &mut self,
-        ops: &[crate::mst::RecordWriteOp<'_>],
+        ops: &[RecordWriteOp<'_>],
         did: &Did<'_>,
         prev: Option<IpldCid>,
         signing_key: &K,
-    ) -> Result<(Vec<crate::commit::firehose::RepoOp<'static>>, CommitData)>
+    ) -> Result<(Vec<RepoOp<'static>>, CommitData)>
     where
-        K: crate::commit::SigningKey,
+        K: SigningKey,
     {
-        use crate::mst::RecordWriteOp;
-        use smol_str::format_smolstr;
-
         // Step 1: Apply all write operations to build new MST
         let mut updated_tree = self.mst.clone();
 
···
 
                     // Serialize record to DAG-CBOR
                     let cbor = serde_ipld_dagcbor::to_vec(record)
-                        .map_err(|e| crate::error::RepoError::serialization(e))?;
+                        .map_err(|e| RepoError::serialization(e))?;
 
                     // Compute CID and store data
                     let cid = self.storage.put(&cbor).await?;
···
 
                     // Serialize record to DAG-CBOR
                     let cbor = serde_ipld_dagcbor::to_vec(record)
-                        .map_err(|e| crate::error::RepoError::serialization(e))?;
+                        .map_err(|e| RepoError::serialization(e))?;
 
                     // Compute CID and store data
                     let cid = self.storage.put(&cbor).await?;
···
                     // Validate prev if provided
                     if let Some(prev_cid) = prev {
                         if &cid != prev_cid {
-                            return Err(crate::error::RepoError::invalid(format!(
+                            return Err(RepoError::invalid(format!(
                                 "Update prev CID mismatch for key {}: expected {}, got {}",
                                 key, prev_cid, cid
                             )));
···
                     let key = format_smolstr!("{}/{}", collection.as_ref(), rkey.as_ref());
 
                     // Check exists
-                    let current = self.mst.get(key.as_str()).await?.ok_or_else(|| {
-                        crate::error::RepoError::not_found("record", key.as_str())
-                    })?;
+                    let current = self
+                        .mst
+                        .get(key.as_str())
+                        .await?
+                        .ok_or_else(|| RepoError::not_found("record", key.as_str()))?;
 
                     // Validate prev if provided
                     if let Some(prev_cid) = prev {
                         if &current != prev_cid {
-                            return Err(crate::error::RepoError::invalid(format!(
+                            return Err(RepoError::invalid(format!(
                                 "Delete prev CID mismatch for key {}: expected {}, got {}",
                                 key, prev_cid, current
                             )));
···
             .storage
             .get(&commit_cid)
             .await?
-            .ok_or_else(|| crate::error::RepoError::not_found("commit block", &commit_cid))?;
+            .ok_or_else(|| RepoError::not_found("commit block", &commit_cid))?;
         let commit = Commit::from_cbor(&commit_bytes)?;
 
         self.commit = commit.into_static();
···
         did: &Did<'_>,
         prev: Option<IpldCid>,
         signing_key: &K,
-    ) -> Result<(Vec<crate::commit::firehose::RepoOp<'static>>, IpldCid)>
+    ) -> Result<(Vec<RepoOp<'static>>, IpldCid)>
     where
-        K: crate::commit::SigningKey,
+        K: SigningKey,
     {
         let (ops, commit_data) = self.create_commit(&[], did, prev, signing_key).await?;
         Ok((ops, self.apply_commit(commit_data).await?))
···
 
 #[cfg(test)]
 mod tests {
-    use std::str::FromStr;
+    use std::{collections::BTreeMap, str::FromStr};
 
     use super::*;
     use crate::storage::MemoryBlockStore;
-    use jacquard_common::types::recordkey::Rkey;
+    use jacquard_common::types::{
+        crypto::{KeyCodec, PublicKey},
+        recordkey::Rkey,
+        value::RawData,
+    };
     use smol_str::SmolStr;
 
     fn make_test_cid(value: u8) -> IpldCid {
···
         IpldCid::new_v1(DAG_CBOR_CID_CODEC, mh)
     }
 
-    fn make_test_record(
-        n: u32,
-    ) -> std::collections::BTreeMap<SmolStr, jacquard_common::types::value::RawData<'static>> {
-        use jacquard_common::types::value::RawData;
-        use smol_str::SmolStr;
-
-        let mut record = std::collections::BTreeMap::new();
+    fn make_test_record(n: u32) -> BTreeMap<SmolStr, RawData<'static>> {
+        let mut record = BTreeMap::new();
         record.insert(
             SmolStr::new("$type"),
             RawData::String("app.bsky.feed.post".into()),
···
 
     #[tokio::test]
     async fn test_commit_signature_verification() {
-        use jacquard_common::types::crypto::{KeyCodec, PublicKey};
-
         let storage = Arc::new(MemoryBlockStore::new());
         let mut repo = create_test_repo(storage.clone()).await;
 
···
 
         // Verify we can deserialize the record data
         let record1_bytes = commit_data.blocks.get(&cid1).unwrap();
-        let record1: std::collections::BTreeMap<SmolStr, jacquard_common::types::value::RawData> =
+        let record1: BTreeMap<SmolStr, RawData> =
             serde_ipld_dagcbor::from_slice(record1_bytes).unwrap();
         assert_eq!(
             record1.get(&SmolStr::new("text")).unwrap(),

crates/jacquard-repo/src/storage/layered.rs

···
         self.base.has(cid).await
     }
 
-    async fn put_many(&self, blocks: impl IntoIterator<Item = (IpldCid, Bytes)> + Send) -> Result<()> {
+    async fn put_many(
+        &self,
+        blocks: impl IntoIterator<Item = (IpldCid, Bytes)> + Send,
+    ) -> Result<()> {
         // All writes go to writable layer
         self.writable.put_many(blocks).await
     }
···
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+
     use super::*;
     use crate::storage::MemoryBlockStore;
 
     #[tokio::test]
     async fn test_layered_read_from_writable() {
-        let base = std::sync::Arc::new(MemoryBlockStore::new());
+        let base = Arc::new(MemoryBlockStore::new());
         let writable = MemoryBlockStore::new();
 
         // Put data in writable layer
···
 
     #[tokio::test]
     async fn test_layered_fallback_to_base() {
-        let base = std::sync::Arc::new(MemoryBlockStore::new());
+        let base = Arc::new(MemoryBlockStore::new());
         let writable = MemoryBlockStore::new();
 
         // Put data in base layer
···
 
     #[tokio::test]
     async fn test_layered_writable_overrides_base() {
-        let base = std::sync::Arc::new(MemoryBlockStore::new());
+        let base = Arc::new(MemoryBlockStore::new());
         let writable = MemoryBlockStore::new();
 
         // Put same content in both layers (will have same CID)
···
 
     #[tokio::test]
     async fn test_layered_writes_to_writable_only() {
-        let base = std::sync::Arc::new(MemoryBlockStore::new());
+        let base = Arc::new(MemoryBlockStore::new());
         let writable = MemoryBlockStore::new();
 
         let layered = LayeredBlockStore::new(writable.clone(), base.clone());
···
 
     #[tokio::test]
     async fn test_layered_has_checks_both_layers() {
-        let base = std::sync::Arc::new(MemoryBlockStore::new());
+        let base = Arc::new(MemoryBlockStore::new());
         let writable = MemoryBlockStore::new();
 
         let base_cid = base.put(b"base").await.unwrap();

crates/jacquard-repo/src/storage/mod.rs

···
 //! Block storage abstraction for MST nodes and records
 
+use crate::{error::Result, repo::CommitData};
 use bytes::Bytes;
 use cid::Cid as IpldCid;
-use crate::error::Result;
 
 /// Async block storage trait
 ///
···
     ///
     /// The provided CIDs should match the data, but implementations may choose to
     /// recalculate and validate them.
-    async fn put_many(&self, blocks: impl IntoIterator<Item = (IpldCid, Bytes)> + Send) -> Result<()>;
+    async fn put_many(
+        &self,
+        blocks: impl IntoIterator<Item = (IpldCid, Bytes)> + Send,
+    ) -> Result<()>;
 
     /// Get multiple blocks at once (optimization for batch reads)
     ///
···
     /// This should be atomic where possible - either both operations succeed or both fail.
     /// For implementations that don't support atomic operations, writes should happen first,
     /// then deletes.
-    async fn apply_commit(&self, commit: crate::repo::CommitData) -> Result<()>;
+    async fn apply_commit(&self, commit: CommitData) -> Result<()>;
 }
 
 pub mod file;