// Shared stale-while-revalidate health probing for connections. Two surfaces// render a connection's health (the detail page's AccountRow and the// integrations-list summary), and both must revalidate the same way: render// the persisted `lastHealth` verdict instantly, then probe in the background// unless the verdict is healthy and fresh. Keeping the guard, the `ifStaleMs`// semantics, and the freshness window here means the two surfaces cannot// drift apart. import { useCallback, useContext, useEffect, useRef, useState } from "react";import { RegistryContext, useAtomSet } from "@effect/atom-react";import * as Exit from "effect/Exit";import type { Connection, HealthCheckResult, HealthStatus, Owner } from "@executor-js/sdk/shared"; import { checkConnectionHealth, connectionsOptimisticAtom } from "../api/atoms";import { connectionCheckKeys } from "../api/reactivity-keys"; /** Freshness window for automatic revalidation: a HEALTHY verdict younger *  than this renders as-is; anything else (stale, missing, or non-healthy) *  triggers a background probe on mount. Server-enforced for the healthy *  path too, so concurrent tabs collapse to one probe. */export const HEALTH_REVALIDATE_MS = 5 * 60 * 1000; const connectionParams = (connection: Connection) => ({  owner: connection.owner,  integration: connection.integration,  name: connection.name,}); /** Whether a persisted verdict may render as-is without a background probe. *  Healthy-and-fresh renders untouched. Everything else revalidates: stale or *  never-checked for obvious reasons, and NON-healthy always; an expired dot *  is exactly the verdict the user is waiting to see change, so recovery must *  show on the next load, not after the freshness window. */const healthyAndFresh = (last: HealthCheckResult | null | undefined): boolean =>  last?.status === "healthy" && Date.now() - last.checkedAt < HEALTH_REVALIDATE_MS; /** The revalidation query: a healthy (but stale) verdict defers to the *  server-enforced window so N open tabs can't stampede the upstream; a *  missing or non-healthy verdict forces a fresh probe. */const revalidateQuery = (  last: HealthCheckResult | null | undefined,): { readonly ifStaleMs?: number } =>  last?.status === "healthy" ? { ifStaleMs: HEALTH_REVALIDATE_MS } : {}; /** Identity of a persisted verdict, for detecting the reconnect transition. *  An OAuth re-mint clears `last_health`, so a verdict giving way to `null` *  means the grant was replaced and the row must re-probe even though it never *  remounts (its React key is owner:integration:name, unchanged by a *  reconnect). This CLEARING transition is the only re-trigger: reacting to *  every epoch change instead would race probes against cache refetches *  (a refetch can deliver a snapshot older than a just-adopted verdict) and *  storm upstreams with re-probes. `null` is a real epoch — never-checked or *  just-re-minted — distinct from the "never seen" sentinel `undefined`. */const verdictEpoch = (last: HealthCheckResult | null | undefined): number | null =>  last?.checkedAt ?? null; /** The verdict to display: whichever of the live probe and the persisted *  verdict is FRESHEST. A plain live-over-persisted preference would let a *  pre-reconnect probe shadow the verdict a completed reconnect persisted *  (any surface may write a newer verdict server-side; this hook only learns *  of it through the refetched row). Ties keep the live result: identical *  timestamps mean it IS the persisted verdict, echoed back. */const freshestVerdict = (  live: HealthCheckResult | null,  persisted: HealthCheckResult | null | undefined,): HealthCheckResult | null => {  if (live === null) return persisted ?? null;  if (persisted == null) return live;  return persisted.checkedAt > live.checkedAt ? persisted : live;}; /** * Imperative invalidation of the connections cache for one owner. The server * persists every verdict on `last_health`, so after a check we must re-read the * connection rows or a later render within the atom TTL serves the pre-check * state. Returns a stable callback usable from a probe's `.then` for any owner * (the loop surface probes across both owners), refreshing the optimistic atom * every connections view derives from. */function useInvalidateConnections(): (owner: Owner) => void {  const registry = useContext(RegistryContext);  return useCallback(    (owner: Owner) => registry.refresh(connectionsOptimisticAtom(owner)),    [registry],  );} /** * Health for ONE connection, stale-while-revalidate. The persisted verdict * renders instantly; a background probe on mount corrects it in place (once * per mount, quiet on failure: the persisted verdict is still the best known * state). `runCheck` is the manual path ("Check now"): it always forces a * fresh probe and folds the result into the same live state. */export function useConnectionHealth(connection: Connection): {  readonly probe: HealthCheckResult | null;  readonly status: HealthStatus;  readonly runCheck: () => Promise<Exit.Exit<HealthCheckResult, unknown>>;} {  // A live probe result, once a check has run; merged with the persisted  // verdict by freshness (see freshestVerdict for why not live-always-wins).  const [liveProbe, setLiveProbe] = useState<HealthCheckResult | null>(null);  const doCheck = useAtomSet(checkConnectionHealth, { mode: "promiseExit" });  const invalidateConnections = useInvalidateConnections();   const probe = freshestVerdict(liveProbe, connection.lastHealth);  const status: HealthStatus = probe?.status ?? "unknown";   // Health checks are AUTOMATIC: loading the list revalidates any verdict  // older than the freshness window (or never checked), stale-while-revalidate  // style: the persisted verdict renders instantly, the probe corrects it in  // place. The guard is once per mount PLUS once per clearing: the ref holds  // the last epoch seen, and a verdict giving way to `null` (an OAuth re-mint  // cleared it) re-arms the probe — that is how a completed reconnect gets its  // recovery probe without a page reload. Only the clearing transition  // re-arms; every other epoch change (a probe's own verdict echoed back by  // the refetch, a concurrent surface's fresher verdict) stays quiet, keeping  // the no-probe-storm invariant of the original once-per-mount guard.  const seenEpoch = useRef<number | null | undefined>(undefined);  useEffect(() => {    const last = connection.lastHealth;    const epoch = verdictEpoch(last);    const firstSight = seenEpoch.current === undefined;    const cleared = epoch === null && seenEpoch.current !== null && !firstSight;    seenEpoch.current = epoch;    if (!firstSight && !cleared) return;    if (healthyAndFresh(last)) return;    void doCheck({      params: connectionParams(connection),      query: revalidateQuery(last),    }).then((exit) => {      // Background refresh: update the dot on success, stay quiet on failure      // (the persisted verdict is still the best known state). Invalidate the      // connections cache ONLY when the verdict actually changed: on the      // common no-change reconfirm we skip it, so an automatic probe never      // churns the cache (which would refetch connections, re-run this      // effect, and, but for the epoch guard, risk a probe loop).      if (!Exit.isSuccess(exit)) return;      seenEpoch.current = exit.value.checkedAt;      setLiveProbe(exit.value);      if (exit.value.status !== (last?.status ?? "unknown")) {        invalidateConnections(connection.owner);      }    });  }, [connection, doCheck, invalidateConnections]);   const runCheck = useCallback(async () => {    // Manual "Check now": invalidate the connections cache unconditionally so    // every surface picks up the freshly persisted verdict. Adopting the    // result's epoch keeps the resulting refetch from re-probing.    const exit = await doCheck({      params: connectionParams(connection),      query: {},      reactivityKeys: connectionCheckKeys,    });    if (Exit.isSuccess(exit)) {      seenEpoch.current = exit.value.checkedAt;      setLiveProbe(exit.value);    }    return exit;  }, [connection, doCheck]);   return { probe, status, runCheck };} const probeKey = (connection: Connection): string =>  `${connection.owner}:${connection.integration}:${connection.name}`; /** * Health for MANY connections at once (the integrations-list summary), where * hooks-in-a-loop is illegal. One effect walks the list and fires the same * guarded per-connection revalidation as `useConnectionHealth`, accumulating * live probes in a map keyed by `owner:integration:name`. The returned reader * resolves a connection's best-known probe: the live result when a check has * run, otherwise the persisted verdict. */export function useConnectionsHealth(  connections: readonly Connection[],): (connection: Connection) => HealthCheckResult | null {  const [liveProbes, setLiveProbes] = useState<ReadonlyMap<string, HealthCheckResult>>(new Map());  const doCheck = useAtomSet(checkConnectionHealth, { mode: "promiseExit" });  const invalidateConnections = useInvalidateConnections();   // Once per VERDICT per connection (same epoch guard as the single-connection  // hook): the list streams in asynchronously, so the effect re-runs as rows  // arrive; each row probes once per persisted-verdict epoch, and a re-minted  // connection (epoch cleared to null) probes again without a remount.  const revalidated = useRef(new Map<string, number | null>());  useEffect(() => {    for (const connection of connections) {      const key = probeKey(connection);      const last = connection.lastHealth;      const epoch = verdictEpoch(last);      if (revalidated.current.has(key) && revalidated.current.get(key) === epoch) continue;      revalidated.current.set(key, epoch);      if (healthyAndFresh(last)) continue;      void doCheck({        params: connectionParams(connection),        query: revalidateQuery(last),      }).then((exit) => {        // Same automatic-path rule as the single-connection hook: reflect the        // verdict, adopt its epoch so the refetch doesn't re-probe, and        // invalidate the connections cache only when the verdict changed so an        // unchanged reconfirm never churns the cache.        if (!Exit.isSuccess(exit)) return;        revalidated.current.set(key, exit.value.checkedAt);        setLiveProbes((current) => new Map(current).set(key, exit.value));        if (exit.value.status !== (last?.status ?? "unknown")) {          invalidateConnections(connection.owner);        }      });    }  }, [connections, doCheck, invalidateConnections]);   return useCallback(    (connection: Connection) =>      freshestVerdict(liveProbes.get(probeKey(connection)) ?? null, connection.lastHealth),    [liveProbes],  );}