derive some clones and impl Processable for things

Cargo.lock

···
 
 [[package]]
 name = "repo-stream"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "bincode",
  "clap",

Cargo.toml

···
 [package]
 name = "repo-stream"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 description = "A robust CAR file -> MST walker for atproto"

src/disk.rs

···
 }
 
 /// Builder-style disk store setup
+#[derive(Debug, Clone)]
 pub struct DiskBuilder {
     /// Database in-memory cache allowance
     ///
···
         self
     }
     /// Open and initialize the actual disk storage
-    pub async fn open(self, path: PathBuf) -> Result<DiskStore, DiskError> {
+    pub async fn open(&self, path: PathBuf) -> Result<DiskStore, DiskError> {
         DiskStore::new(path, self.cache_size_mb, self.max_stored_mb).await
     }
 }

src/drive.rs

···
 }
 
 /// Builder-style driver setup
+#[derive(Debug, Clone)]
 pub struct DriverBuilder {
     pub mem_limit_mb: usize,
 }
···
     }
     /// Begin processing an atproto MST from a CAR file
     pub async fn load_car<R: AsyncRead + Unpin>(
-        self,
+        &self,
         reader: R,
     ) -> Result<Driver<R, Vec<u8>>, DriveError> {
         Driver::load_car(reader, crate::process::noop, self.mem_limit_mb).await
···
 /// Builder-style driver intermediate step
 ///
 /// start from `DriverBuilder`
+#[derive(Debug, Clone)]
 pub struct DriverBuilderWithProcessor<T: Processable> {
     pub mem_limit_mb: usize,
     pub block_processor: fn(Vec<u8>) -> T,
···
     }
     /// Begin processing an atproto MST from a CAR file
     pub async fn load_car<R: AsyncRead + Unpin>(
-        self,
+        &self,
         reader: R,
     ) -> Result<Driver<R, T>, DriveError> {
         Driver::load_car(reader, self.block_processor, self.mem_limit_mb).await

src/lib.rs

···
 pub mod process;
 
 pub use disk::{DiskBuilder, DiskError, DiskStore};
-pub use drive::{DriveError, Driver, DriverBuilder};
+pub use drive::{DriveError, Driver, DriverBuilder, NeedDisk};
 pub use mst::Commit;
 pub use process::Processable;

src/process.rs

···
         direct_size + items_referenced_size
     }
 }
+
+impl<Item: Processable> Processable for Option<Item> {
+    fn get_size(&self) -> usize {
+        self.as_ref().map(|item| item.get_size()).unwrap_or(0)
+    }
+}
+
+impl<Item: Processable, Error: Processable> Processable for Result<Item, Error> {
+    fn get_size(&self) -> usize {
+        match self {
+            Ok(item) => item.get_size(),
+            Err(err) => err.get_size(),
+        }
+    }
+}