@opengeni/react 4.2.1-canary.39642758903001 → 4.3.1

package/dist/{chunk-SOOWLNC5.js → chunk-GJUPLSC5.js}

@@ -3,6 +3,9 @@ import {
   deniesRetainedView,
   useRetainedSessionView
 } from "./chunk-TWXIFWBD.js";
+import {
+  useFileAttachments
+} from "./chunk-I6FIXEL4.js";
 import {
   projectPendingApprovals
 } from "./chunk-UD2PSIIX.js";
@@ -12,10 +15,7 @@ import {
   isToolOutputPreviewEvent,
   sessionStatusFromEvents,
   useToolOutputReads
-} from "./chunk-OS3EQOIS.js";
-import {
-  useFileAttachments
-} from "./chunk-I6FIXEL4.js";
+} from "./chunk-T4F5TW2X.js";
 import {
   useSharedQuery
 } from "./chunk-JKUICTLM.js";
@@ -23,25 +23,22 @@ import {
   cachedClientConfigRead,
   joinClientConfigRead
 } from "./chunk-IGVL3ELX.js";
-import {
-  readAcknowledgementFrontier,
-  sessionAttentionReadThroughSequence
-} from "./chunk-C5ZCSVZ7.js";
-import {
-  isActionableHumanInputRequest
-} from "./chunk-IZV5FTJC.js";
 import {
   FILE_ONLY_MESSAGE_TEXT,
   notifyObserver,
   useComposer
-} from "./chunk-5IQBF2X3.js";
+} from "./chunk-BJPJ2OUX.js";
 import {
   coerceReasoningEffortForModel,
   defaultEffortForModel,
   projectPickerRows,
   runnableLatencyModesForModel,
   sortPickerRows
-} from "./chunk-GRLPRM56.js";
+} from "./chunk-CFEFYPNR.js";
+import {
+  readAcknowledgementFrontier,
+  sessionAttentionReadThroughSequence
+} from "./chunk-C5ZCSVZ7.js";
 import {
   projectionReadThrough,
   useDebouncedCallback,
@@ -61,9 +58,12 @@ import {
   useOpenGeni,
   useOpenGeniClient
 } from "./chunk-TVQCDDSZ.js";
+import {
+  isActionableHumanInputRequest
+} from "./chunk-IZV5FTJC.js";
 import {
   useOpenGeniText
-} from "./chunk-G7VLL3PG.js";
+} from "./chunk-F2YABPRJ.js";
 
 // src/older-history.ts
 var activeReceiptCapture;
@@ -573,6 +573,7 @@ function useSessionControl(sessionId, options = {}) {
 // src/hooks/use-session-events.ts
 import {
   isPresentedSessionToolName,
+  isRetryableStreamError,
   isSessionModelResponsePhase,
   SESSION_EVENT_COMPAT_EXCLUDED_STEP_TYPES,
   SESSION_EVENT_CONTENT_STEP_TYPES,
@@ -582,6 +583,65 @@ import {
 } from "@opengeni/sdk";
 import { startTransition, useCallback as useCallback6, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef4, useState as useState3 } from "react";
 
+// src/hooks/page-wake.ts
+var PAGE_WAKE_CHECK_INTERVAL_MS = 2e3;
+var PAGE_WAKE_GAP_MS = 15e3;
+var listeners = /* @__PURE__ */ new Set();
+var stopDetector = null;
+function subscribePageWake(listener) {
+  listeners.add(listener);
+  stopDetector ??= startDetector();
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0 && stopDetector) {
+      stopDetector();
+      stopDetector = null;
+    }
+  };
+}
+function emitPageWake() {
+  for (const listener of [...listeners]) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+}
+function startDetector() {
+  if (typeof window === "undefined" || typeof document === "undefined") return () => {
+  };
+  let lastTick = Date.now();
+  const check = () => {
+    const now = Date.now();
+    const elapsed = now - lastTick;
+    lastTick = now;
+    if (elapsed > PAGE_WAKE_GAP_MS) emitPageWake();
+  };
+  const onVisibility = () => {
+    if (document.visibilityState !== "hidden") check();
+  };
+  const onPageShow = (event) => {
+    lastTick = Date.now();
+    if (event.persisted) emitPageWake();
+  };
+  const onResume = () => {
+    lastTick = Date.now();
+    emitPageWake();
+  };
+  const timer = setInterval(check, PAGE_WAKE_CHECK_INTERVAL_MS);
+  document.addEventListener("visibilitychange", onVisibility);
+  document.addEventListener("resume", onResume);
+  window.addEventListener("pageshow", onPageShow);
+  window.addEventListener("online", onResume);
+  return () => {
+    clearInterval(timer);
+    document.removeEventListener("visibilitychange", onVisibility);
+    document.removeEventListener("resume", onResume);
+    window.removeEventListener("pageshow", onPageShow);
+    window.removeEventListener("online", onResume);
+  };
+}
+
 // src/hooks/turnless-output-gaps.ts
 import { useCallback as useCallback5, useSyncExternalStore } from "react";
 var MAX_IDLE_ENTRIES = 256;
@@ -639,6 +699,10 @@ var BOUNDARY_PAGE_CAP = 1;
 var FILTERED_PAGE_CAP = 32;
 var DIRECT_REPLAY_MAX_SEQUENCES = 16;
 var CATCHUP_MAX_PAGES = 2;
+var STRICT_REJOIN_ATTEMPTS = 5;
+var REJOIN_STALL_TIMEOUT_MS = 3e4;
+var FOREGROUND_REJOIN_RETRY_MS = 500;
+var FOREGROUND_REJOIN_RETRY_MAX_MS = 8e3;
 var EMPTY_EVENTS = [];
 var encoder = new TextEncoder();
 var SESSION_EVENT_BROWSER_MAX_BYTES = 16 * 1024 * 1024;
@@ -741,8 +805,8 @@ function useSessionEvents(sessionId, options = {}) {
     setStepStores(next);
   }, []);
   const pruneStepStores = useCallback6(
-    (window, sealedBy, rereading = null) => {
-      const present = windowTurns(window);
+    (window2, sealedBy, rereading = null) => {
+      const present = windowTurns(window2);
       const settled = sealedBy ? settledTurns(sealedBy) : null;
       const next = /* @__PURE__ */ new Map();
       for (const [turnId, store] of stepStoresRef.current) {
@@ -1136,49 +1200,59 @@ function useSessionEvents(sessionId, options = {}) {
         setHasOlder(true);
       }
     };
-    const readSessionHead = async () => {
-      const joined = joinSessionDetailRead(client, workspaceId, sessionId, detailReadMark);
+    const effectScope = { signal: controller.signal, isCurrent };
+    const readSessionHead = async (mark, scope) => {
+      const joined = joinSessionDetailRead(client, workspaceId, sessionId, mark);
       if (joined) {
         try {
           return await joined;
         } catch (cause) {
-          if (controller.signal.aborted) throw cause;
+          if (scope.signal.aborted) throw cause;
         }
       }
       return await client.getSession(workspaceId, sessionId, {
         fresh: true,
-        signal: controller.signal
+        signal: scope.signal
       });
     };
-    const rejoinLive = async (force) => {
+    const rejoinLive = async (force, {
+      strict = false,
+      mark = detailReadMark,
+      scope = effectScope
+    } = {}) => {
       const activeTurn = activeConversationTurn(eventWindowRef.current.events);
       if (!force && !activeTurn) return "joined";
       const cursor = streamResumeSequenceRef.current;
       let head;
       let sessionActiveTurn = null;
       try {
-        const session = await readSessionHead();
+        const session = await readSessionHead(mark, scope);
+        scope.progress?.();
         head = session.lastSequence;
         sessionActiveTurn = session.activeTurnId;
       } catch (cause) {
-        if (controller.signal.aborted) throw cause;
+        if (!scope.isCurrent() || strict && isRetryableStreamError(cause)) throw cause;
         return "joined";
       }
-      if (!isCurrent()) throw abortError();
+      if (!scope.isCurrent()) throw abortError();
       if (!Number.isSafeInteger(head) || head - cursor <= DIRECT_REPLAY_MAX_SEQUENCES) {
         return "joined";
       }
       let catchup;
       try {
-        catchup = await loadConversationCatchup(client, workspaceId, sessionId, cursor, head, {
-          signal: controller.signal,
-          isCurrent
-        });
+        catchup = await loadConversationCatchup(
+          client,
+          workspaceId,
+          sessionId,
+          cursor,
+          head,
+          scope
+        );
       } catch (cause) {
-        if (!isCurrent()) throw cause;
+        if (!scope.isCurrent() || strict && isRetryableStreamError(cause)) throw cause;
         return "joined";
       }
-      if (!isCurrent()) throw abortError();
+      if (!scope.isCurrent()) throw abortError();
       if (catchup === null) return "reload";
       const previous = eventWindowRef.current.events;
       installCatchup(catchup, head);
@@ -1190,17 +1264,171 @@ function useSessionEvents(sessionId, options = {}) {
       }
       return "joined";
     };
+    const loadLatestWindow = async (scope = effectScope) => {
+      const window2 = await loadEventWindow(t, client, workspaceId, sessionId, {
+        before: Number.MAX_SAFE_INTEGER,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
+        targetGroups: Number.POSITIVE_INFINITY,
+        maxFetches: INITIAL_FETCH_CAP,
+        boundaryPageCap: BOUNDARY_PAGE_CAP,
+        signal: scope.signal,
+        ...scope.progress ? { progress: scope.progress } : {},
+        filter: CONVERSATION_FILTER
+      });
+      if (!scope.isCurrent()) {
+        return false;
+      }
+      const status = observeSessionStatus(window2.events, sessionStatusRef);
+      const retained = boundBrowserSessionEventWindow(window2.events);
+      navigationGenerationRef.current += 1;
+      loadingOlderRef.current = false;
+      loadingNewerRef.current = false;
+      loadingOldestRef.current = false;
+      setLoadingOlder(false);
+      setLoadingNewer(false);
+      setLoadingOldest(false);
+      const previous = eventWindowRef.current.events;
+      eventWindowRef.current = retained;
+      pruneStepStores(retained.events, previous);
+      oldestSequenceRef.current = retained.events[0]?.sequence ?? window2.oldestSequence ?? window2.scanCursor;
+      newestSequenceRef.current = maxResumeSequenceOrNull(retained.events) ?? window2.newestSequence;
+      hasOlderRef.current = window2.hasOlder || retained.truncated;
+      hasNewerRef.current = false;
+      lastSequenceRef.current = Math.max(lastSequenceRef.current, window2.newestSequence);
+      streamResumeSequenceRef.current = window2.newestSequence;
+      skippedStepsThroughRef.current = retained.events.length === 0 && window2.newestSequence > 0 ? window2.newestSequence : null;
+      initialWindowLoadedRef.current = true;
+      setInitialHistoryReady(true);
+      setError(null);
+      if (status !== void 0) {
+        setSessionStatusProjection(status);
+      }
+      setEventWindow(retained);
+      setHasOlder(window2.hasOlder || retained.truncated);
+      setHasNewer(false);
+      setInitialLoading(false);
+      return true;
+    };
+    const noteStreamResume = () => {
+      if (!fullReplay && streamResumeSequenceRef.current > liveThroughRef.current) {
+        markTurnlessOutputGap(workspaceId, sessionId);
+      }
+      liveThroughRef.current = Math.max(liveThroughRef.current, streamResumeSequenceRef.current);
+    };
+    const boundedRejoin = async (strict, join) => {
+      if (!isCurrent()) throw abortError();
+      const attempt = new AbortController();
+      let timedOut = false;
+      const abortAttempt = () => attempt.abort();
+      controller.signal.addEventListener("abort", abortAttempt, { once: true });
+      const stalled = () => {
+        timedOut = true;
+        attempt.abort();
+      };
+      let timer = setTimeout(stalled, REJOIN_STALL_TIMEOUT_MS);
+      let stopWaiting;
+      const stopped = new Promise((_resolve, reject) => {
+        stopWaiting = () => reject(abortError());
+        attempt.signal.addEventListener("abort", stopWaiting, { once: true });
+      });
+      const scope = {
+        signal: attempt.signal,
+        isCurrent: () => isCurrent() && !attempt.signal.aborted,
+        progress: () => {
+          if (attempt.signal.aborted) return;
+          clearTimeout(timer);
+          timer = setTimeout(stalled, REJOIN_STALL_TIMEOUT_MS);
+        }
+      };
+      try {
+        return await Promise.race([join(scope), stopped]);
+      } catch (cause) {
+        if (!isCurrent()) throw cause;
+        if (timedOut) {
+          return strict ? {
+            retry: new TypeError(
+              `rejoining the live session stalled for ${REJOIN_STALL_TIMEOUT_MS}ms`
+            )
+          } : "joined";
+        }
+        if (strict && isRetryableStreamError(cause)) return { retry: cause };
+        throw cause;
+      } finally {
+        clearTimeout(timer);
+        controller.signal.removeEventListener("abort", abortAttempt);
+        if (stopWaiting) attempt.signal.removeEventListener("abort", stopWaiting);
+      }
+    };
+    const leniently = async (join) => {
+      const result = await boundedRejoin(false, join);
+      return typeof result === "string" ? result : "joined";
+    };
+    let strictFailures = 0;
+    const beforeReconnect = async (cursor) => {
+      flush();
+      if (!isCurrent()) throw abortError();
+      const strict = strictFailures < STRICT_REJOIN_ATTEMPTS;
+      const mark = sessionDetailReadMark();
+      let result;
+      try {
+        result = await boundedRejoin(strict, async (scope) => {
+          if (await rejoinLive(true, { strict, mark, scope }) === "joined") return "joined";
+          let loaded;
+          try {
+            loaded = await loadLatestWindow(scope);
+          } catch (cause) {
+            if (!scope.isCurrent() || strict && isRetryableStreamError(cause)) throw cause;
+            return "joined";
+          }
+          if (!loaded) throw abortError();
+          if (await rejoinLive(true, { strict, mark, scope }) === "reload" && strict) {
+            throw new TypeError("the session outran a fresh window while rejoining it");
+          }
+          return "joined";
+        });
+      } catch (cause) {
+        if (!isCurrent()) throw abortError();
+        if (!isRetryableStreamError(cause)) throw cause;
+        throw new Error(
+          `rejoining the live session failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          { cause }
+        );
+      }
+      if (!isCurrent()) throw abortError();
+      if (typeof result === "object") {
+        strictFailures += 1;
+        throw result.retry;
+      }
+      noteStreamResume();
+      return Math.max(cursor, streamResumeSequenceRef.current);
+    };
     void (async () => {
       try {
         if (reconcileForegroundResume) {
           setConnectionState("connecting");
-          if (await rejoinLive(true) === "reload") {
+          let outcome;
+          for (let attempt = 0; ; attempt += 1) {
+            const strict = attempt < STRICT_REJOIN_ATTEMPTS;
+            const result = await boundedRejoin(
+              strict,
+              (scope) => rejoinLive(true, { strict, scope })
+            );
+            if (typeof result === "string") {
+              outcome = result;
+              break;
+            }
+            await abortableDelay(
+              Math.min(FOREGROUND_REJOIN_RETRY_MS * 2 ** attempt, FOREGROUND_REJOIN_RETRY_MAX_MS),
+              controller.signal
+            );
+          }
+          if (outcome === "reload") {
             initialWindowLoadedRef.current = false;
             setError(null);
           }
         } else if (!fullReplay && initialWindowLoadedRef.current && rejoinPendingRef.current) {
           rejoinPendingRef.current = false;
-          if (await rejoinLive(false) === "reload") {
+          if (await leniently((scope) => rejoinLive(false, { scope })) === "reload") {
             initialWindowLoadedRef.current = false;
           }
         }
@@ -1208,64 +1436,26 @@ function useSessionEvents(sessionId, options = {}) {
         const windowPasses = fullReplay ? 0 : 2;
         for (let attempt = 0; attempt < windowPasses && !initialWindowLoadedRef.current; attempt += 1) {
           setConnectionState("connecting");
-          const window = await loadEventWindow(t, client, workspaceId, sessionId, {
-            before: Number.MAX_SAFE_INTEGER,
-            pageSize: SESSION_HISTORY_PAGE_SIZE,
-            targetGroups: Number.POSITIVE_INFINITY,
-            maxFetches: INITIAL_FETCH_CAP,
-            boundaryPageCap: BOUNDARY_PAGE_CAP,
-            signal: controller.signal,
-            filter: CONVERSATION_FILTER
-          });
-          if (!isCurrent()) {
+          if (!await loadLatestWindow()) {
             return;
           }
-          const status = observeSessionStatus(window.events, sessionStatusRef);
-          const retained = boundBrowserSessionEventWindow(window.events);
-          navigationGenerationRef.current += 1;
-          loadingOlderRef.current = false;
-          loadingNewerRef.current = false;
-          loadingOldestRef.current = false;
-          setLoadingOlder(false);
-          setLoadingNewer(false);
-          setLoadingOldest(false);
-          const previous = eventWindowRef.current.events;
-          eventWindowRef.current = retained;
-          pruneStepStores(retained.events, previous);
-          oldestSequenceRef.current = retained.events[0]?.sequence ?? window.oldestSequence ?? window.scanCursor;
-          newestSequenceRef.current = maxResumeSequenceOrNull(retained.events) ?? window.newestSequence;
-          hasOlderRef.current = window.hasOlder || retained.truncated;
-          hasNewerRef.current = false;
-          lastSequenceRef.current = Math.max(lastSequenceRef.current, window.newestSequence);
-          streamResumeSequenceRef.current = window.newestSequence;
-          skippedStepsThroughRef.current = retained.events.length === 0 && window.newestSequence > 0 ? window.newestSequence : null;
-          initialWindowLoadedRef.current = true;
-          setInitialHistoryReady(true);
-          setError(null);
-          if (status !== void 0) {
-            setSessionStatusProjection(status);
-          }
-          setEventWindow(retained);
-          setHasOlder(window.hasOlder || retained.truncated);
-          setHasNewer(false);
-          setInitialLoading(false);
-          if (await rejoinLive(true) === "reload" && attempt === 0) {
+          if (await leniently((scope) => rejoinLive(true, { scope })) === "reload" && attempt === 0) {
             initialWindowLoadedRef.current = false;
           }
         }
         if (fullReplay) {
           setInitialLoading(false);
         }
-        if (!fullReplay && streamResumeSequenceRef.current > liveThroughRef.current) {
-          markTurnlessOutputGap(workspaceId, sessionId);
-        }
-        liveThroughRef.current = Math.max(liveThroughRef.current, streamResumeSequenceRef.current);
+        noteStreamResume();
         const stream = client.streamEvents(workspaceId, sessionId, {
           after: streamResumeSequenceRef.current,
           signal: controller.signal,
+          // Full replay keeps the SDK's exactly-once reconnects.
+          ...fullReplay ? {} : { beforeReconnect },
           onOpen: () => {
             const initialOpen = openedStreamKeyRef.current !== streamKey;
             openedStreamKeyRef.current = streamKey;
+            strictFailures = 0;
             void Promise.resolve().then(() => reconcileSession(sessionId, { initialOpen })).catch((cause) => {
               if (isCurrent()) {
                 setError(normalizeError(cause));
@@ -1338,6 +1528,17 @@ function useSessionEvents(sessionId, options = {}) {
     presentedCallIds,
     startupTurns
   ]);
+  useEffect3(() => {
+    if (!sessionId || !streamEnabled) return;
+    return subscribePageWake(() => {
+      const stream = streamAbortRef.current;
+      if (!stream || stream.signal.aborted || viewModeRef.current !== "live") return;
+      if (!fullReplay && initialWindowLoadedRef.current) {
+        reconcileAfterPageResumeRef.current = true;
+      }
+      setStreamEpoch((epoch) => epoch + 1);
+    });
+  }, [sessionId, streamEnabled, fullReplay]);
   const navigationBusy = () => loadingTargetRef.current || loadingOlderRef.current || loadingNewerRef.current || loadingOldestRef.current || loadingLatestRef.current;
   const loadOlder = useCallback6(
     () => createOlderHistoryLoadReceipt(async (markCommitted, preserveTail, markTailPreserved) => {
@@ -1357,7 +1558,7 @@ function useSessionEvents(sessionId, options = {}) {
       setLoadingOlder(true);
       let published = false;
       try {
-        const window = await loadEventWindow(t, client, workspaceId, sessionId, {
+        const window2 = await loadEventWindow(t, client, workspaceId, sessionId, {
           before,
           pageSize: SESSION_HISTORY_PAGE_SIZE,
           targetGroups: OLDER_GROUP_TARGET,
@@ -1369,9 +1570,9 @@ function useSessionEvents(sessionId, options = {}) {
         if (!isCurrent()) {
           return false;
         }
-        if (window.events.length === 0) {
-          if (window.hasOlder && window.scanCursor < before) {
-            oldestSequenceRef.current = window.scanCursor;
+        if (window2.events.length === 0) {
+          if (window2.hasOlder && window2.scanCursor < before) {
+            oldestSequenceRef.current = window2.scanCursor;
             return true;
           }
           oldestSequenceRef.current = null;
@@ -1380,15 +1581,15 @@ function useSessionEvents(sessionId, options = {}) {
           return false;
         }
         const current = eventWindowRef.current;
-        assertPrependOrder(current.events, window.events);
-        const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
+        assertPrependOrder(current.events, window2.events);
+        const next = boundBrowserSessionEventWindow([...window2.events, ...current.events], {
           direction: "oldest"
         });
         if (preserveTail && maxResumeSequence(next.events) < maxResumeSequence(current.events)) {
           markTailPreserved();
           return false;
         }
-        const status = observeSessionStatus(window.events, sessionStatusRef);
+        const status = observeSessionStatus(window2.events, sessionStatusRef);
         const retained = {
           ...next,
           truncated: current.truncated || next.truncated
@@ -1409,7 +1610,7 @@ function useSessionEvents(sessionId, options = {}) {
           pruneStepStores(retained.events, current.events);
         } else {
           const skippedThrough = skippedStepsThroughRef.current;
-          if (skippedThrough !== null && windowTurns(window.events).size > 0) {
+          if (skippedThrough !== null && windowTurns(window2.events).size > 0) {
             skippedStepsThroughRef.current = null;
             const working = activeConversationTurn(retained.events);
             const bounds = working ? conversationTurnBounds(retained.events).get(working) : void 0;
@@ -1424,7 +1625,7 @@ function useSessionEvents(sessionId, options = {}) {
         if (evictedLiveTail) {
           streamResumeSequenceRef.current = maxResumeSequence(retained.events);
         }
-        const olderStillAvailable = window.hasOlder;
+        const olderStillAvailable = window2.hasOlder;
         hasOlderRef.current = olderStillAvailable;
         let newer = null;
         let enterHistory = false;
@@ -1477,7 +1678,7 @@ function useSessionEvents(sessionId, options = {}) {
     setLoadingOldest(true);
     let published = false;
     try {
-      const window = await loadForwardEventWindow(t, client, workspaceId, sessionId, {
+      const window2 = await loadForwardEventWindow(t, client, workspaceId, sessionId, {
         after: 0,
         pageSize: SESSION_HISTORY_PAGE_SIZE,
         targetGroups: OLDEST_GROUP_TARGET,
@@ -1488,14 +1689,14 @@ function useSessionEvents(sessionId, options = {}) {
       if (!isCurrent()) {
         return false;
       }
-      if (window.events.length === 0) {
+      if (window2.events.length === 0) {
         hasOlderRef.current = false;
         setHasOlder(false);
         return false;
       }
       streamAbortRef.current?.abort();
-      const status = observeSessionStatus(window.events, sessionStatusRef);
-      const retained = boundBrowserSessionEventWindow(window.events, { direction: "oldest" });
+      const status = observeSessionStatus(window2.events, sessionStatusRef);
+      const retained = boundBrowserSessionEventWindow(window2.events, { direction: "oldest" });
       const retainedOldest = retained.events[0]?.sequence ?? null;
       const retainedNewest = maxResumeSequenceOrNull(retained.events);
       const previous = eventWindowRef.current.events;
@@ -1507,7 +1708,7 @@ function useSessionEvents(sessionId, options = {}) {
       hasOlderRef.current = false;
       const highWater = Math.max(lastSequenceRef.current, retainedNewest ?? 0);
       lastSequenceRef.current = highWater;
-      const newer = window.hasNewer || retained.truncated || retainedNewest !== null && retainedNewest < highWater;
+      const newer = window2.hasNewer || retained.truncated || retainedNewest !== null && retainedNewest < highWater;
       hasNewerRef.current = newer;
       initialWindowLoadedRef.current = true;
       setInitialHistoryReady(true);
@@ -1553,7 +1754,7 @@ function useSessionEvents(sessionId, options = {}) {
     setLoadingNewer(true);
     let published = false;
     try {
-      const window = await loadForwardEventWindow(t, client, workspaceId, sessionId, {
+      const window2 = await loadForwardEventWindow(t, client, workspaceId, sessionId, {
         after: afterSequence,
         pageSize: SESSION_HISTORY_PAGE_SIZE,
         targetGroups: NEWER_GROUP_TARGET,
@@ -1565,9 +1766,9 @@ function useSessionEvents(sessionId, options = {}) {
       if (!isCurrent()) {
         return false;
       }
-      if (window.events.length === 0) {
-        if (window.hasNewer && window.scanCursor > afterSequence) {
-          newestSequenceRef.current = window.scanCursor;
+      if (window2.events.length === 0) {
+        if (window2.hasNewer && window2.scanCursor > afterSequence) {
+          newestSequenceRef.current = window2.scanCursor;
           return true;
         }
         setNewerError(null);
@@ -1581,13 +1782,13 @@ function useSessionEvents(sessionId, options = {}) {
         return false;
       }
       const current = eventWindowRef.current;
-      assertAppendOrder(current.events, window.events);
-      const status = observeSessionStatus(window.events, sessionStatusRef);
+      assertAppendOrder(current.events, window2.events);
+      const status = observeSessionStatus(window2.events, sessionStatusRef);
       const previousOldest = current.events[0]?.sequence ?? null;
-      const next = appendBrowserSessionEventWindow(current, window.events);
+      const next = appendBrowserSessionEventWindow(current, window2.events);
       const retained = {
         ...next,
-        truncated: current.truncated || next.truncated || window.hasNewer
+        truncated: current.truncated || next.truncated || window2.hasNewer
       };
       const retainedOldest = retained.events[0]?.sequence ?? null;
       const retainedNewest = maxResumeSequenceOrNull(retained.events);
@@ -1604,7 +1805,7 @@ function useSessionEvents(sessionId, options = {}) {
       const rearmedOlder = hasOlderRef.current;
       const highWater = Math.max(lastSequenceRef.current, retainedNewest);
       lastSequenceRef.current = highWater;
-      const newer = window.hasNewer || retainedNewest < highWater;
+      const newer = window2.hasNewer || retainedNewest < highWater;
       hasNewerRef.current = newer;
       let resumeLive = false;
       if (!newer) {
@@ -1734,7 +1935,7 @@ function useSessionEvents(sessionId, options = {}) {
       let generation = navigationGenerationRef.current;
       const current = () => ownsNavigation() && generation === navigationGenerationRef.current;
       try {
-        const { resolveLatestQuestion } = await import("./latest-question-VGVNUGAU.js");
+        const { resolveLatestQuestion } = await import("./latest-question-SINEV4U6.js");
         if (!current()) return null;
         const destination = await resolveLatestQuestion(t, {
           client,
@@ -2070,6 +2271,7 @@ async function loadConversationCatchup(client, workspaceId, sessionId, cursor, h
       payloadMode: "full"
     });
     if (!options.isCurrent()) throw abortError();
+    options.progress?.();
     const fresh = page.filter((event) => eventResumeSequence(event) > after);
     assertAscending(fresh);
     events.push(...fresh);
@@ -2100,6 +2302,7 @@ async function loadEventWindow(t, client, workspaceId, sessionId, options) {
       ...options.signal ? { signal: options.signal } : {}
     });
     if (options.isCurrent?.() === false) throw abortError();
+    options.progress?.();
     if (page.raw.oldest === null) {
       reachedStart = true;
       break;
@@ -2121,6 +2324,7 @@ async function loadEventWindow(t, client, workspaceId, sessionId, options) {
       ...options.signal ? { signal: options.signal } : {}
     });
     if (options.isCurrent?.() === false) throw abortError();
+    options.progress?.();
     if (page.raw.oldest === null) {
       reachedStart = true;
       break;
@@ -2339,6 +2543,23 @@ function abortError() {
   error.name = "AbortError";
   return error;
 }
+function abortableDelay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(abortError());
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 var CONTENT_STEP_TYPES = new Set(SESSION_EVENT_CONTENT_STEP_TYPES);
 var COMPAT_EXCLUDED_TYPES = new Set(
   SESSION_EVENT_COMPAT_EXCLUDED_STEP_TYPES
@@ -2389,26 +2610,26 @@ function appendTurnlessSteps(current, incoming) {
   });
   return { events: kept.events, bytes: kept.bytes, ranges, appended };
 }
-function withTurnlessSteps(window, turnless) {
-  const first = window[0]?.sequence;
-  if (first === void 0 || turnless.ranges.length === 0) return window;
+function withTurnlessSteps(window2, turnless) {
+  const first = window2[0]?.sequence;
+  if (first === void 0 || turnless.ranges.length === 0) return window2;
   const placeholders = [];
   for (const [start, end] of turnless.ranges) {
     if (end < first) continue;
     placeholders.push({
       id: `turnless-steps-${start}`,
-      workspaceId: window[0].workspaceId,
-      sessionId: window[0].sessionId,
+      workspaceId: window2[0].workspaceId,
+      sessionId: window2[0].sessionId,
       sequence: start,
       coveredThrough: end,
       type: "terminal.pty.output.delta",
       payload: null,
-      occurredAt: window[0].occurredAt,
+      occurredAt: window2[0].occurredAt,
       turnId: null
     });
   }
-  if (placeholders.length === 0) return window;
-  return [...window, ...placeholders].sort((left, right) => left.sequence - right.sequence);
+  if (placeholders.length === 0) return window2;
+  return [...window2, ...placeholders].sort((left, right) => left.sequence - right.sequence);
 }
 function turnStepLowerBound(bounds) {
   return bounds.started !== null ? bounds.started - 1 : bounds.previous;
@@ -3843,4 +4064,4 @@ export {
   useSessionReadAcknowledgement,
   useNewConversation
 };
-//# sourceMappingURL=chunk-SOOWLNC5.js.map
+//# sourceMappingURL=chunk-GJUPLSC5.js.map