Fix file watching

Author: vdavid

docs/adr/010-migrate-to-bincode2.md

@@ -4,11 +4,13 @@
 
 ## Context
 
-The original `bincode` crate became unmaintained in late 2024/early 2025 due to a doxxing and harassment incident. The maintainer ceased all development and published v3.0.0 as a "tombstone" release that intentionally fails to compile.
+The original `bincode` crate became unmaintained in late 2024/early 2025 due to a doxxing and harassment incident. The
+maintainer ceased all development and published v3.0.0 as a "tombstone" release that intentionally fails to compile.
 
 ## Decision
 
 Migrated to `bincode2` v2, a maintained fork by Pravega, which provides:
+
 - Drop-in replacement with minimal code changes
 - Ongoing maintenance and security updates
 - Compatible API with bincode v1
@@ -25,8 +27,8 @@ Migrated to `bincode2` v2, a maintained fork by Pravega, which provides:
 
 1. **Cargo.toml**: Changed `bincode = "1"` to `bincode2 = "2"`
 2. **src-tauri/src/font_metrics/mod.rs**: Updated two function calls:
-   - `bincode::deserialize()` → `bincode2::deserialize()`
-   - `bincode::serialize()` → `bincode2::serialize()`
+    - `bincode::deserialize()` → `bincode2::deserialize()`
+    - `bincode::serialize()` → `bincode2::serialize()`
 3. **docs/features/font-metrics.md**: Updated documentation to mention bincode2
 
 ## Impact

src-tauri/src/file_system/operations.rs

@@ -310,23 +310,23 @@ pub fn list_directory_start(path: &Path, include_hidden: bool) -> Result<Listing
         all_entries.iter().filter(|e| !e.name.starts_with('.')).count()
     };
 
-    // Start watching the directory
-    if let Err(e) = start_watching(&listing_id, path, all_entries.clone()) {
-        eprintln!("[LISTING] Failed to start watcher: {}", e);
-        // Continue anyway - watcher is optional enhancement
-    }
-
-    // Cache the entries (no cursor needed - frontend fetches by range)
+    // Cache the entries FIRST (watcher will read from here)
     if let Ok(mut cache) = LISTING_CACHE.write() {
         cache.insert(
             listing_id.clone(),
             CachedListing {
                 path: path.to_path_buf(),
-                entries: all_entries.clone(), // Clone to allow reuse below
+                entries: all_entries.clone(),
             },
         );
     }
 
+    // Start watching the directory (reads initial state from cache)
+    if let Err(e) = start_watching(&listing_id, path) {
+        eprintln!("[LISTING] Failed to start watcher: {}", e);
+        // Continue anyway - watcher is optional enhancement
+    }
+
     // Calculate max filename width if font metrics are available
     let max_filename_width = {
         let font_id = "system-400-12"; // Default font for now
@@ -461,6 +461,27 @@ pub fn list_directory_end(listing_id: &str) {
     }
 }
 
+// ============================================================================
+// Internal cache accessors for file watcher
+// ============================================================================
+
+/// Gets entries and path from the listing cache (for watcher diff computation).
+/// Returns None if listing not found.
+pub(super) fn get_listing_entries(listing_id: &str) -> Option<(std::path::PathBuf, Vec<FileEntry>)> {
+    let cache = LISTING_CACHE.read().ok()?;
+    let listing = cache.get(listing_id)?;
+    Some((listing.path.clone(), listing.entries.clone()))
+}
+
+/// Updates the entries in the listing cache (after watcher detects changes).
+pub(super) fn update_listing_entries(listing_id: &str, entries: Vec<FileEntry>) {
+    if let Ok(mut cache) = LISTING_CACHE.write()
+        && let Some(listing) = cache.get_mut(listing_id)
+    {
+        listing.entries = entries;
+    }
+}
+
 // ============================================================================
 // Two-phase metadata loading: Fast core data, then extended metadata
 // ============================================================================

src-tauri/src/file_system/watcher.rs

@@ -1,19 +1,20 @@
 //! File system watcher with debouncing and diff computation.
 //!
 //! Watches directories for changes, computes diffs, and emits events to frontend.
+//! Uses the unified LISTING_CACHE from operations.rs (no duplicate cache).
 
 use notify_debouncer_full::{
     DebounceEventResult, Debouncer, RecommendedCache, new_debouncer,
     notify::{RecommendedWatcher, RecursiveMode},
 };
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::sync::{LazyLock, RwLock};
 use std::time::Duration;
 use tauri::{AppHandle, Emitter};
 
-use super::operations::{FileEntry, list_directory_core};
+use super::operations::{FileEntry, get_listing_entries, list_directory_core, update_listing_entries};
 
 /// Debounce duration in milliseconds
 const DEBOUNCE_MS: u64 = 200;
@@ -44,12 +45,11 @@ pub struct DirectoryDiff {
     pub changes: Vec<DiffChange>,
 }
 
-/// State for a watched directory
+/// State for a watched directory.
+/// NOTE: No `entries` field - we use the unified LISTING_CACHE instead.
 struct WatchedDirectory {
-    path: PathBuf,
-    entries: Vec<FileEntry>,
     sequence: u64,
-    #[allow(dead_code)] // Watcher must be held to keep watching
+    #[allow(dead_code)] // Debouncer must be held to keep watching
     debouncer: Debouncer<RecommendedWatcher, RecommendedCache>,
 }
 
@@ -76,16 +76,16 @@ pub fn init_watcher_manager(app: AppHandle) {
     }
 }
 
-/// Start watching a directory for a given session.
+/// Start watching a directory for a given listing.
 ///
 /// # Arguments
-/// * `session_id` - The session ID from list_directory_start
+/// * `listing_id` - The listing ID from list_directory_start
 /// * `path` - The directory path to watch
-/// * `initial_entries` - The initial directory entries (for diff computation)
-pub fn start_watching(session_id: &str, path: &Path, initial_entries: Vec<FileEntry>) -> Result<(), String> {
-    let session_id_owned = session_id.to_string();
-    let path_owned = path.to_path_buf();
-    let session_for_closure = session_id_owned.clone();
+///
+/// Note: Initial entries are read from LISTING_CACHE when needed.
+pub fn start_watching(listing_id: &str, path: &Path) -> Result<(), String> {
+    let listing_id_owned = listing_id.to_string();
+    let listing_for_closure = listing_id_owned.clone();
 
     // Create the debouncer with a callback that handles changes
     let mut debouncer = new_debouncer(
@@ -94,7 +94,7 @@ pub fn start_watching(session_id: &str, path: &Path, initial_entries: Vec<FileEn
         move |result: DebounceEventResult| {
             if let Ok(_events) = result {
                 // Events occurred - re-read directory and compute diff
-                handle_directory_change(&session_for_closure);
+                handle_directory_change(&listing_for_closure);
             }
         },
     )
@@ -105,45 +105,39 @@ pub fn start_watching(session_id: &str, path: &Path, initial_entries: Vec<FileEn
         .watch(path, RecursiveMode::NonRecursive)
         .map_err(|e| format!("Failed to watch path: {}", e))?;
 
-    // Store in manager
+    // Store in manager (no entries - we use LISTING_CACHE)
     let mut manager = WATCHER_MANAGER.write().map_err(|_| "Failed to acquire watcher lock")?;
 
-    manager.watches.insert(
-        session_id_owned.clone(),
-        WatchedDirectory {
-            path: path_owned,
-            entries: initial_entries,
-            sequence: 0,
-            debouncer,
-        },
-    );
+    manager
+        .watches
+        .insert(listing_id_owned, WatchedDirectory { sequence: 0, debouncer });
 
     Ok(())
 }
 
-/// Stop watching a directory for a given session.
-pub fn stop_watching(session_id: &str) {
+/// Stop watching a directory for a given listing.
+pub fn stop_watching(listing_id: &str) {
     if let Ok(mut manager) = WATCHER_MANAGER.write() {
         // Dropping the WatchedDirectory will drop the debouncer
-        manager.watches.remove(session_id);
+        manager.watches.remove(listing_id);
     }
 }
 
 /// Handle a directory change event.
-/// Re-reads the directory, computes diff, and emits event.
-fn handle_directory_change(session_id: &str) {
-    let (path, old_entries, app_handle) = {
+/// Re-reads the directory, computes diff, updates LISTING_CACHE, and emits event.
+fn handle_directory_change(listing_id: &str) {
+    // Get old entries and path from the unified LISTING_CACHE
+    let Some((path, old_entries)) = get_listing_entries(listing_id) else {
+        return; // Listing no longer exists
+    };
+
+    // Get app handle for emitting events
+    let app_handle = {
         let manager = match WATCHER_MANAGER.read() {
             Ok(m) => m,
             Err(_) => return,
         };
-
-        let watch = match manager.watches.get(session_id) {
-            Some(w) => w,
-            None => return,
-        };
-
-        (watch.path.clone(), watch.entries.clone(), manager.app_handle.clone())
+        manager.app_handle.clone()
     };
 
     // Re-read the directory using core metadata (extended metadata not needed for diffs)
@@ -162,27 +156,29 @@ fn handle_directory_change(session_id: &str) {
         return; // No actual changes
     }
 
-    // Update stored entries and increment sequence
+    // Update the unified LISTING_CACHE with new entries
+    update_listing_entries(listing_id, new_entries);
+
+    // Increment sequence and get current value
     let sequence = {
         let mut manager = match WATCHER_MANAGER.write() {
             Ok(m) => m,
             Err(_) => return,
         };
 
-        let watch = match manager.watches.get_mut(session_id) {
+        let watch = match manager.watches.get_mut(listing_id) {
             Some(w) => w,
             None => return,
         };
 
-        watch.entries = new_entries;
         watch.sequence += 1;
         watch.sequence
     };
 
     // Emit event to frontend
     if let Some(app) = app_handle {
         let diff = DirectoryDiff {
-            listing_id: session_id.to_string(),
+            listing_id: listing_id.to_string(),
             sequence,
             changes,
         };

src/lib/file-explorer/BriefList.svelte

@@ -317,21 +317,29 @@
     // Track previous values to detect actual changes
     let prevListingId = ''
     let prevIncludeHidden = false
+    let prevTotalCount = 0
 
-    // Single effect: fetch when ready, reset cache only when listingId/includeHidden actually changes
+    // Single effect: fetch when ready, reset cache only when listingId/includeHidden/totalCount actually changes
     $effect(() => {
         // Read reactive dependencies
         const currentListingId = listingId
         const currentIncludeHidden = includeHidden
+        const currentTotalCount = totalCount
         if (!currentListingId || containerHeight <= 0) return
 
-        // Check if listingId or includeHidden actually changed
-        if (currentListingId !== prevListingId || currentIncludeHidden !== prevIncludeHidden) {
-            // Reset cache for new listing or filter change
+        // Check if listingId, includeHidden, or totalCount actually changed
+        // totalCount changes when files are added/removed by the file watcher
+        if (
+            currentListingId !== prevListingId ||
+            currentIncludeHidden !== prevIncludeHidden ||
+            currentTotalCount !== prevTotalCount
+        ) {
+            // Reset cache for new listing, filter change, or file count change
             cachedEntries = []
             cachedRange = { start: 0, end: 0 }
             prevListingId = currentListingId
             prevIncludeHidden = currentIncludeHidden
+            prevTotalCount = currentTotalCount
         }
 
         void fetchVisibleRange()

src/lib/file-explorer/FullList.svelte

@@ -274,21 +274,29 @@
     // Track previous values to detect actual changes
     let prevListingId = ''
     let prevIncludeHidden = false
+    let prevTotalCount = 0
 
-    // Single effect: fetch when ready, reset cache only when listingId/includeHidden actually changes
+    // Single effect: fetch when ready, reset cache only when listingId/includeHidden/totalCount actually changes
     $effect(() => {
         // Read reactive dependencies
         const currentListingId = listingId
         const currentIncludeHidden = includeHidden
+        const currentTotalCount = totalCount
         if (!currentListingId || containerHeight <= 0) return
 
-        // Check if listingId or includeHidden actually changed
-        if (currentListingId !== prevListingId || currentIncludeHidden !== prevIncludeHidden) {
-            // Reset cache for new listing or filter change
+        // Check if listingId, includeHidden, or totalCount actually changed
+        // totalCount changes when files are added/removed by the file watcher
+        if (
+            currentListingId !== prevListingId ||
+            currentIncludeHidden !== prevIncludeHidden ||
+            currentTotalCount !== prevTotalCount
+        ) {
+            // Reset cache for new listing, filter change, or file count change
             cachedEntries = []
             cachedRange = { start: 0, end: 0 }
             prevListingId = currentListingId
             prevIncludeHidden = currentIncludeHidden
+            prevTotalCount = currentTotalCount
         }
 
         void fetchVisibleRange()