@fx-/chat-ink 0.0.0-stage → 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,806 @@
+import { BlockLayoutContext, CellBox, FooterHints, FrameInput, ImageLayoutOptions, ImageProvider, ImageState, InkAppearance, InkGlyphs, InkTheme, InkThemeRole, LayoutContext, Line, LineDraft, LineTarget, MarkdownLayout, Measure, MessageFrame, NOTHING_OPEN, OpenState, ROW_PATH, Span, THUMBNAIL, WrappedRow, asciiGlyphs, cachedMeasure, defaultMeasure, emojiGlyphs, footerSpans, graphemes, hardSplit, layoutBody, layoutImage, layoutMessage, lineText, plainGlyphs, plainMarkdownLayout, plainTheme, prefix, resolveAccent, showsSomething, span, suffix, truncate, wrapLines, wrapText } from "./images.d-KUBzdbd9.js";
+import { ClockProviderProps, CoreHooks, ElapsedTimerInput, LiveTokensInput, SharedClock } from "@fx-/chat-core/hooks";
+import { Attachment, CompletionItem, CompletionProvider, CustomBlock, DetailLevel, LivePhase, RenderableMessage, SummaryIconName } from "@fx-/chat-core";
+import * as _0 from "react";
+import * as _3 from "react";
+import { ComponentType, FunctionComponentElement, JSX, ProviderProps, ReactNode, Ref } from "react";
+import * as _1 from "ink";
+import * as _4 from "ink";
+import { DOMElement, Key } from "ink";
+
+//#region src/Composer.d.ts
+/** The composer's content: text, caret offset and attachments. */
+interface ComposerValue {
+    text: string;
+    caret: number;
+    attachments: Attachment[];
+}
+declare const emptyComposerValue: ComposerValue;
+/** Drive a composer that takes its keys from the host (`inputSource: 'host'`). */
+interface ComposerHandle {
+    key: (input: string, key: Key) => void;
+    paste: (text: string) => void;
+}
+interface ComposerProps {
+    /** Called with the text, and the attachments when there are any. */
+    onSubmit: (text: string, attachments?: Attachment[]) => void;
+    /** Esc with no completion open. */
+    onEscape?: () => void;
+    providers?: CompletionProvider<CompletionItem<never> | CompletionItem>[];
+    /** Previous inputs, oldest first. */
+    history?: Array<string | {
+        text: string;
+        attachments?: Attachment[];
+    }>;
+    placeholder?: string;
+    /** Ignore input entirely (e.g. while a dialog owns the keyboard). */
+    disabled?: boolean;
+    /** Hint line under the input. */
+    hint?: string;
+    /** Maximum completion items shown. */
+    maxItems?: number;
+    /** Controlled content; pair with `onChange`. */
+    value?: ComposerValue;
+    onChange?: (value: ComposerValue) => void;
+    /** `boxed` (default) or `plain`: no border, the prompt on the first row only. */
+    variant?: 'boxed' | 'plain';
+    /** Width in cells: rows soft-wrap to fit (one cell is kept for the caret). */
+    width?: number;
+    /** Rows shown at most; the input scrolls to keep the caret's row visible. */
+    maxRows?: number;
+    /** Whether the composer has focus: takes keys and draws the caret (default true). */
+    focused?: boolean;
+    /** Shown after the attachment descriptions, e.g. `Esc removes`. */
+    attachmentHint?: string;
+    /** What Ctrl+U clears: to the line start (default) or the whole input. */
+    killLine?: 'line' | 'input';
+    /** Called first for every key; return true when handled. */
+    onKey?: (input: string, key: Key) => boolean;
+    /** Called first for every bracketed paste; return true when handled. */
+    onPaste?: (text: string) => boolean;
+    /** `own` (default) listens for keys; `host` takes them through `ref`. */
+    inputSource?: 'own' | 'host';
+    ref?: Ref<ComposerHandle>;
+    /** Push the kitty keyboard disambiguate flag while focused. */
+    kittyKeyboard?: boolean;
+    /** Cell measure for soft wrap (default string width). */
+    measure?: Measure;
+}
+/**
+* Cells left for text at `width`: the prompt, the border and padding of the
+* boxed variant, and one cell kept for the caret come off.
+*/
+declare function composerInnerWidth(width: number, variant?: 'boxed' | 'plain', promptWidth?: number): number;
+/**
+* Rows the composer takes at `width` for `value`: its input rows (up to
+* `maxRows`), the attachments row, and the boxed variant's border — not the
+* hint or completion lines under it. Lets a host size the rest of the screen.
+*/
+declare function composerRows(value: Pick<ComposerValue, 'text' | 'attachments'>, width: number, options?: {
+    variant?: 'boxed' | 'plain';
+    maxRows?: number | undefined;
+    promptWidth?: number;
+    measure?: Measure;
+}): number;
+declare function Composer({ onSubmit, onEscape, providers, history: initialHistory, placeholder, disabled, hint, maxItems, value: controlled, onChange, variant, width, maxRows, focused, attachmentHint, killLine, onKey, onPaste, inputSource, ref, kittyKeyboard, measure, }: ComposerProps): JSX.Element;
+
+//#endregion
+//#region src/MessageView.d.ts
+/** Props passed to a host renderer for a custom block kind. */
+interface InkBlockRendererProps {
+    block: CustomBlock;
+    message: RenderableMessage;
+    isStreaming: boolean;
+}
+interface InkExtensions {
+    /** Renderers keyed by custom block `type`. */
+    blockRenderers?: Record<string, ComponentType<InkBlockRendererProps>>;
+}
+interface MessageViewProps {
+    message: RenderableMessage;
+    /** Whether this is the live, streaming message. */
+    isActive?: boolean;
+    /** Show group and row bodies (reasoning text, tool input/output). */
+    expanded?: boolean;
+    /** Fold each assistant turn's auxiliary blocks into one group. */
+    minimal?: boolean;
+    showFooter?: boolean;
+    /** Maximum lines of any tool input/output or reasoning body. */
+    bodyLines?: number;
+    /** Host label for retrying, shown in the footer of a stopped or failed message (e.g. "/retry"). */
+    retryHint?: string;
+    /** Activity after content instead of in stream order. */
+    activityPlacement?: 'inline' | 'after-content';
+    /** While live and collapsed, show only the newest N activity blocks after an `N earlier` row. */
+    liveTail?: number;
+    /** Show the footer (whole-second elapsed and activity facts) while live (opt-in). */
+    liveFooter?: boolean;
+    extensions?: InkExtensions;
+}
+declare function MessageView({ message: original, isActive, expanded, minimal, showFooter, bodyLines, extensions, retryHint, activityPlacement, liveTail, liveFooter, }: MessageViewProps): JSX.Element;
+
+//#endregion
+//#region src/Row.d.ts
+interface RowProps {
+    label: ReactNode;
+    /** Secondary text after the label (e.g. a tool's input), muted. */
+    detail?: string | undefined;
+    /** A qualifier after everything else (e.g. `denied`), in the danger tone. */
+    qualifier?: string | undefined;
+    iconName?: SummaryIconName | undefined;
+    /** Rendered before the icon (e.g. the `(+N)` count). */
+    prefix?: ReactNode;
+    isActive?: boolean | undefined;
+    startedAt?: number | undefined;
+    durationMs?: number | undefined;
+    showTimer?: boolean | undefined;
+    tokensPerSecond?: number | undefined;
+    error?: boolean | undefined;
+    expanded?: boolean | undefined;
+    children?: ReactNode;
+}
+declare function Row({ label, detail, qualifier, iconName, prefix, isActive, startedAt, durationMs, showTimer, tokensPerSecond, error, expanded, children, }: RowProps): JSX.Element;
+/** Clip long text to `maxLines`, noting how many lines were hidden. */
+declare function clipLines(text: string, maxLines: number): string;
+/** Pretty JSON, tolerating values JSON cannot encode. */
+declare function toJson(value: unknown): string;
+
+//#endregion
+//#region src/Spinner.d.ts
+/** @jsxRuntime classic */
+/** @jsx React.createElement */
+/** @jsxFrag React.Fragment */
+/**
+* An animated spinner in the `marker` role, using the injected frames. It
+* steps once per tick of the shared clock when a ClockProvider is in scope,
+* else every `spinnerIntervalMs`.
+*/
+declare function Spinner(): JSX.Element;
+
+//#endregion
+//#region src/Transcript.d.ts
+interface TranscriptProps {
+    messages: RenderableMessage[];
+    isStreaming?: boolean;
+    /** The id of the live message, if any. */
+    streamingMessageId?: string | undefined;
+    /** Expand row bodies of the live turn. */
+    expanded?: boolean;
+    /** Expand row bodies of finished messages as they are printed. */
+    expandFinished?: boolean;
+    minimal?: boolean;
+    showFooter?: boolean;
+    bodyLines?: number;
+    extensions?: InkExtensions;
+    /** Host label for retrying, shown on stopped or failed messages. */
+    retryHint?: string;
+    /** Activity after content instead of in stream order. */
+    activityPlacement?: 'inline' | 'after-content';
+    /** While live and collapsed, show only the newest N activity blocks. */
+    liveTail?: number;
+    /** Show the footer while live (opt-in). */
+    liveFooter?: boolean;
+}
+declare function Transcript({ messages, isStreaming, streamingMessageId, expanded, expandFinished, minimal, showFooter, bodyLines, extensions, retryHint, activityPlacement, liveTail, liveFooter, }: TranscriptProps): JSX.Element;
+
+//#endregion
+//#region src/lines/Lines.d.ts
+/** A span's resolved text props. */
+declare function spanProps(s: Span, theme: InkTheme, highlight?: InkAppearance): Record<string, unknown>;
+/** Split text into runs that keep width measurement cheap. */
+declare function splitRuns(text: string): string[];
+interface LinesProps {
+    lines: readonly Line[];
+    theme: InkTheme;
+    /** Replace a line's drawing (e.g. a selection highlight); return undefined to draw normally. */
+    override?: (line: Line, index: number) => ReactNode | undefined;
+}
+declare function Lines({ lines, theme, override }: LinesProps): JSX.Element;
+
+//#endregion
+//#region src/lines/Status.d.ts
+interface StatusLineProps {
+    width: number;
+    /** The live message, when one streams: drives the pulse and phase. */
+    live?: {
+        message: RenderableMessage;
+        startedAt: number;
+    } | undefined;
+    /** Shown when nothing is live. */
+    notice?: {
+        text: string;
+        tone: 'positive' | 'danger';
+    } | undefined;
+    /** The host's own state when nothing is live and there is no notice (before "↓ N more"). */
+    idle?: string | undefined;
+    /** Lines below the viewport window ("↓ N more"). */
+    below?: number;
+    /** Host facts appended while live, e.g. `2 queued`, `^X stop`. */
+    extras?: string[];
+    /** Host label per phase (return undefined for the default). */
+    phaseLabel?: (phase: LivePhase) => string | undefined;
+    /** Facts appended once a phase has lasted a while (e.g. a cold-start hint). */
+    slowHint?: {
+        afterMs: number;
+        text: string;
+        phases: LivePhase['kind'][];
+    };
+    /** The pulse's appearance (default: the `accent` role). */
+    accent?: InkAppearance;
+    measure?: Measure;
+}
+declare function StatusLine({ width, live, notice, idle, below, extras, phaseLabel, slowHint, accent, measure, }: StatusLineProps): JSX.Element;
+interface PendingItem {
+    text: string;
+    attachments?: number;
+}
+interface PendingRowsProps {
+    items: PendingItem[];
+    width: number;
+    /** At most this many rows, newest last (default 3). */
+    maxRows?: number;
+    measure?: Measure;
+}
+/** Messages queued while an answer streams (the queue itself is host state). */
+declare function PendingRows({ items, width, maxRows, measure, }: PendingRowsProps): JSX.Element | null;
+interface EmptyStateProps {
+    title: string;
+    subtitle?: string;
+    notes?: string[];
+    /** The title's appearance (default: the `accent` role). */
+    accent?: InkAppearance;
+}
+/** A centred empty state; pass it as the viewport's `empty`. */
+declare function EmptyState({ title, subtitle, notes, accent }: EmptyStateProps): JSX.Element;
+
+//#endregion
+//#region src/lines/Viewport.d.ts
+/** Follow the bottom, or stay pinned to a top line. */
+type Scroll = {
+    follow: true;
+} | {
+    follow: false;
+    top: number;
+};
+/** The viewport's geometry: total lines, the first visible one, rows, and lines below. */
+interface Geometry {
+    total: number;
+    first: number;
+    rows: number;
+    below: number;
+}
+declare const scrollHome: Scroll;
+declare const scrollEnd: Scroll;
+/** The window's first line for a scroll state. */
+declare function firstLine(scroll: Scroll, total: number, rows: number): number;
+/** Scroll by `delta` lines, clamped; reaching the bottom returns to follow. */
+declare function scrollBy(scroll: Scroll, delta: number, g: Geometry): Scroll;
+/** Scroll by pages; a page keeps two lines of context. */
+declare function pageBy(scroll: Scroll, pages: number, g: Geometry): Scroll;
+/** Remappable viewport keys; `false` disables a binding (or all of them). */
+interface ViewportKeys {
+    page?: boolean;
+    lines?: boolean;
+    homeEnd?: boolean;
+    detail?: boolean;
+}
+interface TranscriptViewportProps {
+    messages: RenderableMessage[];
+    width: number;
+    height: number;
+    /** The live message's id, when one streams. */
+    streamingMessageId?: string | undefined;
+    scroll: Scroll;
+    onScroll: (next: Scroll) => void;
+    onGeometry?: (geometry: Geometry) => void;
+    detail?: DetailLevel;
+    onDetailChange?: (detail: DetailLevel) => void;
+    /** The message frame (default compact). */
+    frame?: MessageFrame;
+    activityPlacement?: 'inline' | 'after-content';
+    /** Newest tool rows a collapsed live message shows (default 3). */
+    liveTail?: number;
+    /** Footer on the live message (default true here). */
+    liveFooter?: boolean;
+    accentFor?: (message: RenderableMessage) => InkThemeRole | InkAppearance;
+    /** Drawn centred when there is nothing to show. */
+    empty?: ReactNode;
+    /** Controlled open state for rows and JSON members (uncontrolled when omitted). */
+    opened?: OpenState;
+    onToggle?: (blockId: string, path: string) => void;
+    hints?: FooterHints;
+    /**
+     * Injected layouts and measure are compared by identity (part of the layout
+     * cache key): pass stable values, or every change lays everything out again.
+     */
+    markdown?: MarkdownLayout;
+    blockLayouts?: Record<string, (block: CustomBlock, ctx: BlockLayoutContext) => LineDraft[]>;
+    measure?: Measure;
+    /** Whether the viewport takes its keys (default true). */
+    focused?: boolean;
+    /** Key bindings; `false` disables all. Home/End need `homeEnd: true` (no composer). */
+    keys?: ViewportKeys | false;
+    /** Lays out a block image line, when the host draws images (compared by identity). */
+    image?: LayoutContext['image'];
+    /** Draw a line differently (selection highlight); index is within the window. */
+    override?: (line: Line, index: number, absolute: number) => ReactNode | undefined;
+    /** Bumped by an image provider when an image arrives (part of the cache key). */
+    imagesVersion?: number;
+    /** Draws block images (used when `image` is not given). */
+    images?: ImageProvider;
+    /** Rows an expanded image may take (default: the height minus 8). */
+    maxImageHeight?: number;
+    /** Mouse support (opt-in): wheel, drag-select and copy, clicks. */
+    mouse?: ViewportMouse;
+    /** Writes terminal escapes: mouse reporting, copies, the image query (default: stdout). */
+    write?: (data: string) => void;
+    /** Host facts after a message's own footer facts (e.g. `turn 42` in details). */
+    footerExtras?: LayoutContext['footerExtras'];
+    /** A finished answer's activity when collapsed: its rows (default) or only the footer counts. */
+    finishedActivity?: LayoutContext['finishedActivity'];
+    /** A blank line between content and adjacent activity (default true). */
+    activitySpacing?: boolean;
+}
+/** Mouse options. Shift+drag keeps the terminal's own selection. */
+interface ViewportMouse {
+    /** Lines per wheel step (default 3). */
+    wheelStep?: number;
+    /** Double-click interval in ms (default 400). */
+    doubleClickMs?: number;
+    /** Writes this feature's escapes (default: the viewport's `write`). */
+    write?: (data: string) => void;
+    /** Called after a copy with the text and a short description. */
+    onCopy?: (text: string, description: string) => void;
+    /** Ctrl+click on an image; hosts should accept only http(s). */
+    onOpenUrl?: (url: string) => void;
+}
+/** Uncontrolled open state: a version plus the set of open `blockId␟path` keys. */
+declare function useOpenState(): [OpenState, (blockId: string, path: string) => void];
+/** Lay out the transcript and compute the window (for hosts that draw extra chrome). */
+declare function useTranscriptLayout(props: TranscriptViewportProps): {
+    lines: Line[];
+    geometry: Geometry;
+    window: Line[];
+    toggle: (blockId: string, path: string) => void;
+    now: number;
+    imageStates: Map<string, ImageState | undefined>;
+    toggleExpanded: (src: string) => void;
+};
+/** What a key does in the viewport (pure, so every binding is testable). */
+declare function viewportKeyAction(input: string, key: Pick<Key, 'pageUp' | 'pageDown' | 'shift' | 'upArrow' | 'downArrow' | 'home' | 'end' | 'ctrl'>, keys: ViewportKeys | false, scroll: Scroll, geometry: Geometry, detail: DetailLevel): {
+    scroll: Scroll;
+} | {
+    detail: DetailLevel;
+} | undefined;
+declare function TranscriptViewport(props: TranscriptViewportProps): JSX.Element;
+
+//#endregion
+//#region src/lines/mouse.d.ts
+/** Button-event tracking with SGR encoding, on and off. */
+declare const MOUSE_ON: string;
+declare const MOUSE_OFF: string;
+interface MouseEvent {
+    kind: 'press' | 'release' | 'drag' | 'wheel-up' | 'wheel-down';
+    button: 'left' | 'middle' | 'right' | 'none';
+    /** Zero-based screen cell. */
+    x: number;
+    y: number;
+    ctrl: boolean;
+    shift: boolean;
+    meta: boolean;
+}
+/**
+* Every SGR mouse report in a chunk of terminal input. Horizontal wheel
+* reports (buttons 6 and 7) are dropped: the viewport only scrolls vertically.
+*/
+declare function parseMouse(data: string): MouseEvent[];
+/**
+* A reader of terminal reports across input chunks: each call returns the
+* complete CSI sequences in what has arrived, keeping an unfinished one at
+* the end for the next chunk (a terminal may split a report anywhere). The
+* kept tail is bounded; past the bound it is dropped as noise.
+*/
+declare function createReportReader(): (data: string) => string[];
+/** An OSC 52 clipboard write of `text`. */
+declare function osc52(text: string): string;
+/**
+* The element's position on screen, in cells. This relies on the renderer's
+* layout internals (each node's computed offset from its parent), so it is
+* isolated here.
+*/
+declare function screenOrigin(node: DOMElement | null | undefined): {
+    x: number;
+    y: number;
+};
+/** A point in the transcript: an absolute line index and a cell column. */
+interface Point {
+    line: number;
+    col: number;
+}
+/** The two ends of a selection, in reading order. */
+declare function ordered(a: Point, b: Point): [Point, Point];
+/**
+* Copy text between two points (inclusive of the end cell): content spans
+* only, decoration lines skipped, lines right-trimmed, soft joins as a space,
+* hard joins as nothing, other lines by newlines.
+*/
+declare function copyText(lines: readonly Line[], a: Point, b: Point, measure: Measure): string;
+/**
+* Highlight the content cells of a line from `start` to `end` (inclusive) with
+* the selection appearance; selecting past the line's end highlights one more
+* cell. Decoration lines are returned as they are.
+*/
+declare function highlightLine(line: Line, start: number, end: number, selection: InkAppearance, measure: Measure): Line;
+/** Call `handler` with every chunk of raw terminal input while active. */
+declare function useTerminalData(handler: (data: string) => void, active: boolean): void;
+/** Enable mouse reporting while active; disable on deactivation, unmount and process exit. */
+declare function useMouseReporting(active: boolean, write: (data: string) => void): void;
+
+//#endregion
+//#region src/registry.d.ts
+/** Props of the markdown slot. */
+interface InkMarkdownProps {
+    content: string;
+    /** True while the text is still streaming (renderers may relax parsing). */
+    streaming?: boolean;
+}
+interface InkComponents {
+    theme: InkTheme;
+    glyphs: InkGlyphs;
+    /** Renders message text. The default prints it verbatim in the `content` role. */
+    Markdown: ComponentType<InkMarkdownProps>;
+    /** Spinner frame interval in ms (ignored under a shared clock). */
+    spinnerIntervalMs: number;
+    /** Show the brief completion check when a row finishes (default true). */
+    flashComplete: boolean;
+}
+/** A partial registry; nested theme/glyph maps merge per key. */
+interface PartialInkComponents {
+    theme?: Partial<InkTheme>;
+    glyphs?: Partial<InkGlyphs>;
+    Markdown?: ComponentType<InkMarkdownProps>;
+    spinnerIntervalMs?: number;
+    flashComplete?: boolean;
+}
+/** Prints markdown source as-is. */
+declare function PlainMarkdown({ content }: InkMarkdownProps): JSX.Element;
+declare const plainComponents: InkComponents;
+/** Merge a partial registry over a base. */
+declare function mergeInkComponents(base: InkComponents, partial?: PartialInkComponents): InkComponents;
+declare function InkChatProvider({ components, children, }: {
+    components?: PartialInkComponents;
+    children?: ReactNode;
+}): JSX.Element;
+declare function useInkComponents(): InkComponents;
+/** Ink `<Text>` props for an appearance. */
+declare function appearanceProps(appearance: InkAppearance): {
+    strikethrough?: boolean;
+    underline?: boolean;
+    inverse?: boolean;
+    italic?: boolean;
+    bold?: boolean;
+    dimColor?: boolean;
+    color?: string;
+};
+/** Text drawn in a theme role (`tone`). */
+declare function Styled({ tone, wrap, children, }: {
+    tone: InkThemeRole;
+    wrap?: 'wrap' | 'truncate-end';
+    children?: ReactNode;
+}): JSX.Element;
+
+//#endregion
+//#region src/runtime.d.ts
+type ReactApi = typeof _0;
+type InkApi = typeof _1;
+/** What a host hands in. */
+interface ChatInkDeps {
+    React: ReactApi;
+    ink: InkApi;
+}
+declare let React: ReactApi;
+declare let ink: InkApi;
+/** The core render hooks, bound to the host's React. */
+declare let hooks: CoreHooks;
+/** Whether `createChatInk` has run. */
+declare function isBound(): boolean;
+
+//#endregion
+//#region src/create.d.ts
+/**
+* One shared clock for every timer, rate, spinner and pulse this package
+* draws (the core hooks' provider, on the host's React).
+*/
+declare function ClockProvider(props: ClockProviderProps): FunctionComponentElement<ClockProviderProps>;
+declare function createChatInk(deps: ChatInkDeps): {
+    React: typeof _3;
+    ink: typeof _4;
+    /** The core render hooks (clock, timers, rates) on the host's React. */
+    hooks: {
+        ClockProvider: ({ tickMs, children }: ClockProviderProps) => FunctionComponentElement<ProviderProps<SharedClock | null>>;
+        useSharedClock: () => SharedClock | null;
+        useTicks: (active: boolean, fallbackMs: number) => number;
+        useClock: (active: boolean, fallbackMs?: number) => number;
+        useElapsedTimer: ({ startedAt, isActive, durationMs, intervalMs, }: ElapsedTimerInput) => number;
+        useLiveTokensPerSecond: ({ startedAt, isActive, tokenCount, metrics, intervalMs, }: LiveTokensInput) => number | undefined;
+        usePrefersReducedMotion: () => boolean;
+        useFlashComplete: (isActive: boolean, duration?: number, enabled?: boolean) => boolean;
+    };
+    ClockProvider: typeof ClockProvider;
+    Composer: typeof Composer;
+    EmptyState: typeof EmptyState;
+    InkChatProvider: typeof InkChatProvider;
+    Lines: typeof Lines;
+    MessageView: typeof MessageView;
+    PendingRows: typeof PendingRows;
+    PlainMarkdown: typeof PlainMarkdown;
+    Row: typeof Row;
+    Spinner: typeof Spinner;
+    StatusLine: typeof StatusLine;
+    Styled: typeof Styled;
+    Transcript: typeof Transcript;
+    TranscriptViewport: typeof TranscriptViewport;
+    useInkComponents: typeof useInkComponents;
+    useMouseReporting: typeof useMouseReporting;
+    useOpenState: typeof useOpenState;
+    useTerminalData: typeof useTerminalData;
+    useTranscriptLayout: typeof useTranscriptLayout;
+};
+/** The renderer `createChatInk` returns. */
+type ChatInk = ReturnType<typeof createChatInk>;
+
+//#endregion
+//#region src/editor.d.ts
+interface EditorState {
+    value: string;
+    /**
+     * Caret offset into `value` (0…length). Every operation leaves it on a
+     * grapheme boundary, so an emoji, flag or combining sequence is never split;
+     * an offset inside a grapheme is first moved back to that grapheme's start.
+     */
+    caret: number;
+}
+declare const emptyEditor: EditorState;
+/** `caret` clamped to the value and moved back to the start of the grapheme it is inside. */
+declare function caretBoundary(value: string, caret: number): number;
+/**
+* Split `text` at a caret for drawing: before it, the grapheme under it ('' at
+* the end) and after it. The grapheme is whole, so the caret cell covers all
+* of it (two cells for a wide one) and no character is split around it.
+*/
+declare function splitAtCaret(text: string, caret: number): [string, string, string];
+/**
+* Insert at the caret. Text that joins the grapheme after it (a combining
+* mark's base, half a flag) leaves the caret after the joined grapheme.
+*/
+declare function insert(state: EditorState, text: string): EditorState;
+declare function backspace(state: EditorState): EditorState;
+declare function deleteForward(state: EditorState): EditorState;
+/** Move the caret `delta` graphemes (negative: left), stopping at the ends. */
+declare function moveBy(state: EditorState, delta: number): EditorState;
+declare function lineStart(state: EditorState): EditorState;
+declare function lineEnd(state: EditorState): EditorState;
+/** Delete from the line start to the caret. */
+declare function killToLineStart(state: EditorState): EditorState;
+/** Delete from the caret to the line end. */
+declare function killToLineEnd(state: EditorState): EditorState;
+/** Delete the word before the caret (and the whitespace after it). */
+declare function deleteWordBack(state: EditorState): EditorState;
+/**
+* Move the caret one line up (`-1`) or down (`+1`), keeping its cell column
+* where the target line is long enough. Returns `undefined` at the first/last
+* line, so the caller can fall through to history navigation.
+*/
+declare function moveLine(state: EditorState, direction: -1 | 1, measure?: Measure): EditorState | undefined;
+/** Split into lines, each with the caret column (an offset into the line) when the caret is on it. */
+declare function caretLines(state: EditorState): Array<{
+    text: string;
+    caret?: number;
+}>;
+/** Jump to the start of the previous whitespace-separated word. */
+declare function wordLeft(state: EditorState): EditorState;
+/** Jump past the end of the next whitespace-separated word. */
+declare function wordRight(state: EditorState): EditorState;
+/**
+* One drawn row of the input: offsets `[start, end)` into the value (a
+* newline is never inside a row). `soft` rows continue on the next row.
+*/
+interface VisualRow {
+    start: number;
+    end: number;
+    soft: boolean;
+}
+/**
+* Lay the value out in rows: at newlines, and (with a width) wherever the
+* next grapheme would pass `width` cells — never inside a wide character.
+*/
+declare function visualRows(value: string, width?: number, measure?: Measure): VisualRow[];
+/** The row holding the caret: a soft row's end belongs to the next row. */
+declare function caretRow(rows: readonly VisualRow[], caret: number): number;
+/**
+* Move the caret one visual row up or down, keeping its cell column (landing
+* at the end of a shorter row). Undefined at the first or last row.
+*/
+declare function moveVisual(state: EditorState, rows: readonly VisualRow[], direction: -1 | 1, measure?: Measure): EditorState | undefined;
+/** A history entry: text, and the attachments sent with it. */
+interface HistoryEntry {
+    text: string;
+    attachments?: Attachment[];
+}
+/**
+* Input history with a draft: browsing up from a fresh draft keeps it, so
+* coming back down restores what was being typed (with its attachments).
+*/
+interface History {
+    entries: HistoryEntry[];
+    /** Index into `entries` while browsing; `entries.length` means the draft. */
+    index: number;
+    draft: HistoryEntry;
+}
+declare function createHistory(entries?: Array<string | HistoryEntry>): History;
+declare function pushHistory(history: History, entry: string | HistoryEntry): History;
+/**
+* Replace the entries (the host's list changed), keeping the draft and a
+* browse in progress (clamped to the new list).
+*/
+declare function withEntries(history: History, entries: Array<string | HistoryEntry>): History;
+/** Step through history; returns the new history and the entry to show, or undefined at an end. */
+declare function stepHistory(history: History, direction: -1 | 1, current: string | HistoryEntry): {
+    history: History;
+    value: string;
+    attachments?: Attachment[];
+} | undefined;
+
+//#endregion
+//#region src/sanitize.d.ts
+/**
+* Content must never drive the terminal. Model output, tool output, titles
+* and other host- or model-provided strings may carry escape sequences (an
+* OSC 52 clipboard write, an OSC 8 link, SGR colours, cursor moves) that Ink
+* would pass straight through. Everything this package draws is cleaned
+* here first; its own styling travels as Ink props, never as escapes in text.
+*
+* Removed: whole ESC/C1 sequences — CSI, OSC, DCS, SOS, PM, APC (a string
+* command up to its terminator: BEL, `ESC \` or ST), and any other ESC
+* sequence — then every remaining C0 control but `\n` and `\t` (so `\r` and
+* BEL go), DEL, and the C1 controls U+0080–U+009F. An unterminated string
+* command loses its introducer only: the rest is plain text once no control
+* can read it, and the scan stays linear.
+*/
+/** `text` without terminal control sequences or control characters (bar `\n` and `\t`). */
+declare function stripControls(text: string): string;
+/**
+* `value` with `stripControls` applied to every string in it (object keys
+* included), through arrays and plain objects; other objects (Map, Set,
+* Date, class instances) pass through as they are. Anything unchanged keeps
+* its identity, so clean content costs a scan and no copies. Keys that clean
+* to the same name all survive (see `cleanKeys`); a `__proto__` key stays an
+* own property, never a prototype; a cycle is left as it is where it closes.
+*/
+declare function stripControlsDeep<T>(value: T): T;
+
+//#endregion
+//#region src/terminal.d.ts
+/**
+* Terminal protocol helpers shared by the composer and the viewport.
+*/
+/** Mouse reports and terminal replies arrive as input; key handlers ignore them. */
+declare function isTerminalReport(input: string): boolean;
+/** Kitty keyboard protocol: push the disambiguate flag (Shift+Enter is then reported). */
+declare const KITTY_PUSH: string;
+/** Kitty keyboard protocol: pop the flags pushed last. */
+declare const KITTY_POP: string;
+
+//#endregion
+//#region src/lines/frames.d.ts
+/**
+* Compact: a role glyph before the first row (`›` user, `•` answer), rows
+* indented under it, a dim footer line, a blank line after each message.
+*/
+declare const compactFrame: MessageFrame;
+/**
+* Threaded: the user's message in a round-cornered box with its time set into
+* the top edge; an answer hangs from the box on a gutter in its accent and
+* ends with a footer corner (bare when the answer has no footer facts). A live answer that shows nothing yet draws
+* nothing.
+*/
+declare const threadedFrame: MessageFrame;
+
+//#endregion
+//#region src/lines/transcript.d.ts
+/** Memoised `layoutMessage`, keyed by message identity plus a signature. */
+interface LayoutCache {
+    get(message: RenderableMessage, ctx: LayoutContext, next?: RenderableMessage): Line[];
+    /** Layouts computed (not served from the cache) — for tests and diagnostics. */
+    readonly misses: number;
+}
+/**
+* Everything a message's layout reads, as a string. Plain values (hint labels,
+* the resolved accent, host footer facts) count by value; injected functions
+* and the glyph set count by identity, so hosts memoise them.
+*/
+declare function layoutSignature(message: RenderableMessage, ctx: LayoutContext, next?: RenderableMessage, imagesVersion?: number): string;
+declare function createLayoutCache(imagesVersion?: () => number): LayoutCache;
+/** Lay out a transcript: all lines, and where each message starts. */
+declare function layoutTranscript(messages: readonly RenderableMessage[], ctx: LayoutContext, cache?: LayoutCache): {
+    lines: Line[];
+    messageStart: number[];
+};
+
+//#endregion
+//#region src/lines/markdown/blocks.d.ts
+interface MarkdownEnv {
+    measure: Measure;
+    glyphs: InkGlyphs;
+    streaming?: boolean | undefined;
+    image?: ((src: string, alt: string, width: number) => LineDraft[] | undefined) | undefined;
+}
+/** Lay out markdown source lines as blocks; `tight` drops the blank lines between blocks. */
+declare function layoutBlocks(lines: readonly string[], width: number, env: MarkdownEnv, tight?: boolean): LineDraft[];
+/**
+* Split source lines into top-level chunks at blank lines that end a block:
+* never inside a fence, and not where an indented line or a list item
+* continues the block before. Chunks lay out independently.
+*/
+declare function chunks(lines: readonly string[]): string[][];
+/**
+* The default terminal markdown: dependency-free, injected roles and glyphs.
+* Finished blocks are cached, so a streamed delta lays out only the tail.
+*/
+declare const terminalMarkdown: MarkdownLayout;
+
+//#endregion
+//#region src/lines/markdown/inline.d.ts
+/** The attributes inline markup sets on a span. */
+type InlineStyle = Omit<Span, 'text'>;
+/** Show a source the way a reader can use it: a `data:` URL as its type. */
+declare function describeSource(src: string): string;
+/** Merge adjacent spans with identical attributes. */
+declare function mergeSpans(spans: readonly Span[]): Span[];
+/** Parse inline markdown into spans, every span starting from `base`. */
+declare function parseInline(text: string, base: InlineStyle, glyphs: InkGlyphs): Span[];
+
+//#endregion
+//#region src/lines/markdown/table.d.ts
+type Align = 'left' | 'center' | 'right';
+/** The narrowest a wrapped column may get before the table falls back. */
+declare const MIN_COLUMN = 6;
+/** Whether `line` is a GFM table separator row. */
+declare function isSeparator(line: string): boolean;
+/** Split a row into cells on pipes that are neither escaped nor inside a code span. */
+declare function splitRow(line: string): string[];
+/** Column alignments from a separator row. */
+declare function alignments(line: string): Align[];
+/**
+* Fit natural widths into `available` cells: columns within a fair share keep
+* theirs, the rest share what remains. Undefined when a column would fall
+* below its minimum (the minimums together exceed the available cells).
+*/
+declare function fitColumns(natural: readonly number[], available: number): number[] | undefined;
+interface TableEnv {
+    glyphs: InkGlyphs;
+    measure: Measure;
+}
+/** Lay out a table from its header, separator and body source rows. */
+declare function layoutTable(header: string, separator: string, body: readonly string[], maxWidth: number, { glyphs, measure }: TableEnv): LineDraft[];
+
+//#endregion
+//#region src/lines/markdown/wrap.d.ts
+interface SpanRow {
+    spans: Span[];
+    wrap?: 'soft' | 'hard';
+}
+declare function wrapSpans(spans: readonly Span[], width: number, measure: Measure): SpanRow[];
+
+//#endregion
+//#region src/lines/Markdown.d.ts
+interface TerminalMarkdownProps extends InkMarkdownProps {
+    /** Lay out to this many cells instead of the measured box width. */
+    width?: number;
+    /** Cell measurement (default: the one Ink lays out by). */
+    measure?: Measure;
+}
+declare function TerminalMarkdown({ content, streaming, width, measure, }: TerminalMarkdownProps): JSX.Element;
+
+//#endregion
+export { Align, BlockLayoutContext, CellBox, ChatInk, ChatInkDeps, ClockProvider, Composer, ComposerHandle, ComposerProps, ComposerValue, EditorState, EmptyState, EmptyStateProps, FooterHints, FrameInput, Geometry, History, HistoryEntry, ImageLayoutOptions, ImageProvider, ImageState, InkApi, InkAppearance, InkBlockRendererProps, InkChatProvider, InkComponents, InkExtensions, InkGlyphs, InkMarkdownProps, InkTheme, InkThemeRole, InlineStyle, KITTY_POP, KITTY_PUSH, LayoutCache, LayoutContext, Line, LineDraft, LineTarget, Lines, LinesProps, MIN_COLUMN, MOUSE_OFF, MOUSE_ON, MarkdownEnv, MarkdownLayout, Measure, MessageFrame, MessageView, MessageViewProps, MouseEvent, NOTHING_OPEN, OpenState, PartialInkComponents, PendingItem, PendingRows, PendingRowsProps, PlainMarkdown, Point, ROW_PATH, React, ReactApi, Row, RowProps, Scroll, Span, SpanRow, Spinner, StatusLine, StatusLineProps, Styled, THUMBNAIL, TableEnv, TerminalMarkdown, TerminalMarkdownProps, Transcript, TranscriptProps, TranscriptViewport, TranscriptViewportProps, ViewportKeys, ViewportMouse, VisualRow, WrappedRow, alignments, appearanceProps, asciiGlyphs, backspace, cachedMeasure, caretBoundary, caretLines, caretRow, chunks, clipLines, compactFrame, composerInnerWidth, composerRows, copyText, createChatInk, createHistory, createLayoutCache, createReportReader, defaultMeasure, deleteForward, deleteWordBack, describeSource, emojiGlyphs, emptyComposerValue, emptyEditor, firstLine, fitColumns, footerSpans, graphemes, hardSplit, highlightLine, hooks, ink, insert, isBound, isSeparator, isTerminalReport, killToLineEnd, killToLineStart, layoutBlocks, layoutBody, layoutImage, layoutMessage, layoutSignature, layoutTable, layoutTranscript, lineEnd, lineStart, lineText, mergeInkComponents, mergeSpans, moveBy, moveLine, moveVisual, ordered, osc52, pageBy, parseInline, parseMouse, plainComponents, plainGlyphs, plainMarkdownLayout, plainTheme, prefix, pushHistory, resolveAccent, screenOrigin, scrollBy, scrollEnd, scrollHome, showsSomething, span, spanProps, splitAtCaret, splitRow, splitRuns, stepHistory, stripControls, stripControlsDeep, suffix, terminalMarkdown, threadedFrame, toJson, truncate, useInkComponents, useMouseReporting, useOpenState, useTerminalData, useTranscriptLayout, viewportKeyAction, visualRows, withEntries, wordLeft, wordRight, wrapLines, wrapSpans, wrapText };