@opengeni/react 0.48.0 → 0.57.0

package/dist/components/artifacts/presentation-editor.d.ts

@@ -0,0 +1,297 @@
+import { type ReactNode } from "react";
+import type { Presentation, PresentationElement, PresentationPosition, Slide } from "@opengeni/artifact-tool/reference";
+type PresentationObject = PresentationElement;
+export type PresentationCommit = {
+    kind: "slide-insert";
+    slideId: string;
+    index: number;
+    revision?: string | number;
+} | {
+    kind: "slide-delete";
+    slideId: string;
+    index: number;
+    revision?: string | number;
+} | {
+    kind: "object-insert";
+    slideId: string;
+    objectId: string;
+    index: number;
+    position: PresentationPosition;
+    revision?: string | number;
+} | {
+    kind: "object-delete";
+    slideId: string;
+    objectId: string;
+    revision?: string | number;
+} | {
+    kind: "move" | "resize";
+    slideId: string;
+    objectId: string;
+    before: PresentationPosition;
+    after: PresentationPosition;
+    revision?: string | number;
+} | {
+    kind: "text";
+    slideId: string;
+    objectId: string;
+    before: string;
+    after: string;
+    revision?: string | number;
+};
+export type PresentationCommitHandler = ((commit: PresentationCommit) => void) | ((commit: PresentationCommit) => Promise<void>);
+export type PresentationProjectionPosition = Readonly<{
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}>;
+export type PresentationProjectionFill = string | Readonly<{
+    type?: "solid";
+    color: string;
+}>;
+export type PresentationProjectionLine = Readonly<{
+    style?: "solid" | "dash" | "dot" | "none";
+    fill?: PresentationProjectionFill;
+    width?: number;
+}>;
+export type PresentationProjectionTextStyle = Readonly<{
+    fontFamily?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    color?: string;
+    alignment?: "left" | "center" | "right" | "justify";
+    verticalAlignment?: "top" | "middle" | "bottom";
+}>;
+export type PresentationProjectionTextRun = Readonly<{
+    text: string;
+    style: PresentationProjectionTextStyle;
+    language?: string | null;
+}>;
+export type PresentationProjectionTextParagraph = Readonly<{
+    runs: readonly PresentationProjectionTextRun[];
+    alignment: "left" | "center" | "right" | "justify";
+}>;
+export type PresentationProjectionRichText = Readonly<{
+    paragraphs: readonly PresentationProjectionTextParagraph[];
+    verticalAlignment: "top" | "middle" | "bottom";
+}>;
+export type PresentationProjectionElementMetadata = Readonly<{
+    nodeSource?: Readonly<{
+        kind: "master" | "layout" | "slide";
+        id: string;
+    }>;
+    inherited?: boolean;
+    parentId?: string | null;
+    order?: number;
+    /** Inherited master/layout nodes remain visible but cannot be edited in slide mode. */
+    readOnly?: boolean;
+}>;
+export type PresentationProjectionShape = Readonly<{
+    kind: "shape";
+    id: string;
+    name: string;
+    geometry: "textbox" | "rect" | "roundRect" | "ellipse" | "triangle" | "rightArrow" | "line";
+    position: PresentationProjectionPosition;
+    fill?: PresentationProjectionFill;
+    line?: PresentationProjectionLine;
+    rotation?: number;
+    borderRadius?: number | string;
+    text: string;
+    textStyle?: PresentationProjectionTextStyle;
+    richText?: PresentationProjectionRichText;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionChartSeries = Readonly<{
+    name: string;
+    categories?: readonly string[];
+    values: readonly number[];
+    xValues?: readonly number[];
+    bubbleSizes?: readonly number[];
+    fill?: PresentationProjectionFill;
+    line?: PresentationProjectionLine;
+}>;
+export type PresentationProjectionChart = Readonly<{
+    kind: "chart";
+    id: string;
+    name: string;
+    type: "bar" | "line" | "area" | "pie" | "doughnut" | "scatter" | "bubble" | "radar";
+    position: PresentationProjectionPosition;
+    title?: string;
+    titleRichText?: PresentationProjectionRichText;
+    hasLegend?: boolean;
+    series: readonly PresentationProjectionChartSeries[];
+    xAxis?: Readonly<{
+        visible?: boolean;
+        title?: string;
+        min?: number;
+        max?: number;
+    }>;
+    yAxis?: Readonly<{
+        visible?: boolean;
+        title?: string;
+        min?: number;
+        max?: number;
+    }>;
+    dataLabels?: Readonly<{
+        showValue?: boolean;
+        showSeriesName?: boolean;
+        showCategoryName?: boolean;
+        showPercent?: boolean;
+        position?: "center" | "inEnd" | "outEnd";
+    }>;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionImage = Readonly<{
+    kind: "image";
+    id: string;
+    name: string;
+    position: PresentationProjectionPosition;
+    /** Host-resolved data/blob/same-origin URL. Arbitrary remote URLs are ignored. */
+    source?: string;
+    alt?: string;
+    prompt?: string;
+    fit?: "contain" | "cover";
+    crop?: Readonly<{
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }>;
+    geometry?: "rect" | "roundRect" | "ellipse";
+    borderRadius?: number | string;
+    rotation?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    digest?: string;
+    contentType?: string;
+    intrinsicWidth?: number;
+    intrinsicHeight?: number;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionTableCell = Readonly<{
+    text: string;
+    richText?: PresentationProjectionRichText;
+    fill?: PresentationProjectionFill;
+    textStyle?: PresentationProjectionTextStyle;
+    rowSpan?: number;
+    colSpan?: number;
+}>;
+export type PresentationProjectionTable = Readonly<{
+    kind: "table";
+    id: string;
+    name: string;
+    position: PresentationProjectionPosition;
+    rows: readonly (readonly (PresentationProjectionTableCell | null)[])[];
+    columnWidths?: readonly number[];
+    rowHeights?: readonly number[];
+    fill?: PresentationProjectionFill;
+    line?: PresentationProjectionLine;
+    textStyle?: PresentationProjectionTextStyle;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionGroup = Readonly<{
+    kind: "group";
+    id: string;
+    name: string;
+    position: PresentationProjectionPosition;
+    childOffset: Readonly<{
+        left: number;
+        top: number;
+    }>;
+    childExtent: Readonly<{
+        width: number;
+        height: number;
+    }>;
+    rotation?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    children: readonly PresentationProjectionElement[];
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionConnector = Readonly<{
+    kind: "connector";
+    id: string;
+    name: string;
+    connectorKind: "straight" | "elbow" | "curved";
+    position: PresentationProjectionPosition;
+    start: Readonly<{
+        nodeId: string | null;
+        x: number;
+        y: number;
+    }>;
+    end: Readonly<{
+        nodeId: string | null;
+        x: number;
+        y: number;
+    }>;
+    line?: PresentationProjectionLine;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionElement = PresentationProjectionShape | PresentationProjectionChart | PresentationProjectionImage | PresentationProjectionTable | PresentationProjectionGroup | PresentationProjectionConnector;
+export type PresentationSlideProjection = Readonly<{
+    id: string;
+    title?: string;
+    background?: PresentationProjectionFill;
+    elements: readonly PresentationProjectionElement[];
+    layout?: Readonly<{
+        id: string;
+        name: string;
+        masterId: string | null;
+        background: PresentationProjectionFill;
+    }> | null;
+    notes?: PresentationProjectionRichText | null;
+}>;
+/** Immutable render/edit projection; the host keeps the canonical deck off the React thread. */
+export type PresentationEditorProjection = Readonly<{
+    revision: string | number;
+    slideSize: Readonly<{
+        width: number;
+        height: number;
+    }>;
+    slides: readonly PresentationSlideProjection[];
+}>;
+export type PresentationProjectionEditorProps = Omit<PresentationEditorProps, "presentation" | "revision" | "onSlideChange" | "onSelectionChange" | "onCommit"> & {
+    projection: PresentationEditorProjection;
+    commit?: PresentationCommitHandler | undefined;
+    onCommandError?: ((error: Error) => void) | undefined;
+    onSlideChange?: ((slide: PresentationSlideProjection, index: number) => void) | undefined;
+    onSelectionChange?: ((object: PresentationProjectionElement | null, slide: PresentationSlideProjection) => void) | undefined;
+};
+export type PresentationProjectionArtifactSurfaceProps = PresentationProjectionEditorProps & {
+    title?: string | undefined;
+    subtitle?: ReactNode | undefined;
+    actions?: ReactNode | undefined;
+    busy?: boolean | undefined;
+};
+export type PresentationEditorProps = {
+    presentation: Presentation;
+    /** Increment/change after a host applies an out-of-band model mutation. */
+    revision?: string | number | undefined;
+    activeSlideId?: string | undefined;
+    defaultActiveSlideId?: string | undefined;
+    selectedObjectId?: string | null | undefined;
+    defaultSelectedObjectId?: string | null | undefined;
+    zoom?: number | undefined;
+    defaultZoom?: number | undefined;
+    readOnly?: boolean | undefined;
+    className?: string | undefined;
+    onSlideChange?: ((slide: Slide, index: number) => void) | undefined;
+    onSelectionChange?: ((object: PresentationObject | null, slide: Slide) => void) | undefined;
+    onCommit?: PresentationCommitHandler | undefined;
+    onCommandError?: ((error: Error) => void) | undefined;
+    onZoomChange?: ((zoom: number) => void) | undefined;
+};
+export type PresentationArtifactSurfaceProps = PresentationEditorProps & {
+    title?: string | undefined;
+    subtitle?: ReactNode | undefined;
+    actions?: ReactNode | undefined;
+    busy?: boolean | undefined;
+};
+/** Compatibility adapter for the public authoring model. */
+export declare function PresentationEditor(props: PresentationEditorProps): import("react").JSX.Element;
+/**
+ * Projection-first editor. It creates only a disposable render view; all
+ * durable mutations leave through the async command port.
+ */
+export declare function PresentationProjectionEditor({ projection, commit, onCommandError, onSlideChange, onSelectionChange, readOnly, ...props }: PresentationProjectionEditorProps): import("react").JSX.Element;
+/** Artifact chrome plus the editor, for drop-in SDK embedding. */
+export declare function PresentationArtifactSurface({ presentation, title, subtitle, actions, busy, className, ...editorProps }: PresentationArtifactSurfaceProps): import("react").JSX.Element;
+/** Artifact chrome over the projection-first editor. */
+export declare function PresentationProjectionArtifactSurface({ projection, title, subtitle, actions, busy, className, ...editorProps }: PresentationProjectionArtifactSurfaceProps): import("react").JSX.Element;
+export {};

package/dist/components/artifacts/published-html-artifact-frame.d.ts

@@ -0,0 +1,14 @@
+import type { CSSProperties } from "react";
+export declare const PUBLISHED_HTML_ARTIFACT_IFRAME_SANDBOX: string;
+export type PublishedHtmlArtifactFrameProps = {
+    html: string;
+    title: string;
+    className?: string;
+    style?: CSSProperties;
+};
+/**
+ * Render exact published HTML in an opaque-origin iframe. Artifact scripts,
+ * external resources, forms, popups, and downloads work without granting
+ * parent-origin authority, shared cookies/storage, or top-level navigation.
+ */
+export declare function PublishedHtmlArtifactFrame(props: PublishedHtmlArtifactFrameProps): import("react").JSX.Element;

package/dist/components/artifacts/spreadsheet-canvas.d.ts

@@ -0,0 +1,120 @@
+export type SpreadsheetCanvasCellFormat = {
+    fill?: string | undefined;
+    font?: {
+        name?: string | undefined;
+        size?: number | undefined;
+        bold?: boolean | undefined;
+        italic?: boolean | undefined;
+        underline?: boolean | undefined;
+        color?: string | undefined;
+    } | undefined;
+    horizontalAlignment?: "left" | "center" | "right" | "justify" | undefined;
+    verticalAlignment?: "top" | "center" | "bottom" | undefined;
+    wrapText?: boolean | undefined;
+};
+/** One sparse, already-authorized cell projected into the renderer. */
+export type SpreadsheetCanvasCell = {
+    row: number;
+    col: number;
+    value: unknown;
+    formula?: string | null | undefined;
+    format: SpreadsheetCanvasCellFormat;
+};
+export type SpreadsheetCanvasCoverage = {
+    rowStart: number;
+    rowEnd: number;
+    columnStart: number;
+    columnEnd: number;
+};
+/**
+ * A bounded value projection. `coverage` is end-exclusive; omitting it means
+ * the source can answer for the entire sheet. A session-backed adapter can
+ * replace this object as viewport subscriptions advance without making the
+ * React layer or renderer own the canonical workbook model.
+ */
+export type SpreadsheetCanvasProjection = {
+    sheetId: string;
+    generationId: string | null;
+    revision: string | number;
+    coverage?: SpreadsheetCanvasCoverage | undefined;
+    cells: SpreadsheetCanvasCellSource;
+    valueAt: (cell: SpreadsheetCanvasCell) => unknown;
+};
+export type SpreadsheetCanvasCellSource = {
+    forEachInRange: (rowStart: number, rowEnd: number, columnStart: number, columnEnd: number, visit: (cell: SpreadsheetCanvasCell) => void) => void;
+};
+export type SpreadsheetCanvasAxis = {
+    count: number;
+    total: number;
+    offsetAt: (index: number) => number;
+    sizeAt: (index: number) => number;
+    indexAtOffset: (offset: number) => number;
+};
+export type SpreadsheetCanvasSelection = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    focusRow: number;
+    focusColumn: number;
+};
+export type SpreadsheetCanvasTheme = {
+    background: string;
+    headerBackground: string;
+    border: string;
+    foreground: string;
+    mutedForeground: string;
+    accent: string;
+    error: string;
+    fontFamily: string;
+    fontSize: number;
+    headerFontSize: number;
+    signature: string;
+};
+export type SpreadsheetCanvasPaint = {
+    canvas: HTMLCanvasElement;
+    projection: SpreadsheetCanvasProjection;
+    rows: SpreadsheetCanvasAxis;
+    columns: SpreadsheetCanvasAxis;
+    selection: SpreadsheetCanvasSelection;
+    logicalScrollLeft: number;
+    logicalScrollTop: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    rowHeaderWidth: number;
+    columnHeaderHeight: number;
+    dimensionRevision: string | number;
+    devicePixelRatio: number;
+    theme: SpreadsheetCanvasTheme;
+};
+export type SpreadsheetCanvasPaintStats = {
+    cacheSize: number;
+    paintedTiles: number;
+    reusedTiles: number;
+    uncachedTiles: number;
+    devicePixelRatio: number;
+};
+/**
+ * A row-major sparse index over stored worksheet cells. Empty cells never enter
+ * this structure, so a tile query costs O(log k + v), where v is the number of
+ * stored cells intersecting that tile.
+ */
+export declare class SparseSpreadsheetCellIndex {
+    readonly size: number;
+    private readonly rows;
+    constructor(entries: Iterable<SpreadsheetCanvasCell>);
+    forEachInRange(rowStart: number, rowEnd: number, columnStart: number, columnEnd: number, visit: (cell: SpreadsheetCanvasCell) => void): void;
+}
+export declare function spreadsheetCanvasDevicePixelRatio(value: number): number;
+/** Caps backing-store allocation while retaining the full CSS viewport. */
+export declare function spreadsheetCanvasBackingScale(width: number, height: number, devicePixelRatio: number): number;
+/** Retained 2D tile renderer. Dynamic selection and headers are painted above cached body tiles. */
+export declare class SpreadsheetCanvasRenderer {
+    private readonly tiles;
+    private generation;
+    private clock;
+    dispose(): void;
+    paint(input: SpreadsheetCanvasPaint): SpreadsheetCanvasPaintStats | null;
+    private paintTile;
+    private evictTiles;
+}

package/dist/components/artifacts/spreadsheet-grid.d.ts

@@ -0,0 +1,113 @@
+import type { Workbook, Worksheet } from "@opengeni/artifact-tool/reference";
+import { type ReactNode } from "react";
+import { type SpreadsheetCanvasCellFormat, type SpreadsheetCanvasProjection } from "./spreadsheet-canvas.js";
+type CellCoordinate = {
+    row: number;
+    col: number;
+};
+export type SpreadsheetSelection = {
+    sheetId: string;
+    anchor: CellCoordinate;
+    focus: CellCoordinate;
+};
+export type SpreadsheetCommit = {
+    sheetId: string;
+    cell: CellCoordinate;
+    input: string;
+    kind: "formula" | "value";
+};
+/** Row-major rectangular input submitted as one durable spreadsheet command. */
+export type SpreadsheetRangeCommit = {
+    sheetId: string;
+    anchor: CellCoordinate;
+    rows: number;
+    columns: number;
+    inputs: readonly string[];
+};
+/** End-exclusive logical windows emitted at most once per animation frame. */
+export type SpreadsheetViewport = {
+    sheetId: string;
+    rowStart: number;
+    rowEnd: number;
+    columnStart: number;
+    columnEnd: number;
+    overscanRowStart: number;
+    overscanRowEnd: number;
+    overscanColumnStart: number;
+    overscanColumnEnd: number;
+    logicalScrollLeft: number;
+    logicalScrollTop: number;
+    viewportWidth: number;
+    viewportHeight: number;
+};
+export type SpreadsheetGridProps = {
+    workbook: Workbook;
+    worksheet: Worksheet;
+    readOnly?: boolean | undefined;
+    /** Addressable rows in the interactive projection. Grows to include used data. */
+    rowCount?: number | undefined;
+    /** Addressable columns in the interactive projection. Grows to include used data. */
+    columnCount?: number | undefined;
+    overscanRows?: number | undefined;
+    overscanColumns?: number | undefined;
+    onSelectionChange?: ((selection: SpreadsheetSelection) => void) | undefined;
+    onCommit?: ((commit: SpreadsheetCommit) => void) | undefined;
+    onViewportChange?: ((viewport: SpreadsheetViewport) => void) | undefined;
+    className?: string | undefined;
+};
+export type SpreadsheetProjectionCell = {
+    value: unknown;
+    input: string;
+    format: SpreadsheetCanvasCellFormat;
+};
+/**
+ * Synchronous, bounded view state consumed by the React editor. Durable model
+ * ownership stays with the caller (legacy Workbook, SDK Worker, or another
+ * projection adapter); edits return through `commit` / `clear` ports.
+ */
+export type SpreadsheetGridProjection = SpreadsheetCanvasProjection & {
+    sheetName: string;
+    rowCount: number;
+    columnCount: number;
+    defaultRowHeight?: number | undefined;
+    defaultColumnWidth?: number | undefined;
+    rowHeights?: readonly (readonly [number, number])[] | undefined;
+    columnWidths?: readonly (readonly [number, number])[] | undefined;
+    dimensionRevision?: string | number | undefined;
+    usedRange?: {
+        row: number;
+        col: number;
+        rowCount: number;
+        colCount: number;
+    } | null | undefined;
+    readCell: (row: number, column: number) => SpreadsheetProjectionCell | null;
+};
+export type SpreadsheetProjectionGridProps = {
+    projection: SpreadsheetGridProjection;
+    readOnly?: boolean | undefined;
+    overscanRows?: number | undefined;
+    overscanColumns?: number | undefined;
+    onSelectionChange?: ((selection: SpreadsheetSelection) => void) | undefined;
+    commit?: ((commit: SpreadsheetCommit) => void | Promise<void>) | undefined;
+    commitRange?: ((commit: SpreadsheetRangeCommit) => void | Promise<void>) | undefined;
+    clear?: ((selection: SpreadsheetSelection) => void | Promise<void>) | undefined;
+    onCommandError?: ((error: Error) => void) | undefined;
+    onViewportChange?: ((viewport: SpreadsheetViewport) => void) | undefined;
+    className?: string | undefined;
+};
+export type SpreadsheetArtifactSurfaceProps = Omit<SpreadsheetGridProps, "worksheet"> & {
+    title?: string | undefined;
+    subtitle?: ReactNode | undefined;
+    actions?: ReactNode | undefined;
+    initialSheetId?: string | undefined;
+    allowAddSheet?: boolean | undefined;
+};
+/** A reusable workbook shell with first-class sheet switching. */
+export declare function SpreadsheetArtifactSurface({ workbook, title, subtitle, actions, initialSheetId, allowAddSheet, readOnly, ...gridProps }: SpreadsheetArtifactSurfaceProps): import("react").JSX.Element;
+export declare function SpreadsheetGrid({ workbook, worksheet, readOnly, rowCount: requestedRowCount, columnCount: requestedColumnCount, overscanRows, overscanColumns, onSelectionChange, onCommit, onViewportChange, className, }: SpreadsheetGridProps): import("react").JSX.Element;
+/**
+ * Two-axis virtualized, accessible spreadsheet projection. The caller owns
+ * durable model state; React owns only viewport, selection, and edit state.
+ */
+export declare function SpreadsheetProjectionGrid({ projection, readOnly, overscanRows, overscanColumns, onSelectionChange, commit, commitRange, clear, onCommandError, onViewportChange, className, }: SpreadsheetProjectionGridProps): import("react").JSX.Element;
+export {};

package/dist/components/browser-input.d.ts

@@ -0,0 +1,7 @@
+import type { KeyboardEvent } from "react";
+import { type InteractionHostPlatform } from "../lib/host-platform.js";
+export declare const HUMAN_BROWSER_HOME_URL = "https://www.google.com/";
+/** Apply browser-style omnibox behavior: navigate hosts, search ordinary text. */
+export declare function normalizeBrowserAddress(value: string): string | null;
+/** Translate executable keyboard chords for the BrowserSession action API. */
+export declare function browserKey(event: Pick<KeyboardEvent<HTMLTextAreaElement>, "altKey" | "ctrlKey" | "key" | "metaKey" | "shiftKey">, hostPlatform?: InteractionHostPlatform): string | null;

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

@@ -0,0 +1,30 @@
+import type { ComputerSession, InteractionPlacement } from "@opengeni/sdk/interaction";
+import { type ReactNode } from "react";
+import { type BrowserFrameWebSocketFactory } from "../hooks/use-browser-frame-stream.js";
+import type { EmbeddedBrowserInteractionClientOverride } from "../session-context.js";
+export type BrowserViewerNotification = {
+    kind: "error" | "info";
+    message: string;
+};
+export type BrowserViewerProps = EmbeddedBrowserInteractionClientOverride & {
+    /** The selected OpenGeni agent/session. Peer BrowserSessions stay discoverable. */
+    sessionId: string;
+    enabled?: boolean | undefined;
+    className?: string | undefined;
+    onNotify?: ((notification: BrowserViewerNotification) => void) | undefined;
+    /** Tests/demos only. Production uses the browser's native WebSocket. */
+    webSocketFactory?: BrowserFrameWebSocketFactory | undefined;
+    renderEmpty?: ((create: () => void, creating: boolean) => ReactNode) | undefined;
+    /** Optional host capability for placing a human-created headed browser inside
+     * an exact ComputerSession. Browser-only embedders still create a headed
+     * browser; they simply omit the linked desktop resource. */
+    createLinkedComputer?: ((name: string, placement?: InteractionPlacement) => Promise<Pick<ComputerSession, "id" | "placement">>) | undefined;
+    /** Navigate to the exact linked ComputerSession; never a lookalike desktop. */
+    onOpenComputer?: ((computerSessionId: string) => void) | undefined;
+};
+/**
+ * Complete browser-native session surface: workspace discovery, agent relevance,
+ * browser/tab switching, live frames, semantic fallback, direct human input,
+ * address navigation, diagnostics, and reconnect. Closing it never closes the browser.
+ */
+export declare function BrowserViewer({ sessionId, enabled, className, onNotify, webSocketFactory, renderEmpty, createLinkedComputer, onOpenComputer, ...override }: BrowserViewerProps): import("react").JSX.Element | null;

package/dist/components/chat-composer.d.ts

@@ -1,12 +1,12 @@
 import type { ClientModel, EffectiveSessionControl } from "@opengeni/sdk";
 import type { ClipboardEvent, ReactNode } from "react";
-import type { SlashCommand } from "../commands/types";
-import type { ComposerState } from "../hooks/use-composer";
-import type { UseFileAttachmentsResult } from "../hooks/use-file-attachments";
-import type { SlashCommandContext } from "../hooks/use-slash-commands";
-import { OPEN_WORKSTREAM_CONTROL_EVENT } from "../workstream-control-event";
-import { type ChatComposerMessages, type ComposerControlLinks, type ResponsiveBasis } from "./composer";
-import { type ComposerTranscriptionControlProps } from "./composer-transcription-control";
+import type { SlashCommand } from "../commands/types.js";
+import type { ComposerState } from "../hooks/use-composer.js";
+import type { UseFileAttachmentsResult } from "../hooks/use-file-attachments.js";
+import type { SlashCommandContext } from "../hooks/use-slash-commands.js";
+import { OPEN_WORKSTREAM_CONTROL_EVENT } from "../workstream-control-event.js";
+import { type ChatComposerMessages, type ComposerControlLinks, type ResponsiveBasis } from "./composer.js";
+import { type ComposerTranscriptionControlProps } from "./composer-transcription-control.js";
 export { OPEN_WORKSTREAM_CONTROL_EVENT };
 export type ChatComposerProps = {
     composer: ComposerState;
@@ -64,4 +64,4 @@ export type ChatComposerProps = {
  * the public controller and compound primitives exported by the composer
  * subpath, so custom and default layouts share one behavioral implementation.
  */
-export declare function ChatComposer({ composer, responsiveBasis, effectiveControl, queuedAheadCount, canControlWorkspace, controlLinks, placeholder, disabled, autoFocus, hint, controlsLeading, controlsStart, actionsStart, attachButtonClassName, transcription, transcriptionClassName, transcriptionSuppressed, header, onPaste, attachments, models, selectedModel, onSelectModel, className, commands, commandContext, onClearView, messages, }: ChatComposerProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChatComposer({ composer, responsiveBasis, effectiveControl, queuedAheadCount, canControlWorkspace, controlLinks, placeholder, disabled, autoFocus, hint, controlsLeading, controlsStart, actionsStart, attachButtonClassName, transcription, transcriptionClassName, transcriptionSuppressed, header, onPaste, attachments, models, selectedModel, onSelectModel, className, commands, commandContext, onClearView, messages, }: ChatComposerProps): import("react").JSX.Element;

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

@@ -8,8 +8,13 @@ export type CodeEditorProps = {
     path: string;
     /** The decoded text contents to seed the editor with. */
     initialContents: string;
-    /** Persist the current buffer. Resolves when the write lands; rejects to surface an error. */
-    onSave: (contents: string) => Promise<unknown>;
+    /**
+     * Persist the current buffer against the exact contents it was edited from.
+     * The second argument is the immutable compare-and-swap baseline; hosts must
+     * not replace it with a newer remote snapshot or concurrent writes can be
+     * silently overwritten.
+     */
+    onSave: (contents: string, expectedContents: string) => Promise<unknown>;
     /** Explicitly overwrite after a visible expected-content conflict. */
     onOverwrite?: ((contents: string) => Promise<unknown>) | undefined;
     /** Re-read the selected file after a visible save conflict. */
@@ -27,6 +32,23 @@ export type CodeEditorProps = {
     fallback?: ReactNode | undefined;
     className?: string | undefined;
 };
+export type EditorBufferState = {
+    path: string;
+    value: string;
+    baseline: string;
+};
+/**
+ * Reconcile a remote file snapshot without destroying unsaved local work.
+ *
+ * A different path is a new document and always resets. For the same path, a
+ * clean editor follows the remote snapshot while a dirty editor retains both
+ * its local value and the original CAS baseline. The eventual save will then
+ * either succeed against that baseline or surface a typed conflict.
+ */
+export declare function reconcileEditorBuffer(current: EditorBufferState, incoming: {
+    path: string;
+    contents: string;
+}): EditorBufferState;
 /**
  * The EDITABLE single-file pane: CodeMirror 6 with a per-language grammar chosen
  * from the filename, og-* themed, with dirty tracking and a save path wired to
@@ -39,5 +61,5 @@ export type CodeEditorProps = {
  * `readOnly` suppresses every mutation path so a truncated/binary file can never
  * 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-runtime").JSX.Element;
+export declare function CodeEditor({ path, initialContents, onSave, onOverwrite, onReload, onEditIntent, readOnly, themeType, loading, fallback, className, }: CodeEditorProps): import("react").JSX.Element;
 export {};

package/dist/components/command-palette.d.ts

@@ -1,4 +1,4 @@
-import type { SlashCommand } from "../commands/types";
+import type { SlashCommand } from "../commands/types.js";
 export type CommandPaletteProps = {
     open: boolean;
     items: SlashCommand[];
@@ -22,4 +22,4 @@ export type CommandPaletteProps = {
  * the opengeni#46 design tokens. Full keyboard nav lives in useSlashCommands;
  * this component is presentational + aria.
  */
-export declare function CommandPalette({ open, items, highlight, onHighlight, onRun, argHintText, listboxId, label, dangerLabel, }: CommandPaletteProps): import("react/jsx-runtime").JSX.Element;
+export declare function CommandPalette({ open, items, highlight, onHighlight, onRun, argHintText, listboxId, label, dangerLabel, }: CommandPaletteProps): import("react").JSX.Element;