Fix live file count during large folder loading

The listing-progress event was defined but never emitted, so opening 100k+ file folders showed no incremental count.
- Add list_directory_with_progress to Volume trait
- LocalPosixVolume reports stat loop progress every 200ms
- streaming.rs now emits listing-progress Tauri events
- Frontend handler was already wired up, no changes needed

Author: vdavid

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

@@ -66,7 +66,7 @@ Frontend                          Backend
 **Decision**: Three-stage progress: opening → progress → read-complete → complete
 **Why**: Gives user fine-grained feedback:
 - `listing-opening`: "About to start slow I/O" (for network folders)
-- `listing-progress`: "Loaded N files..." (every 500ms)
+- `listing-progress`: "Loaded N files..." (every 200ms, via `list_directory_core_with_progress`)
 - `listing-read-complete`: "All files read, sorting now"
 - `listing-complete`: "Ready to render"
 

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

@@ -14,7 +14,7 @@ pub use operations::{
     ListingStartResult, ListingStats, ResortResult, find_file_index, get_file_at, get_file_range, get_listing_stats,
     get_max_filename_width, get_total_count, list_directory_end, list_directory_start_with_volume, resort_listing,
 };
-pub use reading::{get_single_entry, list_directory_core};
+pub use reading::{get_single_entry, list_directory_core, list_directory_core_with_progress};
 pub use sorting::{DirectorySortMode, SortColumn, SortOrder};
 pub use streaming::{StreamingListingStartResult, cancel_listing, list_directory_start_streaming};
 

apps/desktop/src-tauri/src/file_system/listing/reading.rs

@@ -63,6 +63,25 @@ pub fn list_directory(path: &Path) -> Result<Vec<FileEntry>, std::io::Error> {
 ///
 /// Use `get_extended_metadata_batch()` to fetch extended metadata later.
 pub fn list_directory_core(path: &Path) -> Result<Vec<FileEntry>, std::io::Error> {
+    list_directory_core_impl(path, None)
+}
+
+/// Like `list_directory_core`, but calls `on_progress(loaded_count)` every ~200ms
+/// during the stat loop so callers can report incremental progress.
+pub fn list_directory_core_with_progress(
+    path: &Path,
+    on_progress: &dyn Fn(usize),
+) -> Result<Vec<FileEntry>, std::io::Error> {
+    list_directory_core_impl(path, Some(on_progress))
+}
+
+/// Interval between progress callbacks during the stat loop.
+const PROGRESS_REPORT_INTERVAL: std::time::Duration = std::time::Duration::from_millis(200);
+
+fn list_directory_core_impl(
+    path: &Path,
+    on_progress: Option<&dyn Fn(usize)>,
+) -> Result<Vec<FileEntry>, std::io::Error> {
     benchmark::log_event("list_directory_core START");
     let overall_start = std::time::Instant::now();
     let mut entries = Vec::new();
@@ -74,6 +93,7 @@ pub fn list_directory_core(path: &Path) -> Result<Vec<FileEntry>, std::io::Error
     benchmark::log_event_value("readdir END, count", dir_entries.len());
 
     benchmark::log_event("stat_loop START");
+    let mut last_progress = std::time::Instant::now();
     for entry in dir_entries {
         let entry = entry?;
         match process_dir_entry(&entry) {
@@ -107,6 +127,13 @@ pub fn list_directory_core(path: &Path) -> Result<Vec<FileEntry>, std::io::Error
                 });
             }
         }
+
+        if let Some(cb) = on_progress
+            && last_progress.elapsed() >= PROGRESS_REPORT_INTERVAL
+        {
+            cb(entries.len());
+            last_progress = std::time::Instant::now();
+        }
     }
     benchmark::log_event_value("stat_loop END, entries", entries.len());
 

apps/desktop/src-tauri/src/file_system/listing/streaming.rs

@@ -3,8 +3,6 @@
 //! Provides non-blocking directory reading with progress events and cancellation.
 //! The implementation spawns background tasks and emits Tauri events.
 
-#![allow(dead_code, reason = "ListingProgressEvent is part of public API for future use")]
-
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::Path;
@@ -111,7 +109,7 @@ pub(crate) static STREAMING_STATE: LazyLock<RwLock<HashMap<String, Arc<Streaming
 /// Starts a streaming directory listing that returns immediately and emits progress events.
 ///
 /// This is non-blocking - the actual directory reading happens in a background task.
-/// Progress is reported via Tauri events every 500ms.
+/// Progress is reported via Tauri events every ~200ms.
 #[allow(
     clippy::too_many_arguments,
     reason = "Streaming operation requires many state parameters"
@@ -270,9 +268,21 @@ fn read_directory_with_progress(
     let read_start = std::time::Instant::now();
     let path_for_thread = path.to_path_buf();
     let (tx, rx) = mpsc::channel();
+    let app_for_progress = app.clone();
+    let listing_id_for_progress = listing_id.to_string();
 
     std::thread::spawn(move || {
-        let result = volume.list_directory(&path_for_thread);
+        let on_progress = |loaded_count: usize| {
+            use tauri::Emitter;
+            let _ = app_for_progress.emit(
+                "listing-progress",
+                ListingProgressEvent {
+                    listing_id: listing_id_for_progress.clone(),
+                    loaded_count,
+                },
+            );
+        };
+        let result = volume.list_directory_with_progress(&path_for_thread, &on_progress);
         let _ = tx.send(result);
     });
 

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

@@ -3,7 +3,7 @@
 use super::{
     CopyScanResult, ScanConflict, SourceItemInfo, SpaceInfo, Volume, VolumeError, VolumeScanner, VolumeWatcher,
 };
-use crate::file_system::listing::{FileEntry, get_single_entry, list_directory_core};
+use crate::file_system::listing::{FileEntry, get_single_entry, list_directory_core, list_directory_core_with_progress};
 use crate::indexing::scanner::{self, ScanConfig, ScanError, ScanHandle, ScanSummary};
 use crate::indexing::watcher::{DriveWatcher, FsChangeEvent, WatcherError};
 use crate::indexing::writer::IndexWriter;
@@ -88,6 +88,15 @@ impl Volume for LocalPosixVolume {
         list_directory_core(&abs_path).map_err(VolumeError::from)
     }
 
+    fn list_directory_with_progress(
+        &self,
+        path: &Path,
+        on_progress: &dyn Fn(usize),
+    ) -> Result<Vec<FileEntry>, VolumeError> {
+        let abs_path = self.resolve(path);
+        list_directory_core_with_progress(&abs_path, on_progress).map_err(VolumeError::from)
+    }
+
     fn get_metadata(&self, path: &Path) -> Result<FileEntry, VolumeError> {
         let abs_path = self.resolve(path);
         get_single_entry(&abs_path).map_err(VolumeError::from)

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

@@ -181,6 +181,18 @@ pub trait Volume: Send + Sync {
     /// Returns entries sorted with directories first, then files, both alphabetically.
     fn list_directory(&self, path: &Path) -> Result<Vec<FileEntry>, VolumeError>;
 
+    /// Like `list_directory`, but calls `on_progress(loaded_count)` periodically
+    /// during the stat loop so callers can report incremental progress to the UI.
+    ///
+    /// Default implementation delegates to `list_directory` with no incremental updates.
+    fn list_directory_with_progress(
+        &self,
+        path: &Path,
+        _on_progress: &dyn Fn(usize),
+    ) -> Result<Vec<FileEntry>, VolumeError> {
+        self.list_directory(path)
+    }
+
     /// Gets metadata for a single path (relative to volume root).
     fn get_metadata(&self, path: &Path) -> Result<FileEntry, VolumeError>;