@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/dist/types/prompt/orchestrate.d.ts

@@ -0,0 +1,13 @@
+import { type KeywordHighlighter } from "./gradient-highlight.js";
+/**
+ * Whether `text` contains the standalone keyword "orchestrate" (lowercase,
+ * prose-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
+export declare function containsOrchestrate(text: string): boolean;
+/**
+ * Highlight every standalone "orchestrate" in `text` for editor display with a
+ * cool teal→violet gradient (hue 150..280), visually distinct from ultrathink's
+ * full-spectrum rainbow.
+ */
+export declare const highlightOrchestrate: KeywordHighlighter;

package/dist/types/prompt/prompt-action-autocomplete.d.ts

@@ -0,0 +1,56 @@
+import { type AutocompleteItem, type AutocompleteProvider, type SlashCommand } from "../index.js";
+import { type KeybindingsManager } from "../app-keybindings.js";
+import { type InternalUrlCallerContext } from "./internal-url-autocomplete.js";
+import { type ModelMentionCandidateSource } from "./model-mention-autocomplete.js";
+/** Set the process-wide emoji completion preference. */
+export declare function setEmojiAutocompleteEnabled(enabled: boolean): void;
+interface PromptActionDefinition {
+    id: string;
+    label: string;
+    description: string;
+    keywords: string[];
+    execute: (prefix: string) => void;
+}
+interface PromptActionAutocompleteOptions {
+    commands: SlashCommand[];
+    basePath: string;
+    /** Usage count per command name for frequency-ranked slash completions. */
+    commandUsage?: (name: string) => number;
+    /** Read the receiving session at lookup time, following focus and session replacement. */
+    internalUrlCaller?: () => InternalUrlCallerContext;
+    /** Session-scoped models available for `^` mentions. */
+    modelMentions?: ModelMentionCandidateSource;
+    keybindings: KeybindingsManager;
+    copyCurrentLine: () => void;
+    copyPrompt: () => void;
+    undo: (prefix: string) => void;
+    moveCursorToMessageEnd: () => void;
+    moveCursorToMessageStart: () => void;
+    moveCursorToLineStart: () => void;
+    moveCursorToLineEnd: () => void;
+}
+export declare class PromptActionAutocompleteProvider implements AutocompleteProvider {
+    #private;
+    constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[], commandUsage?: (name: string) => number, internalUrlCaller?: () => InternalUrlCallerContext, modelMentions?: ModelMentionCandidateSource);
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number, signal?: AbortSignal): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+        onApplied?: () => void;
+    };
+    getInlineHint(lines: string[], cursorLine: number, cursorCol: number): string | null;
+    trySyncSlashCompletion(textBeforeCursor: string): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+    trySyncInlineReplace(textBeforeCursor: string): {
+        replaceLen: number;
+        insert: string;
+    } | null;
+}
+export declare function createPromptActionAutocompleteProvider(options: PromptActionAutocompleteOptions): PromptActionAutocompleteProvider;
+export {};

package/dist/types/prompt/queue-input.d.ts

@@ -0,0 +1,8 @@
+/** Prefix matcher shared by queue-list parsing and editor highlighting. */
+export declare const QUEUE_LIST_MARKER_RE: RegExp;
+/** Extract the message body from the `->` / `=>` yield-queue shorthand. */
+export declare function parseQueueShorthand(text: string): string | undefined;
+/** Whether text currently forms a sequential queue list, including an unfinished trailing item. */
+export declare function isQueuedMessageList(text: string): boolean;
+/** Split a sequential numeric, Roman-numeral, or alphabetic list into queue entries. */
+export declare function splitQueuedMessages(text: string): string[];

package/dist/types/prompt/skill-tokens.d.ts

@@ -0,0 +1,13 @@
+/**
+ * One `/skill:<name>` token delimited by whitespace or line edges. Group 1 is
+ * the leading delimiter (empty at line start), group 2 the bare skill name.
+ * Global so callers can walk every token; reset `lastIndex` before reuse.
+ */
+export declare const SKILL_TOKEN_RE: RegExp;
+/**
+ * Whether `/skill:<name>` tokens in `text` are invocations rather than content
+ * belonging to another slash command or local-execution sigil.
+ */
+export declare function allowsSkillTokens(text: string): boolean;
+/** Whether model mentions may collapse in this draft; local execution consumes its body verbatim. */
+export declare function allowsModelMentions(text: string): boolean;

package/dist/types/prompt/tools-markdown.d.ts

@@ -0,0 +1,12 @@
+export interface ToolsMarkdownBindings {
+    tools: ReadonlyArray<{
+        description: string;
+        name: string;
+    }>;
+    /** Tools mounted under `xd://` URLs, listed after the active set. */
+    xdevTools?: ReadonlyArray<{
+        name: string;
+        summary: string;
+    }>;
+}
+export declare function buildToolsMarkdown(bindings: ToolsMarkdownBindings): string;

package/dist/types/prompt/ultrathink.d.ts

@@ -0,0 +1,13 @@
+import { type KeywordHighlighter } from "./gradient-highlight.js";
+/**
+ * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
+ * prose-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
+export declare function containsUltrathink(text: string): boolean;
+/**
+ * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
+ * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
+ * gradient resolves smoothly regardless of casing or match length.
+ */
+export declare const highlightUltrathink: KeywordHighlighter;

package/dist/types/prompt/usage-amounts.d.ts

@@ -0,0 +1,26 @@
+import { type UsageLimit } from "@oh-my-pi/pi-ai/usage";
+export declare function isUsedOnlyAbsoluteAmount(limit: UsageLimit): boolean;
+export declare function isRemainingOnlyAbsoluteAmount(limit: UsageLimit): boolean;
+/**
+ * Total the prepaid headroom a set of limits actually represents.
+ *
+ * A `scope.shared` limit is one account-wide pool observed once per stored
+ * credential, so N keys on the same account yield N identical rows that must
+ * collapse to a single value — summing them would claim several times the
+ * credits a single request can draw on. Limits without the flag are genuinely
+ * per-account and do add up. Returns `undefined` unless every limit is
+ * remaining-only and agrees on a unit, so mixed buckets fall through to the
+ * caller's own handling.
+ */
+export declare function totalRemainingOnly(limits: readonly UsageLimit[]): {
+    value: number;
+    unit: UsageLimit["amount"]["unit"];
+} | undefined;
+/** `"100 credits left"` for a bucket of remaining-only limits, else `undefined`. */
+export declare function formatRemainingOnlyTotal(limits: readonly UsageLimit[]): string | undefined;
+/**
+ * Text for a bucket no quota bar can draw: spend-to-date or prepaid headroom.
+ * Used-only limits report the worst (highest) spend; remaining-only limits go
+ * through {@link totalRemainingOnly} so shared pools are not double-counted.
+ */
+export declare function formatAbsoluteOnlyAmount(limits: readonly UsageLimit[]): string | undefined;

package/dist/types/prompt/video.d.ts

@@ -0,0 +1,18 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+/** True when the path names a video container we handle through ffmpeg. */
+export declare function isVideoPath(filePath: string): boolean;
+/**
+ * Original local source path stored on a generated contact-sheet image. Symbol
+ * metadata stays out of serialized/model-bound image data while traveling with
+ * the draft object until AgentSession creates its hidden companion message.
+ */
+declare const kVideoPreviewSource: unique symbol;
+/** A contact-sheet image tagged with the original local video path. */
+export type VideoPreviewImage = ImageContent & {
+    readonly [kVideoPreviewSource]: string;
+};
+/** Create a model-ready contact-sheet image tagged with its original video path. */
+export declare function createVideoPreviewImage(preview: ImageContent, sourcePath: string): VideoPreviewImage;
+/** Return the original video path associated with a generated contact-sheet image. */
+export declare function videoPreviewSource(preview: ImageContent): string | undefined;
+export {};

package/dist/types/prompt/welcome.d.ts

@@ -0,0 +1,83 @@
+import type { Component } from "../tui.js";
+/**
+ * Fixed number of session rows in the welcome box so its height stays stable
+ * across recent-session updates.
+ */
+export declare const WELCOME_SESSION_SLOTS = 4;
+/**
+ * Fixed number of LSP-server rows, for the same reason. Overflow is sliced so
+ * the box height is constant regardless of how many servers a project has.
+ */
+export declare const WELCOME_LSP_SLOTS = 4;
+/** Pick a tip from `tips`, biased toward "[NEW]" tips by {@link NEW_TIP_WEIGHT};
+ *  `r` is a uniform sample in [0, 1). Returns "" when `tips` is empty.
+ *  Exported for tests. */
+export declare function pickWeightedTip(tips: readonly string[], r: number): string;
+export declare function renderWelcomeTip(tip: string, boxWidth: number, phase?: number): string[];
+export interface RecentSession {
+    name: string;
+    timeAgo: string;
+}
+export interface LspServerInfo {
+    name: string;
+    status: "ready" | "error" | "connecting" | "available";
+    fileTypes: string[];
+}
+/**
+ * Premium welcome screen with block-based OMP logo and two-column layout.
+ */
+export declare class WelcomeComponent implements Component {
+    #private;
+    private version;
+    private modelName;
+    private providerName;
+    private recentSessions;
+    private lspServers;
+    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[]);
+    get tip(): string | undefined;
+    invalidate(): void;
+    /** The intro keeps the welcome block mutable; settling lets it retire to history. */
+    isTranscriptBlockFinalized(): boolean;
+    /**
+     * Play a one-shot intro that sweeps the gradient through every phase
+     * before settling on the resting frame. Safe to call multiple times —
+     * subsequent calls reset and replay.
+     */
+    playIntro(requestRender: () => void): void;
+    /**
+     * Redirect a running intro's render callback to a new target when a host
+     * remounts this component mid-animation.
+     * Returns true while the intro is still animating; false = no-op (settled).
+     */
+    retargetIntro(requestRender: () => void): boolean;
+    /** Stop the intro immediately and settle on the resting frame. Safe when idle. */
+    stopIntro(): void;
+    /** Update the version embedded in the welcome border title. */
+    setVersion(version: string): void;
+    setModel(modelName: string, providerName: string): void;
+    setRecentSessions(sessions: RecentSession[]): void;
+    setLspServers(servers: LspServerInfo[]): void;
+    render(termWidth: number): readonly string[];
+}
+/** Block-grid brand mark shared by the welcome and setup surfaces. */
+export declare const PI_LOGO: string[];
+export interface ShineConfig {
+    /** Overall opacity of the shine overlay, in [0, 1]. */
+    strength: number;
+    /** Center of the shine band along the diagonal, in [0, 1]. */
+    pos: number;
+}
+/**
+ * Resolve the gradient SGR foreground escape for a normalized position `t`
+ * (0..1) along the diagonal, compositing the optional sliding shine highlight.
+ * Shared by {@link gradientLogo} and the setup splash so both stay
+ * color-identical (truecolor when available, 256-color ramp otherwise).
+ */
+export declare function gradientEscape(t: number, shine?: ShineConfig): string;
+/**
+ * Apply a multi-stop diagonal gradient (top-left → bottom-right) plus an
+ * optional sliding shine band across multi-line art. `phase` (0..1) shifts the
+ * gradient along the diagonal, wrapping at 1. When `shine` is provided, a soft
+ * white highlight is composited on top, centered at `shine.pos`.
+ */
+export declare function gradientLogo(lines: readonly string[], phase?: number, shine?: ShineConfig): string[];

package/dist/types/prompt/workflow.d.ts

@@ -0,0 +1,13 @@
+import { type KeywordHighlighter } from "./gradient-highlight.js";
+/**
+ * Whether `text` contains the standalone keyword "workflowz"
+ * (lowercase, prose-delimited) in prose — never inside a code block, inline
+ * code span, or XML/HTML section.
+ */
+export declare function containsWorkflow(text: string): boolean;
+/**
+ * Highlight every standalone "workflowz" in `text` for editor display
+ * with a warm amber→green gradient (hue 30..150), visually distinct from
+ * ultrathink's rainbow and orchestrate's teal→violet.
+ */
+export declare const highlightWorkflow: KeywordHighlighter;

package/dist/types/render/code-cell.d.ts

@@ -0,0 +1,51 @@
+import { type Theme } from "../theme/theme.js";
+/** Content and display limits for a code preview with optional output. */
+export interface CodeCellOptions {
+    code: string;
+    language?: string;
+    index?: number;
+    total?: number;
+    title?: string;
+    status?: "pending" | "running" | "warning" | "complete" | "error";
+    spinnerFrame?: number;
+    duration?: number;
+    output?: string;
+    outputMaxLines?: number;
+    codeMaxLines?: number;
+    /**
+     * Show the LAST `codeMaxLines` rows (the live streaming edge) instead of the
+     * first, with a "… N earlier lines" marker on top. Lets a pending preview
+     * follow code as it is written while staying bounded. Ignored when `expanded`.
+     */
+    codeTail?: boolean;
+    expanded?: boolean;
+    /**
+     * Prefix the header with the cell's language icon (resolved through the
+     * active symbol preset: nerd-font devicon, unicode emoji, or ascii
+     * shorthand). Opt-in so only the eval kernel renderer labels each cell;
+     * read/write/browser code cells stay icon-free.
+     */
+    showLanguage?: boolean;
+    width: number;
+    codeStartLine?: number;
+    codeLineNumbers?: Array<number | null>;
+}
+/** Render a syntax-highlighted code preview and its optional output block. */
+export declare function renderCodeCell(options: CodeCellOptions, theme: Theme): string[];
+/** Content and display limits for a Markdown preview with optional output. */
+export interface MarkdownCellOptions {
+    content: string;
+    index?: number;
+    total?: number;
+    title?: string;
+    status?: "pending" | "running" | "warning" | "complete" | "error";
+    spinnerFrame?: number;
+    duration?: number;
+    output?: string;
+    outputMaxLines?: number;
+    contentMaxLines?: number;
+    expanded?: boolean;
+    width: number;
+}
+/** Render a Markdown preview and its optional output block. */
+export declare function renderMarkdownCell(options: MarkdownCellOptions, theme: Theme): string[];

package/dist/types/render/file-list.d.ts

@@ -0,0 +1,22 @@
+import type { Theme } from "../theme/theme.js";
+/** A file-list item with optional display metadata. */
+export interface FileEntry {
+    path: string;
+    /** Absolute filesystem path. When provided together with {@link FileListOptions.hyperlinkFn}, the
+     * rendered path text is wrapped in an OSC 8 hyperlink. */
+    absPath?: string;
+    isDirectory?: boolean;
+    meta?: string;
+}
+/** Files and presentation options for a tree-style listing. */
+export interface FileListOptions {
+    files: FileEntry[];
+    expanded?: boolean;
+    maxCollapsed?: number;
+    showIcons?: boolean;
+    /** When provided, called with the entry's absolute path and the ANSI-styled display string to
+     * optionally wrap the path in an OSC 8 hyperlink. Only invoked when {@link FileEntry.absPath} is set. */
+    hyperlinkFn?: (absPath: string, displayText: string) => string;
+}
+/** Render file entries as a themed tree listing. */
+export declare function renderFileList(options: FileListOptions, theme: Theme): string[];

package/dist/types/render/hyperlink.d.ts

@@ -0,0 +1,80 @@
+import { type TerminalId } from "../terminal-capabilities.js";
+/**
+ * Build the OSC 8 target for a file path on `terminalId`.
+ *
+ * A `file:` URI handed to an editor has to be a plain path. `Paths.get(URI)`
+ * rejects one carrying a query or a fragment outright — `IllegalArgumentException:
+ * URI has a query component` / `URI has a fragment component` — so appending
+ * `?line=` made every JVM-based language server (Kotlin LSP, Eclipse JDT LS)
+ * fail *every* request for the resulting document, and VS Code reads the query
+ * as part of the resource identity rather than as a cursor position: a blank
+ * editor tab that navigates nowhere and persists across window reloads (#12109).
+ *
+ * The VS Code family instead navigates the documented
+ * `vscode://file/<path>:<line>:<col>` form. Everywhere else the plain `file:`
+ * URI is right, with the location left in the visible text — terminals that
+ * parse a `path:line:col` suffix resolve that on their own.
+ */
+export declare function fileUriForTerminal(filePath: string, opts: {
+    line?: number;
+    col?: number;
+} | undefined, terminalId: TerminalId): string;
+/**
+ * Returns true when OSC 8 hyperlinks should be emitted.
+ *
+ * Respects `tui.hyperlinks` setting:
+ * - `"off"`: never
+ * - `"auto"`: when `process.stdout.isTTY`, `NO_COLOR` is unset, and the detected terminal reports hyperlink support
+ * - `"always"`: unconditionally (useful for viewers that support OSC 8 without advertising it)
+ * Uses the last policy pushed by the host, defaulting to `"auto"`.
+ */
+export declare function isHyperlinkEnabled(): boolean;
+/**
+ * Push the resolved `tui.hyperlinks` policy into {@link TERMINAL}.hyperlinks, the
+ * effective flag that pi-tui renderers gating on it directly — the Markdown
+ * component's `[text](url)`/bare-URL links and the status-line PR link — consult.
+ *
+ * Detection stays immutable in {@link DETECTED_TERMINAL_HYPERLINKS}, so this only
+ * ever writes the effective decision; `auto` transitions restore real detection
+ * via {@link isHyperlinkEnabled}. Called at TUI startup and whenever the setting
+ * changes at runtime.
+ * Accepts the raw (unvalidated) setting value; anything but a known mode falls
+ * back to the last policy pushed by the host.
+ */
+export declare function applyHyperlinkSetting(mode?: unknown): void;
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at `uri`.
+ *
+ * Returns `displayText` unchanged when hyperlinks are disabled, `uri` contains
+ * terminal control bytes, or `displayText` already contains an OSC 8 sequence.
+ */
+export declare function uriHyperlink(uri: string, displayText: string): string;
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at an HTTP(S) URL.
+ * `www.example.com` inputs are linked as `https://www.example.com`.
+ */
+export declare function urlHyperlink(url: string, displayText: string): string;
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at an HTTP(S) URL,
+ * bypassing terminal capability auto-detection. Used for auth prompts where
+ * an inert "click" label blocks login on terminals whose capabilities are
+ * not advertised. Still returns plain text when the host has explicitly opted
+ * out by pushing the `"off"` policy.
+ */
+export declare function urlHyperlinkAlways(url: string, displayText: string): string;
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at a filesystem path.
+ *
+ * Returns `displayText` unchanged when hyperlinks are disabled or when
+ * the text already contains an OSC 8 sequence (prevents double-wrapping).
+ * Relative paths resolve against the current working directory before URI
+ * encoding so the OSC 8 target is always a valid `file://` URL.
+ *
+ * @param filePath - Filesystem path
+ * @param displayText - Text to render as the hyperlink anchor (may contain ANSI codes)
+ * @param opts - Optional line/col position appended as `?line=N&col=M` query params
+ */
+export declare function fileHyperlink(filePath: string, displayText: string, opts?: {
+    line?: number;
+    col?: number;
+}): string;

package/dist/types/render/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Public exports for shared TUI components.
+ */
+export * from "./code-cell.js";
+export * from "./file-list.js";
+export * from "./hyperlink.js";
+export * from "./output-block.js";
+export * from "./output-pane.js";
+export * from "./render-utils.js";
+export * from "./sixel.js";
+export * from "./status-line.js";
+export * from "./tool-card.js";
+export * from "./tree-list.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./width-aware-text.js";

package/dist/types/render/output-block.d.ts

@@ -0,0 +1,54 @@
+import type { Theme, ThemeColor } from "../theme/theme.js";
+import type { Component } from "../tui.js";
+import type { State } from "./types.js";
+/** Sections and presentation options for a bordered output block. */
+export interface OutputBlockOptions {
+    header?: string;
+    headerMeta?: string;
+    state?: State;
+    sections?: Array<{
+        label?: string;
+        lines: readonly string[];
+        separator?: boolean;
+    }>;
+    width: number;
+    applyBg?: boolean;
+    contentPaddingLeft?: number;
+    contentPaddingRight?: number;
+    /** Override the state-derived border color. Used for muted "legacy" tool
+     * frames that should not visually compete with framed-output tools. */
+    borderColor?: ThemeColor;
+}
+declare const FRAMED_BLOCK_COMPONENT: unique symbol;
+/** A component marked as rendering its own output frame. */
+export type FramedBlockComponent = Component & {
+    [FRAMED_BLOCK_COMPONENT]?: true;
+};
+/** Mark a component as owning its output frame. */
+export declare function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent;
+/** Return whether a component owns its output frame. */
+export declare function isFramedBlockComponent(component: Component): boolean;
+/**
+ * Inner content width that {@link renderOutputBlock} wraps its body to, for a
+ * given outer `width`: both vertical borders plus symmetric content padding.
+ * An explicit left padding of zero keeps legacy flush blocks flush on both
+ * sides unless a right padding is provided separately.
+ */
+export declare function outputBlockContentWidth(width: number, contentPaddingLeft?: number, contentPaddingRight?: number): number;
+/** Render a bordered output block with optional header and sections. */
+export declare function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[];
+/**
+ * Cached wrapper around `renderOutputBlock`.
+ *
+ * Since output blocks are re-rendered on every frame (via `render(width)` closures),
+ * but their content rarely changes, this cache avoids redundant `visibleWidth()` and
+ * `padding()` computations on ~99% of render calls.
+ */
+export declare class CachedOutputBlock {
+    #private;
+    /** Render with caching. Returns the cached (shared, caller-immutable) lines if options haven't changed. */
+    render(options: OutputBlockOptions, theme: Theme): readonly string[];
+    /** Invalidate the cache, forcing a rebuild on next render. */
+    invalidate(): void;
+}
+export {};

package/dist/types/render/output-pane.d.ts

@@ -0,0 +1,80 @@
+import type { Theme } from "../theme/theme.js";
+import type { Component } from "../tui.js";
+/** Which side of an output stream remains visible when the pane is capped. */
+export type OutputPaneEdge = "head" | "tail";
+/** Inputs for the shared output capping and styling algorithm. */
+export interface OutputPaneFormatOptions {
+    lines: readonly string[];
+    expanded: boolean;
+    collapsedMaxLines: number;
+    expandedMaxLines?: number;
+    edge?: OutputPaneEdge;
+    /** Apply the cap after terminal-width wrapping instead of to logical rows. */
+    visual?: boolean;
+    /** Content width used by visual capping. Required when `visual` is true. */
+    width?: number;
+    styleLine?: (line: string, index: number) => string;
+    /** Keep sixel payload rows byte-for-byte and show the complete payload. */
+    uncapSixel?: boolean;
+    showHiddenMarker?: boolean;
+    showExpandHint?: boolean;
+    showExpandHintWhenUncapped?: boolean;
+    formatHidden?: (hidden: number, shown: number, total: number, edge: OutputPaneEdge) => string;
+}
+/** Result of formatting one bounded output pane. */
+export interface OutputPaneFormatResult {
+    lines: readonly string[];
+    hiddenCount: number;
+    hasSixel: boolean;
+}
+/**
+ * Split terminal text without allowing carriage-return progress updates to
+ * corrupt following TUI rows. The final segment after a bare CR wins, matching
+ * a terminal cursor-return overwrite.
+ */
+export declare function splitTerminalOutputLines(text: string): string[];
+/**
+ * Style and cap output rows for code cells, tool cards, and live execution
+ * panes. Sixel rows are never styled or split; with `uncapSixel`, the complete
+ * payload is retained so terminal image protocols remain valid.
+ */
+export declare function formatOutputPaneLines(options: OutputPaneFormatOptions, theme: Theme): OutputPaneFormatResult;
+/** Mutable options for a live {@link OutputPane}. */
+export interface OutputPaneOptions extends Omit<OutputPaneFormatOptions, "lines"> {
+    paddingX?: number;
+    leadingBlank?: boolean;
+    maxStoredLines?: number;
+    /** Normalize each logical row before it enters the retained stream. */
+    normalizeLine?: (line: string) => string;
+}
+/**
+ * Stateful, cached output viewport. Streaming callers append chunks while
+ * settled callers may replace all rows. Unchanged renders preserve array
+ * identity through the inner Text cache.
+ */
+export declare class OutputPane implements Component {
+    #private;
+    constructor(theme: Theme, options: OutputPaneOptions, text?: string);
+    /** Replace the complete output snapshot. */
+    setText(text: string): void;
+    /** Replace the complete output snapshot with caller-owned immutable rows. */
+    setLines(lines: readonly string[]): void;
+    /**
+     * Append a streaming chunk. Bare CR overwrites the current logical row;
+     * a CRLF split across chunks remains a newline, so chunked and whole-text
+     * ingestion produce the same settled rows.
+     */
+    append(chunk: string): void;
+    /** Settle a trailing bare carriage return once no later LF can pair with it. */
+    finish(): void;
+    /** Update presentation without replacing streamed content. */
+    configure(options: Partial<OutputPaneOptions>): void;
+    setExpanded(expanded: boolean): void;
+    get lineCount(): number;
+    get hasSixel(): boolean;
+    getText(): string;
+    render(width: number): readonly string[];
+    invalidate(): void;
+}
+/** Default styling for plain tool output while preserving existing ANSI. */
+export declare function styleToolOutputLine(line: string, theme: Theme): string;