Packages list: subscribe before snapshot so a clearing event can't leave a row stale-red

The autosync-paused row could stay wrongly red when a package resolved
(publish or non-paused status) right as the list mounted. tauri_bridge::listen
registers its backend listener asynchronously and Tauri does not replay events
emitted before registration completes, so a clear landing between the snapshot
capture and the listener going active was dropped, resolved_since_mount never
recorded it, and the snapshot merge resurrected the stale pause.

Add listen_with_ready, which returns the EventListener synchronously (cleanup
unchanged) plus a future that resolves once the registration Promise settles
(a clone of the same Promise the internal task awaits, so no new dependency).
Register the status and published listeners with it and await both readiness
futures before fetching the snapshot, closing the registration gap; keep the
resolved_since_mount skip as the belt for the capture-to-merge window.

Author: fiskus

quilt-sync/ui/src/pages/installed_packages_list.rs

@@ -90,43 +90,40 @@ pub fn InstalledPackagesList() -> impl IntoView {
     // *before* those events, so it must not resurrect a pause the user has
     // already resolved — the merge skips anything in this set.
     let resolved_since_mount: RwSignal<HashSet<String>> = RwSignal::new(HashSet::new());
-    leptos::task::spawn_local(async move {
-        if let Ok(snapshot) = commands::get_autosync_snapshot().await {
-            let resolved = resolved_since_mount.get_untracked();
-            paused_map.update(|map| {
-                for entry in snapshot.paused {
-                    if resolved.contains(&entry.namespace) {
-                        continue;
-                    }
-                    if let Some(message) = entry.message {
-                        map.insert(entry.namespace, message);
-                    }
-                }
-            });
-        }
-    });
 
-    let listener = tauri_bridge::listen::<PackageStatusEvent>(PACKAGE_STATUS_EVENT, move |ev| {
-        // Any non-paused status means the namespace is no longer
-        // autosync-paused — drop it so the row stops rendering red.
-        if ev.status != "paused" {
-            let ns = ev.namespace.clone();
-            paused_map.update(|map| {
-                map.remove(&ns);
-            });
-            resolved_since_mount.update(|r| {
-                r.insert(ns);
-            });
-        }
-        status_event.set(Some(ev));
-    });
+    // Subscribe-then-fetch. `tauri_bridge::listen` registers the backend
+    // listener asynchronously and Tauri does not replay events emitted
+    // before the registration Promise resolves. So a clear (publish /
+    // non-paused status) landing between the snapshot capture and the
+    // listener becoming active would be dropped, `resolved_since_mount`
+    // would never record it, and the merge below would resurrect the stale
+    // pause. To close that window we register the two clear-relevant
+    // listeners up front, then `.await` their readiness before fetching the
+    // snapshot: any clear after the snapshot is captured is delivered to an
+    // already-active listener, and any clear before capture is already
+    // reflected in the snapshot itself.
+    let (listener, status_ready) =
+        tauri_bridge::listen_with_ready::<PackageStatusEvent>(PACKAGE_STATUS_EVENT, move |ev| {
+            // Any non-paused status means the namespace is no longer
+            // autosync-paused — drop it so the row stops rendering red.
+            if ev.status != "paused" {
+                let ns = ev.namespace.clone();
+                paused_map.update(|map| {
+                    map.remove(&ns);
+                });
+                resolved_since_mount.update(|r| {
+                    r.insert(ns);
+                });
+            }
+            status_event.set(Some(ev));
+        });
     on_cleanup(move || drop(listener));
 
     // Autosync publish events — emit a toast mirroring the manual
     // Commit & Push success notification, and clear any pause for the
     // published namespace so its row is no longer red.
-    let publish_listener =
-        tauri_bridge::listen::<PublishedEvent>(AUTOSYNC_PUBLISHED_EVENT, move |ev| {
+    let (publish_listener, published_ready) =
+        tauri_bridge::listen_with_ready::<PublishedEvent>(AUTOSYNC_PUBLISHED_EVENT, move |ev| {
             let ns = ev.namespace.clone();
             paused_map.update(|map| {
                 map.remove(&ns);
@@ -141,6 +138,29 @@ pub fn InstalledPackagesList() -> impl IntoView {
         });
     on_cleanup(move || drop(publish_listener));
 
+    // Fetch the snapshot only after both clear-relevant listeners are active
+    // on the backend (see subscribe-then-fetch note above). The
+    // `resolved_since_mount` skip remains the belt for the residual
+    // capture→merge window, where a clear can arrive after the snapshot is
+    // captured but before this merge runs.
+    leptos::task::spawn_local(async move {
+        status_ready.await;
+        published_ready.await;
+        if let Ok(snapshot) = commands::get_autosync_snapshot().await {
+            let resolved = resolved_since_mount.get_untracked();
+            paused_map.update(|map| {
+                for entry in snapshot.paused {
+                    if resolved.contains(&entry.namespace) {
+                        continue;
+                    }
+                    if let Some(message) = entry.message {
+                        map.insert(entry.namespace, message);
+                    }
+                }
+            });
+        }
+    });
+
     // Autosync pause events — surface as a warning toast carrying the
     // reason. The detail page reads the same event to drive its
     // persistent banner, so the user sees both the immediate toast

quilt-sync/ui/src/tauri.rs

@@ -68,8 +68,32 @@ enum ListenerState {
 /// `Drop` and the JS side actually detaching.
 pub fn listen<T: DeserializeOwned + 'static>(
     event: &str,
-    mut callback: impl FnMut(T) + 'static,
+    callback: impl FnMut(T) + 'static,
 ) -> EventListener {
+    // Discarding the readiness future is safe: it is a plain async block
+    // (nothing is spawned) so dropping it unpolled runs no work and leaks
+    // nothing — callers that don't care when registration completes keep
+    // the old synchronous ergonomics.
+    listen_with_ready(event, callback).0
+}
+
+/// Like [`listen`], but also exposes when the backend listener is
+/// *active*. `tauri_listen_raw` registers asynchronously: it returns a
+/// Promise and events emitted before that Promise resolves are dropped
+/// (Tauri does not replay). Callers that must observe every event from a
+/// point in time onward can `.await` the returned future before doing the
+/// thing that triggers those events (e.g. fetching a snapshot), so no
+/// event falls into the registration gap.
+///
+/// The `EventListener` is returned synchronously — `on_cleanup` can drop
+/// it exactly as with [`listen`]. The future resolves once the same
+/// registration Promise has settled (resolved *or* rejected: a failed
+/// registration is logged by the internal task, and hanging the caller
+/// forever would be worse than proceeding).
+pub fn listen_with_ready<T: DeserializeOwned + 'static>(
+    event: &str,
+    mut callback: impl FnMut(T) + 'static,
+) -> (EventListener, impl std::future::Future<Output = ()>) {
     let event_name = event.to_string();
     let event_name_for_closure = event_name.clone();
     let closure: Closure<dyn FnMut(JsValue)> = Closure::new(move |raw: JsValue| {
@@ -83,6 +107,12 @@ pub fn listen<T: DeserializeOwned + 'static>(
     let promise = tauri_listen_raw(&event_name, closure.as_ref().unchecked_ref());
     closure.forget();
 
+    // A JS Promise can be awaited by multiple consumers; a clone shares the
+    // same underlying settlement. The internal task below awaits `promise`
+    // to capture the `unlisten` function, while the readiness future awaits
+    // this clone — both fire when the backend listener becomes active.
+    let ready_promise = promise.clone();
+
     // `SendWrapper` lets the !Send JS handle satisfy `on_cleanup`'s
     // `Send + Sync` bound; WASM is single-threaded so the wrapper
     // never panics in practice.
@@ -116,9 +146,15 @@ pub fn listen<T: DeserializeOwned + 'static>(
         }
     });
 
-    EventListener {
+    let listener = EventListener {
         state: SendWrapper::new(state),
-    }
+    };
+    let ready = async move {
+        // Settlement (resolve or reject) is the readiness signal; on reject
+        // the internal task already logged the failure.
+        let _ = JsFuture::from(ready_promise).await;
+    };
+    (listener, ready)
 }
 
 pub struct EventListener {