fix(webapp): stop the URI resolver working after the panel closes

A request still in flight at unmount rejected afterwards, and the catch scheduled
a retry that fetched again and set state for a component that was gone. The hook
tracks whether it is still mounted and neither records nor reschedules once it is
not.

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/resolve-uris.test.ts

@@ -1,5 +1,6 @@
+import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
-import { MAX_URIS_PER_RESOLVE_REQUEST, planUriBatches } from "./resolve-uris";
+import { MAX_URIS_PER_RESOLVE_REQUEST, planUriBatches, shouldScheduleRetry } from "./resolve-uris";
 
 const uri = (index: number) => `trigger://runs/run_${index}`;
 
@@ -30,3 +31,39 @@ describe("planUriBatches", () => {
     expect(planUriBatches([])).toEqual([]);
   });
 });
+
+describe("shouldScheduleRetry", () => {
+  it("retries a transient failure while the cards are still on screen", () => {
+    expect(shouldScheduleRetry({ mounted: true, timerPending: false })).toBe(true);
+  });
+
+  it("schedules nothing once the panel is gone", () => {
+    // A request in flight at unmount rejects afterwards; its retry would fetch
+    // again and set state for a component that no longer exists.
+    expect(shouldScheduleRetry({ mounted: false, timerPending: false })).toBe(false);
+    expect(shouldScheduleRetry({ mounted: false, timerPending: true })).toBe(false);
+  });
+
+  it("lets one timer serve every batch", () => {
+    expect(shouldScheduleRetry({ mounted: true, timerPending: true })).toBe(false);
+  });
+});
+
+/**
+ * Structural guard, not behavioural proof: the webapp has no DOM test environment, so nothing
+ * here mounts the hook or unmounts it mid-flight. It asserts the policy above is the one the
+ * hook asks, and that the unmount path is wired.
+ */
+describe("useTriggerUriResolver's unmount wiring", () => {
+  const source = readFileSync(new URL("./useTriggerUriResolver.ts", import.meta.url), "utf8");
+
+  it("asks `shouldScheduleRetry` rather than testing the timer itself", () => {
+    expect(source).toContain("shouldScheduleRetry({");
+    expect(source).not.toMatch(/if \(retryTimer\.current === undefined\)/);
+  });
+
+  it("marks itself unmounted on cleanup and drops state updates after that", () => {
+    expect(source).toContain("mounted.current = false");
+    expect(source).toContain("if (!mounted.current) return;");
+  });
+});

apps/webapp/app/components/dashboard-agent/resolve-uris.ts

@@ -11,6 +11,21 @@ export const MAX_RESOLVE_ATTEMPTS = 3;
 
 export const RESOLVE_RETRY_DELAY_MS = 1_000;
 
+/**
+ * A request in flight at unmount rejects afterwards. Its retry must not be scheduled: the
+ * callback would fetch again for a component that is gone, and record the answer into state.
+ * One timer serves every batch, so a pending one is not replaced either.
+ */
+export function shouldScheduleRetry({
+  mounted,
+  timerPending,
+}: {
+  mounted: boolean;
+  timerPending: boolean;
+}): boolean {
+  return mounted && !timerPending;
+}
+
 /** Deduplicates, then splits into requests no bigger than the cap. */
 export function planUriBatches(
   uris: readonly string[],

apps/webapp/app/components/dashboard-agent/useTriggerUriResolver.ts

@@ -1,7 +1,12 @@
 import { isTriggerUri } from "@internal/dashboard-agent-contracts";
 import { useCallback, useEffect, useRef, useState } from "react";
 import type { ResolvedUri } from "./ReportView";
-import { MAX_RESOLVE_ATTEMPTS, planUriBatches, RESOLVE_RETRY_DELAY_MS } from "./resolve-uris";
+import {
+  MAX_RESOLVE_ATTEMPTS,
+  planUriBatches,
+  RESOLVE_RETRY_DELAY_MS,
+  shouldScheduleRetry,
+} from "./resolve-uris";
 
 /**
  * Synchronous facade over the panel's async `resolve-many` action: the first render of a URI
@@ -16,6 +21,7 @@ export function useTriggerUriResolver(actionPath: string): (uri: string) => Reso
   const inFlight = useRef(new Set<string>());
   const attempts = useRef(new Map<string, number>());
   const retryTimer = useRef<number | undefined>(undefined);
+  const mounted = useRef(true);
 
   const resolveUri = useCallback(
     (uri: string): ResolvedUri | null => {
@@ -27,6 +33,7 @@ export function useTriggerUriResolver(actionPath: string): (uri: string) => Reso
   );
 
   const record = useCallback((entries: Record<string, ResolvedUri | null>) => {
+    if (!mounted.current) return;
     answered.current = { ...answered.current, ...entries };
     setResolved((previous) => ({ ...previous, ...entries }));
   }, []);
@@ -72,7 +79,12 @@ export function useTriggerUriResolver(actionPath: string): (uri: string) => Reso
           }
           if (Object.keys(exhausted).length > 0) record(exhausted);
           // One timer for all batches; a render may never follow, so it can't be the trigger.
-          if (retryTimer.current === undefined) {
+          if (
+            shouldScheduleRetry({
+              mounted: mounted.current,
+              timerPending: retryTimer.current !== undefined,
+            })
+          ) {
             retryTimer.current = window.setTimeout(() => {
               retryTimer.current = undefined;
               flushRef.current();
@@ -92,12 +104,14 @@ export function useTriggerUriResolver(actionPath: string): (uri: string) => Reso
     flush();
   });
 
-  useEffect(
-    () => () => {
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
       if (retryTimer.current !== undefined) window.clearTimeout(retryTimer.current);
-    },
-    []
-  );
+      retryTimer.current = undefined;
+    };
+  }, []);
 
   return resolveUri;
 }