MTP→SMB copy: kill 2-min stall, speed up scan

- Fix O(n²) in `MtpVolume::scan_for_copy_batch`: build a `HashMap<name, Entry>` per parent listing. 15k photos in one MTP dir went from ~10 s of name-find sweeps to ~50 ms (visible as the "Verifying before copy..." dialog stuck at 0/0/0).
- Stop discarding per-path data after the volume scan preview. `CachedScanResult` now carries `BatchScanResult::per_path`; `copy_volumes_with_progress` seeds its `source_hints` from the cache instead of looping `is_directory` per source. Each MTP `is_directory` lists the parent dir, so 15k sources = 15k sequential parent listings, a ~2-minute stall between scan-complete and copy-start (visible as the dialog stuck on "Scanning" with the final tallies pre-populated and no progress).

Author: vdavid

apps/desktop/src-tauri/src/file_system/volume/mtp.rs

@@ -509,11 +509,19 @@ impl Volume for MtpVolume {
                 let parent_str = parent.to_string_lossy();
                 let entries = self.list_directory(Path::new(parent_str.as_ref()), None).await?;
 
+                // Index entries by name so each child lookup is O(1). A naive
+                // `entries.iter().find(...)` per child is O(n) and the outer
+                // loop is also O(n), so 15k photos in /DCIM/Camera turned a
+                // single parent listing into ~225M string comparisons (~10 s
+                // stall in the scan preview).
+                let entries_by_name: std::collections::HashMap<&str, &FileEntry> =
+                    entries.iter().map(|e| (e.name.as_str(), e)).collect();
+
                 for child_path in children {
                     let mtp_path = self.to_mtp_path(child_path);
                     let name = Path::new(&mtp_path).file_name().and_then(|n| n.to_str()).unwrap_or("");
 
-                    if let Some(entry) = entries.iter().find(|e| e.name == name) {
+                    if let Some(entry) = entries_by_name.get(name).copied() {
                         if entry.is_directory {
                             let scan = self.scan_for_copy(child_path).await?;
                             aggregate.file_count += scan.file_count;

apps/desktop/src-tauri/src/file_system/write_operations/scan.rs

@@ -200,6 +200,7 @@ pub(super) fn take_cached_scan_result(preview_id: &str) -> Option<ScanResult> {
             dirs: cached.dirs,
             file_count: cached.file_count,
             total_bytes: cached.total_bytes,
+            per_path: cached.per_path,
         })
     } else {
         None
@@ -397,6 +398,7 @@ fn scan_sources_internal(
         files,
         dirs,
         total_bytes,
+        per_path: Vec::new(),
     })
 }
 

apps/desktop/src-tauri/src/file_system/write_operations/scan_preview.rs

@@ -18,7 +18,6 @@ use super::types::{
     ScanPreviewStartResult,
 };
 use crate::file_system::listing::{SortColumn, SortOrder};
-use crate::file_system::volume::CopyScanResult;
 use crate::file_system::volume::Volume;
 
 /// Starts a scan preview for the Copy dialog.
@@ -175,6 +174,7 @@ fn run_scan_preview(
                             dirs,
                             file_count,
                             total_bytes,
+                            per_path: Vec::new(),
                         },
                     );
                 }
@@ -211,33 +211,35 @@ async fn run_volume_scan_preview(
 ) {
     use tauri::Emitter;
 
-    let result: Result<CopyScanResult, String> = async {
+    let result: Result<crate::file_system::volume::BatchScanResult, String> = async {
         if state.cancelled.load(Ordering::Relaxed) {
             return Err("Cancelled".to_string());
         }
 
         volume
             .scan_for_copy_batch(&sources)
             .await
-            .map(|b| b.aggregate)
             .map_err(|e| format!("Scan failed: {}", e))
     }
     .await;
 
     // Extract stats from the result for the completion event
     let (total_files, total_dirs, total_bytes) = match &result {
-        Ok(scan) => (scan.file_count, scan.dir_count, scan.total_bytes),
+        Ok(batch) => (
+            batch.aggregate.file_count,
+            batch.aggregate.dir_count,
+            batch.aggregate.total_bytes,
+        ),
         Err(_) => (0, 0, 0),
     };
-    let result = result.map(|_| ());
 
     // Clean up state
     if let Ok(mut cache) = SCAN_PREVIEW_STATE.write() {
         cache.remove(&preview_id);
     }
 
     match result {
-        Ok(()) => {
+        Ok(batch) => {
             if state.cancelled.load(Ordering::Relaxed) {
                 let _ = app.emit(
                     "scan-preview-cancelled",
@@ -246,8 +248,9 @@ async fn run_volume_scan_preview(
                     },
                 );
             } else {
-                // Cache results: volume scans don't produce per-file FileInfo,
-                // but the cache stores aggregate stats that copy_between_volumes can reuse.
+                // Cache results: volume scans don't produce per-file FileInfo, but
+                // the cache stores aggregate stats AND per-path scan results so
+                // copy_between_volumes can reuse both without re-statting.
                 if let Ok(mut cache) = SCAN_PREVIEW_RESULTS.write() {
                     cache.insert(
                         preview_id.clone(),
@@ -256,6 +259,7 @@ async fn run_volume_scan_preview(
                             dirs: Vec::new(),
                             file_count: total_files,
                             total_bytes,
+                            per_path: batch.per_path,
                         },
                     );
                 }

apps/desktop/src-tauri/src/file_system/write_operations/state.rs

@@ -13,6 +13,7 @@ use super::types::{
     ConflictResolution, OperationEventSink, OperationStatus, OperationSummary, WriteOperationPhase, WriteOperationType,
     WriteProgressEvent,
 };
+use crate::file_system::volume::CopyScanResult;
 
 // ============================================================================
 // Operation intent (state machine for cancellation)
@@ -376,6 +377,12 @@ pub(super) struct CachedScanResult {
     pub dirs: Vec<PathBuf>,
     pub file_count: usize,
     pub total_bytes: u64,
+    /// Per-source-path scan results from volume scans. Empty for local-FS
+    /// previews (the `files` Vec already carries everything the local copy
+    /// engine needs). Populated by `run_volume_scan_preview` so the copy
+    /// pipeline's cached branch can rebuild `source_hints` without per-path
+    /// `is_directory` probes (which on MTP each list the parent dir).
+    pub per_path: Vec<(PathBuf, CopyScanResult)>,
 }
 
 /// Global cache for scan preview states.
@@ -461,6 +468,10 @@ pub(super) struct ScanResult {
     /// Not including directories.
     pub file_count: usize,
     pub total_bytes: u64,
+    /// Per-source-path scan results, populated by volume scan previews so the
+    /// copy pipeline can seed `source_hints` without re-statting. Empty for
+    /// local-FS scans.
+    pub per_path: Vec<(PathBuf, CopyScanResult)>,
 }
 
 // ============================================================================

apps/desktop/src-tauri/src/file_system/write_operations/volume_copy.rs

@@ -319,22 +319,30 @@ pub(crate) async fn copy_volumes_with_progress(
         total_files = cached.file_count;
         total_bytes = cached.total_bytes;
         log::debug!(
-            "copy_volumes_with_progress: reused cached scan for operation_id={}, files={}, bytes={}",
+            "copy_volumes_with_progress: reused cached scan for operation_id={}, files={}, bytes={}, per_path={}",
             operation_id,
             total_files,
-            total_bytes
+            total_bytes,
+            cached.per_path.len()
         );
-        // TODO: extend the preview cache to carry per-source type + size so this
-        // branch doesn't need to re-stat. For now, the preview path already saved
-        // one full scan per source, and this extra stat is bounded by source count
-        // and the compound fast-path falls back cleanly when size is unknown.
-        for source_path in source_paths {
-            let is_dir = source_volume.is_directory(source_path).await.unwrap_or(false);
+        // Volume scan previews carry per-path results so we can seed source_hints
+        // directly. Without this, we'd `is_directory` each path here, and on MTP
+        // every `is_directory` lists the parent dir (15k photos in /DCIM/Camera =
+        // 15k sequential parent listings, ~2 min stall before the copy starts).
+        // Local-FS scans don't populate per_path; the unwrap_or default leaves
+        // source_hints empty (the conflict-resolution and SMB compound fast-paths
+        // both fall back cleanly when a hint is missing).
+        for (source_path, scan) in cached.per_path {
+            let size = if scan.top_level_is_directory {
+                0
+            } else {
+                scan.total_bytes
+            };
             source_hints.insert(
-                source_path.clone(),
+                source_path,
                 SourceHint {
-                    is_directory: is_dir,
-                    size: 0,
+                    is_directory: scan.top_level_is_directory,
+                    size,
                 },
             );
         }