@opengeni/react 7.4.0 → 7.5.0-canary.36927100590001

package/dist/components/artifacts/artifact-chrome.d.ts

@@ -0,0 +1,120 @@
+import { type ComponentProps, type ReactNode } from "react";
+/**
+ * Shared chrome for artifact surfaces: the OpenGeni console and embedding hosts
+ * render the same header, controls, and load states. Class names use the
+ * package theme aliases, so the console's own Tailwind build and the compiled
+ * `.og-root` stylesheet resolve them identically.
+ */
+export type ArtifactKind = "document" | "spreadsheet" | "presentation" | "site" | "image" | "file";
+declare const BUTTON_VARIANT: {
+    readonly ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50";
+    readonly outline: "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:border-border dark:bg-input/30 dark:hover:bg-input/50";
+};
+declare const BUTTON_SIZE: {
+    readonly sm: "h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5";
+    readonly icon: "size-9";
+    readonly "icon-sm": "size-8";
+};
+export declare function ArtifactButton({ variant, size, className, type, ...props }: ComponentProps<"button"> & {
+    variant?: keyof typeof BUTTON_VARIANT;
+    size?: keyof typeof BUTTON_SIZE;
+}): import("react").JSX.Element;
+export declare function ArtifactBadge({ className, ...props }: ComponentProps<"span">): import("react").JSX.Element;
+export declare const ArtifactSelect: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;
+export declare function artifactKindIcon(kind: ArtifactKind): ReactNode;
+export declare function artifactKindSubtitle(kind: ArtifactKind): string;
+type LoadErrorCopy = Readonly<Record<"unavailable" | "invalid" | "transient", {
+    title: string;
+    message: string;
+}>>;
+/**
+ * Every user-facing string in the artifact surfaces (inline Site preview, Site
+ * frame, viewer header and states). Hosts translate by passing a partial
+ * `labels` object; unspecified keys keep the English defaults.
+ */
+export type ArtifactLabels = Readonly<{
+    back: string;
+    close: string;
+    /** Header title and loading copy until an artifact's title is known. */
+    opening: string;
+    /** Header title when an artifact cannot be opened. */
+    artifact: string;
+    startingEditor: string;
+    kindSubtitle: (kind: ArtifactKind) => string;
+    live: string;
+    reloadSite: string;
+    openFullScreen: string;
+    editWithAgent: string;
+    editShort: string;
+    preview: string;
+    loadPreview: string;
+    loadSitePreview: string;
+    siteVersion: string;
+    savedVersion: string;
+    version: (revision: number) => string;
+    openSite: string;
+    loadingSite: string;
+    siteArchived: string;
+    siteUnpublished: string;
+    siteReferenceInvalid: string;
+    siteLoadFailed: string;
+    retry: string;
+    tryAgain: string;
+    toolCount: (count: number) => string;
+    toolsAvailable: (count: number) => string;
+    sourceFileCount: (count: number) => string;
+    viewingDisabled: {
+        title: string;
+        message: string;
+    };
+    editorsMissing: {
+        title: string;
+        message: string;
+    };
+    siteErrors: LoadErrorCopy;
+    editableErrors: LoadErrorCopy;
+    reference: (id: string) => string;
+}>;
+export declare const DEFAULT_ARTIFACT_LABELS: ArtifactLabels;
+/** Translate every artifact surface below; nested providers override outer ones. */
+export declare function ArtifactLabelsProvider({ labels, children, }: {
+    labels: Partial<ArtifactLabels> | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useArtifactLabels(): ArtifactLabels;
+/**
+ * One artifact header: optional Back, the kind tile, title (or a host-supplied
+ * title control), trailing actions, and optional Close. The console dock and
+ * embedded viewers share it.
+ */
+export declare function ArtifactViewerHeader({ kind, title, subtitle, titleSlot, onBack, backLabel, actions, onClose, closeLabel, }: Readonly<{
+    /** `null` while the host does not know the modality yet. */
+    kind: ArtifactKind | null;
+    title: string;
+    subtitle?: string | undefined;
+    /** Replaces the title text, for example with a picker. */
+    titleSlot?: ReactNode;
+    onBack?: (() => void) | undefined;
+    backLabel?: string | undefined;
+    actions?: ReactNode;
+    onClose?: (() => void) | undefined;
+    closeLabel?: string | undefined;
+}>): import("react").JSX.Element;
+export declare function ArtifactLoading({ label }: {
+    label: string;
+}): import("react").JSX.Element;
+export declare function ArtifactProblem({ view, onRetry, }: {
+    view: ArtifactLoadErrorView;
+    onRetry?: (() => void) | undefined;
+}): import("react").JSX.Element;
+export type ArtifactLoadErrorKind = "site" | "editable";
+export type ArtifactLoadErrorView = Readonly<{
+    title: string;
+    message: string;
+    retryable: boolean;
+    correlationId?: string;
+}>;
+/** Site/editor load copy. Never surfaces raw OpenGeni API status text. */
+export declare function artifactLoadErrorView(error: unknown, kind: ArtifactLoadErrorKind, labels?: ArtifactLabels): ArtifactLoadErrorView;
+export declare function artifactLoadErrorMessage(view: ArtifactLoadErrorView, labels?: ArtifactLabels): string;
+export {};

package/dist/components/artifacts/artifact-sandbox.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from "react";
+import { type PublishedHtmlArtifactToolBridge } from "./published-html-artifact-frame.js";
+export type ArtifactSandboxProps = {
+    html: string;
+    height?: number | undefined;
+    autoHeight?: boolean | undefined;
+    theme?: "light" | "dark" | undefined;
+    headerControls?: ReactNode | undefined;
+    title: string;
+    /** Hide the visible title/icon while retaining the accessible iframe title. */
+    showTitle?: boolean | undefined;
+    showLiveStatus?: boolean | undefined;
+    versionLabel?: string | undefined;
+    className?: string | undefined;
+    editDisabled?: boolean | undefined;
+    onEdit?: (() => void) | undefined;
+    toolBridge?: PublishedHtmlArtifactToolBridge | undefined;
+    connectedToolCount?: number | undefined;
+    sourceFileCount?: number | undefined;
+    fill?: boolean | undefined;
+};
+/**
+ * The Site/preview frame chrome shared by the console and embedding hosts:
+ * title, version and tool badges, live status, reload, and a full-screen mode
+ * that escapes the host's scroll containers through the modal top layer.
+ */
+export declare function ArtifactSandbox(props: ArtifactSandboxProps): import("react").JSX.Element;

package/dist/components/artifacts/chat-interactive-block.d.ts

@@ -0,0 +1,29 @@
+import type { OpenGeniClient, ToolGatewayIdentity } from "@opengeni/sdk";
+import { type ArtifactLabels } from "./artifact-chrome.js";
+import type { PublishedHtmlArtifactToolBridge } from "./published-html-artifact-frame.js";
+/** Reads a Site needs to render; the console client, the SDK client, or a proxy. */
+export type SiteSnapshotClient = Pick<OpenGeniClient, "getWorkspaceArtifact" | "getWorkspaceArtifactHtml"> & Partial<Pick<OpenGeniClient, "getWorkspaceArtifactContent">>;
+/** The exact saved Site a tool bridge is pinned to (absent for inline HTML). */
+export type SiteToolScope = {
+    artifactId: string;
+    siteVersionId: string;
+    requestedTools: readonly ToolGatewayIdentity[];
+};
+/** Host-owned Site API access. Omit it and Sites render without workspace tools. */
+export type SiteToolBridgeFactory = (site?: SiteToolScope) => PublishedHtmlArtifactToolBridge | undefined;
+export type ChatInteractiveBlockProps = {
+    workspaceId: string;
+    kind: "html" | "site";
+    content: string;
+    client: SiteSnapshotClient;
+    toolBridge?: SiteToolBridgeFactory | undefined;
+    theme?: "light" | "dark" | undefined;
+    /** Translations for the preview's copy; defaults to English. */
+    labels?: Partial<ArtifactLabels> | undefined;
+};
+/**
+ * Inline preview for an assistant `opengeni-html` or `opengeni-site` fence, as
+ * the OpenGeni console renders it. "Open Site" goes through the nearest
+ * `resolveLink`, so a host decides where a Site opens.
+ */
+export declare function ChatInteractiveBlock({ labels, ...props }: ChatInteractiveBlockProps): import("react").JSX.Element;

package/dist/components/artifacts/deferred-chat-media.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from "react";
+/**
+ * Reserve the chat slot before starting expensive media work. Activation is
+ * one-way: scrolling away must not discard an interactive preview's state.
+ * The timeline parks at its initial tip in layout effects before this observer
+ * is attached, so historical previews above the entry viewport stay dormant.
+ */
+export declare function DeferredChatMedia({ children, height, label, actionLabel, }: {
+    children: ReactNode;
+    height: number;
+    /** What is loading, as in "Load {label}". */
+    label?: string | undefined;
+    /** The complete (translated) activation label; overrides `label`. */
+    actionLabel?: string | undefined;
+}): import("react").JSX.Element;

package/dist/components/artifacts/editable-artifact-ui.d.ts

@@ -5,9 +5,10 @@ export declare function editableArtifactProjectionKey(view: EditableArtifactSync
 export declare function editableArtifactStatusLabel(view: EditableArtifactSyncView): string;
 /** Revoked read authority must hide any projection retained before invalidation. */
 export declare function editableArtifactAccessRevoked(view: EditableArtifactSyncView): boolean;
-export declare function EditableArtifactMessage({ title, detail, retry, }: {
+export declare function EditableArtifactMessage({ title, detail, retry, retryLabel, }: {
     title: string;
     detail: string;
     retry?: (() => void) | undefined;
+    retryLabel?: string | undefined;
 }): import("react").JSX.Element;
 export declare function asEditableArtifactError(cause: unknown, fallback: string): Error;

package/dist/components/artifacts/editable-artifact-view.d.ts

@@ -0,0 +1,46 @@
+import type { EditableArtifactResource } from "@opengeni/sdk/artifacts";
+import { type CreateBrowserEditableArtifactSessionOptions, type EditableArtifactBrowserRuntime, type EditableArtifactCacheAuthority } from "@opengeni/sdk/editable-artifacts";
+import { type ArtifactLoadErrorView } from "./artifact-chrome.js";
+/**
+ * The browser kernels an editor needs, one per modality, plus the host-built
+ * Worker URL (for Vite: `@opengeni/sdk/editable-artifacts/worker?worker&url`).
+ * Kernels come from `@opengeni/artifact-kernel-wasm-{document,spreadsheet,presentation}`.
+ */
+export type EditableArtifactRuntimes = Readonly<{
+    document: Omit<EditableArtifactBrowserRuntime, "workerUrl" | "workerFactory">;
+    spreadsheet: Omit<EditableArtifactBrowserRuntime, "workerUrl" | "workerFactory">;
+    presentation: Omit<EditableArtifactBrowserRuntime, "workerUrl" | "workerFactory">;
+    workerUrl: string;
+    applicationOrigin?: string | undefined;
+    /** Loopback development only. */
+    allowInsecureDevelopmentAssets?: boolean | undefined;
+}>;
+/** Everything needed to open one artifact for the current principal. */
+export type OpenedEditableArtifact = Readonly<{
+    artifact: EditableArtifactResource;
+    authority: EditableArtifactCacheAuthority;
+    replicaId: string;
+}>;
+export type EditableArtifactViewProps = Readonly<{
+    /** Absolute API (or session proxy) base the live transport talks to. */
+    baseUrl: URL;
+    workspaceId: string;
+    artifactId: string;
+    /** Resolve metadata, cache authority, and replica; called again on retry. */
+    open: (signal: AbortSignal) => Promise<OpenedEditableArtifact>;
+    runtimes: EditableArtifactRuntimes;
+    transport?: CreateBrowserEditableArtifactSessionOptions["transport"];
+    /** Show the editor's own title header (hosts with their own header hide it). */
+    showHeader?: boolean | undefined;
+    /** Re-open when this changes (for example the host's credential version). */
+    authorityKey?: string | undefined;
+    describeError?: ((error: unknown) => ArtifactLoadErrorView) | undefined;
+    onTitle?: ((title: string) => void) | undefined;
+    /** Loading copy; defaults to the `opening` label. */
+    loadingLabel?: string | undefined;
+}>;
+/**
+ * One editable document, spreadsheet, or presentation with its first-party
+ * editor. The console dock/page and embedding hosts supply only data access.
+ */
+export declare function EditableArtifactView({ baseUrl, workspaceId, artifactId, open, runtimes, transport, showHeader, authorityKey, describeError, onTitle, loadingLabel, }: EditableArtifactViewProps): import("react").JSX.Element;

package/dist/components/artifacts/index.d.ts

@@ -1,3 +1,10 @@
+export { ArtifactBadge, ArtifactLabelsProvider, DEFAULT_ARTIFACT_LABELS, useArtifactLabels, type ArtifactLabels, ArtifactButton, ArtifactLoading, ArtifactProblem, ArtifactSelect, ArtifactViewerHeader, artifactKindIcon, artifactKindSubtitle, artifactLoadErrorMessage, artifactLoadErrorView, type ArtifactKind, type ArtifactLoadErrorKind, type ArtifactLoadErrorView, } from "./artifact-chrome.js";
+export { ArtifactSandbox, type ArtifactSandboxProps } from "./artifact-sandbox.js";
+export { DeferredChatMedia } from "./deferred-chat-media.js";
+export { ChatInteractiveBlock, type ChatInteractiveBlockProps, type SiteSnapshotClient, type SiteToolBridgeFactory, type SiteToolScope, } from "./chat-interactive-block.js";
+export { SiteView, type SiteViewProps } from "./site-view.js";
+export { EditableArtifactView, type EditableArtifactRuntimes, type EditableArtifactViewProps, type OpenedEditableArtifact, } from "./editable-artifact-view.js";
+export { SessionArtifactViewer, type SessionArtifactTarget, type SessionArtifactViewerLabels, type SessionArtifactViewerProps, } from "./session-artifact-viewer.js";
 export { ArtifactSurface, type ArtifactModality, type ArtifactSurfaceProps, } from "./artifact-surface.js";
 export { PUBLISHED_HTML_ARTIFACT_IFRAME_SANDBOX, PublishedHtmlArtifactFrame, openGeniSiteBridgePortFromBootstrap, publishedHtmlArtifactDocument, type PublishedHtmlArtifactFrameProps, type PublishedHtmlArtifactToolBridge, } from "./published-html-artifact-frame.js";
 export { SpreadsheetArtifactSurface, SpreadsheetGrid, SpreadsheetProjectionGrid, type SpreadsheetArtifactSurfaceProps, type SpreadsheetCommit, type SpreadsheetRangeCommit, type SpreadsheetGridProps, type SpreadsheetGridProjection, type SpreadsheetProjectionCell, type SpreadsheetProjectionGridProps, type SpreadsheetSelection, type SpreadsheetViewport, } from "./spreadsheet-grid.js";

package/dist/components/artifacts/latest-task-runner.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Runs one task at a time; a task scheduled while another runs replaces any
+ * task still waiting, so only the newest request starts next. Editors use it
+ * for projection loads: replaying a long history emits one revision per
+ * committed transaction, and composing a projection for each of them at once
+ * would overrun the artifact Worker's bounded request queue.
+ */
+export declare function createLatestTaskRunner(): (task: () => Promise<void>) => void;
+/**
+ * One runner per artifact session. A composition still pending on a replaced
+ * session (for example one whose Worker stopped answering) must never hold up
+ * the next session's first load, so the runner is scoped to the session object
+ * rather than to the component.
+ */
+export declare function useLatestTaskRunner(session: object): (task: () => Promise<void>) => void;

package/dist/components/artifacts/session-artifact-viewer.d.ts

@@ -0,0 +1,39 @@
+import { type ClientOverride } from "../../session-context.js";
+import { type ArtifactLabels } from "./artifact-chrome.js";
+import { type EditableArtifactRuntimes } from "./editable-artifact-view.js";
+import type { SiteToolBridgeFactory } from "./chat-interactive-block.js";
+/** An artifact opened from a session: the targets agent links and Site previews name. */
+export type SessionArtifactTarget = Readonly<{
+    kind: "editable-artifact";
+    artifactId: string;
+    title?: string | undefined;
+} | {
+    kind: "site";
+    artifactId: string;
+    title?: string | undefined;
+}>;
+/** Every string the viewer shows, including its Site frame and states. */
+export type SessionArtifactViewerLabels = Partial<ArtifactLabels>;
+export type SessionArtifactViewerProps = ClientOverride & Readonly<{
+    /** The conversation the artifact belongs to; the proxy only serves its artifacts. */
+    sessionId: string;
+    target: SessionArtifactTarget;
+    onClose: () => void;
+    /** Show a Back control, for example to return to the conversation on phones. */
+    onBack?: (() => void) | undefined;
+    /** Browser kernels and Worker for documents, spreadsheets, and presentations. */
+    editableRuntimes?: EditableArtifactRuntimes | undefined;
+    theme?: "light" | "dark" | undefined;
+    /** Host-owned Site API access; omit it and Sites render without workspace tools. */
+    siteToolBridge?: SiteToolBridgeFactory | undefined;
+    labels?: SessionArtifactViewerLabels | undefined;
+    className?: string | undefined;
+}>;
+/**
+ * A host-mountable viewer for one editable artifact or Site from a session,
+ * with its own header (title, Back, Close). Mount it in any sized container
+ * (a side panel, a sheet); it fills it. Data flows through the provider's
+ * client and `createSessionProxyHandler({ artifacts: true })`, scoped to
+ * `sessionId`.
+ */
+export declare function SessionArtifactViewer({ labels, ...props }: SessionArtifactViewerProps): import("react").JSX.Element;

package/dist/components/artifacts/site-view.d.ts

@@ -0,0 +1,23 @@
+import type { SiteSnapshotClient, SiteToolBridgeFactory } from "./chat-interactive-block.js";
+export type SiteViewProps = {
+    client: SiteSnapshotClient;
+    workspaceId: string;
+    siteId: string;
+    /** Host-owned Site API access. Omit it and the Site renders without workspace tools. */
+    toolBridge?: SiteToolBridgeFactory | undefined;
+    theme?: "light" | "dark" | undefined;
+    /** Shown instead of the archived notice; the console links to its full page. */
+    archivedMessage?: string | undefined;
+    /** Show the Site title in the frame bar; hide it under a host header that already does. */
+    showTitle?: boolean | undefined;
+    /** Loading copy; defaults to "Loading Site…". */
+    loadingLabel?: string | undefined;
+    /** Called with the loaded title, for a host header. */
+    onTitle?: ((title: string) => void) | undefined;
+    className?: string | undefined;
+};
+/**
+ * A published Site filling its container: the console's session dock and an
+ * embedding host's artifact viewer render the same view.
+ */
+export declare function SiteView({ client, workspaceId, siteId, toolBridge, theme, archivedMessage, showTitle, loadingLabel, onTitle, className, }: SiteViewProps): import("react").JSX.Element;

package/dist/components/browser-select-control.d.ts

@@ -1,6 +1,8 @@
 import type { BrowserAction, BrowserActionReceipt, BrowserObservation } from "@opengeni/sdk/interaction";
 /** Human fallback for native popup windows missing from Chromium page frames. */
 export declare function BrowserSelectControl(props: {
+    /** Older controllers need an explicit read to discover native popup options. */
+    manualFallback?: boolean;
     activation?: {
         observation: BrowserObservation | null;
         anchor: {
@@ -11,4 +13,4 @@ export declare function BrowserSelectControl(props: {
     onDismiss?: () => void;
     observe: () => Promise<BrowserObservation>;
     act: (action: BrowserAction, observation: BrowserObservation) => Promise<BrowserActionReceipt>;
-}): import("react").JSX.Element;
+}): import("react").JSX.Element | null;

package/dist/components/code-editor.d.ts

@@ -1,8 +1,6 @@
 import { type ReactNode } from "react";
-/** Language grammar loaders, keyed by the extension class we infer from the path. */
-declare const LANGUAGE_LOADERS: Record<string, () => Promise<unknown>>;
 /** Map a filename to a grammar key (or null for plain text — still fully editable). */
-export declare function languageForPath(path: string): keyof typeof LANGUAGE_LOADERS | null;
+export declare function languageForPath(path: string): string | null;
 export type CodeEditorProps = {
     /** Workspace-relative path — drives language inference (and the save target upstream). */
     path: string;
@@ -62,4 +60,3 @@ export declare function reconcileEditorBuffer(current: EditorBufferState, incomi
  * be saved back (which would corrupt it by writing the truncated prefix).
  */
 export declare function CodeEditor({ path, initialContents, onSave, onOverwrite, onReload, onEditIntent, readOnly, themeType, loading, fallback, className, }: CodeEditorProps): import("react").JSX.Element;
-export {};

package/dist/components/desktop-viewer.d.ts

@@ -15,7 +15,7 @@ export type DesktopViewerProps = {
     /** Render the built-in Watching ⇄ Take control toggle (default true). */
     showControlToggle?: boolean | undefined;
     scaleViewport?: boolean | undefined;
-    /** Custom RFB factory (tests / a WebRTC swap). Defaults to lazy @novnc/novnc. */
+    /** Custom RFB factory; otherwise enableDesktopViewer() supplies lazy noVNC. */
     rfbFactory?: DesktopRfbFactory | undefined;
     /** Authenticated controller protocols for proxied RFB transports. */
     webSocketProtocols?: string[] | undefined;

package/dist/components/message-timeline.d.ts

@@ -3,9 +3,12 @@ import { type GenieLoadingOptions } from "../timeline/genie-loading.js";
 import type { DraftTimelineAnnotation, SessionEvent, SessionStatus } from "@opengeni/sdk";
 import { type ReactNode } from "react";
 import { type OlderHistoryLoader } from "../older-history.js";
+import { type MarkdownProps } from "./markdown.js";
 import { type OpenGeniLinkResolver } from "./open-geni-links.js";
 import { type UserMessageDisclosureLabels } from "./user-message-body.js";
 import { type AgentMessageItem, type AuthNeededItem, type TimelineGroup, type TimelineItem, type RetainedArtifactLoader, type RetainedScreenshotLoader, type VideoArtifactPlaybackLoader, type ToolRegistry, type TurnSummaryOptions, type UserMessageItem } from "../timeline/index.js";
+import { type RenderAllowanceExhausted } from "../timeline/allowance-exhausted-row.js";
+import type { AllowanceLabels } from "../usage/allowance-copy.js";
 export type MessageTimelineProps = {
     /** Exact durable search hit; clearing it removes highlighting without moving the reader. */
     searchTarget?: TimelineSearchTarget | null | undefined;
@@ -23,6 +26,11 @@ export type MessageTimelineProps = {
     renderMessageText?: ((text: string, item: AgentMessageItem | UserMessageItem, context: {
         searchTarget: TimelineSearchTarget | null;
     }) => ReactNode) | undefined;
+    /**
+     * Render assistant `opengeni-html` / `opengeni-site` fences in the default
+     * message renderer (`SessionConversation` supplies the inline Site preview).
+     */
+    renderInteractiveBlock?: MarkdownProps["renderInteractiveBlock"];
     /** Drill into a spawned worker session. */
     onOpenSession?: ((sessionId: string) => void) | undefined;
     /**
@@ -44,6 +52,15 @@ export type MessageTimelineProps = {
     onReconnect?: ((item: AuthNeededItem) => void | Promise<void>) | undefined;
     /** Host-owned inline connection setup. Return undefined to use the default recovery card. */
     renderAuthNeeded?: ((item: AuthNeededItem) => ReactNode | undefined) | undefined;
+    /**
+     * Replace the "usage limit reached" row shown when a workspace or member
+     * usage allowance stops work (an `allowance_exhausted` refusal). Receives the
+     * typed refusal (scope, reset time) and the default row; return undefined to
+     * keep the default. Use it to point people at your own plan or admin page.
+     */
+    renderAllowanceExhausted?: RenderAllowanceExhausted | undefined;
+    /** Replace the words of the default "usage limit reached" row. */
+    allowanceExhaustedLabels?: Partial<AllowanceLabels> | undefined;
     /**
      * Decide which durable authentication notices this timeline presents.
      * Defaults to showing every notice. Embedded hosts can suppress notices for
@@ -121,8 +138,8 @@ export type MessageTimelineProps = {
      * scrolls the in-memory window.
      */
     onJumpToLatest?: (() => void | Promise<void>) | undefined;
-    /** Resolve the newest durable user message and load its bounded window.
-     * Wire useSessionEvents().jumpToLatestQuestion for unloaded history. */
+    /** @deprecated Retained for source compatibility; contextual prompt navigation
+     * uses only mounted prompts and never invokes this global resolver. */
     onJumpToLatestQuestion?: (() => Promise<number | null>) | undefined;
     /** Host-owned content appended after timeline groups, such as startup progress. */
     trailingState?: ReactNode | undefined;
@@ -135,7 +152,7 @@ export type MessageTimelineProps = {
  * cards, goal markers, and status transitions. Owns stick-to-bottom scrolling
  * with a "jump to latest" affordance when the reader scrolls back.
  */
-export declare function MessageTimeline({ resolveLink, userMessageDisclosureLabels, searchTarget, events, items, status: _status, renderMessageActions, renderMessageText, onOpenSession, onMemoryClick, onReconnect, renderAuthNeeded, shouldRenderAuthNeeded, resolveProviderLogo, toolRegistry, loadRetainedScreenshot, loadRetainedArtifact, loadVideoArtifactPlayback, computeLabel, genieLoading, turnSummary, autoFollow, onAnnotate, draftAnnotations, onDraftAnnotationSelect, hasOlder, loadingOlder, onLoadOlder, onJumpToStart, loadingOldest, hasNewer, loadingNewer, onLoadNewer, onJumpToLatest, onJumpToLatestQuestion, trailingState, emptyState, className, }: MessageTimelineProps): import("react").JSX.Element;
+export declare function MessageTimeline({ resolveLink, renderInteractiveBlock, userMessageDisclosureLabels, searchTarget, events, items, status: _status, renderMessageActions, renderMessageText, onOpenSession, onMemoryClick, onReconnect, renderAuthNeeded, renderAllowanceExhausted, allowanceExhaustedLabels, shouldRenderAuthNeeded, resolveProviderLogo, toolRegistry, loadRetainedScreenshot, loadRetainedArtifact, loadVideoArtifactPlayback, computeLabel, genieLoading, turnSummary, autoFollow, onAnnotate, draftAnnotations, onDraftAnnotationSelect, hasOlder, loadingOlder, onLoadOlder, onJumpToStart, loadingOldest, hasNewer, loadingNewer, onLoadNewer, onJumpToLatest, trailingState, emptyState, className, }: MessageTimelineProps): import("react").JSX.Element;
 /**
  * Settled turns lift the final agent answer out as a sibling group. Include it
  * in "Copy turn" when present so the chip copies the full assistant reply.

package/dist/components/open-geni-links.d.ts

@@ -50,3 +50,19 @@ export declare function sessionLinkResolver(input: {
     sessionId: string;
     sandboxFiles?: boolean;
 }): OpenGeniLinkResolver;
+/** An editable artifact or Site to open in a host-mounted viewer. */
+export type OpenGeniViewerTarget = Readonly<{
+    kind: "editable-artifact" | "site";
+    artifactId: string;
+    /** The link text the agent wrote, until the viewer loads the real title. */
+    title?: string | undefined;
+}>;
+/**
+ * "Open in host viewer": resolve agent links to editable artifacts and Sites
+ * in this workspace to `open(target)`, for example to mount
+ * `SessionArtifactViewer` beside the conversation. Other targets fall through.
+ */
+export declare function viewerLinkResolver(input: {
+    workspaceId: string;
+    open: (target: OpenGeniViewerTarget) => void;
+}): OpenGeniLinkResolver;

package/dist/components/session-conversation.d.ts

@@ -3,7 +3,7 @@ import { type ClientOverride } from "../session-context.js";
 import { type ChatComposerProps } from "./chat-composer.js";
 import { type HumanInputSurfaceProps } from "./human-input-surface.js";
 import { type MessageTimelineProps } from "./message-timeline.js";
-import { type OpenGeniLinkResolver } from "./open-geni-links.js";
+import { type OpenGeniLinkResolver, type OpenGeniViewerTarget } from "./open-geni-links.js";
 import type { UserMessageDisclosureLabels } from "./user-message-body.js";
 export type SessionConversationProps = ClientOverride & {
     sessionId: string;
@@ -16,8 +16,27 @@ export type SessionConversationProps = ClientOverride & {
      * editable artifacts and Sites stay unavailable until the host resolves them.
      */
     resolveLink?: OpenGeniLinkResolver | undefined;
+    /**
+     * Open agent links to editable artifacts and Sites in a host viewer, for
+     * example `SessionArtifactViewer` mounted beside the conversation. Asked
+     * after `resolveLink`.
+     */
+    onOpenArtifact?: ((target: OpenGeniViewerTarget) => void) | undefined;
+    /**
+     * Inline previews for assistant `opengeni-site` / `opengeni-html` fences.
+     * Defaults to the OpenGeni preview (Site reads need the proxy's
+     * `artifacts` option); `false` shows the fence as code.
+     */
+    renderInteractiveBlock?: MessageTimelineProps["renderInteractiveBlock"] | false;
     /** Product-specific tool-call renderers; defaults to the built-in registry. */
     toolRegistry?: MessageTimelineProps["toolRegistry"];
+    /**
+     * Replace the "usage limit reached" row for an `allowance_exhausted`
+     * refusal, for example to link your own plan or admin page.
+     */
+    renderAllowanceExhausted?: MessageTimelineProps["renderAllowanceExhausted"];
+    /** Replace the words of the default "usage limit reached" row. */
+    allowanceExhaustedLabels?: MessageTimelineProps["allowanceExhaustedLabels"];
     /**
      * File attachments in the composer. Defaults to true; the attach control
      * appears only when the deployment's client config enables file uploads.

package/dist/components/timeline-pill-geometry.d.ts

@@ -0,0 +1,8 @@
+import type { TimelinePillPlacement, TimelinePillPosition } from "./timeline-pill-placement.js";
+/** The full contextual label may not fit beside a compact toolbar on phones. */
+export declare function chooseQuestionPosition(pill: HTMLElement, frame: HTMLElement, scroller: HTMLElement, preference: readonly TimelinePillPlacement[], current: TimelinePillPosition): TimelinePillPosition;
+/**
+ * Hit-testing for useTimelinePillPlacement, loaded only once a pill shows so it
+ * stays out of a session's first load.
+ */
+export declare function choosePlacement(pill: HTMLElement, frame: HTMLElement, scroller: HTMLElement, preference: readonly TimelinePillPlacement[], current: TimelinePillPlacement): TimelinePillPlacement;

package/dist/components/timeline-pill-placement.d.ts

@@ -0,0 +1,24 @@
+import { type RefObject } from "react";
+/** Where a floating timeline pill sits along its edge of the conversation. */
+export type TimelinePillPlacement = "start" | "center" | "end";
+export type TimelinePillPosition = {
+    placement: TimelinePillPlacement;
+    offsetY: number;
+};
+/**
+ * Floating pills (Jump to latest, Back to your message) sit over the scrolling
+ * conversation. Prefer sliding one sideways when its spot would cover
+ * a control: a link, a button, or the label and chevron of a full-width row
+ * such as the active turn's "Working" header. Plain prose may sit under a pill;
+ * controls may not. The top contextual pill can also move below a toolbar when
+ * no horizontal slot fits. Only the pill moves — the scroller's size, padding, and
+ * scroll position never change — so timeline anchoring stays untouched.
+ */
+export declare function useTimelinePillPlacement({ pillRef, scrollerRef, active, preference, allowDownwardFallback, }: {
+    pillRef: RefObject<HTMLElement | null>;
+    scrollerRef: RefObject<HTMLElement | null>;
+    active: boolean;
+    /** Placements in order of preference; the first is the resting position. */
+    preference: readonly TimelinePillPlacement[];
+    allowDownwardFallback?: boolean;
+}): TimelinePillPosition;

package/dist/components/usage-limit-notice.d.ts

@@ -0,0 +1,49 @@
+import type { UsageAllowancePeriod, WorkspaceUsageResponse } from "@opengeni/sdk/usage-allowances";
+import { type ReactNode } from "react";
+import { type UsageClientLike } from "../hooks/use-usage.js";
+import { type AllowanceLabels } from "../usage/allowance-copy.js";
+import { type UsageSummary } from "../usage/summary.js";
+export type UsageLimitNoticeLabels = AllowanceLabels & {
+    /** "You've used 85% of your usage limit." */
+    memberWarning: (percent: string) => string;
+    /** "This workspace has used 85% of its usage budget." */
+    workspaceWarning: (percent: string) => string;
+    memberExhausted: string;
+    workspaceExhausted: string;
+    dismiss: string;
+};
+export declare const DEFAULT_USAGE_LIMIT_NOTICE_LABELS: UsageLimitNoticeLabels;
+type NoticeBaseProps = {
+    labels?: Partial<UsageLimitNoticeLabels> | undefined;
+    /**
+     * Your own next step beside the message, for example an "Upgrade" or
+     * "Request more" button. Receives the summary so it can differ by scope.
+     */
+    action?: ((summary: UsageSummary) => ReactNode) | undefined;
+    /**
+     * Remember a dismissed warning for this browser tab. The key should name the
+     * workspace; the period and scope are added for you, so a new warning (or a
+     * new period) shows again. Reaching the limit is never dismissible.
+     */
+    dismissStorageKey?: string | undefined;
+    className?: string | undefined;
+};
+export type UsageLimitNoticeProps = NoticeBaseProps & {
+    /** A usage response you already loaded; omit it to read `/usage/me`. */
+    usage?: WorkspaceUsageResponse | null | undefined;
+    client?: UsageClientLike | undefined;
+    workspaceId?: string | undefined;
+    period?: UsageAllowancePeriod | undefined;
+    refreshKey?: unknown;
+};
+/**
+ * A calm line for the composer when a member is close to, or at, a usage
+ * limit: what happened, who can raise it, and when it resets. Renders nothing
+ * while usage is comfortable, unlimited, loading, or unreadable.
+ */
+export declare function UsageLimitNotice({ usage, client, workspaceId, period, refreshKey, ...view }: UsageLimitNoticeProps): import("react").JSX.Element;
+/** Presentational notice for a summary you computed (`summarizeUsage`). */
+export declare function UsageLimitNoticeView({ summary, labels: overrides, action, dismissStorageKey, className, }: NoticeBaseProps & {
+    summary: UsageSummary | null;
+}): import("react").JSX.Element | null;
+export {};