Move dialog: restore the Size progress bar

- Cross-volume move (e.g. MTP→local) was shipping `bytes_total = 0` on
  every progress event, so the FE's `{#if bytesTotal > 0}` gate hid the
  Size bar — only the Files bar showed during the operation, even though
  `bytes_done` was being tracked correctly. Same-volume rename had the
  same shape.
- Extract the preflight scan that `volume_copy` was already doing into a
  shared `volume_preflight.rs` module. `scan_volume_sources` reuses the
  cached `TransferDialog` preview when one's available (the common
  dialog-driven path is hit-the-cache for free), otherwise dispatches
  `volume.scan_for_copy_batch`. Returns `(total_files, total_bytes,
  source_hints)`; also emits the `Scanning`-phase event and emits
  `write-cancelled` on pre-scan cancel so the FE dialog closes cleanly.
- Both `move_volumes_with_progress` and
  `move_within_same_volume_with_progress` now call it. Real `total_bytes`
  flows into the driver and every per-source emit; the file-only bulk-skip
  uses `preflight.known_directory_paths()`.
- Side cleanups the shared scan enables:
    * dropped `collect_known_directory_paths` (per-source stat to filter
      directories — replaced by `is_directory` from the cached scan).
    * dropped the cross-volume copy+delete loop's per-source
      `is_directory` probe.
    * dropped the same-volume rename's per-iter `get_metadata` for size.
    * conflict resolution now gets a real `source_size_hint`, so MTP
      conflict dialogs no longer re-list the parent dir per conflict.
- `volume_copy` slimmed by ~104 lines; its inline scan/cached-preview
  block + inline `known_directory_paths` builder are gone.
- Tests: `cross_volume_move_emits_bytes_total_on_progress` +
  `same_volume_move_emits_bytes_total_on_progress` pin the regression.

Author: vdavid

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

@@ -33,6 +33,7 @@ Pre-flight scans reuse cached listings when the source volume reports an active
 | `chunked_copy.rs` | 1 MB chunked read/write, the default copy method for all non-APFS-clonefile copies on macOS and network copies on Linux. Checks cancellation between chunks. Copies xattrs, ACLs, timestamps. |
 | `volume_copy.rs` | Volume-to-volume copy (Local↔MTP↔SMB): `copy_between_volumes`, `scan_for_volume_copy`. Uses `OperationEventSink` (not `AppHandle` directly) for event emission. Handles conflict detection, resolution, progress, rollback (delete all copied files in reverse with progress), and partial-file cleanup on cancel. Shared `map_volume_error` helper. |
 | `volume_move.rs` | Volume-to-volume move: `move_between_volumes`, `move_within_same_volume`. Same-volume uses `Volume::rename`; cross-volume does copy+delete. |
+| `volume_preflight.rs` | Shared preflight scan for both volume copy and move: `scan_volume_sources` returns a `VolumePreflight { total_files, total_bytes, source_hints }`. Reuses a cached preview from `TransferDialog` when one is available; otherwise dispatches `volume.scan_for_copy_batch` (so MTP's group-by-parent and SMB's pipelined-stat optimizations still kick in). Emits one `WriteProgressEvent { phase: Scanning, … }` so the FE sees the scan stage. On pre-scan cancel, emits `write-cancelled` and returns `Err(Cancelled)` so the FE dialog closes cleanly. |
 | `volume_conflict.rs`, `volume_strategy.rs` | Conflict resolution (Stop/Skip/Overwrite/Rename/OverwriteSmaller/OverwriteOlder) and copy strategy selection for volume operations. `volume_conflict.rs` mirrors the local-FS `reduce_conditional_resolution` from `helpers.rs` with its own `reduce_volume_conditional_resolution` (async, uses size hints + `get_metadata` for mtime). |
 | `transfer_driver.rs` | Shared per-source transfer driver for copy/move ops. Owns the bulk-skip prelude, per-iter cancellation check, conflict-resolve dispatch (async path), per-iter skip accounting, and paired progress/status emit. Two sibling entry points: `drive_transfer_serial_sync` (used by `copy.rs::copy_files_with_progress_inner`; closure captures `&mut CopyTransaction` / `&mut created_dirs` / `&mut SourceItemTracker`) and `drive_transfer_serial_async` (used by `volume_copy::copy_volumes_with_progress`'s serial path and both `volume_move` paths; driver owns top-level conflict detection + dispatch). The `FuturesUnordered` concurrent path in `volume_copy.rs` stays inline (1-of-4 abstraction; see plan § "Concurrent driver scope"). |
 | `tests.rs` | Unit tests. |
@@ -276,6 +277,9 @@ volume-delete handler.
 **Decision**: Volume delete reuses the scan preview and is oracle-aware on the no-preview path.
 **Why**: Before this, `delete_volume_files_with_progress_inner` ignored `config.preview_id` entirely and ran `scan_volume_recursive` again. On MTP that meant a second 17 s parent listing for a 135-photo `/DCIM/Camera` delete after the user had just paid that cost in the pre-flight dialog — and the second scan emitted no per-top-level-file progress, so the UI looked frozen. The fix has three parts. (1) `delete_volume_files_with_progress_inner` calls `take_cached_scan_result(preview_id)` at the top; on hit, top-level files are recorded from `CopyScanResult::total_bytes` with no `is_directory` probe and no `list_directory` round-trip, and top-level dirs recurse via the oracle-aware `scan_volume_recursive` (passing `is_dir_hint = Some(true)` so the recursion never re-probes). (2) The walker's internal `volume.list_directory(path, ...)` is now preceded by `try_get_watched_listing(volume_id, path)`; on hit, the cached entries replace the volume call entirely at every recursion level. (3) On the no-preview path (MCP triggers, programmatic deletes), the top-level `volume.is_directory(source)` probe stays only when the parent oracle misses — when a pane has the source's parent open and watcher-fresh, the type comes from the cached `FileEntry` and the probe is skipped. The cache-hit path also emits a throttled scan-progress event per `progress_interval` while building the entry list, so the FE dialog shows movement during the fast path instead of waiting for the delete phase to start. Pinned by `delete_volume_reuse_tests.rs`. Data-safety contract: stale-by-one cached entries can either silently skip a now-gone file (acceptable: the user already moved it elsewhere) or attempt to delete a missing one (the volume's `delete` errors cleanly). Neither direction can delete the wrong file because we feed `volume.delete(&entry.path)` exact paths the cache observed; a cached entry that races with a concurrent rename ends up addressing the old path the next call won't find.
 
+**Decision**: Volume move runs the same preflight scan as volume copy (extracted to `volume_preflight.rs`).
+**Why**: Both `move_volumes_with_progress` (cross-volume copy+delete) and `move_within_same_volume_with_progress` (rename) used to skip the scan phase entirely, sending `bytes_total = 0` on every progress event. The FE's `TransferProgressDialog` hides the Size progress bar behind `{#if bytesTotal > 0}`, so during an MTP→local move the user saw only the Files bar with no size feedback — even though `bytes_done` was being tracked correctly. The fix shares one helper (`scan_volume_sources`) between copy and move: reuses a cached `TransferDialog` preview when available (free in the common dialog-driven path), falls through to `volume.scan_for_copy_batch` otherwise. Move now gets the same `(total_files, total_bytes, source_hints)` triple copy has, so progress events carry the real `bytes_total`, the per-source `is_directory` probe inside the move loop is gone (hint comes from the scan), and the same-volume rename's per-iter `get_metadata` for size is gone (hint again). The previous `collect_known_directory_paths` helper (file-only-bulk-skip via per-source `get_metadata`) is replaced by `VolumePreflight::known_directory_paths()`. Behavior change to flag: programmatic moves with no `preview_id` (MCP, etc.) now pay one batch scan up front; for MTP this is ~one parent listing's RTT. Same cost copy has always paid; consistent across both ops. Pinned by `volume_move::tests::*_emits_bytes_total_on_progress`.
+
 **Decision**: Keep `exacl` crate for ACL copy in chunked copies (not custom FFI bindings).
 **Why**: `exacl` adds zero new transitive dependencies (all of its deps, `bitflags`, `log`, `scopeguard`, `uuid`, are already in our tree). It provides cross-platform ACL support (macOS, Linux, FreeBSD) and full ACL parsing/manipulation for potential future UI features. The crate appears unmaintained (last release Feb 2024) but ACL APIs are stable and don't change. Our usage is best-effort with graceful fallback: if `exacl` ever breaks, files still copy, they just lose ACLs. MIT licensed (compatible with BSL).
 

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

@@ -36,6 +36,7 @@ mod types;
 mod volume_conflict;
 mod volume_copy;
 mod volume_move;
+mod volume_preflight;
 mod volume_strategy;
 
 use std::path::PathBuf;

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

@@ -28,31 +28,21 @@ use uuid::Uuid;
 use futures_util::StreamExt;
 use futures_util::stream::FuturesUnordered;
 
-use super::scan::take_cached_scan_result;
-use super::transfer_driver::{
-    ConflictDecision, ConflictDecisionInput, DriverConfig, PostLoopIntent, TransferContext, TransferOutcome,
-    build_pre_skip_set, drive_transfer_serial_async,
-};
-
-/// Per-source hints collected during the scan phase, so the copy loop can
-/// skip re-probing the source type/size per file. `size` is only meaningful
-/// when `is_directory == false`; it's the top-level file's size and feeds
-/// the SMB compound fast-path.
-#[derive(Clone, Copy, Default)]
-struct SourceHint {
-    is_directory: bool,
-    size: u64,
-}
 use super::state::{
     OperationIntent, WRITE_OPERATION_STATE, WriteOperationState, is_cancelled, load_intent, register_operation_status,
     unregister_operation_status, update_operation_status,
 };
+use super::transfer_driver::{
+    ConflictDecision, ConflictDecisionInput, DriverConfig, PostLoopIntent, TransferContext, TransferOutcome,
+    build_pre_skip_set, drive_transfer_serial_async,
+};
 use super::types::{
     ConflictResolution, OperationEventSink, TauriEventSink, VolumeCopyConfig, VolumeCopyScanResult,
     WriteCancelledEvent, WriteCompleteEvent, WriteErrorEvent, WriteOperationConfig, WriteOperationError,
     WriteOperationPhase, WriteOperationStartResult, WriteOperationType, WriteProgressEvent,
 };
 use super::volume_conflict::resolve_volume_conflict;
+use super::volume_preflight::{SourceHint, scan_volume_sources};
 use super::volume_strategy::copy_single_path;
 use crate::file_system::volume::{SourceItemInfo, Volume, VolumeError};
 
@@ -422,112 +412,24 @@ pub(crate) async fn copy_volumes_with_progress(
         source_paths.len()
     );
 
-    // Phase 1: Scan sources (or reuse cached scan from preview)
-    let total_files;
-    let total_bytes;
-
-    // Per-source hint collected during the scan: whether the top-level path
-    // is a directory and, for top-level files, the file size. The copy loop
-    // reuses these to skip an `is_directory` probe per file and, for SMB, to
-    // pick the 1-RTT compound fast-path when the file fits in one READ.
-    let mut source_hints: HashMap<PathBuf, SourceHint> = HashMap::with_capacity(source_paths.len());
-
-    if let Some(cached) = config.preview_id.as_deref().and_then(take_cached_scan_result) {
-        total_files = cached.file_count;
-        total_bytes = cached.total_bytes;
-        log::debug!(
-            "copy_volumes_with_progress: reused cached scan for operation_id={}, files={}, bytes={}, per_path={}",
-            operation_id,
-            total_files,
-            total_bytes,
-            cached.per_path.len()
-        );
-        // 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,
-                SourceHint {
-                    is_directory: scan.top_level_is_directory,
-                    size,
-                },
-            );
-        }
-    } else {
-        log::debug!(
-            "copy_volumes_with_progress: scanning sources for operation_id={}",
-            operation_id
-        );
-
-        state.emit_progress_via_sink(
-            &*events,
-            WriteProgressEvent::new(
-                operation_id.to_string(),
-                WriteOperationType::Copy,
-                WriteOperationPhase::Scanning,
-                None,
-                0,
-                0,
-                0,
-                0,
-            ),
-        );
-
-        if is_cancelled(&state.intent) {
-            return Err(WriteFailure::synthetic(WriteOperationError::Cancelled {
-                message: "Operation cancelled by user".to_string(),
-            }));
-        }
-
-        // Single pipelined batch scan. For SMB this fires N stat requests
-        // over one session in parallel instead of N sequential RTTs (Fix 4).
-        // Default impl loops per-path for backends where per-path I/O is
-        // cheap (local FS, in-memory). MTP overrides to group by parent dir.
-        let batch = source_volume.scan_for_copy_batch(source_paths).await.map_err(|e| {
-            // No specific source path here; pick the first one or fall back to the dest.
-            let path = source_paths.first().cloned().unwrap_or_else(|| dest_path.to_path_buf());
-            WriteFailure::from_volume(&path, e)
-        })?;
-
-        total_files = batch.aggregate.file_count;
-        let total_dirs = batch.aggregate.dir_count;
-        total_bytes = batch.aggregate.total_bytes;
-
-        for (source_path, scan) in &batch.per_path {
-            // For top-level files, `scan.total_bytes` == the file size.
-            // For directories, we leave `size = 0` (unused downstream).
-            let size = if scan.top_level_is_directory {
-                0
-            } else {
-                scan.total_bytes
-            };
-            source_hints.insert(
-                source_path.clone(),
-                SourceHint {
-                    is_directory: scan.top_level_is_directory,
-                    size,
-                },
-            );
-        }
-
-        log::debug!(
-            "copy_volumes_with_progress: scan complete for operation_id={}, files={}, dirs={}, bytes={}",
-            operation_id,
-            total_files,
-            total_dirs,
-            total_bytes
-        );
-    }
+    // Phase 1: Preflight scan (reuses the dialog's cached preview when one is
+    // available). Populates `total_files`, `total_bytes`, and per-source
+    // `is_directory` / `size` hints so the copy loop doesn't have to re-probe
+    // each source. Shared with the move pipeline.
+    let preflight = scan_volume_sources(
+        &source_volume,
+        source_paths,
+        config,
+        operation_id,
+        WriteOperationType::Copy,
+        state,
+        &*events,
+    )
+    .await?;
+    let total_files = preflight.total_files;
+    let total_bytes = preflight.total_bytes;
+    let known_directory_paths = preflight.known_directory_paths();
+    let mut source_hints = preflight.source_hints;
 
     // Phase 2: Check destination space
     let dest_space = dest_volume
@@ -613,15 +515,9 @@ pub(crate) async fn copy_volumes_with_progress(
     // conflict instead of jumping to the full skipped count immediately.
     // Bulk-skip is **file-only**: a top-level directory's name matching a
     // pre-known conflict means only some of its children collide at dest, so
-    // dropping the whole subtree would lose non-conflicting files. We collect
-    // the top-level directory paths from `source_hints` (populated by the
-    // batched scan above) and exclude them; the loop falls through to
-    // per-iter conflict resolution for those.
-    let known_directory_paths: HashSet<PathBuf> = source_hints
-        .iter()
-        .filter(|&(_path, hint)| hint.is_directory)
-        .map(|(path, _hint)| path.clone())
-        .collect();
+    // dropping the whole subtree would lose non-conflicting files. Top-level
+    // directory paths come from `preflight.known_directory_paths()` (computed
+    // from the batched scan's `is_directory` hints).
     let pre_skip_paths: HashSet<PathBuf> = build_pre_skip_set(
         source_paths,
         config.conflict_resolution,