Bulk-skip pre-known conflicts under Skip-all for copy and move

TransferDialog already runs a pre-flight `scan_for_conflicts` and surfaces the result as "N files already exist". Previously that information was thrown away once the user clicked Copy: the backend re-discovered each conflict serially via per-file `dest.get_metadata` between (slow) copies, so under Skip-all the progress bar trickled by 1 per conflict instead of jumping to N immediately. For a 1046-file MTP→SMB copy with ~100 scattered conflicts this looked like the bar was stuck for many minutes while iteration crept through copies in between.

Now the FE forwards the full conflicting-name list as `preKnownConflicts` on `VolumeCopyConfig` / `WriteOperationConfig`. The BE builds a `HashSet<PathBuf>` of source paths whose filename matches and, under Skip mode, bulk-accounts them in one shot before the main loop: bumps `files_done`/`bytes_done`, emits one progress event, and the main loop `continue`s past them. Other modes (Stop / Overwrite / Rename) ignore the list — Stop still emits per-file conflict events, Overwrite still overwrites.

Three paths now apply it: `copy_volumes_with_progress` (cross-volume copy), `move_between_volumes` + `move_within_same_volume` (cross-volume / same-volume move), and `copy_files_with_progress` (local↔local copy via the short-circuit in `copy_between_volumes`).

Bundled together because they share the same FE wire and the same data-safety pattern:

- The `continue` is positioned before any destructive call (no `dest` write, no `source.delete()`), so skipped files are untouched on both sides.
- Move-side per-iter `Skip` arm also picks up a latent fix: previously it `continue`d without bumping `files_done`, so the bar stalled through a run of conflicts even when "Skip all" was chosen via Stop's per-file dialog.

`resolve_volume_conflict` now accepts `source_size_hint` / `dest_size_hint`. The copy path supplies real hints (source from `source_hints`, dest from `dest_meta`); the move path passes `None` for source (no scan phase) but supplies the dest hint. Before the hints, an MTP source's `scan_for_copy` listed the whole parent dir per conflict — an 18s stall before the very first conflict prompt on a 1046-file directory.

TransferDialog now displays the true conflict count instead of capping at `maxConflictsToShow` (the cap was only meaningful for the per-row conflict list, which this dialog doesn't actually render). The "100+" misdirection is gone.

Tests (in `volume_copy_tests.rs`):
- `test_pre_known_conflicts_are_bulk_skipped_upfront` — happy path, concurrent loop
- `test_stop_mode_does_not_bulk_skip_pre_known_conflicts` — Stop still emits per-file prompts
- `test_pre_known_conflicts_ignored_outside_skip_mode` — Overwrite proceeds with overwrite
- `test_pre_known_conflicts_with_stale_entries_is_safe` — stale or non-matching names can't crash or skip the wrong files
- `test_pre_known_conflicts_bulk_skip_on_real_local_volumes` — `LocalPosixVolume` on tmpfile (catches `InMemoryVolume`-only assumptions)
- `test_skipped_files_count_toward_progress` — per-iter skip accounting (Bug 2 from earlier in this thread)
- `test_stop_conflict_does_not_rescan_source_when_hint_provided` — size-hint path doesn't re-scan

Author: vdavid

Cargo.lock

@@ -15,7 +15,7 @@ use super::helpers::{
     find_unique_name, is_same_file, resolve_conflict, run_cancellable, spawn_async_sync, validate_disk_space,
     validate_path_length,
 };
-use super::scan::{SourceItemTracker, handle_dry_run, scan_sources, take_cached_scan_result};
+use super::scan::{SourceItemTracker, handle_dry_run, scan_sources, take_cached_scan_result, top_level_source_path};
 use super::state::{
     CopyTransaction, OperationIntent, WriteOperationState, is_cancelled, load_intent, update_operation_status,
 };
@@ -81,7 +81,7 @@ pub(super) fn copy_files_with_progress(
     }
 
     // Phase 1: Scan (or reuse cached preview results)
-    let scan_result = if let Some(preview_id) = &config.preview_id {
+    let mut scan_result = if let Some(preview_id) = &config.preview_id {
         // Try to reuse cached scan results from preview.
         // Volume scans (MTP, etc.) cache aggregate stats only (empty `files` list).
         // This per-file copy path needs the file list, so treat an empty-files cache
@@ -179,6 +179,74 @@ pub(super) fn copy_files_with_progress(
         scan_result.total_bytes,
     );
 
+    // Bulk-skip pre-known conflicts (Skip mode only). For local↔local, the
+    // per-file `get_metadata` is cheap (microseconds), so the user-facing bug
+    // is much milder than the cross-volume case — but we still want the bar
+    // to reflect the user's "Skip all" decision immediately. The set is keyed
+    // by the absolute top-level source path (matching what
+    // `top_level_source_path(file_info)` returns).
+    let pre_skip_top_levels: HashSet<PathBuf> =
+        if config.conflict_resolution == ConflictResolution::Skip && !config.pre_known_conflicts.is_empty() {
+            let names: HashSet<&str> = config.pre_known_conflicts.iter().map(String::as_str).collect();
+            sources
+                .iter()
+                .filter(|p| {
+                    p.file_name()
+                        .and_then(|n| n.to_str())
+                        .map(|n| names.contains(n))
+                        .unwrap_or(false)
+                })
+                .cloned()
+                .collect()
+        } else {
+            HashSet::new()
+        };
+
+    if !pre_skip_top_levels.is_empty() {
+        let mut skipped_count = 0usize;
+        let mut skipped_bytes = 0u64;
+        scan_result.files.retain(|fi| {
+            let top = top_level_source_path(fi);
+            if pre_skip_top_levels.contains(&top) {
+                skipped_count += 1;
+                skipped_bytes += fi.size;
+                false
+            } else {
+                true
+            }
+        });
+        files_done = skipped_count;
+        bytes_done = skipped_bytes;
+        log::info!(
+            "copy_files_with_progress: bulk-skipping {} files ({} bytes) for {} pre-known conflicting top-level sources",
+            skipped_count,
+            skipped_bytes,
+            pre_skip_top_levels.len()
+        );
+        state.emit_progress_via_app(
+            app,
+            WriteProgressEvent::new(
+                operation_id.to_string(),
+                WriteOperationType::Copy,
+                WriteOperationPhase::Copying,
+                None,
+                files_done,
+                scan_result.file_count,
+                bytes_done,
+                scan_result.total_bytes,
+            ),
+        );
+        update_operation_status(
+            operation_id,
+            WriteOperationPhase::Copying,
+            None,
+            files_done,
+            scan_result.file_count,
+            bytes_done,
+            scan_result.total_bytes,
+        );
+    }
+
     log::debug!(
         "copy_files_with_progress: starting copy loop for operation_id={}, {} files",
         operation_id,

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

@@ -567,6 +567,10 @@ pub struct WriteOperationConfig {
     /// Maximum number of conflicts to include in DryRunResult (default: 100)
     #[serde(default = "default_max_conflicts_to_show")]
     pub max_conflicts_to_show: usize,
+    /// Source filenames already known to conflict at the destination. See
+    /// `VolumeCopyConfig::pre_known_conflicts` for the full rationale.
+    #[serde(default)]
+    pub pre_known_conflicts: Vec<String>,
 }
 
 impl Default for WriteOperationConfig {
@@ -580,6 +584,7 @@ impl Default for WriteOperationConfig {
             sort_order: SortOrder::default(),
             preview_id: None,
             max_conflicts_to_show: default_max_conflicts_to_show(),
+            pre_known_conflicts: Vec::new(),
         }
     }
 }
@@ -779,6 +784,16 @@ pub struct VolumeCopyConfig {
     /// Preview scan ID to reuse cached scan results (from start_scan_preview).
     #[serde(default)]
     pub preview_id: Option<String>,
+    /// Source filenames already known to conflict at the destination (from the
+    /// pre-flight `scan_for_conflicts` call). When `conflict_resolution == Skip`,
+    /// the copy pipeline bulk-skips these upfront so the progress bar jumps to
+    /// reflect them immediately, rather than discovering each one serially via
+    /// per-file `get_metadata` stats while non-conflict copies run in between.
+    /// Ignored for other resolution modes (Stop still prompts; Overwrite still
+    /// proceeds normally). Empty if the FE didn't pre-scan or found no
+    /// conflicts.
+    #[serde(default)]
+    pub pre_known_conflicts: Vec<String>,
 }
 
 impl Default for VolumeCopyConfig {
@@ -788,6 +803,7 @@ impl Default for VolumeCopyConfig {
             conflict_resolution: ConflictResolution::Stop,
             max_conflicts_to_show: 100,
             preview_id: None,
+            pre_known_conflicts: Vec::new(),
         }
     }
 }
@@ -799,6 +815,7 @@ impl From<&WriteOperationConfig> for VolumeCopyConfig {
             conflict_resolution: config.conflict_resolution,
             max_conflicts_to_show: config.max_conflicts_to_show,
             preview_id: config.preview_id.clone(),
+            pre_known_conflicts: config.pre_known_conflicts.clone(),
         }
     }
 }

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

@@ -29,6 +29,16 @@ pub(super) async fn resolve_volume_conflict(
     operation_id: &str,
     state: &Arc<WriteOperationState>,
     apply_to_all_resolution: &mut Option<ConflictResolution>,
+    // Size hints for the conflict dialog. `Some` skips a `scan_for_copy` call
+    // on that side. The copy path already has both: source size in
+    // `source_hints` (from the cached preview scan), dest size in `dest_meta`
+    // from the stat just done by the caller. Without these hints, an MTP
+    // source means listing the parent directory of `source_path` to find one
+    // entry's size — 18 s for /DCIM/Camera with 1046 photos when the listing
+    // cache has lapsed. The move path doesn't have a scan phase, so it still
+    // falls through to `scan_for_copy` for unknown hints.
+    source_size_hint: Option<u64>,
+    dest_size_hint: Option<u64>,
 ) -> Result<Option<PathBuf>, WriteOperationError> {
     // Determine effective conflict resolution
     let resolution = if let Some(saved_resolution) = apply_to_all_resolution {
@@ -41,16 +51,24 @@ pub(super) async fn resolve_volume_conflict(
     match resolution {
         ConflictResolution::Stop => {
             // Need to prompt user - gather metadata for the conflict event
-            let source_scan = source_volume.scan_for_copy(source_path).await.ok();
-            let source_size = source_scan.as_ref().map(|s| s.total_bytes).unwrap_or(0);
+            let source_size = if let Some(s) = source_size_hint {
+                s
+            } else {
+                let source_scan = source_volume.scan_for_copy(source_path).await.ok();
+                source_scan.as_ref().map(|s| s.total_bytes).unwrap_or(0)
+            };
 
-            // Try to get destination size by scanning (best effort)
-            let dest_size = dest_volume
-                .scan_for_copy(dest_path)
-                .await
-                .ok()
-                .map(|s| s.total_bytes)
-                .unwrap_or(0);
+            // Try to get destination size; prefer the hint to avoid a scan.
+            let dest_size = if let Some(s) = dest_size_hint {
+                s
+            } else {
+                dest_volume
+                    .scan_for_copy(dest_path)
+                    .await
+                    .ok()
+                    .map(|s| s.total_bytes)
+                    .unwrap_or(0)
+            };
 
             // We can't easily get modification times from Volume trait, so use None
             let source_modified: Option<i64> = None;