@opengeni/react 6.8.0 → 6.8.1-canary.41842879332001

package/src/timeline/projection.ts

@@ -2482,6 +2482,184 @@ export function sessionStatusFromEvents(events: SessionEvent[]): SessionStatus |
   return null;
 }
 
+/**
+ * A span in which the session's work was paused: by Pause of the chat, of
+ * an ancestor, or of the workspace. An open span (no `endedAt`) is a pause
+ * still in force.
+ */
+export type TimelinePauseSpan = { startedAt: string; endedAt?: string };
+
+/**
+ * The host's live view of the session's Pause, from its effective control.
+ * `since` is when the pause in force began, when known. `resumedAt` is when
+ * the host saw the pause end, for a resume whose events have not arrived.
+ */
+export type TimelineLivePause = {
+  paused: boolean;
+  since?: string | null | undefined;
+  resumedAt?: string | null | undefined;
+};
+
+/** Interruption reasons that park a turn for Resume rather than end it. */
+const PAUSE_INTERRUPTION_REASONS: ReadonlySet<unknown> = new Set([
+  "session_pause",
+  "workspace_pause",
+]);
+
+type LivePauseBlocker = { changedAt?: string | null | undefined };
+
+/**
+ * The live pause from an effective session control; undefined when it is
+ * unknown. A pause in force since several blockers took hold began with the
+ * earliest of them.
+ */
+export function timelineLivePause(
+  control:
+    | {
+        state: string;
+        primaryBlocker?: LivePauseBlocker | null | undefined;
+        blockers?: readonly LivePauseBlocker[] | null | undefined;
+      }
+    | null
+    | undefined,
+): TimelineLivePause | undefined {
+  if (!control) return undefined;
+  if (control.state !== "paused") return { paused: false };
+  let since: string | null = null;
+  for (const blocker of [control.primaryBlocker, ...(control.blockers ?? [])]) {
+    const changedAt = blocker?.changedAt;
+    if (changedAt && (since === null || Date.parse(changedAt) < Date.parse(since)))
+      since = changedAt;
+  }
+  return { paused: true, since };
+}
+
+/** Events that start or end a pause span. */
+const PAUSE_EVENT_TYPES: ReadonlySet<string> = new Set([
+  "session.control.paused",
+  "session.control.resumed",
+  "turn.recovery.requested",
+  "session.status.changed",
+  "turn.started",
+]);
+
+/**
+ * When the session's work was paused, from its events and (when the host
+ * knows it) its live control.
+ *
+ * Pause parks the running turn for Resume instead of ending it, so the turn
+ * stays open. A direct Pause records `session.control.paused`; a Pause of an
+ * ancestor or of the workspace reaches the chat only as the interruption
+ * (`turn.recovery.requested` with a pause reason) and the parked idle status.
+ * Work resumes with `session.control.resumed`, or when the turn runs again.
+ * A wait that a pause held without interrupting anything has no events at
+ * all, so the live control decides whether a pause is in force now, and
+ * `observed` carries pauses the host saw begin and end only through it.
+ */
+export function timelinePauseSpans(
+  events: readonly SessionEvent[],
+  live?: TimelineLivePause | null,
+  observed: readonly TimelinePauseSpan[] = [],
+): TimelinePauseSpan[] {
+  let latest: SessionEvent | undefined;
+  const relevant: SessionEvent[] = [];
+  for (const event of events) {
+    if (!latest || event.sequence > latest.sequence) latest = event;
+    if (PAUSE_EVENT_TYPES.has(event.type)) relevant.push(event);
+  }
+  relevant.sort((left, right) => left.sequence - right.sequence);
+  const spans: TimelinePauseSpan[] = [];
+  let open: TimelinePauseSpan | null = null;
+  // Cancel also leaves the control paused while the turn winds down; that is
+  // not a pause of the work, which is ending.
+  let cancelling = false;
+  for (const event of relevant) {
+    const payload = asRecord(event.payload);
+    if (
+      (event.type === "session.control.paused" && payload.terminal === true) ||
+      // A parent's Cancel reaches its sub-chats as their status alone.
+      (event.type === "session.status.changed" && payload.status === "cancelled")
+    ) {
+      cancelling = true;
+      continue;
+    }
+    const starts =
+      event.type === "session.control.paused" ||
+      (event.type === "turn.recovery.requested" &&
+        PAUSE_INTERRUPTION_REASONS.has(payload.reason)) ||
+      (event.type === "session.status.changed" &&
+        payload.status === "idle" &&
+        payload.reason === "paused_recovery_settled");
+    if (starts) {
+      open ??= { startedAt: event.occurredAt };
+      continue;
+    }
+    if (
+      event.type === "session.control.resumed" ||
+      event.type === "turn.started" ||
+      (event.type === "session.status.changed" && payload.status === "running")
+    ) {
+      cancelling = false;
+      if (open) {
+        spans.push({ startedAt: open.startedAt, endedAt: event.occurredAt });
+        open = null;
+      }
+    }
+  }
+  const latestAt = latest?.occurredAt;
+  if (live?.paused && !cancelling) {
+    const startedAt = open?.startedAt ?? live.since ?? latestAt;
+    if (startedAt) spans.push({ startedAt });
+  } else if (open) {
+    if (live) {
+      // The host already sees the session running again; its resume events
+      // are still on their way. End the pause when the host saw it end.
+      const endedAt = live.resumedAt ?? latestAt ?? open.startedAt;
+      spans.push({
+        startedAt: open.startedAt,
+        endedAt: Date.parse(endedAt) > Date.parse(open.startedAt) ? endedAt : open.startedAt,
+      });
+    } else {
+      spans.push(open);
+    }
+  }
+  // A pause seen only through the live control, by the host's clock; skip it
+  // where the events record the same pause.
+  const recorded = [...spans];
+  for (const span of observed) {
+    if (!span.endedAt) continue;
+    const start = Date.parse(span.startedAt);
+    const end = Date.parse(span.endedAt);
+    const overlaps = recorded.some(
+      (other) =>
+        Date.parse(other.startedAt) < end &&
+        (other.endedAt === undefined || Date.parse(other.endedAt) > start),
+    );
+    if (!overlaps) spans.push(span);
+  }
+  return spans;
+}
+
+/** Total length of the union of intervals, each clipped to `[from, to)`. */
+function unionLength(
+  intervals: ReadonlyArray<readonly [number, number]>,
+  from: number,
+  to: number,
+): number {
+  const clipped = intervals
+    .map(([start, end]) => [Math.max(start, from), Math.min(end, to)] as const)
+    .filter(([start, end]) => Number.isFinite(start) && Number.isFinite(end) && end > start)
+    .sort((left, right) => left[0] - right[0]);
+  let total = 0;
+  let cursor = Number.NEGATIVE_INFINITY;
+  for (const [start, end] of clipped) {
+    const begin = Math.max(start, cursor);
+    if (end > begin) total += end - begin;
+    cursor = Math.max(cursor, end);
+  }
+  return total;
+}
+
 /* ----------------------------------------------------------------------------
    Visual grouping: consecutive activity items (reasoning / tools / workers /
    sandbox) cluster into collapsible blocks. Once a turn settles, the full
@@ -2549,6 +2727,12 @@ export type GroupTimelineOptions = {
   readableTurns?: boolean;
   /** @deprecated Use readableTurns. Cross-turn exchange folding has been removed. */
   foldExchanges?: boolean;
+  /**
+   * When the session was paused ({@link timelinePauseSpans}). A readable
+   * turn still open under a pause in force reads as paused, and paused time
+   * is not counted as work.
+   */
+  pauses?: readonly TimelinePauseSpan[];
 };
 
 export function groupTimeline(
@@ -2556,7 +2740,8 @@ export function groupTimeline(
   items: TimelineItem[],
   options: GroupTimelineOptions = {},
 ): TimelineGroup[] {
-  if (options.readableTurns || options.foldExchanges) return groupReadableTurns(t, items);
+  if (options.readableTurns || options.foldExchanges)
+    return groupReadableTurns(t, items, options.pauses ?? []);
   const groups: TimelineGroup[] = [];
   for (const item of items) {
     // A recovered capacity wait is over; it leaves no warning behind.
@@ -2585,7 +2770,11 @@ export function groupTimeline(
 }
 
 /** Live prose stays primary; settled progress joins its own turn's work history. */
-function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGroup[] {
+function groupReadableTurns(
+  t: OpenGeniText,
+  items: TimelineItem[],
+  pauses: readonly TimelinePauseSpan[],
+): TimelineGroup[] {
   type Work = Extract<TimelineGroup, { kind: "activity" }>;
   let groups: TimelineGroup[] = [];
   const turns = new Map<string, Work>();
@@ -2721,12 +2910,12 @@ function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGro
         group.work!.details.push({ kind: "activity", id: `work-item-${item.id}`, items: [item] });
       delete group.work!.waiting;
     } else if (item.kind === "notice" && item.capacityWait) {
-      const pauses = idleSpans.get(key) ?? [];
-      pauses.push({
+      const idle = idleSpans.get(key) ?? [];
+      idle.push({
         startedAt: item.occurredAt,
         ...(item.resolvedAt ? { endedAt: item.resolvedAt } : {}),
       });
-      idleSpans.set(key, pauses);
+      idleSpans.set(key, idle);
       if (!item.resolvedAt) {
         if (settlements.has(key)) groups.push({ kind: "item", item });
         else {
@@ -2842,6 +3031,7 @@ function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGro
                 ? t("timeline.projection.waitingForYou")
                 : t("timeline.projection.waiting"),
             since: item.occurredAt,
+            ...(item.approval === true ? { waitingOn: "you" as const } : {}),
           };
         } else if (
           item.kind === "session-status" &&
@@ -2852,6 +3042,7 @@ function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGro
           current.waiting = {
             label: t("timeline.projection.waitingForYou"),
             since: item.occurredAt,
+            waitingOn: "you",
           };
         } else if (
           item.kind === "session-status" &&
@@ -2890,17 +3081,38 @@ function groupReadableTurns(t: OpenGeniText, items: TimelineItem[]): TimelineGro
         untimed: true,
       };
     }
-    const pausedMs = (idleSpans.get(key) ?? []).reduce((total, pause) => {
-      if (!pause.endedAt) return total;
-      const start = Math.max(Date.parse(work.startedAt), Date.parse(pause.startedAt));
-      const end = Math.min(
-        work.endedAt ? Date.parse(work.endedAt) : Number.POSITIVE_INFINITY,
-        Date.parse(pause.endedAt),
-      );
-      return Number.isFinite(start) && Number.isFinite(end) && end > start
-        ? total + end - start
-        : total;
-    }, 0);
+    const workStart = Date.parse(work.startedAt);
+    const workEnd = work.endedAt ? Date.parse(work.endedAt) : Number.POSITIVE_INFINITY;
+    // A pause still in force over this open turn: the turn is parked for
+    // Resume, so it reads as paused and its clock stops when the pause began.
+    // A wait on the person (an approval, a question) keeps saying so.
+    const openPause =
+      work.endedAt || work.waiting?.waitingOn === "you"
+        ? undefined
+        : pauses.find((pause) => !pause.endedAt && Date.parse(pause.startedAt) < workEnd);
+    const pausedAt = openPause
+      ? Math.max(workStart, Date.parse(openPause.startedAt))
+      : Number.POSITIVE_INFINITY;
+    if (openPause && Number.isFinite(pausedAt)) {
+      work.pausedAt = new Date(pausedAt).toISOString();
+      delete work.waiting;
+    }
+    // Capacity waits, failed-attempt gaps and pauses can overlap; their union
+    // is time the agent was not working. A span still open runs to the end of
+    // the work (a turn cancelled while paused) or to the pause that stopped
+    // its clock; on a turn still running it has no end yet and counts later.
+    const until = Math.min(workEnd, pausedAt);
+    const pausedMs = unionLength(
+      [...(idleSpans.get(key) ?? []), ...pauses].flatMap((span) =>
+        span.endedAt
+          ? [[Date.parse(span.startedAt), Date.parse(span.endedAt)] as const]
+          : Number.isFinite(until)
+            ? [[Date.parse(span.startedAt), until] as const]
+            : [],
+      ),
+      workStart,
+      until,
+    );
     if (pausedMs > 0) work.pausedMs = pausedMs;
   }
   groups = groups.filter((entry) => {

package/src/timeline/turn-summary-model.ts

@@ -81,10 +81,11 @@ export type TurnSummaryOptions = Readonly<{
 
 /**
  * Exchange status shown in place of the plain facet line. `working` and
- * `waiting` run a live clock from `since`; `worked` shows the settled span.
+ * `waiting` run a live clock from `since`; `worked` shows the settled span;
+ * `paused` shows the work done before the pause, with its clock stopped.
  */
 export type TurnSummaryStatus = Readonly<{
-  kind: "working" | "waiting" | "worked";
+  kind: "working" | "waiting" | "worked" | "paused";
   /** Replaces the default "Working" / "Waiting" wording. */
   label?: string | undefined;
   /** Who the wait is on: `you` when it needs the reader. */
@@ -93,7 +94,7 @@ export type TurnSummaryStatus = Readonly<{
   updates?: number | undefined;
   /** Live clock start for `working` and `waiting`. */
   since?: string | undefined;
-  /** Settled span for `worked`. */
+  /** Settled span for `worked`; work done before the pause for `paused`. */
   durationMs?: number | undefined;
   /** Live step preview under the row while it is collapsed. */
   preview?: ReactNode;

package/src/timeline/turn-summary.tsx

@@ -597,8 +597,9 @@ export function TurnSummary({
 }
 
 /**
- * "Working · 2m 14s", "Waiting for 2 agents · 3m 5s", or "Worked for 4m 10s";
- * null when a settled span is too short to state.
+ * "Working · 2m 14s", "Waiting for 2 agents · 3m 5s", "Paused · 2m 14s" (its
+ * clock stopped), or "Worked for 4m 10s"; null when a settled span is too
+ * short to state.
  */
 function turnSummaryStatusLine(t: OpenGeniText, status: TurnSummaryStatus): ReactNode {
   if (status.kind === "worked") {
@@ -610,6 +611,18 @@ function turnSummaryStatusLine(t: OpenGeniText, status: TurnSummaryStatus): Reac
       </span>
     ) : null;
   }
+  if (status.kind === "paused") {
+    return (
+      <span data-og-exchange-status="paused">
+        {status.label ?? t("timeline.turnSummary.paused")}
+        {status.durationMs !== undefined &&
+        Number.isFinite(status.durationMs) &&
+        status.durationMs >= 1000 ? (
+          <span className="tabular-nums">{` · ${formatElapsed(t, status.durationMs)}`}</span>
+        ) : null}
+      </span>
+    );
+  }
   const label =
     status.label ??
     (status.kind === "working"

package/src/timeline/types.ts

@@ -782,10 +782,16 @@ export type TimelineGroup =
         /**
          * Settled time inside this work span in which the agent was not
          * working: capacity waits, and the gap between a failed attempt and
-         * the Retry that reopened the turn. The worked duration and the live
-         * working clock exclude it.
+         * the Retry that reopened the turn, and settled pauses. The worked
+         * duration and the live working clock exclude it.
          */
         pausedMs?: number;
+        /**
+         * Set while a pause is in force over this still-open turn: when it
+         * began. Pause parks the turn for Resume, so it reads as paused with
+         * its clock stopped here, not as working.
+         */
+        pausedAt?: string;
         details: TimelineGroup[];
         /**
          * While the turn is live, its progress notes stay readable above the

package/src/timeline/use-timeline-pauses.ts

@@ -0,0 +1,105 @@
+import type { SessionEvent } from "@opengeni/sdk";
+import { useMemo, useState } from "react";
+import { timelinePauseSpans, type TimelineLivePause, type TimelinePauseSpan } from "./projection";
+
+/** At most this many pauses seen only through the live control are kept. */
+const OBSERVED_PAUSE_LIMIT = 20;
+
+type LivePauseHistory = {
+  sessionId: string | null;
+  /** The live pause as last rendered; undefined while it is unknown. */
+  live: boolean | undefined;
+  /** The last known pause state: a brief unknown does not forget a pause. */
+  paused: boolean | undefined;
+  /** When the pause in force began, as best known. */
+  since: string | null;
+  /** When this view saw the latest pause end. */
+  resumedAt: string | null;
+  /** Pauses this view saw begin and end. */
+  observed: TimelinePauseSpan[];
+};
+
+function nextHistory(
+  previous: LivePauseHistory | null,
+  sessionId: string | null,
+  paused: boolean | undefined,
+  since: string | null,
+  now: string,
+): LivePauseHistory {
+  if (!previous || previous.sessionId !== sessionId) {
+    return {
+      sessionId,
+      live: paused,
+      paused,
+      since: paused ? (since ?? now) : null,
+      resumedAt: null,
+      observed: [],
+    };
+  }
+  if (paused === undefined) return { ...previous, live: paused };
+  if (previous.paused === true && paused === false) {
+    return {
+      ...previous,
+      live: paused,
+      paused,
+      since: null,
+      resumedAt: now,
+      observed: [...previous.observed, { startedAt: previous.since ?? now, endedAt: now }].slice(
+        -OBSERVED_PAUSE_LIMIT,
+      ),
+    };
+  }
+  if (paused === true && previous.paused !== true) {
+    return { ...previous, live: paused, paused, since: since ?? now, resumedAt: null };
+  }
+  return { ...previous, live: paused, paused };
+}
+
+/**
+ * The session's pause spans for `groupTimeline`, from its events and its live
+ * pause (`timelineLivePause(session.effectiveControl)`).
+ *
+ * A pause that held a waiting turn, or an ancestor's pause of a turn it did
+ * not interrupt, leaves no events, so this view remembers the pauses it saw
+ * through the live control. It also notes the moment it saw a pause end, so
+ * the paused time never counts as work while the resume's events arrive.
+ */
+export function useTimelinePauses(
+  events: readonly SessionEvent[] | undefined,
+  pause: TimelineLivePause | null | undefined,
+  enabled = true,
+): TimelinePauseSpan[] {
+  const paused = pause?.paused;
+  const since = pause?.since ?? null;
+  const sessionId = events?.[0]?.sessionId ?? null;
+  const [stored, setStored] = useState<LivePauseHistory | null>(null);
+  let history = stored;
+  if (!history || history.sessionId !== sessionId || history.live !== paused) {
+    // Derived during render so the first render after a flip is already right.
+    history = nextHistory(stored, sessionId, paused, since, new Date().toISOString());
+    setStored(history);
+  }
+  // While the control is briefly unknown, the last known pause stays in force.
+  const livePaused = paused ?? (history.paused === true ? true : undefined);
+  const historySince = history.since;
+  const historyResumedAt = history.resumedAt;
+  const observed = history.observed;
+  const resumedAt = pause?.resumedAt ?? null;
+  return useMemo(
+    () =>
+      enabled
+        ? timelinePauseSpans(
+            events ?? [],
+            livePaused === undefined
+              ? undefined
+              : {
+                  paused: livePaused,
+                  since: since ?? historySince,
+                  resumedAt: resumedAt ?? historyResumedAt,
+                },
+            observed,
+          )
+        : [],
+    [enabled, events, livePaused, since, historySince, resumedAt, historyResumedAt, observed],
+  );
+}

package/src/timeline/work-presentation.ts

@@ -92,6 +92,7 @@ export function isPreparingWork(group: ActivityGroup, options: ReadableWorkOptio
     !options.startupDismissed &&
     !group.work.endedAt &&
     !group.work.waiting &&
+    !group.work.pausedAt &&
     phases.length > 0 &&
     group.items.every(
       (item) => item.kind === "startup-phase" || (item.kind === "reasoning" && !item.text.trim()),
@@ -132,9 +133,10 @@ export function readableWorkHasDetails(
 /**
  * Status of a readable turn's work row, minus the host-rendered live preview.
  * Time spent waiting for model capacity, or between a failed attempt and its
- * Retry, is not work: the worked duration and the live working clock exclude
- * it, and a capacity wait itself shows no clock. A
- * wait's `detail` is its one quiet secondary line.
+ * Retry, or paused, is not work: the worked duration and the live working
+ * clock exclude it, and a capacity wait itself shows no clock. A turn parked
+ * by a pause still in force reads as paused, its clock stopped where the
+ * pause began. A wait's `detail` is its one quiet secondary line.
  */
 export function readableWorkStatus(
   t: OpenGeniText,
@@ -157,8 +159,15 @@ export function readableWorkStatus(
       durationMs: durationMs === undefined ? undefined : Math.max(0, durationMs - pausedMs),
     };
   }
+  if (group.work.pausedAt) {
+    const durationMs = durationBetween(group.work.startedAt, group.work.pausedAt);
+    return {
+      kind: "paused",
+      durationMs: durationMs === undefined ? undefined : Math.max(0, durationMs - pausedMs),
+    };
+  }
   if (group.work.waiting) {
-    const { untimed, since, ...waiting } = group.work.waiting;
+    const { untimed, since, waitingOn: _waitingOn, ...waiting } = group.work.waiting;
     return { kind: "waiting", ...waiting, ...(untimed ? {} : { since }) };
   }
   const started = Date.parse(group.work.startedAt);

package/dist/chunk-2OXSB2OL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/app/lib/session-branch-cache.tsx"],"sourcesContent":["import type { Session as SessionDetails } from \"../types\";\nimport type { RailSession as Session } from \"./session-list-entry\";\n\nimport { mergeSessionForRail } from \"./sessions-group\";\n\nexport type SessionBranchPage<T extends Session = SessionDetails> = {\n  sessions: T[];\n  /** Per-row causal generations for rows returned by accepted branch reads. */\n  channelGenerations: ReadonlyMap<string, number>;\n  nextCursor: string | null;\n  loading: boolean;\n  /** Whether this load cycle may paint loading or retry feedback in the tree. */\n  feedbackVisible: boolean;\n  failed: boolean;\n  stale: boolean;\n  requestId: number | null;\n  retryCursor: string | null;\n};\n\nexport type SessionBranchSummaryDecision = {\n  acknowledge: boolean;\n  refresh: boolean;\n  markStale: boolean;\n};\n\n/**\n * Stable summary of the server-owned descendant facts that make an already\n * loaded branch stale. Child creation changes direct/total counts; lifecycle\n * changes advance the status aggregates. Title/content stays owned by the\n * child page or active route projection.\n */\nexport function sessionBranchSummaryKey(session: Session, readRevision = 0): string {\n  const stats = session.treeStats;\n  if (!stats) return `${session.id}:${session.updatedAt}:unknown:${readRevision}`;\n  return [\n    readRevision,\n    session.id,\n    session.updatedAt,\n    stats.directChildren,\n    stats.totalDescendants,\n    stats.runningDescendants,\n    stats.queuedDescendants,\n    stats.attentionDescendants,\n    stats.pausedDescendants,\n    stats.failedDescendants,\n    stats.unreadFailedDescendants ?? stats.failedDescendants,\n    stats.unreadDescendants ?? 0,\n    stats.activelyWorkingDescendants ?? 0,\n    stats.attentionSince ?? \"\",\n    stats.truncated ? 1 : 0,\n  ].join(\":\");\n}\n\n/**\n * Persist a route/lineage child in its already-loaded parent branch. The route\n * owns current lifecycle/content while the cached row retains rail ordering\n * timestamps and may own treeStats.\n */\nexport function upsertSessionBranchChild(\n  pages: ReadonlyMap<string, SessionBranchPage<SessionDetails>>,\n  child: SessionDetails,\n): ReadonlyMap<string, SessionBranchPage<SessionDetails>>;\nexport function upsertSessionBranchChild<T extends Session = SessionDetails>(\n  pages: ReadonlyMap<string, SessionBranchPage<T>>,\n  child: T,\n): ReadonlyMap<string, SessionBranchPage<T>>;\nexport function upsertSessionBranchChild<T extends Session = SessionDetails>(\n  pages: ReadonlyMap<string, SessionBranchPage<T>>,\n  child: T,\n): ReadonlyMap<string, SessionBranchPage<T>> {\n  const parentSessionId = child.parentSessionId;\n  if (!parentSessionId) return pages;\n  const page = pages.get(parentSessionId);\n  const sessions = page?.sessions ?? [];\n  const index = sessions.findIndex((session) => session.id === child.id);\n  const nextSessions = [...sessions];\n  if (index === -1) {\n    nextSessions.push(child);\n  } else {\n    const cached = sessions[index]!;\n    const merged = {\n      ...mergeSessionForRail(cached, child),\n      // Route/detail timestamps can be millisecond-truncated or ahead of the\n      // list activity clock. Only a branch-page commit replaces rail ordering.\n      createdAt: cached.createdAt,\n      updatedAt: cached.updatedAt,\n    };\n    nextSessions[index] = page?.channelGenerations.has(child.id)\n      ? { ...merged, channelId: cached.channelId ?? null }\n      : merged;\n  }\n  return new Map(pages).set(parentSessionId, {\n    sessions: nextSessions,\n    channelGenerations: page?.channelGenerations ?? new Map(),\n    nextCursor: page?.nextCursor ?? null,\n    loading: page?.loading ?? false,\n    feedbackVisible: page?.feedbackVisible ?? false,\n    failed: page?.failed ?? false,\n    stale: page?.stale ?? false,\n    requestId: page?.requestId ?? null,\n    retryCursor: page?.retryCursor ?? null,\n  });\n}\n\n/** Mark one exact branch request active without discarding loaded children. */\nexport function beginSessionBranchRequest<T extends Session = SessionDetails>(\n  pages: ReadonlyMap<string, SessionBranchPage<T>>,\n  parentSessionId: string,\n  requestId: number,\n  cursor?: string,\n  options: { feedbackVisible?: boolean | undefined } = {},\n): ReadonlyMap<string, SessionBranchPage<T>> {\n  const previous = pages.get(parentSessionId);\n  return new Map(pages).set(parentSessionId, {\n    sessions: previous?.sessions ?? [],\n    channelGenerations: previous?.channelGenerations ?? new Map(),\n    nextCursor: previous?.nextCursor ?? null,\n    loading: true,\n    feedbackVisible: options.feedbackVisible ?? true,\n    failed: false,\n    stale: false,\n    requestId,\n    retryCursor: cursor ?? null,\n  });\n}\n\n/** Refresh the already-loaded window with bounded, opaque-cursor reads. */\nexport async function readLoadedSessionBranchWindow<T extends Session = SessionDetails>(\n  readPage: (cursor?: string) => Promise<{ sessions: T[]; pinned: T[]; nextCursor: string | null }>,\n  minimumCount: number,\n  initialCursor?: string,\n): Promise<{ sessions: T[]; nextCursor: string | null }> {\n  const sessions = new Map<string, T>();\n  const seen = new Set<string>();\n  let cursor = initialCursor;\n  for (let reads = 0; reads <= Math.max(1, minimumCount); reads += 1) {\n    const page = await readPage(cursor);\n    for (const session of [...page.sessions, ...page.pinned]) sessions.set(session.id, session);\n    if (!page.nextCursor || sessions.size >= minimumCount) {\n      return { sessions: [...sessions.values()], nextCursor: page.nextCursor };\n    }\n    if (seen.has(page.nextCursor)) throw new Error(\"Child pagination cursor repeated\");\n    seen.add(page.nextCursor);\n    cursor = page.nextCursor;\n  }\n  throw new Error(\"Child pagination made no progress\");\n}\n\n/** Commit one server child page or a fully refreshed loaded window. */\nexport function commitSessionBranchPage(\n  pages: ReadonlyMap<string, SessionBranchPage<SessionDetails>>,\n  parentSessionId: string,\n  input: { sessions: readonly SessionDetails[]; nextCursor: string | null },\n  options?: {\n    append?: boolean | undefined;\n    replaceWindow?: boolean | undefined;\n    preserve?: readonly SessionDetails[] | undefined;\n    requestId?: number | undefined;\n    readGeneration?: number | undefined;\n  },\n): ReadonlyMap<string, SessionBranchPage<SessionDetails>>;\nexport function commitSessionBranchPage<T extends Session = SessionDetails>(\n  pages: ReadonlyMap<string, SessionBranchPage<T>>,\n  parentSessionId: string,\n  input: { sessions: readonly T[]; nextCursor: string | null },\n  options?: {\n    append?: boolean | undefined;\n    replaceWindow?: boolean | undefined;\n    preserve?: readonly T[] | undefined;\n    requestId?: number | undefined;\n    readGeneration?: number | undefined;\n  },\n): ReadonlyMap<string, SessionBranchPage<T>>;\nexport function commitSessionBranchPage<T extends Session = SessionDetails>(\n  pages: ReadonlyMap<string, SessionBranchPage<T>>,\n  parentSessionId: string,\n  input: { sessions: readonly T[]; nextCursor: string | null },\n  options: {\n    append?: boolean | undefined;\n    replaceWindow?: boolean | undefined;\n    preserve?: readonly T[] | undefined;\n    requestId?: number | undefined;\n    readGeneration?: number | undefined;\n  } = {},\n): ReadonlyMap<string, SessionBranchPage<T>> {\n  const previous = pages.get(parentSessionId);\n  if (options.requestId !== undefined && previous?.requestId !== options.requestId) return pages;\n  const merged = new Map<string, T>();\n  const channelGenerations = options.append\n    ? new Map(previous?.channelGenerations ?? [])\n    : new Map<string, number>();\n  if (options.append) {\n    for (const session of [\n      ...(previous?.sessions ?? []),\n      ...(options.preserve ?? []),\n      ...input.sessions,\n    ]) {\n      merged.set(session.id, session);\n    }\n  } else {\n    // A refreshed first page owns the leading order. Retain already-loaded\n    // tail entries (including an active child outside the first 50) behind it.\n    for (const session of input.sessions) merged.set(session.id, session);\n    for (const session of [\n      ...(options.replaceWindow ? [] : (previous?.sessions ?? [])),\n      ...(options.preserve ?? []),\n    ]) {\n      if (!merged.has(session.id)) merged.set(session.id, session);\n    }\n  }\n  const readGeneration = options.readGeneration ?? 0;\n  if (readGeneration > 0) {\n    for (const session of input.sessions) {\n      channelGenerations.set(session.id, readGeneration);\n    }\n  }\n  return new Map(pages).set(parentSessionId, {\n    sessions: [...merged.values()],\n    channelGenerations,\n    nextCursor: input.nextCursor,\n    loading: false,\n    feedbackVisible: false,\n    failed: false,\n    stale: false,\n    requestId: null,\n    retryCursor: null,\n  });\n}\n\n/** Current branch rows that may own channel filing, with their actual read starts. */\nexport function authoritativeSessionBranchChannels<T extends Session = SessionDetails>(\n  page: SessionBranchPage<T>,\n): Array<readonly [session: T, readGeneration: number]> {\n  const byId = new Map(page.sessions.map((session) => [session.id, session]));\n  const evidence: Array<readonly [session: T, readGeneration: number]> = [];\n  for (const [sessionId, readGeneration] of page.channelGenerations) {\n    const session = byId.get(sessionId);\n    if (session && readGeneration > 0) evidence.push([session, readGeneration]);\n  }\n  return evidence;\n}\n\n/** Fail only the still-current request and expose its exact retry cursor. */\nexport function failSessionBranchRequest<T extends Session = SessionDetails>(\n  pages: ReadonlyMap<string, SessionBranchPage<T>>,\n  parentSessionId: string,\n  requestId: number,\n): ReadonlyMap<string, SessionBranchPage<T>> {\n  const previous = pages.get(parentSessionId);\n  if (!previous || previous.requestId !== requestId) return pages;\n  return new Map(pages).set(parentSessionId, {\n    ...previous,\n    loading: false,\n    // Background hydration may suppress transient loading feedback, but a\n    // failure must become actionable instead of leaving the branch silently\n    // incomplete for the rest of the active route.\n    feedbackVisible: true,\n    failed: true,\n    stale: false,\n    requestId: null,\n  });\n}\n\n/** A fresh cached page already owns the active child's parent branch. */\nexport function sessionBranchNeedsHydration<T extends Session = SessionDetails>(\n  page: SessionBranchPage<T> | undefined,\n): boolean {\n  return page === undefined || page.failed || page.stale;\n}\n\n/** Decide whether a changed parent summary can be acknowledged right now. */\nexport function sessionBranchSummaryDecision(input: {\n  previousKey: string | undefined;\n  nextKey: string;\n  loading: boolean;\n  expanded: boolean;\n  stale: boolean;\n}): SessionBranchSummaryDecision {\n  if (input.loading) {\n    return {\n      acknowledge: input.previousKey === input.nextKey,\n      refresh: false,\n      markStale: false,\n    };\n  }\n  if (input.previousKey === undefined || input.previousKey === input.nextKey) {\n    return { acknowledge: true, refresh: false, markStale: false };\n  }\n  return {\n    acknowledge: true,\n    refresh: input.expanded,\n    markStale: !input.expanded && !input.stale,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-7YTR3UFO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/timeline-annotations.tsx"],"sourcesContent":["import type { TimelineAnnotationSource } from \"@opengeni/sdk\";\nimport { QuoteIcon, XIcon } from \"lucide-react\";\nimport {\n  Suspense,\n  lazy,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useState,\n  type ReactNode,\n  type RefObject,\n} from \"react\";\nimport { cn } from \"../lib/cn\";\nimport {\n  AnnotationAccentRow,\n  AnnotationNotePreview,\n  AnnotationQuoteSourceButton,\n  type TimelineAnnotationLike,\n} from \"./timeline-annotation-chrome\";\nimport { ANNOTATION_CARD_STACK_SCROLL_AT } from \"./timeline-annotation-layout\";\nimport {\n  TimelineAnnotationSourceRootContext,\n  useTimelineAnnotationSourceRoot,\n} from \"./timeline-annotation-reveal-context\";\nimport {\n  annotationDisplayOrdinal,\n  annotationHasNote,\n  resolveAnnotationRevealRoot,\n} from \"./timeline-annotation-shared\";\nimport { useOpenGeniText } from \"../messages/runtime\";\n\nexport type { TimelineAnnotationLike } from \"./timeline-annotation-chrome\";\n\nconst TimelineAnnotationsDialog = lazy(() => import(\"./timeline-annotations-dialog\"));\n\nfunction AnnotationSourceRootBridge({\n  triggerRef,\n  children,\n}: {\n  triggerRef: RefObject<HTMLElement | null>;\n  children: ReactNode;\n}) {\n  const inheritedRoot = useTimelineAnnotationSourceRoot();\n  const conversationRootRef = useRef<HTMLElement | null>(null);\n  if (!inheritedRoot) {\n    conversationRootRef.current = resolveAnnotationRevealRoot(triggerRef.current);\n  }\n  useLayoutEffect(() => {\n    if (inheritedRoot) return;\n    conversationRootRef.current = resolveAnnotationRevealRoot(triggerRef.current);\n  });\n  if (inheritedRoot) return children;\n  return (\n    <TimelineAnnotationSourceRootContext.Provider value={conversationRootRef}>\n      {children}\n    </TimelineAnnotationSourceRootContext.Provider>\n  );\n}\n\nexport function TimelineAnnotationCards({\n  annotations,\n  onRevealSource,\n  className,\n}: {\n  annotations: readonly TimelineAnnotationLike[];\n  onRevealSource?: ((source: TimelineAnnotationSource) => boolean) | undefined;\n  className?: string | undefined;\n}) {\n  const t = useOpenGeniText();\n  const [unavailableId, setUnavailableId] = useState<string | null>(null);\n  if (annotations.length === 0) return null;\n  return (\n    <div\n      data-og-annotation-cards=\"\"\n      className={cn(\n        \"grid gap-2\",\n        annotations.length >= ANNOTATION_CARD_STACK_SCROLL_AT &&\n          \"max-h-[min(28rem,55vh)] overflow-x-hidden overflow-y-auto overscroll-contain pr-1\",\n        className,\n      )}\n    >\n      {annotations.map((annotation, index) => {\n        const ordinal = annotationDisplayOrdinal(annotation, index);\n        return (\n          <section\n            key={annotation.id}\n            aria-label={t(\"timelineAnnotations.annotationOrdinal\", { ordinal })}\n          >\n            <AnnotationAccentRow>\n              <p className=\"mb-0.5 text-og-xs font-medium tabular-nums text-og-fg-subtle\">\n                {t(\"timelineAnnotations.annotationOrdinal\", { ordinal })}\n              </p>\n              <AnnotationQuoteSourceButton\n                annotation={annotation}\n                lines={2}\n                onRevealSource={onRevealSource}\n                onUnavailable={setUnavailableId}\n              />\n              {unavailableId === annotation.id ? (\n                <p role=\"status\" className=\"text-og-xs text-og-status-waiting\">\n                  {t(\"timelineAnnotations.sourceIsOutsideTheLoaded\")}\n                </p>\n              ) : null}\n              <AnnotationNotePreview\n                note={annotation.note}\n                annotationId={annotation.id}\n                ordinal={ordinal}\n              />\n            </AnnotationAccentRow>\n          </section>\n        );\n      })}\n    </div>\n  );\n}\n\nexport function TimelineAnnotationsChip({\n  annotations,\n  editable = false,\n  focusAnnotationId,\n  onFocusConsumed,\n  onUpdate,\n  onRemove,\n  onRevealSource,\n  className,\n  compact = false,\n  onCommit,\n}: {\n  annotations: readonly TimelineAnnotationLike[];\n  editable?: boolean | undefined;\n  focusAnnotationId?: string | null | undefined;\n  onFocusConsumed?: (() => void) | undefined;\n  onUpdate?: ((id: string, note: string) => void) | undefined;\n  onRemove?: ((id: string) => void) | undefined;\n  /** Return focus to the owning input after all notes are completed with Enter. */\n  onCommit?: (() => void) | undefined;\n  onRevealSource?: ((source: TimelineAnnotationSource) => boolean) | undefined;\n  className?: string | undefined;\n  /** Dense trigger for single-line rows such as the compact queue dock. */\n  compact?: boolean | undefined;\n}) {\n  const t = useOpenGeniText();\n  const focusRequested = Boolean(\n    focusAnnotationId && annotations.some((item) => item.id === focusAnnotationId),\n  );\n  const [open, setOpen] = useState(focusRequested);\n  const triggerRef = useRef<HTMLButtonElement | null>(null);\n  const openedFocusId = useRef<string | null>(focusRequested ? (focusAnnotationId ?? null) : null);\n\n  useEffect(() => {\n    if (!focusRequested || !focusAnnotationId) {\n      if (!focusRequested) openedFocusId.current = null;\n      return;\n    }\n    if (openedFocusId.current === focusAnnotationId) return;\n    openedFocusId.current = focusAnnotationId;\n    setOpen(true);\n  }, [focusAnnotationId, focusRequested]);\n\n  if (annotations.length === 0) return null;\n  const countLabel = t(\"counts.annotations\", { count: annotations.length });\n  const incomplete = annotations.some((annotation) => !annotationHasNote(annotation.note));\n  const canClear = Boolean(editable && onRemove);\n\n  const dismiss = (restoreFocus: boolean) => {\n    setOpen(false);\n    onFocusConsumed?.();\n    if (restoreFocus) triggerRef.current?.focus();\n  };\n\n  return (\n    <span className={cn(\"inline-flex max-w-full items-center\", className)}>\n      <span\n        className={cn(\n          \"inline-flex max-w-full items-center rounded-full border bg-og-surface-1 text-og-fg-muted\",\n          incomplete ? \"border-og-accent/45 bg-og-accent-soft/50\" : \"border-og-border\",\n        )}\n      >\n        <button\n          ref={triggerRef}\n          type=\"button\"\n          className={cn(\n            \"inline-flex min-w-0 max-w-full items-center gap-1.5 rounded-full border-0 bg-transparent font-medium outline-hidden transition hover:text-og-fg focus-visible:ring-2 focus-visible:ring-og-accent pointer-coarse:min-h-[44px]\",\n            compact ? \"min-h-6 py-0.5 text-og-xs\" : \"min-h-8 py-1 text-og-sm\",\n            canClear ? \"pr-1 pl-2.5\" : \"px-2.5\",\n          )}\n          aria-label={t(\"timelineAnnotations.reviewCountlabel\", { countLabel })}\n          aria-haspopup=\"dialog\"\n          aria-expanded={open}\n          onClick={() => setOpen((current) => !current)}\n        >\n          <QuoteIcon className=\"size-3.5 shrink-0 text-og-accent\" aria-hidden=\"true\" />\n          <span className=\"min-w-0 truncate\">{countLabel}</span>\n        </button>\n        {canClear ? (\n          <button\n            type=\"button\"\n            className=\"inline-flex size-7 shrink-0 items-center justify-center rounded-full border-0 bg-transparent text-og-fg-subtle outline-hidden hover:text-og-status-failed focus-visible:ring-2 focus-visible:ring-og-accent pointer-coarse:size-11\"\n            aria-label={t(\"timelineAnnotations.removeAllAnnotations\")}\n            onClick={() => {\n              for (const annotation of annotations) onRemove?.(annotation.id);\n            }}\n          >\n            <XIcon className=\"size-3.5\" aria-hidden=\"true\" />\n          </button>\n        ) : null}\n      </span>\n      {open ? (\n        <AnnotationSourceRootBridge triggerRef={triggerRef}>\n          <Suspense fallback={null}>\n            <TimelineAnnotationsDialog\n              annotations={annotations}\n              editable={editable}\n              focusAnnotationId={focusAnnotationId}\n              onFocusConsumed={onFocusConsumed}\n              onUpdate={onUpdate}\n              onRemove={onRemove}\n              onRevealSource={onRevealSource}\n              triggerRef={triggerRef}\n              countLabel={countLabel}\n              onDismiss={dismiss}\n              onCommit={() => {\n                dismiss(!onCommit);\n                onCommit?.();\n              }}\n            />\n          </Suspense>\n        </AnnotationSourceRootBridge>\n      ) : null}\n    </span>\n  );\n}\n\nexport default TimelineAnnotationsChip;\n"],"mappings":"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","names":[]}