fix: register cancel flags for image/webpage/document compares, fix progress bar and cache invalidation

- Document, image, and webpage compare endpoints now register cancel
  flags so the Stop button can interrupt them. After the core compare
  returns, the result is discarded if cancelled (returns {cancelled:true}).
  Refactored the cancel+progress registration into a CancellableRequest
  struct to avoid clippy type_complexity.
- Folder compare progress bar no longer stalls near 50%: the walk emits
  Discovered events per-side (~2x for similar trees), so the compare-phase
  total now uses discovered_total/2 as the estimate with .max() self-
  correction for asymmetric trees.
- folder_op_execute_bridge_response now invalidates folder_compare_cache
  after mutating the filesystem, preventing stale reads if a subsequent
  /folder/query runs before the GUI triggers a recompare.

Author: visorcraft

apps/linsync-gui/src/bridge.rs

@@ -308,10 +308,10 @@ pub(crate) fn bridge_response_with_token(
                 Ok(p) => p,
                 Err(err) => return bridge_error(400, "Bad Request", &err),
             };
-            let (request_id, progress) =
-                register_progress_request(&params, state, "extracting", 3, "Extracting text");
+            let req =
+                register_cancellable_request(&params, state, "extracting", 3, "Extracting text");
             set_progress(
-                &progress,
+                &req.progress,
                 "extracting",
                 1,
                 3,
@@ -322,8 +322,19 @@ pub(crate) fn bridge_response_with_token(
                     query,
                     &profile.document,
                 );
+            // If the user hit Stop during the (potentially slow) plugin
+            // extraction, discard the result and report cancellation.
+            if req.is_cancelled() {
+                remove_cancellable_request(&req, state);
+                return http_response(
+                    200,
+                    "OK",
+                    "application/json",
+                    br#"{"cancelled":true}"#.to_vec(),
+                );
+            }
             set_progress(
-                &progress,
+                &req.progress,
                 "finalizing",
                 2,
                 3,
@@ -356,8 +367,8 @@ pub(crate) fn bridge_response_with_token(
                     }
                 }
             }
-            set_progress(&progress, "done", 3, 3, String::new());
-            remove_progress_request(request_id.as_deref(), state);
+            set_progress(&req.progress, "done", 3, 3, String::new());
+            remove_cancellable_request(&req, state);
             http_response(200, "OK", "application/json", body.into_bytes())
         }
         "/profiles/list" => profiles_list_bridge_response(paths),
@@ -374,8 +385,21 @@ pub(crate) fn bridge_response_with_token(
                 Ok(p) => p,
                 Err(err) => return bridge_error(400, "Bad Request", &err),
             };
+            let req =
+                register_cancellable_request(&params, state, "comparing", 1, "Comparing images");
             let (mut body, result) =
                 linsync::image_compare_bridge_response_with_profile(query, &profile.image);
+            // If the user hit Stop during the compare, discard the result.
+            if req.is_cancelled() {
+                remove_cancellable_request(&req, state);
+                return http_response(
+                    200,
+                    "OK",
+                    "application/json",
+                    br#"{"cancelled":true}"#.to_vec(),
+                );
+            }
+            remove_cancellable_request(&req, state);
             let result_for_tab = result.clone();
             let overlay_path = serde_json::from_str::<serde_json::Value>(&body)
                 .ok()
@@ -420,10 +444,10 @@ pub(crate) fn bridge_response_with_token(
                 Ok(p) => p,
                 Err(err) => return bridge_error(400, "Bad Request", &err),
             };
-            let (request_id, progress) =
-                register_progress_request(&params, state, "fetching", 3, "Fetching webpages");
+            let req =
+                register_cancellable_request(&params, state, "fetching", 3, "Fetching webpages");
             set_progress(
-                &progress,
+                &req.progress,
                 "fetching",
                 1,
                 3,
@@ -434,8 +458,19 @@ pub(crate) fn bridge_response_with_token(
                 paths,
                 &profile.webpage,
             );
+            // If the user hit Stop during the (potentially slow) fetch/render,
+            // discard the result and report cancellation.
+            if req.is_cancelled() {
+                remove_cancellable_request(&req, state);
+                return http_response(
+                    200,
+                    "OK",
+                    "application/json",
+                    br#"{"cancelled":true}"#.to_vec(),
+                );
+            }
             set_progress(
-                &progress,
+                &req.progress,
                 "finalizing",
                 2,
                 3,
@@ -457,8 +492,8 @@ pub(crate) fn bridge_response_with_token(
                     state,
                 );
             }
-            set_progress(&progress, "done", 3, 3, String::new());
-            remove_progress_request(request_id.as_deref(), state);
+            set_progress(&req.progress, "done", 3, 3, String::new());
+            remove_cancellable_request(&req, state);
             http_response(200, "OK", "application/json", body.into_bytes())
         }
         "/compare/webpage/clear-cache" => {
@@ -3869,6 +3904,13 @@ pub(crate) fn folder_op_execute_bridge_response(
         linsync_core::PermanentDeleteConfirmation::NotConfirmed
     };
     let outcomes = execute_folder_operation_plan(&plan, &paths.data_dir, use_trash, confirmation);
+    // The filesystem changed — invalidate the cached folder compare so the
+    // next /folder/query doesn't serve pre-operation results. (The GUI
+    // normally calls requestCompare after execute, which also clears it,
+    // but this is defense-in-depth against stale-cache reads.)
+    if let Ok(mut state) = state.lock() {
+        state.folder_compare_cache = None;
+    }
     let body = folder_outcomes_to_json(&plan, &outcomes).to_string();
     http_response(200, "OK", "application/json", body.into_bytes())
 }

apps/linsync-gui/src/main.rs

@@ -515,6 +515,61 @@ fn remove_progress_request(request_id: Option<&str>, state: &Arc<Mutex<GuiBridge
     }
 }
 
+/// A registered cancellable compare request: holds the request id (for
+/// cleanup), a should_cancel closure (polled by the compare), and a progress
+/// tracker (updated by the compare, read by `/progress`).
+struct CancellableRequest {
+    request_id: Option<String>,
+    should_cancel: Box<dyn Fn() -> bool>,
+    progress: Option<Arc<Mutex<CompareProgress>>>,
+}
+
+impl CancellableRequest {
+    /// Polls the cancellation flag. Returns `false` when no `request_id`
+    /// was supplied (nothing to cancel).
+    fn is_cancelled(&self) -> bool {
+        (self.should_cancel)()
+    }
+}
+
+/// Register both a progress tracker and a cancellation flag for a compare
+/// request. Call [`CancellableRequest::remove`] (or
+/// [`remove_cancellable_request`]) when the compare finishes or is cancelled.
+fn register_cancellable_request(
+    params: &[(String, String)],
+    state: &Arc<Mutex<GuiBridgeState>>,
+    phase: &str,
+    total: usize,
+    message: &str,
+) -> CancellableRequest {
+    let (request_id, progress) = register_progress_request(params, state, phase, total, message);
+    let should_cancel: Box<dyn Fn() -> bool> = if let Some(id) = &request_id {
+        let flag = Arc::new(AtomicBool::new(false));
+        if let Ok(mut state) = state.lock() {
+            state.compare_cancels.insert(id.clone(), Arc::clone(&flag));
+        }
+        Box::new(move || flag.load(Ordering::Relaxed))
+    } else {
+        Box::new(|| false)
+    };
+    CancellableRequest {
+        request_id,
+        should_cancel,
+        progress,
+    }
+}
+
+/// Remove the cancel flag and progress tracker registered by
+/// [`register_cancellable_request`].
+fn remove_cancellable_request(req: &CancellableRequest, state: &Arc<Mutex<GuiBridgeState>>) {
+    if let Some(id) = &req.request_id
+        && let Ok(mut state) = state.lock()
+    {
+        state.compare_cancels.remove(id);
+    }
+    remove_progress_request(req.request_id.as_deref(), state);
+}
+
 const GUI_HISTORY_LIMIT: usize = 16;
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
@@ -2233,7 +2288,11 @@ fn folder_tab_cancellable(
                 {
                     p.phase = "comparing".to_owned();
                     p.current = compared_count;
-                    p.total = discovered_total.max(compared_count);
+                    // Discovered fires per-side (left walk + right walk), so
+                    // the unique entry count is roughly half. Use that as the
+                    // compare-phase total estimate; .max() self-corrects for
+                    // asymmetric trees where one side dominates.
+                    p.total = (discovered_total / 2).max(compared_count);
                     p.message = relative_path.display().to_string();
                 }
             }
@@ -2243,7 +2302,7 @@ fn folder_tab_cancellable(
                 {
                     p.phase = "done".to_owned();
                     p.current = compared_count;
-                    p.total = discovered_total.max(compared_count);
+                    p.total = compared_count;
                     p.message.clear();
                 }
             }