Fix file_viewer: surface SearchStatus::Cancelled to the FE on cancel

search_cancel set the cancel flag and immediately nulled session.search.
That made the Cancelled state in the spawned search thread unobservable:
search_poll saw session.search == None and returned Idle, erasing the
'search was cancelled' signal the FE needs to distinguish 'completed
naturally' from 'aborted partway'. The Cancelled variant existed but had
no public path back to the caller.

Stop nulling session.search on cancel. The thread observes the flag,
exits its loop, and writes SearchStatus::Cancelled to the shared status
mutex. Subsequent polls see it. The next search_start atomically replaces
session.search with a fresh state, so the Cancelled status is naturally
cleared when a new search begins (search_start already calls search_cancel
first, so the contract holds end-to-end).

Update search_cancel_works to assert the observable Cancelled transition
instead of the previous 'Idle (because state was cleared)' behaviour.

Author: vdavid

apps/desktop/src-tauri/src/file_viewer/session.rs

@@ -391,6 +391,12 @@ pub fn search_poll(session_id: &str, since_index: usize) -> Result<SearchPollRes
 }
 
 /// Cancels an ongoing search.
+///
+/// Sets the cancel flag and leaves the `SearchState` in place so the spawned
+/// search thread can write the final `SearchStatus::Cancelled` and so
+/// subsequent `search_poll` calls surface that transition to the FE. The
+/// `SearchState` is replaced atomically the next time `search_start` is called
+/// (which itself begins by calling this function, then installs a fresh state).
 pub fn search_cancel(session_id: &str) -> Result<(), ViewerError> {
     let mut sessions = SESSIONS.lock_ignore_poison();
     let session = sessions
@@ -400,7 +406,6 @@ pub fn search_cancel(session_id: &str) -> Result<(), ViewerError> {
     if let Some(search) = &session.search {
         search.cancel.store(true, Ordering::Relaxed);
     }
-    session.search = None;
 
     Ok(())
 }

apps/desktop/src-tauri/src/file_viewer/session_test.rs

@@ -164,12 +164,27 @@ fn search_cancel_works() {
 
     session::search_start(sid, "hello".to_string()).unwrap();
 
-    // Cancel immediately
+    // Cancel immediately. The cancel flag is set synchronously; the search
+    // thread will see it on its next iteration and exit, writing the final
+    // `SearchStatus::Cancelled` to the shared status mutex.
     session::search_cancel(sid).unwrap();
 
-    // Poll should show cancelled or idle (since we removed the search state)
-    let poll = session::search_poll(sid, 0).unwrap();
-    assert!(matches!(poll.status, SearchStatus::Idle));
+    // Poll until the thread observes the cancel and transitions to Cancelled.
+    let mut saw_cancelled = false;
+    for _ in 0..200 {
+        let poll = session::search_poll(sid, 0).unwrap();
+        if matches!(poll.status, SearchStatus::Cancelled) {
+            saw_cancelled = true;
+            break;
+        }
+        assert!(
+            matches!(poll.status, SearchStatus::Running),
+            "expected Running or Cancelled while cancellation propagates, got {:?}",
+            poll.status
+        );
+        thread::sleep(Duration::from_millis(10));
+    }
+    assert!(saw_cancelled, "search did not transition to Cancelled in time");
 
     session::close_session(sid).unwrap();
     cleanup(&dir);