fix: Race when openning many sequenital dirs

closes #269
closes #256

Author: dmtrKovalenko

README.md

@@ -282,8 +282,7 @@ require('fff').setup({
 #### Available Methods
 
 ```lua
-require('fff').find_files()                         -- Find files in current directory
-require('fff').find_in_git_root()                   -- Find files in the current git repository
+require('fff').find_files()                         -- Find files in current repositro
 require('fff').scan_files()                         -- Trigger rescan of files in the current directory
 require('fff').refresh_git_status()                 -- Refresh git status for the active file lock
 require('fff').find_files_in_dir(path)              -- Find files in a specific directory

crates/fff-core/src/file_picker.rs

@@ -186,6 +186,7 @@ pub struct FilePicker {
     scanned_files_count: Arc<AtomicUsize>,
     background_watcher: Option<BackgroundWatcher>,
     warmup_mmap_cache: bool,
+    cancelled: Arc<AtomicBool>,
 }
 
 impl std::fmt::Debug for FilePicker {
@@ -250,6 +251,7 @@ impl FilePicker {
         // rather than a stale `false` (the thread hasn't started yet).
         let scan_signal = Arc::new(AtomicBool::new(true));
         let synced_files_count = Arc::new(AtomicUsize::new(0));
+        let cancelled = Arc::new(AtomicBool::new(false));
 
         let picker = FilePicker {
             base_path: path.clone(),
@@ -258,6 +260,7 @@ impl FilePicker {
             scanned_files_count: Arc::clone(&synced_files_count),
             background_watcher: None,
             warmup_mmap_cache,
+            cancelled: Arc::clone(&cancelled),
         };
 
         // Place the picker into the shared handle before spawning the
@@ -274,6 +277,7 @@ impl FilePicker {
             warmup_mmap_cache,
             shared_picker,
             shared_frecency,
+            cancelled,
         );
 
         Ok(())
@@ -578,6 +582,11 @@ impl FilePicker {
             .retain_files(|file| !file.path.starts_with(dir_path))
     }
 
+    /// We use this to prevent any substantial background threads from acquiring the locks
+    pub fn cancel(&self) {
+        self.cancelled.store(true, Ordering::Release);
+    }
+
     pub fn stop_background_monitor(&mut self) {
         if let Some(watcher) = self.background_watcher.take() {
             watcher.stop();
@@ -644,6 +653,7 @@ fn spawn_scan_and_watcher(
     warmup_mmap_cache: bool,
     shared_picker: SharedPicker,
     shared_frecency: SharedFrecency,
+    cancelled: Arc<AtomicBool>,
 ) {
     std::thread::spawn(move || {
         // scan_signal is already `true` (set by the caller before spawning)
@@ -653,6 +663,12 @@ fn spawn_scan_and_watcher(
         let mut git_workdir = None;
         match scan_filesystem(&base_path, &synced_files_count, &shared_frecency) {
             Ok(sync) => {
+                if cancelled.load(Ordering::Acquire) {
+                    info!("Scan completed but picker was replaced, discarding results");
+                    scan_signal.store(false, Ordering::Relaxed);
+                    return;
+                }
+
                 info!(
                     "Initial filesystem scan completed: found {} files",
                     sync.files.len()
@@ -672,13 +688,8 @@ fn spawn_scan_and_watcher(
                 }
 
                 // OPTIMIZATION: Warmup mmap cache in background to avoid blocking first grep.
-                // The aggressive parallel warmup was causing cache thrashing and delaying
-                // initial searches. Now it runs async and doesn't block.
-                //
-                // We warmup under a read lock on the picker's actual files so that
-                // the OnceLock<Mmap> instances are populated in-place — no clone needed.
-                // Read locks allow concurrent readers so this doesn't block searches.
                 if warmup_mmap_cache
+                    && !cancelled.load(Ordering::Acquire)
                     && let Ok(guard) = shared_picker.read()
                     && let Some(ref picker) = *guard
                 {
@@ -691,6 +702,12 @@ fn spawn_scan_and_watcher(
         }
         scan_signal.store(false, Ordering::Relaxed);
 
+        // Don't create a watcher if this picker instance was already replaced
+        if cancelled.load(Ordering::Acquire) {
+            info!("Picker was replaced, skipping background watcher creation");
+            return;
+        }
+
         match BackgroundWatcher::new(
             base_path,
             git_workdir,
@@ -700,6 +717,15 @@ fn spawn_scan_and_watcher(
             Ok(watcher) => {
                 info!("Background file watcher initialized successfully");
 
+                // Final cancellation check: if the picker was replaced between
+                // watcher creation and this write, drop the watcher instead of
+                // storing it in the wrong picker.
+                if cancelled.load(Ordering::Acquire) {
+                    info!("Picker was replaced, dropping orphaned watcher");
+                    drop(watcher);
+                    return;
+                }
+
                 let write_result = shared_picker.write().ok().map(|mut guard| {
                     if let Some(ref mut picker) = *guard {
                         picker.background_watcher = Some(watcher);

crates/fff-nvim/src/lib.rs

@@ -100,17 +100,24 @@ pub fn init_file_picker(_: &Lua, base_path: String) -> LuaResult<bool> {
 }
 
 fn reinit_file_picker_internal(path: &Path) -> Result<(), Error> {
-    // Stop existing picker
+    // Cancel and stop the old picker under a single write lock to avoid
+    // a window where FILE_PICKER is None (which causes FilePickerMissing
+    // errors if the UI is searching concurrently).
     {
         let mut guard = FILE_PICKER
             .write()
             .with_lock_error(Error::AcquireItemLock)?;
-        if let Some(mut picker) = guard.take() {
+        if let Some(ref mut picker) = *guard {
+            // Signal cancellation BEFORE stopping — this tells any orphaned
+            // scan threads from this picker to discard their results.
+            picker.cancel();
             picker.stop_background_monitor();
         }
+        // Don't take() here — leave the old picker in place so searches
+        // still work until new_with_shared_state replaces it atomically.
     }
 
-    // Create new picker backed by the same shared state
+    // Create new picker — this atomically replaces the old one via write lock
     FilePicker::new_with_shared_state(
         path.to_string_lossy().to_string(),
         false,
@@ -134,6 +141,12 @@ pub fn restart_index_in_path(_: &Lua, new_path: String) -> LuaResult<()> {
         LuaError::RuntimeError(format!("Failed to canonicalize path '{}': {}", new_path, e))
     })?;
 
+    if let Ok(Some(picker)) = FILE_PICKER.read().as_deref() {
+        if picker.base_path() == canonical_path {
+            return Ok(()); // same dir
+        }
+    }
+
     // Spawn a background thread to avoid blocking Lua/UI thread
     std::thread::spawn(move || {
         if let Err(e) = reinit_file_picker_internal(&canonical_path) {
@@ -564,21 +577,28 @@ pub fn get_historical_grep_query(_: &Lua, offset: usize) -> LuaResult<Option<Str
 }
 
 pub fn wait_for_initial_scan(_: &Lua, timeout_ms: Option<u64>) -> LuaResult<bool> {
-    let file_picker = FILE_PICKER
-        .read()
-        .with_lock_error(Error::AcquireItemLock)
-        .into_lua_result()?;
-    let picker = file_picker
-        .as_ref()
-        .ok_or(Error::FilePickerMissing)
-        .into_lua_result()?;
+    // Extract the scan signal Arc WITHOUT holding the read lock, so the
+    // scan thread can acquire the write lock to store its results.
+    // Holding a read lock while polling would deadlock: the scan thread
+    // needs a write lock to finish, but can't acquire it while we hold the read lock.
+    let scan_signal = {
+        let file_picker = FILE_PICKER
+            .read()
+            .with_lock_error(Error::AcquireItemLock)
+            .into_lua_result()?;
+        let picker = file_picker
+            .as_ref()
+            .ok_or(Error::FilePickerMissing)
+            .into_lua_result()?;
+        picker.scan_signal()
+    }; // read lock released here
 
     let timeout_ms = timeout_ms.unwrap_or(500);
     let timeout_duration = Duration::from_millis(timeout_ms);
     let start_time = std::time::Instant::now();
     let mut sleep_duration = Duration::from_millis(1);
 
-    while picker.is_scan_active() {
+    while scan_signal.load(std::sync::atomic::Ordering::Relaxed) {
         if start_time.elapsed() >= timeout_duration {
             ::tracing::warn!("wait_for_initial_scan timed out after {}ms", timeout_ms);
             return Ok(false);

lua/fff/core.lua

@@ -65,12 +65,6 @@ local function setup_global_autocmds(config)
     end,
     desc = 'Automatically sync FFF directory changes',
   })
-
-  vim.api.nvim_create_autocmd('VimLeavePre', {
-    group = group,
-    callback = function() pcall(fuzzy.cleanup_file_picker) end,
-    desc = 'Cleanup FFF background threads on Neovim exit',
-  })
 end
 
 --- @return boolean

lua/fff/list_renderer.lua

@@ -189,17 +189,17 @@ local function apply_all_highlights(lines, item_to_lines, ctx, list_buf, ns_id)
   for i = ctx.display_start, ctx.display_end do
     local item = ctx.items[i]
     local item_lines = item_to_lines[i]
-    if not item_lines then goto continue end
 
-    -- The content line is always the last line in the mapping
-    local line_idx = item_lines.last
-    local line_content = lines[line_idx]
+    if item_lines then
+      -- The content line is always the last line in the mapping
+      local line_idx = item_lines.last
+      local line_content = lines[line_idx]
 
-    if not line_content then goto continue end
-
-    ---@diagnostic disable-next-line: param-type-mismatch
-    renderer.apply_highlights(item, ctx, i, list_buf, ns_id, line_idx, line_content)
-    ::continue::
+      if line_content then
+        ---@diagnostic disable-next-line: param-type-mismatch
+        renderer.apply_highlights(item, ctx, i, list_buf, ns_id, line_idx, line_content)
+      end
+    end
   end
 end
 

lua/fff/main.lua

@@ -42,6 +42,8 @@ function M.live_grep(opts)
   picker_ui.open(picker_opts)
 end
 
+--- Changes the directory indexed by the file picker to the git root and opens the file picker
+--- @deprecated Use `find_files` instead
 function M.find_in_git_root()
   local fuzzy = require('fff.core').ensure_initialized()
   local ok, git_root = pcall(fuzzy.get_git_root)