SMB: Add real-time progress for file transfers

- Add `export_to_local_with_progress` and `import_from_local_with_progress` to Volume trait (default delegates to non-progress version)
- SmbVolume overrides both using smb2's `read_file_with_progress` / `write_file_with_progress` with pipelined I/O
- `copy_single_path` and `copy_volumes_with_progress` wired to pass progress callback through to Volume methods
- Progress callback uses `AtomicU64` + `Cell<Instant>` for throttled Tauri event emission (satisfies `Fn` constraint)
- Cancellation flows via `ControlFlow::Break` from callback → smb2 stops transfer
- Update smb2 dependency to latest (adds `read_file_with_progress`)

Author: vdavid

Cargo.lock

@@ -43,6 +43,7 @@ Optional methods default to `Err(VolumeError::NotSupported)` or `false`, so new
 - `smb_connection_state()` — returns `Some(SmbConnectionState)` for SMB volumes (green/yellow indicator in volume picker). Default `None`. Only `SmbVolume` implements it.
 - `on_unmount()` — lifecycle hook called before unregistration. `SmbVolume` uses it to disconnect its smb2 session. Default is no-op.
 - `scanner()` / `watcher()` — drive indexing hooks; `None` by default.
+- `export_to_local_with_progress()` / `import_from_local_with_progress()` — per-file progress callbacks during copy. Default delegates to the non-progress version. `SmbVolume` overrides both, using smb2's `read_file_with_progress`/`write_file_with_progress`. The callback takes `(bytes_done, bytes_total)` for the current file and returns `ControlFlow::Break(())` to cancel. `MtpVolume` and `LocalPosixVolume` use the default (no intra-file progress).
 
 ## Path handling gotchas
 
@@ -141,6 +142,9 @@ provides a manual upgrade path.
 **Gotcha**: Watcher filenames are NFC (from server) but macOS mount paths are NFD
 **Why**: SMB servers return NFC-normalized filenames. macOS filesystem paths use NFD. The watcher NFD-normalizes filenames before constructing display paths used for cache lookups.
 
+**Decision**: Progress callbacks use `&dyn Fn(u64, u64) -> ControlFlow<()>`, not `FnMut`
+**Why**: The Volume trait is object-safe (`dyn Volume`), so callbacks must be `Fn` (not `FnMut`). Callers use `AtomicU64` for byte counters and `Cell<Instant>` for timestamps to mutate state inside a `Fn` closure. This avoids needing `RefCell` or `Mutex` in the hot path.
+
 ## Testing
 
 - `in_memory_test.rs` — unit tests for `InMemoryVolume` (CRUD, sorting, concurrency, stress 50k entries)

apps/desktop/src-tauri/src/file_system/volume/CLAUDE.md

@@ -397,6 +397,21 @@ pub trait Volume: Send + Sync {
         Err(VolumeError::NotSupported)
     }
 
+    /// Exports a file from this volume to a local path, reporting progress.
+    ///
+    /// `on_progress(bytes_done, bytes_total)` is called periodically during the transfer.
+    /// Return `ControlFlow::Break(())` from the callback to cancel the transfer.
+    /// Default implementation delegates to `export_to_local` (no per-file progress).
+    fn export_to_local_with_progress(
+        &self,
+        source: &Path,
+        local_dest: &Path,
+        on_progress: &dyn Fn(u64, u64) -> std::ops::ControlFlow<()>,
+    ) -> Result<u64, VolumeError> {
+        let _ = on_progress;
+        self.export_to_local(source, local_dest)
+    }
+
     /// Imports/uploads a file or directory from a local path to this volume.
     /// For local volumes, this is a file copy. For MTP, this uploads.
     /// Returns bytes transferred.
@@ -405,6 +420,21 @@ pub trait Volume: Send + Sync {
         Err(VolumeError::NotSupported)
     }
 
+    /// Imports a file from a local path to this volume, reporting progress.
+    ///
+    /// `on_progress(bytes_done, bytes_total)` is called periodically during the transfer.
+    /// Return `ControlFlow::Break(())` from the callback to cancel the transfer.
+    /// Default implementation delegates to `import_from_local` (no per-file progress).
+    fn import_from_local_with_progress(
+        &self,
+        local_source: &Path,
+        dest: &Path,
+        on_progress: &dyn Fn(u64, u64) -> std::ops::ControlFlow<()>,
+    ) -> Result<u64, VolumeError> {
+        let _ = on_progress;
+        self.import_from_local(local_source, dest)
+    }
+
     /// Checks destination for conflicts with source items.
     /// Returns list of files that already exist at destination.
     fn scan_for_conflicts(