Indexing: Scanning state stuck after replay

vdavid · vdavid · commit fb796e725280 · 2026-03-18T13:19:26.000+01:00
- `run_replay_event_loop` handles both replay AND the live event loop, only returning on shutdown. `scanning.store(false)` in `mod.rs` was placed after the `.await`, so it was unreachable during normal operation — the backend reported `scanning: true` for the entire app lifetime after any cold-start replay
- Pass `scanning: Arc&lt;AtomicBool&gt;` into `run_replay_event_loop` and clear it at the replay→live transition point, right before entering the live loop
- Frontend defense-in-depth: `eventVersion` counter in `index-state.svelte.ts` prevents the `get_index_status` IPC response from overriding state that a more recent event already set
diff --git a/apps/desktop/src-tauri/src/indexing/event_loop.rs b/apps/desktop/src-tauri/src/indexing/event_loop.rs
@@ -281,6 +281,7 @@ pub(super) async fn run_replay_event_loop(
     config: ReplayConfig,
     fallback_tx: tokio::sync::oneshot::Sender<()>,
     watcher_overflow: Option<Arc<AtomicBool>>,
+    scanning: Arc<AtomicBool>,
 ) -> Result<(), String> {
     let ReplayConfig {
         volume_id,
@@ -563,6 +564,9 @@ pub(super) async fn run_replay_event_loop(
     ]);
     DEBUG_STATS.set_phase(super::ActivityPhase::Live, "post-replay");
 
+    // Replay done — allow verifier to run and report scanning=false to frontend.
+    scanning.store(false, Ordering::Relaxed);
+
     log::info!("Replay: switching to live mode");
     let mut reconciler = EventReconciler::new();
     reconciler.switch_to_live();
diff --git a/apps/desktop/src-tauri/src/indexing/mod.rs b/apps/desktop/src-tauri/src/indexing/mod.rs
@@ -404,10 +404,12 @@ impl IndexManager {
                 },
                 fallback_tx,
                 watcher_overflow,
+                Arc::clone(&scanning),
             )
             .await;
 
-            // Replay done (now in live mode) — allow verifier to run.
+            // Live event loop ended (shutdown). Clear scanning as a safety net
+            // (normally cleared inside run_replay_event_loop after replay phase).
             scanning.store(false, Ordering::Relaxed);
 
             if let Err(e) = result {
diff --git a/apps/desktop/src/lib/indexing/index-state.svelte.ts b/apps/desktop/src/lib/indexing/index-state.svelte.ts
@@ -18,6 +18,10 @@ let replayEventsProcessed = $state(0)
 let replayEstimatedTotal = $state(0)
 let replayStartedAt = $state(0)
 
+// Monotonic counter bumped by every scan/replay event. Prevents the `get_index_status`
+// IPC response (which can arrive late) from overwriting state that an event already set.
+let eventVersion = 0
+
 // Aggregation state
 let aggregating = $state(false)
 let aggregationPhase = $state('')
@@ -118,6 +122,7 @@ const unlistenHandles: UnlistenFn[] = []
 /** Set up listeners for index scan events. Call once during app init. */
 export async function initIndexState(): Promise<void> {
     const unlistenStarted = await listen<{ volumeId: string }>('index-scan-started', () => {
+        eventVersion++
         scanning = true
         resetCounters()
         resetAggregation()
@@ -141,6 +146,7 @@ export async function initIndexState(): Promise<void> {
         totalDirs: number
         durationMs: number
     }>('index-scan-complete', (event) => {
+        eventVersion++
         scanning = false
         entriesScanned = event.payload.totalEntries
         dirsFound = event.payload.totalDirs
@@ -199,6 +205,7 @@ export async function initIndexState(): Promise<void> {
         volumeId: string
         durationMs: number
     }>('index-replay-complete', () => {
+        eventVersion++
         resetReplay()
         scanning = false
     })
@@ -207,6 +214,10 @@ export async function initIndexState(): Promise<void> {
     // Query current status to catch scans already in progress before the frontend loaded.
     // The scan starts in Tauri's setup() hook, so the 'index-scan-started' event may fire
     // before the frontend's event listeners are registered.
+    //
+    // Guard: snapshot eventVersion before the IPC call. If any scan/replay event arrived
+    // while the response was in flight, the event's state is more recent — skip the IPC result.
+    const versionBeforeIpc = eventVersion
     try {
         const status = await invoke<{
             initialized: boolean
@@ -216,7 +227,7 @@ export async function initIndexState(): Promise<void> {
             indexStatus: unknown
             dbFileSize: number | null
         }>('get_index_status')
-        if (status.scanning) {
+        if (status.scanning && eventVersion === versionBeforeIpc) {
             scanning = true
             entriesScanned = status.entriesScanned
             dirsFound = status.dirsFound
