Transfer dialog: surface folder merges, decouple conflict check

- Folder collisions classify as a silent merge, not a conflict: the upfront `TransferDialog` shows an informational line ("N folders will merge with existing folders") instead of counting them toward the conflict radios. A type mismatch (file vs same-named folder) stays a real conflict on the red-warning path.
- The cheap top-level conflict check now runs on mount in parallel with the (slow) scan preview, assigned before the auto-confirm branch so the MCP fast path dispatches with `conflictNames` populated. Conflict info appears as soon as the one dest listing returns, not after the recursive byte scan.
- `scan_volume_for_conflicts` optionally takes the source volume id + source paths and resolves each item's real `is_directory` + size authoritatively on the source volume via ONE batched `scan_for_copy_batch` (O(top-level items), never a subtree walk), replacing the FE's name-only placeholders. Back-compatible when omitted; regenerated typed bindings.
- Dir-dir merge names never enter the file bulk-skip set ("Skip all" no longer skips a folder wholesale); a type mismatch under "Overwrite all" shows the existing red warning so the bulk path isn't quieter than the per-file dialog.
- Tests: backend batch-merge unit + the bulk-skip-excludes-merging-dir pin (seen red first), FE component tests for parallel render / merge classification / bulk-skip forwarding / cross-type warning / auto-confirm payload, a11y siblings for the new UI states, and an IPC contract test pinning the new 5-arg wire shape.

Author: vdavid

apps/desktop/src-tauri/src/commands/CLAUDE.md

@@ -9,7 +9,7 @@ immediately to business-logic modules. No significant logic lives here.
 |------|--------|-------|
 | `mod.rs` | Re-exports | `mtp`, `network` gated behind `#[cfg(any(target_os = "macos", target_os = "linux"))]`; `volumes` behind `#[cfg(target_os = "macos")]`; `volumes_linux` behind `#[cfg(target_os = "linux")]` |
 | `util.rs` | Shared helpers | `TimedOut<T>`, `IpcError`, `blocking_with_timeout`, `blocking_with_timeout_flag`, `blocking_result_with_timeout`. See "Timeout-aware return types" below. |
-| `file_system/` | File listing & writes | Directory module split by operation type. `mod.rs` has `expand_tilde()`, re-exports, and tests. `listing.rs`: streaming + virtual-scroll listing API, path queries, `find_first_fuzzy_match` (type-to-jump), benchmarking, `get_brief_column_text_widths` (per-column widest-filename text widths for Brief mode; replaces the removed `get_max_filename_width`). `refresh_listing` short-circuits on watcher-backed listings (`Volume::listing_is_watched(path) == true`): the cache is already kept fresh by `notify_mutation`, so a redundant full re-read after every transfer outcome (the FE's `refreshPanesAfterTransfer`) used to wedge slow volumes (MTP 17 s + USB session collision). Logs at debug `target: "refresh_listing"` when the short-circuit fires. `write_ops.rs`: create, copy, move, delete, trash, scan preview, conflict resolution, synthetic diff helpers. `volume_copy.rs`: cross-volume copy/move/scan, `SourceItemInput`. `drag.rs`: native drag, self-drag overlay. `e2e_support.rs`: feature-gated E2E/debug commands. |
+| `file_system/` | File listing & writes | Directory module split by operation type. `mod.rs` has `expand_tilde()`, re-exports, and tests. `listing.rs`: streaming + virtual-scroll listing API, path queries, `find_first_fuzzy_match` (type-to-jump), benchmarking, `get_brief_column_text_widths` (per-column widest-filename text widths for Brief mode; replaces the removed `get_max_filename_width`). `refresh_listing` short-circuits on watcher-backed listings (`Volume::listing_is_watched(path) == true`): the cache is already kept fresh by `notify_mutation`, so a redundant full re-read after every transfer outcome (the FE's `refreshPanesAfterTransfer`) used to wedge slow volumes (MTP 17 s + USB session collision). Logs at debug `target: "refresh_listing"` when the short-circuit fires. `write_ops.rs`: create, copy, move, delete, trash, scan preview, conflict resolution, synthetic diff helpers. `volume_copy.rs`: cross-volume copy/move/scan, `SourceItemInput`. `scan_volume_for_conflicts` optionally takes a source volume id + source paths and resolves each item's real `is_directory` + size from the source volume via ONE batched `scan_for_copy_batch` (O(top-level items), never a subtree walk), overriding the FE's name-only placeholders so dir-vs-dir collisions classify as silent merges; back-compatible when omitted. `drag.rs`: native drag, self-drag overlay. `e2e_support.rs`: feature-gated E2E/debug commands. |
 | `volumes.rs` | Volume management (macOS) | `list_volumes`, `get_default_volume_id`, `get_volume_space`, `resolve_path_volume` (statfs-based, no volume enumeration) |
 | `volumes_linux.rs` | Volume management (Linux) | Same interface as `volumes.rs`, delegates to `volumes_linux` module |
 | `mtp.rs` | MTP devices | Full MTP command surface (connect, disconnect, list, download, upload, delete, rename, move, scan) |

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

@@ -129,18 +129,28 @@ pub async fn scan_volume_for_copy(
 }
 
 /// Checks which source items already exist at the destination. Returns conflict details for UI.
+///
+/// When `source_volume_id` and `source_paths` are both provided, each item's
+/// `is_directory` and `size` are resolved authoritatively on the source volume
+/// via ONE batched stat (`scan_for_copy_batch`, strictly O(top-level items),
+/// never a subtree walk), overriding whatever the caller passed in `source_items`.
+/// This lets the dialog classify dir-vs-dir collisions as silent merges without
+/// the FE having to plumb per-item types. Callers that don't pass the source
+/// volume keep the legacy name-only behavior.
 #[tauri::command]
 #[specta::specta]
 pub async fn scan_volume_for_conflicts(
     volume_id: String,
     source_items: Vec<SourceItemInput>,
     dest_path: String,
+    source_volume_id: Option<String>,
+    source_paths: Option<Vec<String>>,
 ) -> Result<Vec<ScanConflict>, IpcError> {
     let volume = get_volume_manager()
         .get(&volume_id)
         .ok_or_else(|| IpcError::from_err(format!("Volume '{}' not found", volume_id)))?;
 
-    let source_items: Vec<crate::file_system::SourceItemInfo> = source_items
+    let mut source_items: Vec<crate::file_system::SourceItemInfo> = source_items
         .into_iter()
         .map(|item| crate::file_system::SourceItemInfo {
             name: item.name,
@@ -149,6 +159,26 @@ pub async fn scan_volume_for_conflicts(
             is_directory: item.is_directory,
         })
         .collect();
+
+    // Resolve real per-item types and sizes from the source volume when the
+    // caller supplied it. One batched stat, O(top-level items).
+    if let (Some(src_volume_id), Some(src_paths)) = (source_volume_id, source_paths)
+        && let Some(src_volume) = get_volume_manager().get(&src_volume_id) {
+            let paths: Vec<PathBuf> = src_paths.iter().map(PathBuf::from).collect();
+            match tokio::time::timeout(Duration::from_secs(30), src_volume.scan_for_copy_batch(&paths)).await {
+                Ok(Ok(batch)) => merge_source_types_from_batch(&mut source_items, &batch),
+                // A failed source-side stat is non-fatal: fall back to the
+                // name-only items the caller sent. Conflict detection still
+                // works by name; only the dir/size hints degrade.
+                Ok(Err(e)) => {
+                    log::debug!(target: "conflict_scan", "Source batch stat failed, using name-only items: {}", e);
+                }
+                Err(_) => {
+                    log::debug!(target: "conflict_scan", "Source batch stat timed out, using name-only items");
+                }
+            }
+        }
+
     let dest_path = PathBuf::from(dest_path);
 
     // Run conflict scan (now async)
@@ -161,6 +191,35 @@ pub async fn scan_volume_for_conflicts(
     .map_err(|e| IpcError::from_err(e.to_string()))
 }
 
+/// Overlays authoritative `is_directory` + `size` from a source-volume batch
+/// stat onto the caller-supplied `source_items`, matched by base filename.
+///
+/// The match key is the path's final component, which is exactly the `name`
+/// the FE derives for each `SourceItemInput`. An item with no batch hit keeps
+/// the values the caller sent (the safe fallback). For a top-level directory
+/// the batch's `total_bytes` is the recursive size, which we deliberately do
+/// NOT copy into `size` — a directory's conflict-UI size is meaningless and the
+/// dir-dir case never renders a size. Only files get their real size.
+fn merge_source_types_from_batch(
+    source_items: &mut [crate::file_system::SourceItemInfo],
+    batch: &crate::file_system::BatchScanResult,
+) {
+    use std::collections::HashMap;
+    let by_name: HashMap<&str, &crate::file_system::CopyScanResult> = batch
+        .per_path
+        .iter()
+        .filter_map(|(path, scan)| path.file_name().and_then(|n| n.to_str()).map(|n| (n, scan)))
+        .collect();
+    for item in source_items.iter_mut() {
+        if let Some(scan) = by_name.get(item.name.as_str()) {
+            item.is_directory = scan.top_level_is_directory;
+            if !scan.top_level_is_directory {
+                item.size = scan.total_bytes;
+            }
+        }
+    }
+}
+
 /// Input type for source item information (used by scan_volume_for_conflicts).
 #[derive(Debug, Clone, serde::Deserialize, specta::Type)]
 #[serde(rename_all = "camelCase")]
@@ -177,3 +236,73 @@ pub struct SourceItemInput {
     #[serde(default)]
     pub is_directory: bool,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::merge_source_types_from_batch;
+    use crate::file_system::{BatchScanResult, CopyScanResult, SourceItemInfo};
+    use std::path::PathBuf;
+
+    fn scan(is_dir: bool, bytes: u64) -> CopyScanResult {
+        CopyScanResult {
+            file_count: if is_dir { 0 } else { 1 },
+            dir_count: if is_dir { 1 } else { 0 },
+            total_bytes: bytes,
+            dedup_bytes: bytes,
+            top_level_is_directory: is_dir,
+        }
+    }
+
+    fn item(name: &str) -> SourceItemInfo {
+        SourceItemInfo {
+            name: name.to_string(),
+            size: 0,
+            modified: None,
+            is_directory: false,
+        }
+    }
+
+    #[test]
+    fn overlays_real_directory_flag_onto_placeholder_items() {
+        let mut items = vec![item("photos"), item("readme.txt")];
+        let batch = BatchScanResult {
+            aggregate: scan(false, 0),
+            per_path: vec![
+                (PathBuf::from("/src/photos"), scan(true, 999_999)),
+                (PathBuf::from("/src/readme.txt"), scan(false, 42)),
+            ],
+        };
+
+        merge_source_types_from_batch(&mut items, &batch);
+
+        // The directory item is now flagged as such; its recursive byte total
+        // is deliberately NOT copied into `size` (a dir's conflict size is
+        // meaningless).
+        assert!(items[0].is_directory);
+        assert_eq!(items[0].size, 0);
+        // The file item gets its real size.
+        assert!(!items[1].is_directory);
+        assert_eq!(items[1].size, 42);
+    }
+
+    #[test]
+    fn keeps_caller_values_when_no_batch_hit() {
+        let mut items = vec![SourceItemInfo {
+            name: "ghost".to_string(),
+            size: 7,
+            modified: Some(123),
+            is_directory: true,
+        }];
+        let batch = BatchScanResult {
+            aggregate: scan(false, 0),
+            per_path: vec![(PathBuf::from("/src/other"), scan(false, 1))],
+        };
+
+        merge_source_types_from_batch(&mut items, &batch);
+
+        // No matching name → the caller's values survive untouched.
+        assert!(items[0].is_directory);
+        assert_eq!(items[0].size, 7);
+        assert_eq!(items[0].modified, Some(123));
+    }
+}

apps/desktop/src-tauri/src/file_system/mod.rs

@@ -50,8 +50,8 @@ pub use volume::SmbVolume;
 pub use volume::manager::VolumeManager;
 #[allow(unused_imports, reason = "Public API re-exports for future use")]
 pub use volume::{
-    CopyScanResult, InMemoryVolume, LocalPosixVolume, MutationEvent, ScanConflict, SourceItemInfo, SpaceInfo, Volume,
-    VolumeError,
+    BatchScanResult, CopyScanResult, InMemoryVolume, LocalPosixVolume, MutationEvent, ScanConflict, SourceItemInfo,
+    SpaceInfo, Volume, VolumeError,
 };
 // Watcher management - init_watcher_manager must be called from lib.rs
 #[cfg(feature = "playwright-e2e")]

apps/desktop/src-tauri/src/file_system/write_operations/transfer/transfer_driver_tests.rs

@@ -199,6 +199,36 @@ fn build_pre_skip_set_excludes_known_directory_paths() {
     );
 }
 
+/// A dir-vs-dir collision (a source folder landing on a same-named dest folder)
+/// must NEVER enter the file bulk-skip set, even under `Skip all`. Folders
+/// always merge; "Skip all" governs the clashing FILES inside the merge, not
+/// the folder wholesale. The upfront FE forwards the folder's name as a
+/// pre-known conflict, but the preflight scan also reports it via
+/// `known_directory_paths`, so it falls through to per-child resolution. This
+/// pins that the merge-not-skip-wholesale semantics hold at the bulk-skip gate.
+#[test]
+fn build_pre_skip_set_never_bulk_skips_a_merging_directory() {
+    let sources = paths(&["/photos", "/notes.txt"]);
+    let mut known_dirs = HashSet::new();
+    // `/photos` is a directory (a dir-dir merge at the destination).
+    known_dirs.insert(PathBuf::from("/photos"));
+    let set = build_pre_skip_set(
+        &sources,
+        ConflictResolution::Skip,
+        // Both names arrive as pre-known conflicts from the FE.
+        &["photos".into(), "notes.txt".into()],
+        &known_dirs,
+    );
+    // Only the file is bulk-skipped; the merging folder is left to per-child
+    // resolution so its non-clashing children still copy.
+    assert_eq!(set.len(), 1);
+    assert!(set.contains(&PathBuf::from("/notes.txt")));
+    assert!(
+        !set.contains(&PathBuf::from("/photos")),
+        "a merging directory must never be bulk-skipped wholesale"
+    );
+}
+
 // ===========================================================================
 // Sync driver: data-safety
 // ===========================================================================

apps/desktop/src/lib/file-operations/transfer/CLAUDE.md

@@ -41,6 +41,22 @@ for the shared state machine, ETA/throughput, and settle contract.
      "Ask later" since a single conflict can't be asked "for each". The conditional policies map to the typed
      `ConflictResolution` variants `overwrite_smaller` / `overwrite_older`. See the BE doc § "Key patterns and gotchas
      (shared)" for the strict-comparison / fail-closed contract.
+   - **Folders always merge; the upfront check classifies collisions.** `checkConflicts()` runs on mount **in parallel
+     with the scan preview** (it's one cheap dest listing, not the recursive byte scan — `conflictCheckPromise` is
+     assigned synchronously in `onMount` BEFORE the auto-confirm branch so the MCP fast path dispatches with
+     `conflictNames` populated). Each collision is classified by the backend-resolved `sourceIsDirectory` /
+     `destIsDirectory` flags (the BE resolves real per-item types + sizes from the source volume via one batched stat
+     when `checkConflicts` passes `sourceVolumeId` + `sourcePaths`):
+     - **dir + dir** → a silent merge, NOT a conflict. Surfaced as an informational line ("N folders will merge with
+       existing folders"); never counted in `totalConflictCount`; never forwarded as a bulk-skip name (a merging folder
+       must not be skipped wholesale).
+     - **file + file / cross-type (file↔folder)** → a real conflict. Counts toward `totalConflictCount` and feeds the
+       `preKnownConflicts` bulk-skip list.
+     - The file-policy radios show when there's a real conflict OR a folder merge — a merge can surface file clashes
+       mid-operation the upfront (top-level-only) check can't see, and the radios pre-answer them.
+     - **Cross-type guardrail.** When a real conflict is a type mismatch AND the user selects "Overwrite all", a red
+       warning appears (mirrors the per-file dialog's file→folder warning): overwriting replaces items of a different
+       type, including folder contents.
 
 2. **TransferProgressDialog** (operation execution)
    - If `scanInProgress`, subscribes to scan preview events (`scan-preview-progress`, `scan-preview-complete`, etc.) to

apps/desktop/src/lib/file-operations/transfer/TransferDialog.a11y.test.ts

@@ -11,8 +11,13 @@
 import { describe, it, vi } from 'vitest'
 import { mount, tick } from 'svelte'
 import TransferDialog from './TransferDialog.svelte'
+import type { VolumeConflictInfo } from '$lib/tauri-commands'
 import { expectNoA11yViolations } from '$lib/test-a11y'
 
+// Mutable per-test result for the conflict scan, so the merge-info and
+// cross-type-warning a11y cases can drive specific collision shapes.
+let conflictResult: VolumeConflictInfo[] = []
+
 vi.mock('$lib/tauri-commands', () => ({
   notifyDialogOpened: vi.fn(() => Promise.resolve()),
   notifyDialogClosed: vi.fn(() => Promise.resolve()),
@@ -27,7 +32,7 @@ vi.mock('$lib/tauri-commands', () => ({
   onScanPreviewComplete: vi.fn(() => Promise.resolve(() => {})),
   onScanPreviewError: vi.fn(() => Promise.resolve(() => {})),
   onScanPreviewCancelled: vi.fn(() => Promise.resolve(() => {})),
-  scanVolumeForConflicts: vi.fn(() => Promise.resolve([])),
+  scanVolumeForConflicts: vi.fn(() => Promise.resolve(conflictResult)),
   DEFAULT_VOLUME_ID: 'root',
 }))
 
@@ -94,4 +99,93 @@ describe('TransferDialog a11y', () => {
     await tick()
     await expectNoA11yViolations(target)
   })
+
+  it('dialog with a folder-merge info line has no a11y violations', async () => {
+    conflictResult = [
+      {
+        sourcePath: 'photos',
+        destPath: 'photos',
+        sourceSize: 0,
+        destSize: 0,
+        sourceModified: null,
+        destModified: null,
+        sourceIsDirectory: true,
+        destIsDirectory: true,
+      },
+    ]
+    const target = document.createElement('div')
+    document.body.appendChild(target)
+    mount(TransferDialog, {
+      target,
+      props: {
+        operationType: 'copy',
+        sourcePaths: ['/Users/test/photos'],
+        destinationPath: '/Users/test/dest',
+        direction: 'right',
+        currentVolumeId: 'root',
+        fileCount: 0,
+        folderCount: 1,
+        sourceFolderPath: '/Users/test',
+        sortColumn: 'name',
+        sortOrder: 'ascending',
+        sourceVolumeId: 'root',
+        destVolumeId: 'root',
+        onConfirm: () => {},
+        onCancel: () => {},
+      },
+    })
+    // Let the parallel conflict check resolve so the merge line renders.
+    for (let i = 0; i < 6; i++) {
+      await new Promise<void>((resolve) => setTimeout(resolve, 0))
+      await tick()
+    }
+    await expectNoA11yViolations(target)
+    conflictResult = []
+  })
+
+  it('dialog with the cross-type Overwrite-all warning has no a11y violations', async () => {
+    conflictResult = [
+      {
+        sourcePath: 'photos',
+        destPath: 'photos',
+        sourceSize: 0,
+        destSize: 0,
+        sourceModified: null,
+        destModified: null,
+        sourceIsDirectory: false,
+        destIsDirectory: true,
+      },
+    ]
+    const target = document.createElement('div')
+    document.body.appendChild(target)
+    mount(TransferDialog, {
+      target,
+      props: {
+        operationType: 'copy',
+        sourcePaths: ['/Users/test/photos'],
+        destinationPath: '/Users/test/dest',
+        direction: 'right',
+        currentVolumeId: 'root',
+        fileCount: 1,
+        folderCount: 0,
+        sourceFolderPath: '/Users/test',
+        sortColumn: 'name',
+        sortOrder: 'ascending',
+        sourceVolumeId: 'root',
+        destVolumeId: 'root',
+        onConfirm: () => {},
+        onCancel: () => {},
+      },
+    })
+    for (let i = 0; i < 6; i++) {
+      await new Promise<void>((resolve) => setTimeout(resolve, 0))
+      await tick()
+    }
+    // Select Overwrite all to surface the red warning, then assert clean a11y.
+    const overwrite = target.querySelector<HTMLInputElement>('input[type="radio"][value="overwrite"]')
+    overwrite?.click()
+    await tick()
+    await expectNoA11yViolations(target)
+    conflictResult = []
+  })
 })