@opengeni/react 1.0.1 → 1.0.2-canary.37191796234001

package/dist/timeline/retained-image.d.ts

@@ -0,0 +1,18 @@
+import type { RetainedArtifactReference } from "@opengeni/sdk";
+import type { ToolRendererProps } from "./registry.js";
+type RetainedImageState = {
+    kind: "loading";
+} | {
+    kind: "ready";
+    url: string;
+} | {
+    kind: "unavailable";
+    label: string;
+} | {
+    kind: "error";
+    message: string;
+};
+export { isRetainedImageContentType } from "./presented-image.js";
+export declare function useRetainedImageObjectUrl(artifact: RetainedArtifactReference, load: ToolRendererProps["loadRetainedArtifact"]): RetainedImageState & {
+    retry: () => void;
+};

package/dist/timeline/rolling-activity.d.ts

@@ -0,0 +1,11 @@
+import type { ToolRegistry } from "./registry.js";
+import type { ActivityItem } from "./types.js";
+/** One stable viewport; updates replace its content without moving the conversation. */
+export declare function RollingActivity({ items, toolRegistry, previousItem, showCount, }: {
+    items: ActivityItem[];
+    /** The standalone item visible immediately before this reel mounted. */
+    previousItem?: ActivityItem | undefined;
+    toolRegistry?: ToolRegistry;
+    /** Show "+N earlier"; off when an enclosing status line already counts steps. */
+    showCount?: boolean;
+}): import("react").JSX.Element | null;

package/dist/timeline/screenshot-lightbox.d.ts

@@ -1,6 +1,10 @@
 import { type ReactNode } from "react";
 type LightboxController = {
-    open: (src: string, caption?: string, source?: HTMLElement | null, label?: string) => void;
+    open: (src: string, caption?: string, source?: HTMLElement | null, label?: string, downloadFilename?: string, controlLabels?: LightboxControlLabels, releaseSource?: () => void) => void;
+};
+export type LightboxControlLabels = {
+    download?: string | undefined;
+    close?: string | undefined;
 };
 /** Open the app-level screenshot lightbox. No-op outside a `LightboxProvider`. */
 export declare function useLightbox(): LightboxController;
@@ -10,6 +14,11 @@ export declare function useLightbox(): LightboxController;
  * (rather than a dead "Expand" button that announces an action it cannot do).
  */
 export declare function useLightboxOptional(): LightboxController | null;
+/** @internal Owns one optional retained lightbox source and releases it exactly once. */
+export declare function createLightboxSourceOwner(): {
+    replace(release?: (() => void) | undefined): void;
+    release(): void;
+};
 /**
  * The app-level screenshot lightbox. Render once near the timeline; renderers
  * call `useLightbox().open(src)`.
@@ -23,4 +32,10 @@ export declare function useLightboxOptional(): LightboxController | null;
 export declare function LightboxProvider({ children }: {
     children: ReactNode;
 }): import("react").JSX.Element;
+/** @internal Exact controls rendered by an open screenshot lightbox. */
+export declare function ScreenshotLightboxControls({ src, downloadFilename, controlLabels, }: {
+    src: string;
+    downloadFilename?: string | undefined;
+    controlLabels?: LightboxControlLabels | undefined;
+}): import("react").JSX.Element;
 export {};

package/dist/timeline/shared.d.ts

@@ -14,6 +14,8 @@ export declare function ToolCallTruncationProvider({ value, children, }: {
     children: ReactNode;
 }): import("react").JSX.Element;
 export type ActivityDisclosureProps = {
+    /** Override the rolling preview; null keeps rapidly streaming details out of the header. */
+    compactPreview?: ReactNode;
     icon: ReactNode;
     /** Icon tint. Defaults to the muted foreground; renderers pass accent/failed. */
     iconTone?: "accent" | "failed" | "running" | "muted" | undefined;
@@ -67,7 +69,8 @@ export type ActivityDisclosureProps = {
  * inline media, and at most one right-gutter settle chip. Compact by default;
  * the body mounts only when expanded.
  */
-export declare function ActivityDisclosure({ icon, iconTone: iconToneProp, title, titleMono, running, preview, media, chip: chipProp, failed, cancelled, expandable, defaultOpen, children, }: ActivityDisclosureProps): import("react").JSX.Element;
+export declare const CompactActivityContext: import("react").Context<boolean>;
+export declare function ActivityDisclosure({ icon, iconTone: iconToneProp, title, titleMono, running, preview, compactPreview, media, chip: chipProp, failed, cancelled, expandable, defaultOpen, children, }: ActivityDisclosureProps): import("react").JSX.Element;
 export declare function TermBlock({ command, workdir, output, live, tailLines, failed, }: {
     /**
      * The command shown in the prompt header. Pass `null` when the row title
@@ -114,12 +117,13 @@ export declare function MediaEmpty(): import("react").JSX.Element;
  * Outside one it degrades to a plain, non-interactive image — never a dead
  * "Expand" button that announces an action it cannot perform.
  */
-export declare function Thumbnail({ src, caption, alt, expandLabel, lightboxLabel, }: {
+export declare function Thumbnail({ src, caption, alt, expandLabel, lightboxLabel, downloadFilename, }: {
     src: string;
     caption?: string | undefined;
     alt?: string;
     expandLabel?: string | undefined;
     lightboxLabel?: string | undefined;
+    downloadFilename?: string | undefined;
 }): import("react").JSX.Element;
 /**
  * The expanded screenshot inside a tool body: a contained, clickable preview
@@ -127,10 +131,11 @@ export declare function Thumbnail({ src, caption, alt, expandLabel, lightboxLabe
  * so it never breaks the row layout. Like {@link Thumbnail}, it degrades to a
  * plain image outside a `LightboxProvider`.
  */
-export declare function ScreenshotFigure({ src, caption, alt, expandLabel, lightboxLabel, }: {
+export declare function ScreenshotFigure({ src, caption, alt, expandLabel, lightboxLabel, downloadFilename, }: {
     src: string;
     caption?: string | undefined;
     alt?: string;
     expandLabel?: string | undefined;
     lightboxLabel?: string | undefined;
+    downloadFilename?: string | undefined;
 }): import("react").JSX.Element;

package/dist/timeline/startup-preference.d.ts

@@ -0,0 +1,3 @@
+export declare function setStartupDetails(value: boolean): void;
+/** Presentation preference only. Startup evidence is always retained. */
+export declare function useStartupDetails(): boolean;

package/dist/timeline/startup-timings.d.ts

@@ -0,0 +1,4 @@
+import type { StartupPhaseItem } from "./types.js";
+export declare function StartupTimings({ phases }: {
+    phases: StartupPhaseItem[];
+}): import("react").JSX.Element;

package/dist/timeline/tool-display-name.d.ts

@@ -6,6 +6,7 @@
  * and bare `session_create` resolve the same UI — without inventing previews
  * from argument JSON.
  */
+import type { ToolDisplayMetadata } from "@opengeni/sdk";
 /** Leaf tool name after the first `__` server boundary (or the whole name). */
 export declare function mcpToolLeaf(name: string): string;
 /**
@@ -18,4 +19,4 @@ export declare function toolMatchesLeaf(wireName: string, leaf: string): boolean
  * Readable label for a tool call ("session_create" / "opengeni__session_create"
  * → "Session create"). Title-cases the first character of the leaf phrase.
  */
-export declare function toolDisplayName(name: string): string;
+export declare function toolDisplayName(name: string, display?: ToolDisplayMetadata): string;

package/dist/timeline/turn-summary.d.ts

@@ -56,15 +56,36 @@ type ReplaceTurnSummaryFacets = Readonly<{
 }>;
 export type TurnSummaryFacetConfiguration = ModifyTurnSummaryFacets | ReplaceTurnSummaryFacets;
 export type TurnSummaryOptions = Readonly<{
+    /**
+     * Readable per-turn presentation. Assistant progress stays fully formatted;
+     * each turn has its own Working / Worked row and rolling latest step.
+     * Ordinary tip-follow and manual scrolling are unchanged.
+     */
+    rolling?: boolean;
     facets?: TurnSummaryFacetConfiguration;
 }>;
+/**
+ * Exchange status shown in place of the plain facet line. `working` and
+ * `waiting` run a live clock from `since`; `worked` shows the settled span.
+ */
+export type TurnSummaryStatus = Readonly<{
+    kind: "working" | "waiting" | "worked";
+    /** Replaces the default "Working" / "Waiting" wording. */
+    label?: string | undefined;
+    /** Live clock start for `working` and `waiting`. */
+    since?: string | undefined;
+    /** Settled span for `worked`. */
+    durationMs?: number | undefined;
+    /** Live step preview under the row while it is collapsed. */
+    preview?: ReactNode;
+}>;
 export type TurnSummaryProps = {
     /** The activity items in the turn (used only to compute the facet counts). */
     items: ActivityItem[];
     /**
      * The settled verdict — or absent for a completed CLUSTER of a still-running
-     * turn, which folds neutrally: no verdict glyph (the turn has none yet), a
-     * quiet pulse dot in its place so alignment and the running feel both hold.
+     * turn, which folds neutrally. Only unfinished activity inside this summary
+     * animates; the parent turn may still be composing a response elsewhere.
      */
     outcome?: TurnOutcome | undefined;
     /** A short failure reason shown inline on a failed chip (never hidden). */
@@ -73,6 +94,7 @@ export type TurnSummaryProps = {
     durationMs?: number | undefined;
     /** Start expanded. */
     defaultOpen?: boolean | undefined;
+    liveHeader?: ReactNode;
     /**
      * A nested fold — a cluster or sub-turn INSIDE an already-expanded turn. It
      * drops the bordered/filled chip and renders as a plain disclosure node on the
@@ -110,7 +132,14 @@ export type TurnSummaryProps = {
     copyText?: string | undefined;
     /** Adjacent compaction landmark count for the secondary chip facet. */
     contextCompactionCount?: number | undefined;
+    /**
+     * Exchange status line (compact progress presentation). Replaces the state
+     * marker and the duration facet; a settled `worked` row reads as a separator.
+     */
+    status?: TurnSummaryStatus | undefined;
     /** The rendered activity rail revealed on expand. */
     children: ReactNode;
 };
-export declare function TurnSummary({ items, outcome, failureText, durationMs, defaultOpen, bare, facets: facetConfiguration, settleFold, foldKey, copyText, contextCompactionCount, children, }: TurnSummaryProps): import("react").JSX.Element;
+export declare function TurnSummary({ items, outcome, failureText, durationMs, defaultOpen, liveHeader, bare, facets: facetConfiguration, settleFold, foldKey, copyText, contextCompactionCount, status, children, }: TurnSummaryProps): import("react").JSX.Element;
+/** Elapsed wall time with seconds below an hour: "14s", "2m 14s", "1h 05m". */
+export declare function formatElapsed(durationMs: number): string;

package/dist/timeline/types.d.ts

@@ -1,10 +1,17 @@
-import type { MediaGenerationResult, ResourceRef, SessionStatus, TimelineAnnotation, TimelineAnnotationSource, ToolAuthNeededPayload, ToolRef } from "@opengeni/sdk";
+import type { AllowanceExhaustedRefusal, HumanInputQuestion, HumanInputResponse, MediaGenerationResult, ResourceRef, SessionStatus, TimelineAnnotation, TimelineAnnotationSource, ToolAuthNeededPayload, ToolRef, ToolDisplayMetadata } from "@opengeni/sdk";
 export type TimelineAnnotationSourceDescriptor = Omit<TimelineAnnotationSource, "startOffset" | "endOffset" | "contextBefore" | "contextAfter"> & {
     text: string;
 };
 export type UserMessageItem = {
     kind: "user-message";
     id: string;
+    /**
+     * Renderer-only identity shared by a locally acknowledged message and the
+     * durable event that replaces it. The canonical event id remains `id`; this
+     * key only prevents the optimistic-to-durable handoff from remounting and
+     * replaying the row entrance animation.
+     */
+    reconciliationKey?: string | undefined;
     text: string;
     annotations?: TimelineAnnotation[] | undefined;
     annotationSource?: TimelineAnnotationSourceDescriptor | undefined;
@@ -23,17 +30,51 @@ export type UserMessageItem = {
         state: "sending" | "queued" | "failed";
         error?: string | undefined;
         onRetry?: (() => void) | undefined;
+        onEdit?: (() => void) | undefined;
         onRemove?: (() => void) | undefined;
     } | undefined;
 };
+export type HumanInputAnswerSummary = {
+    questionId: string;
+    label: string;
+    prompt: string;
+    values: string[];
+};
+/**
+ * One resolved structured question in the conversation. The live pending form
+ * is rendered at the timeline tip by the host; after settlement this item keeps
+ * both the agent's question and the human's answer visible as chat history.
+ */
+export type HumanInputItem = {
+    kind: "human-input";
+    id: string;
+    turnId: string | null;
+    requestId: string;
+    questions: HumanInputQuestion[];
+    response: HumanInputResponse;
+    answers: HumanInputAnswerSummary[];
+    occurredAt: string;
+};
 export type AgentMessageItem = {
     kind: "agent-message";
     id: string;
     turnId: string | null;
     text: string;
+    /**
+     * Assistant channel: provider-declared, or `commentary` when the model asked
+     * for tool work in the same response. Absent on legacy events and on
+     * undeclared final messages. Known from the first delta for Responses models.
+     */
+    phase?: "commentary" | "final_answer" | undefined;
     /** Still receiving deltas (no completed/turn-end seen yet). */
     streaming: boolean;
     occurredAt: string;
+    /**
+     * When the first streamed text arrived, kept once completion moves
+     * `occurredAt` to the completion time. Absent for a message that never
+     * streamed.
+     */
+    startedAt?: string | undefined;
     /** Available only after the canonical completed event lands. */
     annotationSource?: TimelineAnnotationSourceDescriptor | undefined;
 };
@@ -67,6 +108,7 @@ export type ToolCallItem = {
     turnId: string | null;
     callId: string | null;
     name: string;
+    display?: ToolDisplayMetadata;
     arguments: unknown;
     output: unknown;
     truncation?: ToolCallTruncation | null;
@@ -130,6 +172,22 @@ export type SandboxItem = {
     status: "running" | "complete" | "failed" | "cancelled";
     occurredAt: string;
 };
+export type StartupPhase = "queue" | "sandbox" | "rig" | "repository" | "files" | "tools" | "model_preparation" | "provider_first_byte";
+/** A compact user-visible critical-path span reconstructed from durable events. */
+export type StartupPhaseItem = {
+    kind: "startup-phase";
+    id: string;
+    turnId: string | null;
+    phase: StartupPhase;
+    status: "running" | "complete" | "failed" | "cancelled";
+    startedAt: string;
+    completedAt: string | null;
+    durationMs: number | null;
+    /** Sandbox origin and rig marker outcomes refine the settled label only. */
+    outcome: "created" | "restored" | "resumed" | "skipped" | null;
+    blockedReason?: "capture_in_progress" | "rotation_in_progress" | "provider_recovery_in_progress" | undefined;
+    occurredAt: string;
+};
 /**
  * A first-party workspace-memory write the agent made mid-turn — a `memory.saved`
  * (it committed a new preference / fact / procedure / decision / history) or a
@@ -139,6 +197,17 @@ export type SandboxItem = {
  * `onMemoryClick` handler the row also deep-links to the record in its memory
  * pane; without one it is non-interactive rich content.
  */
+export type KnowledgeItem = {
+    kind: "knowledge";
+    id: string;
+    turnId: string | null;
+    status: "complete" | "failed";
+    outcome: "published" | "pending" | "rejected" | "archived" | "failed";
+    fileId?: string | undefined;
+    filename?: string | undefined;
+    entryId?: string | undefined;
+    occurredAt: string;
+};
 export type MemoryItem = {
     kind: "memory";
     id: string;
@@ -183,7 +252,7 @@ export type FleetDecisionItem = {
     policyVersion: "adaptive-shadow-v1";
     actualOutcome: "selected" | "waiting" | "none";
     actualCandidateKey: string | null;
-    actualReason: "lease_reused" | "pin" | "rotation" | "active" | "all_capped" | "none";
+    actualReason: "lease_reused" | "pin" | "rotation" | "active" | "all_capped" | "allocator_disabled" | "none";
     shadowOutcome: "selected" | "paced" | "none";
     shadowCandidateKey: string | null;
     shadowReason: "fenced_in_flight" | "fenced_candidate_missing" | "admission_paced" | "no_eligible_candidate" | "overlay_isolated_empty" | "best_score" | "affinity_best" | "hysteresis_hold";
@@ -204,12 +273,14 @@ export type SessionStatusItem = {
     kind: "session-status";
     id: string;
     status: SessionStatus;
+    /** Presentation-only evidence that this historical attention state resumed. */
+    resolvedAt?: string;
     occurredAt: string;
 };
 export type GoalItem = {
     kind: "goal";
     id: string;
-    action: "set" | "updated" | "completed" | "paused" | "resumed" | "cleared" | "continuation";
+    action: "set" | "updated" | "completed" | "paused" | "resumed" | "cleared" | "held" | "continuation";
     text: string | null;
     occurredAt: string;
 };
@@ -218,6 +289,18 @@ export type NoticeItem = {
     id: string;
     tone: "waiting" | "cancelled" | "failed" | "input";
     text: string;
+    /** Presentation-only evidence that a historical approval wait resumed. */
+    resolvedAt?: string;
+    /** A preserved turn-end outcome, not a claim about current session state. */
+    recordedOutcome?: true;
+    /**
+     * Recorded agent wait only: delegated worker sessions that had not reported
+     * back when the wait began. Best effort from the loaded history; absent when
+     * none are known.
+     */
+    waitingAgents?: number;
+    /** Recorded agent wait only: when later input ended the wait. */
+    waitEndedAt?: string;
     /** Optional evidence kept inspectable without overwhelming the main rail. */
     details?: {
         label: string;
@@ -227,6 +310,12 @@ export type NoticeItem = {
         label: string;
         url: string;
     };
+    /**
+     * A usage ceiling refused further work. `text` keeps the canonical sentence
+     * for plain-text consumers; `MessageTimeline` renders this structured row
+     * (customizable with `renderAllowanceExhausted` / `allowanceExhaustedLabels`).
+     */
+    allowance?: AllowanceExhaustedRefusal;
     occurredAt: string;
 };
 /**
@@ -242,13 +331,25 @@ export type ContextCompactionItem = {
     estimatedTokensBefore: number | null;
     estimatedTokensAfter: number | null;
     skipReason: string | null;
+    /**
+     * Present only for a `summarization_failed` skip where the provider
+     * definitively rejected the compaction request. Content-free identifiers.
+     */
+    providerRejection: ContextCompactionProviderRejection | null;
     /** Provider implementation id for debug disclosure only. */
     implementation: string | null;
     occurredAt: string;
 };
+export type ContextCompactionProviderRejection = {
+    httpStatus: number;
+    type: string | null;
+    code: string | null;
+    param: string | null;
+    requestId: string | null;
+};
 export type MachineInputMember = {
     id: string;
-    kind: "scheduled_occurrence" | "goal_continuation" | "agent_message" | "agent_steer_instruction" | "child_terminal_result" | "media_generation_result";
+    kind: "scheduled_occurrence" | "goal_continuation" | "background_command_result" | "session_wait_timeout" | "agent_message" | "agent_steer_instruction" | "child_terminal_result" | "media_generation_result" | "child_requires_action" | "child_requires_action_resolved" | "child_paused" | "child_waiting_capacity" | "child_progress";
     classification: "success" | "failure" | "action_required" | "info";
     sourceId: string;
     summary: string;
@@ -263,6 +364,8 @@ export type MachineInputBatchItem = {
     id: string;
     turnId: string | null;
     members: MachineInputMember[];
+    /** Readable-turn presentation keeps machine payload prose inside the disclosure. */
+    compact?: boolean;
     occurredAt: string;
 };
 /**
@@ -281,12 +384,17 @@ export type AuthNeededItem = {
     turnId: string | null;
     /** The runtime surface that requested recovery, when the event is an MCP auth signal. */
     serverId: string | null;
+    /** Explicit recovery identity; never inferred from an opaque execution alias. */
+    canonicalServerId?: string | null;
+    connectionSubjectScope?: "workspace" | "subject" | null;
     /** Durable event family that produced this notice. */
     source?: "tool" | "credential" | "capability" | undefined;
     /** The connection's registrable domain, e.g. "linear.app". */
     providerDomain: string;
     /** The lapsed connection to reconnect, when the row survived. */
     connectionId: string | null;
+    /** Host-owned bindings must never be routed into OpenGeni's native reconnect flow. */
+    authoritySource?: ToolAuthNeededPayload["authoritySource"] | null | undefined;
     reason: ToolAuthNeededPayload["reason"] | null;
     /** Scopes the provider now needs; may inform the copy, never shown as a raw label. */
     scopes: string[];
@@ -298,20 +406,35 @@ export type AuthNeededItem = {
     authorizationUrl: string | null;
     /** Agent-selected catalog recommendation. The host still owns authorization. */
     capability?: NonNullable<ToolAuthNeededPayload["capability"]> | null | undefined;
+    /** Human-reviewed custom integration proposal. Never treated as catalog authority. */
+    setupRequest?: ToolAuthNeededPayload["setupRequest"] | null | undefined;
     occurredAt: string;
 };
 export type TurnOutcome = "complete" | "failed" | "cancelled";
 export type TurnEndItem = {
     kind: "turn-end";
+    /** A durable Retry reopened this failed logical turn; its failure is history. */
+    resumedAt?: string;
+    /** Keep an existing answer visible when a recorded input wait ends without final output. */
+    preserveWaitResponse?: true;
     id: string;
     turnId: string | null;
     outcome: TurnOutcome;
     failureText: string | null;
     occurredAt: string;
 };
-export type TimelineItem = UserMessageItem | AgentMessageItem | ReasoningItem | ToolCallItem | WorkerItem | WorkerCompletionItem | SandboxItem | SessionStatusItem | GoalItem | NoticeItem | ContextCompactionItem | MachineInputBatchItem | AuthNeededItem | MemoryItem | FleetDecisionItem | TurnEndItem;
-/** Activity items cluster between chat messages (reasoning, tools, workers, sandbox, memory). */
-export type ActivityItem = ReasoningItem | ToolCallItem | WorkerItem | SandboxItem | MemoryItem | FleetDecisionItem;
+export type TimelineItem = (UserMessageItem | HumanInputItem | AgentMessageItem | ReasoningItem | ToolCallItem | WorkerItem | WorkerCompletionItem | SandboxItem | StartupPhaseItem | SessionStatusItem | GoalItem | NoticeItem | ContextCompactionItem | MachineInputBatchItem | AuthNeededItem | MemoryItem | KnowledgeItem | FleetDecisionItem | TurnEndItem) & {
+    /** Durable identities, independent of renderer/reconciliation keys. */
+    sourceEvents?: readonly {
+        eventId: string;
+        sequence: number;
+    }[] | undefined;
+};
+/**
+ * Activity items cluster between chat messages (reasoning, tools, workers,
+ * sandbox, memory). Assistant prose is rendered separately.
+ */
+export type ActivityItem = ReasoningItem | ToolCallItem | WorkerItem | SandboxItem | StartupPhaseItem | MemoryItem | KnowledgeItem | FleetDecisionItem | AgentMessageItem;
 export type TimelineGroup = {
     kind: "item";
     item: TimelineItem;
@@ -321,6 +444,17 @@ export type TimelineGroup = {
     items: ActivityItem[];
     outcome?: TurnOutcome;
     failureText?: string;
+    /** One turn's chronological work history, including progress prose after settlement. */
+    work?: {
+        startedAt: string;
+        endedAt?: string;
+        responseStartedAt?: string;
+        waiting?: {
+            label: string;
+            since: string;
+        };
+        details: TimelineGroup[];
+    };
 } | {
     kind: "turn";
     id: string;

package/dist/timeline-annotation-markers-GNDHTGBD.js

@@ -0,0 +1,165 @@
+import {
+  annotationBoxIntersects,
+  annotationViewportBox,
+  layoutAnnotationBadges
+} from "./chunk-ZYRGEKWS.js";
+import {
+  annotatableText,
+  annotationDisplayOrdinal,
+  annotationHasNote,
+  buildQuoteRange,
+  cssEscapeAttribute,
+  matchingQuoteInSource,
+  occurrenceOffsets
+} from "./chunk-447JLCBU.js";
+import {
+  cn
+} from "./chunk-22KP6LR5.js";
+
+// src/components/timeline-annotation-markers.tsx
+import { useLayoutEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { jsx } from "react/jsx-runtime";
+function lastVisibleRect(range) {
+  try {
+    const rects = range.getClientRects();
+    for (let index = rects.length - 1; index >= 0; index--) {
+      const rect = rects.item(index);
+      if (rect && (rect.width > 0 || rect.height > 0)) return rect;
+    }
+  } catch {
+  }
+  try {
+    const bounding = range.getBoundingClientRect();
+    if (bounding.width > 0 || bounding.height > 0) return bounding;
+  } catch {
+  }
+  return null;
+}
+function occurrenceForAnnotation(sourceEl, annotation) {
+  const { text } = annotatableText(sourceEl);
+  const quote = matchingQuoteInSource(text, annotation.quote) ?? annotation.quote;
+  const offsets = occurrenceOffsets(text, quote);
+  if (offsets.length <= 1) return 0;
+  let best = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  offsets.forEach((offset, index) => {
+    const distance = Math.abs(offset - annotation.source.startOffset);
+    if (distance < bestDistance) {
+      best = index;
+      bestDistance = distance;
+    }
+  });
+  return best;
+}
+function timelineScroller(root) {
+  if (root.matches("[data-og-timeline-scroller]")) return root;
+  const nested = root.querySelector("[data-og-timeline-scroller]");
+  return nested instanceof HTMLElement ? nested : root;
+}
+function currentAnnotationViewport(root) {
+  const scroller = timelineScroller(root);
+  const rect = scroller.getBoundingClientRect();
+  const scrollerBox = {
+    left: rect.left,
+    right: rect.right,
+    top: rect.top,
+    bottom: rect.bottom
+  };
+  return annotationViewportBox(window.innerWidth || 1024, window.innerHeight || 768, scrollerBox);
+}
+function sourceInTimeline(root, eventId) {
+  const source = root.querySelector(
+    `[data-og-annotation-source-key="${cssEscapeAttribute(eventId)}"]`
+  );
+  return source instanceof HTMLElement ? source : null;
+}
+function collectMarkers(root, annotations) {
+  if (!root) return [];
+  const viewport = currentAnnotationViewport(root);
+  const next = [];
+  for (const [index, annotation] of annotations.entries()) {
+    const source = sourceInTimeline(root, annotation.source.eventId);
+    if (!source) continue;
+    const quote = matchingQuoteInSource(annotatableText(source).text, annotation.quote) ?? annotation.quote;
+    const range = buildQuoteRange(source, quote, occurrenceForAnnotation(source, annotation));
+    if (!range) continue;
+    const rect = lastVisibleRect(range);
+    if (!rect) continue;
+    if (!annotationBoxIntersects(
+      { left: rect.left, right: rect.right, top: rect.top, bottom: rect.bottom },
+      viewport
+    )) {
+      continue;
+    }
+    next.push({
+      id: annotation.id,
+      ordinal: annotationDisplayOrdinal(annotation, index),
+      left: rect.right,
+      top: rect.top,
+      incomplete: !annotationHasNote(annotation.note)
+    });
+  }
+  return layoutAnnotationBadges(next, viewport);
+}
+function TimelineAnnotationMarkers({
+  annotations,
+  onSelect,
+  rootRef
+}) {
+  const [markers, setMarkers] = useState([]);
+  useLayoutEffect(() => {
+    const root = rootRef.current;
+    if (!root || annotations.length === 0) {
+      setMarkers([]);
+      return;
+    }
+    const update = () => setMarkers(collectMarkers(root, annotations));
+    update();
+    window.addEventListener("resize", update);
+    window.addEventListener("scroll", update, true);
+    const observer = typeof ResizeObserver === "function" ? new ResizeObserver(update) : null;
+    observer?.observe(root);
+    for (const annotation of annotations) {
+      const source = sourceInTimeline(root, annotation.source.eventId);
+      if (source) observer?.observe(source);
+    }
+    return () => {
+      window.removeEventListener("resize", update);
+      window.removeEventListener("scroll", update, true);
+      observer?.disconnect();
+    };
+  }, [annotations, rootRef]);
+  if (markers.length === 0 || typeof document === "undefined") return null;
+  return createPortal(
+    /* @__PURE__ */ jsx("div", { className: "og-root pointer-events-none fixed inset-0 z-[35]", children: markers.map((marker) => /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        "data-og-annotation-badge": "",
+        "data-og-annotation-badge-ordinal": marker.ordinal,
+        style: { left: marker.left, top: marker.top, zIndex: marker.ordinal },
+        className: cn(
+          "pointer-events-auto absolute flex h-4 min-w-4 -translate-x-1/2 -translate-y-[110%] items-center justify-center rounded-full bg-og-accent px-0.5 text-[10px] font-semibold tabular-nums text-og-accent-fg shadow-sm outline-hidden select-none after:absolute after:-inset-2 after:content-[''] focus-visible:ring-2 focus-visible:ring-og-accent pointer-coarse:after:-inset-2.5",
+          marker.incomplete && "ring-1 ring-og-accent-fg/35"
+        ),
+        "aria-label": `Annotation ${marker.ordinal}`,
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+          onSelect?.(marker.id);
+        },
+        children: marker.ordinal
+      },
+      marker.id
+    )) }),
+    document.body
+  );
+}
+var timeline_annotation_markers_default = TimelineAnnotationMarkers;
+export {
+  TimelineAnnotationMarkers,
+  timeline_annotation_markers_default as default
+};
+//# sourceMappingURL=timeline-annotation-markers-GNDHTGBD.js.map