Fix copy progress: per-file counter and stale scan prevention

- Add `on_file_complete` callback to `copy_single_path` and recursive helpers. File counter now increments per individual file during directory copies, not per top-level item. Progress bar shows accurate "42/200000 files".
- Remove stale `previewId` adoption in `TransferDialog.isOurScanEvent()`. Events from orphaned previous scans are now rejected instead of adopted. After IPC returns, checks `checkScanPreviewStatus` for the race where scan completes before the ID is known.

Author: vdavid

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

@@ -19,7 +19,7 @@ use std::cell::Cell;
 use std::ops::ControlFlow;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-use std::sync::atomic::{AtomicU8, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicU8, AtomicU64, AtomicUsize, Ordering};
 use std::time::{Duration, Instant};
 use uuid::Uuid;
 
@@ -379,6 +379,9 @@ fn copy_volumes_with_progress(
     }
 
     // Phase 3: Copy files with progress
+    // files_done tracks individual files (updated by on_file_complete callback from recursive copy).
+    // total_files is the recursive count from the scan.
+    let files_done_atomic = AtomicUsize::new(0);
     let mut files_done = 0;
     let mut bytes_done = 0u64;
     let mut last_progress_time = Instant::now();
@@ -510,6 +513,9 @@ fn copy_volumes_with_progress(
             let delta = file_bytes_done.saturating_sub(prev);
             let current_total = atomic_bytes_done.fetch_add(delta, Ordering::Relaxed) + delta;
 
+            // Read current files_done from the atomic (updated by on_file_complete)
+            let current_files_done = files_done_atomic.load(Ordering::Relaxed);
+
             // Throttled progress emission
             let last = last_progress_cell.get();
             if last.elapsed() >= progress_interval {
@@ -521,7 +527,7 @@ fn copy_volumes_with_progress(
                         operation_type: WriteOperationType::Copy,
                         phase: WriteOperationPhase::Copying,
                         current_file: file_name_for_cb.clone(),
-                        files_done,
+                        files_done: current_files_done,
                         files_total: total_files,
                         bytes_done: current_total,
                         bytes_total: total_bytes,
@@ -531,7 +537,7 @@ fn copy_volumes_with_progress(
                     operation_id,
                     WriteOperationPhase::Copying,
                     file_name_for_cb.clone(),
-                    files_done,
+                    current_files_done,
                     total_files,
                     current_total,
                     total_bytes,
@@ -541,6 +547,11 @@ fn copy_volumes_with_progress(
             ControlFlow::Continue(())
         };
 
+        // Build the on_file_complete callback that increments the atomic file counter
+        let on_file_complete = || {
+            files_done_atomic.fetch_add(1, Ordering::Relaxed);
+        };
+
         // Remember the destination path before copying (for partial-file cleanup)
         last_dest_path = Some(dest_item_path.clone());
 
@@ -551,13 +562,15 @@ fn copy_volumes_with_progress(
             &dest_item_path,
             state,
             &on_file_progress,
+            &on_file_complete,
         ) {
             Ok(bytes_copied) => {
                 // Copy succeeded — record destination path for potential rollback
                 copied_paths.push(dest_item_path);
                 last_dest_path = None;
 
-                files_done += 1;
+                // Sync files_done from the atomic (updated by on_file_complete during recursive copy)
+                files_done = files_done_atomic.load(Ordering::Relaxed);
                 // Sync bytes_done from the atomic (the callback may have updated it mid-file)
                 bytes_done = atomic_bytes_done.load(Ordering::Relaxed);
                 // If the volume didn't call the progress callback (default impl), add bytes_copied
@@ -1004,6 +1017,7 @@ pub async fn move_between_volumes(
                     &dest_item,
                     &state,
                     &no_progress,
+                    &|| {},
                 )
                 .map_err(|e| map_volume_error(&source_path.display().to_string(), e))?;
 

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

@@ -40,6 +40,7 @@ pub(super) fn copy_single_path(
     dest_path: &Path,
     state: &Arc<WriteOperationState>,
     on_file_progress: &dyn Fn(u64, u64) -> ControlFlow<()>,
+    on_file_complete: &dyn Fn(),
 ) -> Result<u64, VolumeError> {
     // Check cancellation
     if super::state::is_cancelled(&state.intent) {
@@ -90,9 +91,18 @@ pub(super) fn copy_single_path(
         // For directories, walk the tree ourselves so we can check cancellation between files.
         // import_from_local(dir) would import everything in one shot with no cancellation.
         if local_source.is_dir() {
-            import_directory_cancellable(&local_source, dest_path, dest_volume, state, on_file_progress)
+            import_directory_cancellable(
+                &local_source,
+                dest_path,
+                dest_volume,
+                state,
+                on_file_progress,
+                on_file_complete,
+            )
         } else {
-            dest_volume.import_from_local_with_progress(&local_source, dest_path, on_file_progress)
+            let bytes = dest_volume.import_from_local_with_progress(&local_source, dest_path, on_file_progress)?;
+            on_file_complete();
+            Ok(bytes)
         }
     } else if !source_is_local && dest_is_local {
         // Source is not local, dest is local (like SMB/MTP → Local)
@@ -104,20 +114,29 @@ pub(super) fn copy_single_path(
         // For directories, walk the tree ourselves for cancellation support.
         let is_dir = source_volume.is_directory(source_path).unwrap_or(false);
         if is_dir {
-            export_directory_cancellable(source_path, &local_dest, source_volume, state, on_file_progress)
+            export_directory_cancellable(
+                source_path,
+                &local_dest,
+                source_volume,
+                state,
+                on_file_progress,
+                on_file_complete,
+            )
         } else {
-            source_volume.export_to_local_with_progress(source_path, &local_dest, on_file_progress)
+            let bytes = source_volume.export_to_local_with_progress(source_path, &local_dest, on_file_progress)?;
+            on_file_complete();
+            Ok(bytes)
         }
     } else {
         // Both are local, use export which resolves paths internally
-        // Note: export_to_local takes a path relative to the volume root for source,
-        // and an absolute local path for destination
         let local_dest = if dest_path.is_absolute() {
             dest_path.to_path_buf()
         } else {
             dest_volume.root().join(dest_path)
         };
-        source_volume.export_to_local(source_path, &local_dest)
+        let bytes = source_volume.export_to_local(source_path, &local_dest)?;
+        on_file_complete();
+        Ok(bytes)
     }
 }
 
@@ -130,6 +149,7 @@ fn import_directory_cancellable(
     dest_volume: &Arc<dyn Volume>,
     state: &Arc<WriteOperationState>,
     on_file_progress: &dyn Fn(u64, u64) -> ControlFlow<()>,
+    on_file_complete: &dyn Fn(),
 ) -> Result<u64, VolumeError> {
     // Create the directory on the destination
     dest_volume.create_directory(dest_path)?;
@@ -149,10 +169,17 @@ fn import_directory_cancellable(
         let child_dest = dest_path.join(&child_name);
 
         if child_local.is_dir() {
-            total_bytes +=
-                import_directory_cancellable(&child_local, &child_dest, dest_volume, state, on_file_progress)?;
+            total_bytes += import_directory_cancellable(
+                &child_local,
+                &child_dest,
+                dest_volume,
+                state,
+                on_file_progress,
+                on_file_complete,
+            )?;
         } else {
             total_bytes += dest_volume.import_from_local_with_progress(&child_local, &child_dest, on_file_progress)?;
+            on_file_complete();
         }
     }
 
@@ -167,6 +194,7 @@ fn export_directory_cancellable(
     source_volume: &Arc<dyn Volume>,
     state: &Arc<WriteOperationState>,
     on_file_progress: &dyn Fn(u64, u64) -> ControlFlow<()>,
+    on_file_complete: &dyn Fn(),
 ) -> Result<u64, VolumeError> {
     // Create the local directory
     std::fs::create_dir_all(local_dest).map_err(|e| VolumeError::IoError(e.to_string()))?;
@@ -185,10 +213,17 @@ fn export_directory_cancellable(
         let child_local = local_dest.join(&entry.name);
 
         if entry.is_directory {
-            total_bytes +=
-                export_directory_cancellable(child_source, &child_local, source_volume, state, on_file_progress)?;
+            total_bytes += export_directory_cancellable(
+                child_source,
+                &child_local,
+                source_volume,
+                state,
+                on_file_progress,
+                on_file_complete,
+            )?;
         } else {
             total_bytes += source_volume.export_to_local_with_progress(child_source, &child_local, on_file_progress)?;
+            on_file_complete();
         }
     }
 
@@ -291,6 +326,7 @@ mod tests {
             Path::new("dest.txt"),
             &state,
             &no_progress,
+            &|| {},
         )
         .unwrap();
 
@@ -332,6 +368,7 @@ mod tests {
             Path::new("dest.txt"),
             &state,
             &no_progress,
+            &|| {},
         );
 
         assert!(result.is_err());

apps/desktop/src/lib/file-operations/transfer/TransferDialog.svelte

@@ -5,6 +5,7 @@
         formatBytes,
         startScanPreview,
         cancelScanPreview,
+        checkScanPreviewStatus,
         onScanPreviewProgress,
         onScanPreviewComplete,
         onScanPreviewError,
@@ -254,9 +255,9 @@
 
     /** Accepts the event if it belongs to our scan, filtering stale events from previous scans. */
     function isOurScanEvent(eventPreviewId: string): boolean {
-        // previewId may still be null if the scan completes before startScanPreview returns.
-        // In that case, adopt the first event's previewId (it's from the scan we just started).
-        if (!previewId) previewId = eventPreviewId
+        // Don't accept events until we know our previewId from the IPC return.
+        // This prevents adopting stale events from previous orphaned scans.
+        if (!previewId) return false
         return eventPreviewId === previewId
     }
 
@@ -302,6 +303,22 @@
         const progressIntervalMs = getSetting('fileOperations.progressUpdateInterval')
         const result = await startScanPreview(sourcePaths, sortColumn, sortOrder, progressIntervalMs, sourceVolumeId)
         previewId = result.previewId
+
+        // Check if the scan already completed while we were awaiting the IPC return.
+        // Events that arrived before previewId was set were dropped (isOurScanEvent returned false),
+        // so we need to check the backend's cached result.
+        if (isScanning) {
+            const alreadyComplete = await checkScanPreviewStatus(previewId)
+            if (alreadyComplete) {
+                // The scan finished before we could listen. Re-fetch the result by triggering
+                // a fresh scan status check — the backend will re-emit the complete event.
+                // For now, mark as complete with whatever stats we have (they'll be updated
+                // when the copy starts and reads the cached scan result).
+                isScanning = false
+                scanComplete = true
+                void checkConflicts()
+            }
+        }
     }
 
     onMount(async () => {