@comma-agents/tui 2.0.0-rc.0

package/dist/components/ScrollableView/ScrollableView.types.d.ts

@@ -0,0 +1,113 @@
+import type { DOMElement } from "ink";
+import type React from "react";
+import type { ScrollableViewTheme } from "./ScrollableView.theme";
+/**
+ * Snapshot of {@link ScrollableView}'s scroll state, delivered to
+ * `onScrollChange` whenever the offset, viewport, or content size
+ * changes.
+ */
+export interface ScrollableViewState {
+    /** Current top offset in terminal rows. */
+    readonly rowOffset: number;
+    /** Total content height in rows (sum of all measured row heights). */
+    readonly totalRows: number;
+    /** Measured viewport height in rows. */
+    readonly viewportRows: number;
+    /** True when `rowOffset` is at the largest valid value. */
+    readonly atBottom: boolean;
+}
+/**
+ * Props for {@link ScrollableView}.
+ *
+ * `ScrollableView` is the lower-level scrolling primitive: it lays out a
+ * variable-height list of items inside a measured viewport and clips with
+ * `overflow: hidden`. It has no concept of a selected row — only a scroll
+ * offset and a mouse-wheel handler. Use {@link ScrollableList} when you
+ * need keyboard-driven selection.
+ *
+ * Row heights are measured automatically via Ink's headless layout
+ * (`measureLayout`) keyed by `(getKey(item, index), viewportWidth)`. When
+ * an item's identity changes, the previous height is reused until the new
+ * object is re-measured. Only items inside the visible window plus a small
+ * overscan are mounted in the rendered tree.
+ */
+export interface ScrollableViewProps<ItemType> {
+    /** The items to render. */
+    readonly items: readonly ItemType[];
+    /**
+     * Stable key for each item. Used as the React key for the row and as
+     * the primary cache key for measured heights — keep it stable when the
+     * item's logical identity stays the same and let it change when content
+     * fundamentally changes.
+     */
+    readonly getKey: (item: ItemType, index: number) => string;
+    /**
+     * Renders a single row. The same JSX is invoked twice per
+     * `(item, viewportWidth)` combination: once inside a detached yoga
+     * tree to measure the row's natural height, then once in the live
+     * tree for the visible window. Both invocations happen synchronously
+     * with the same input, so the result must be a pure function of the
+     * arguments. Avoid spawning side effects from `renderItem` itself.
+     */
+    readonly renderItem: (item: ItemType, index: number) => React.ReactNode;
+    /**
+     * When set, the view auto-scrolls so the row at this index is visible
+     * after every layout commit. Use this to implement "follow the selected
+     * row" behavior from a parent component.
+     */
+    readonly scrollToRow?: number;
+    /**
+     * When `true`, the view pins itself to the bottom on every layout
+     * commit — new items push the visible window forward. Disengages
+     * automatically the moment the user scrolls up with the wheel; re-
+     * engages once they scroll back to the bottom edge.
+     */
+    readonly stickToBottom?: boolean;
+    /** Notified whenever scroll state changes. */
+    readonly onScrollChange?: (state: ScrollableViewState) => void;
+    /** Text shown when `items` is empty. Defaults to "No items." */
+    readonly emptyText?: string;
+}
+/**
+ * Props for {@link ScrollableViewRender}.
+ *
+ * Pure render props — all hook-derived values are computed by the
+ * container and passed down.
+ */
+export interface ScrollableViewRenderProps<ItemType> {
+    /** The items to render. */
+    readonly items: readonly ItemType[];
+    /** Stable key for each item. */
+    readonly getKey: (item: ItemType, index: number) => string;
+    /** Renders a single row. */
+    readonly renderItem: (item: ItemType, index: number) => React.ReactNode;
+    /** Total number of items. */
+    readonly totalCount: number;
+    /** Measured viewport height in rows. */
+    readonly viewportHeight: number;
+    /** Total content height in rows. */
+    readonly totalRows: number;
+    /** Current scroll offset in rows. */
+    readonly rowOffset: number;
+    /**
+     * Number of rows clipped off the top of the first rendered item.
+     * Equals `max(0, rowOffset - rowOffsets[renderStart])` — the portion
+     * of `items[renderStart]` that sits above the viewport when the scroll
+     * line lands inside that item's body. The renderer applies this as a
+     * negative `marginTop` on the inner content column so Ink's
+     * `overflow: hidden` clips the leading rows at the viewport top.
+     */
+    readonly topClipRows: number;
+    /** First item index to mount (inclusive). */
+    readonly renderStart: number;
+    /** One past the last item index to mount. */
+    readonly renderEnd: number;
+    /** Whether the scrollbar should be visible. */
+    readonly showScrollbar: boolean;
+    /** Text shown when items is empty. */
+    readonly emptyText: string;
+    /** Spread-ready theme style objects. */
+    readonly theme: ScrollableViewTheme;
+    /** Ref for the viewport box, attached by this render. */
+    readonly viewportRef: React.RefObject<DOMElement>;
+}

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

@@ -0,0 +1,4 @@
+export { ScrollableView, ScrollableViewRender } from "./ScrollableView";
+export type { ScrollableViewTheme } from "./ScrollableView.theme";
+export { useScrollableViewTheme } from "./ScrollableView.theme";
+export type { ScrollableViewProps, ScrollableViewRenderProps, ScrollableViewState, } from "./ScrollableView.types";

package/dist/components/Scrollbar/Scrollbar.d.ts

@@ -0,0 +1,21 @@
+import type React from "react";
+import type { ScrollbarTheme } from "./Scrollbar.theme";
+import type { ScrollbarProps, ScrollbarRenderProps } from "./Scrollbar.types";
+/**
+ * A single-column vertical scrollbar.
+ *
+ * Purely presentational — the caller owns the scroll model and passes in
+ * `total` / `windowSize` / `offset`. When the content fits (`total <=
+ * windowSize`) the thumb fills the track, which is visually indistinguishable
+ * from a "no scrolling possible" state.
+ *
+ * @example
+ * ```tsx
+ * <Scrollbar total={lines.length} windowSize={visibleRows} offset={scrollTop} />
+ * ```
+ */
+export declare function Scrollbar(props: ScrollbarProps): React.ReactElement;
+/** Presentational form of `Scrollbar`; takes resolved geometry and theme. */
+export declare function ScrollbarRender(props: ScrollbarRenderProps & {
+    readonly theme: ScrollbarTheme;
+}): React.ReactElement;

package/dist/components/Scrollbar/Scrollbar.theme.d.ts

@@ -0,0 +1,16 @@
+/** Spread-ready style tokens for the `Scrollbar` component. */
+export interface ScrollbarTheme {
+    /** Thumb foreground color. */
+    readonly thumbColor: string;
+    /** Track foreground color. */
+    readonly trackColor: string;
+    /** Single-character glyph used for the thumb. */
+    readonly thumbChar: string;
+    /** Single-character glyph used for the track. */
+    readonly trackChar: string;
+}
+/**
+ * Returns themed style tokens for `Scrollbar`. Consumes global tokens via
+ * `useTheme()`.
+ */
+export declare function useScrollbarTheme(): ScrollbarTheme;

package/dist/components/Scrollbar/Scrollbar.types.d.ts

@@ -0,0 +1,27 @@
+/** Props for the `Scrollbar` presentational component. */
+export interface ScrollbarProps {
+    /** Total number of scrollable units (e.g. lines or list items). */
+    readonly total: number;
+    /** Number of units currently visible. */
+    readonly windowSize: number;
+    /** Zero-based offset of the first visible unit into `total`. */
+    readonly offset: number;
+    /**
+     * Height of the rendered scrollbar, in terminal rows. Defaults to
+     * `windowSize` (one scrollbar row per visible unit).
+     */
+    readonly height?: number;
+}
+/** Props for the `ScrollbarRender` render-only form. */
+export interface ScrollbarRenderProps {
+    /** Scrollbar column height, in rows. */
+    readonly height: number;
+    /**
+     * Inclusive top index of the thumb within `[0, height)`. When the
+     * scrollbar is inactive (content fits), this is `0` and
+     * `thumbHeight === height` (i.e. the thumb fills the whole track).
+     */
+    readonly thumbTop: number;
+    /** Thumb height in rows. Always `>= 1` when `height >= 1`. */
+    readonly thumbHeight: number;
+}

package/dist/components/Scrollbar/Scrollbar.utils.d.ts

@@ -0,0 +1,21 @@
+import type { ScrollbarRenderProps } from "./Scrollbar.types";
+/**
+ * Compute the thumb position and size for a vertical scrollbar.
+ *
+ * - When `total <= windowSize` (content fits), the thumb fills the full
+ *   track — callers can use this to render a "neutral" scrollbar or hide it
+ *   entirely at their discretion.
+ * - Thumb height scales proportionally with the visible fraction but is
+ *   always at least 1 row.
+ * - Thumb top is distributed linearly across the non-thumb slack.
+ *
+ * Invariants:
+ *   - `0 <= thumbTop <= height - thumbHeight`
+ *   - `1 <= thumbHeight <= height`
+ */
+export declare function computeScrollbarGeometry(params: {
+    readonly total: number;
+    readonly windowSize: number;
+    readonly offset: number;
+    readonly height: number;
+}): ScrollbarRenderProps;

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

@@ -0,0 +1,4 @@
+export { Scrollbar, ScrollbarRender } from "./Scrollbar";
+export type { ScrollbarTheme } from "./Scrollbar.theme";
+export { useScrollbarTheme } from "./Scrollbar.theme";
+export type { ScrollbarProps, ScrollbarRenderProps } from "./Scrollbar.types";

package/dist/components/SearchInput/SearchInput.d.ts

@@ -0,0 +1,22 @@
+import type React from "react";
+import type { SearchInputTheme } from "./SearchInput.theme";
+import type { SearchInputProps, SearchInputRenderProps } from "./SearchInput.types";
+/**
+ * Single-line controlled search input with a rounded border, prompt caret,
+ * and placeholder.
+ *
+ * Typing appends characters; Backspace/Delete removes the last character.
+ * Navigation keys (arrows, Enter, Escape) are intentionally not handled so
+ * the parent can own list navigation and dismissal.
+ *
+ * @example
+ * ```tsx
+ * const [query, setQuery] = useState("");
+ * <SearchInput value={query} onChange={setQuery} placeholder="Search..." />
+ * ```
+ */
+export declare function SearchInput({ id, value, onChange, placeholder, prompt, }: SearchInputProps): React.ReactElement;
+/** Presentational form of `SearchInput`; takes resolved props + theme. */
+export declare function SearchInputRender(props: SearchInputRenderProps & {
+    readonly theme: SearchInputTheme;
+}): React.ReactElement;

package/dist/components/SearchInput/SearchInput.theme.d.ts

@@ -0,0 +1,30 @@
+import type { BoxProps } from "ink";
+/** Spread-ready style objects for the SearchInput component. */
+export interface SearchInputTheme {
+    /** Rounded-border wrapper around the single-line input. */
+    readonly inputBorder: {
+        readonly borderStyle: BoxProps["borderStyle"];
+        readonly borderColor: string;
+        readonly paddingX: number;
+        readonly width: string;
+    };
+    /** Text style for the prompt caret. */
+    readonly prompt: {
+        readonly color: string;
+        readonly bold: boolean;
+    };
+    /** Text style for the user-entered query. */
+    readonly query: {
+        readonly color: string;
+    };
+    /** Text style for the placeholder shown when the query is empty. */
+    readonly placeholder: {
+        readonly color: string;
+        readonly dimColor: boolean;
+    };
+}
+/**
+ * Returns themed style objects for the SearchInput component.
+ * Consumes global tokens via `useTheme()`.
+ */
+export declare function useSearchInputTheme(): SearchInputTheme;

package/dist/components/SearchInput/SearchInput.types.d.ts

@@ -0,0 +1,25 @@
+/** Props for the `SearchInput` container component. */
+export interface SearchInputProps {
+    /** Current query string (controlled). */
+    readonly value: string;
+    /** Called with the new query whenever it changes. */
+    readonly onChange: (next: string) => void;
+    /** Placeholder shown when `value` is empty. */
+    readonly placeholder?: string;
+    /** Prompt character rendered at the start of the input. Defaults to `› `. */
+    readonly prompt?: string;
+    /**
+     * Stable focus ID for programmatic focusing via `useFocusManager().focus(id)`.
+     * When omitted the component still participates in tab-order cycling.
+     */
+    readonly id?: string;
+}
+/** Props for the `SearchInputRender` presentational component. */
+export interface SearchInputRenderProps {
+    /** Current query value. */
+    readonly value: string;
+    /** Placeholder text for when the query is empty. */
+    readonly placeholder: string;
+    /** Prompt character(s) shown before the query. */
+    readonly prompt: string;
+}

package/dist/components/SearchInput/SearchInput.utils.d.ts

@@ -0,0 +1,22 @@
+/** TODO: Why does it cost so much slop just to search for a string??? tf */
+/**
+ * Split a query into whitespace-separated tokens (lowercased, trimmed).
+ * Returns an empty array when the query is empty or whitespace-only.
+ */
+export declare function tokenizeQuery(query: string): readonly string[];
+/**
+ * Token-match predicate: returns `true` when every token in `query` appears
+ * (case-insensitively) somewhere in `haystack`.
+ *
+ * Cheap, non-ranked, "every token must be found" semantics — appropriate
+ * for small in-memory lists where a linear scan is fast enough to feel
+ * instant and ranked matching adds no practical value.
+ */
+export declare function matchesQuery(haystack: string, query: string): boolean;
+/**
+ * Filter a list of items by a query, where each item projects to a searchable
+ * haystack string via `getHaystack`. The filter is stable — it preserves the
+ * original order of the matching items.
+ */
+export declare function filterByQuery<ItemType>(items: readonly ItemType[], query: string, getHaystack: (item: ItemType) => string): readonly ItemType[];
+export { isMouseEscape } from "../../utils/mouseEscape";

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

@@ -0,0 +1,5 @@
+export { SearchInput, SearchInputRender } from "./SearchInput";
+export type { SearchInputTheme } from "./SearchInput.theme";
+export { useSearchInputTheme } from "./SearchInput.theme";
+export type { SearchInputProps, SearchInputRenderProps, } from "./SearchInput.types";
+export { filterByQuery, isMouseEscape, } from "./SearchInput.utils";

package/dist/components/Separator/Separator.d.ts

@@ -0,0 +1,39 @@
+import type React from "react";
+import type { SeparatorTheme } from "./Separator.theme";
+export interface SeparatorProps {
+    /**
+     * Width of the separator line.
+     *
+     * - `"full"` (default): spans the available width of the parent flex
+     *   container. Implemented via Yoga's flex layout + text truncation —
+     *   no measurement, no resize listeners, no first-frame flash.
+     * - `number`: a fixed number of characters, useful for callouts or
+     *   visual rhythm where a uniform width across terminals is desired.
+     */
+    readonly width?: "full" | number;
+}
+/**
+ * Horizontal separator line.
+ *
+ * Defaults to filling the available width of its parent flex container.
+ * Pass a numeric `width` for a fixed-length separator.
+ *
+ * @example
+ * ```tsx
+ * // Fills parent's available width:
+ * <Separator />
+ * // Fixed 40-character separator:
+ * <Separator width={40} />
+ * ```
+ */
+export declare function Separator({ width, }: SeparatorProps): React.ReactElement;
+export interface SeparatorRenderProps {
+    /** Resolved separator theme. */
+    readonly theme: SeparatorTheme;
+    /**
+     * Width mode: `"full"` grows to fill the parent via flex+truncate,
+     * a `number` renders a fixed-length line.
+     */
+    readonly width?: "full" | number;
+}
+export declare function SeparatorRender({ theme, width, }: SeparatorRenderProps): React.ReactElement;

package/dist/components/Separator/Separator.theme.d.ts

@@ -0,0 +1,22 @@
+import { type ThemeOf } from "../../Theme";
+/** Memoized themed style objects for the `Separator` component. */
+export declare const useSeparatorTheme: () => {
+    /** Outer container holding the separator line. */
+    container: {
+        flexDirection: "row";
+        flexGrow: number;
+        flexShrink: number;
+        alignSelf: "stretch";
+        paddingX: number;
+    };
+    /** Text props for the separator character itself. */
+    text: {
+        dimColor: boolean;
+    };
+    /** Single character repeated to draw the line. */
+    char: string;
+    /** Default fixed-length width when no explicit width is provided and full mode is off. */
+    defaultFixedWidth: number;
+};
+/** Resolved style object shape returned by {@link useSeparatorTheme}. */
+export type SeparatorTheme = ThemeOf<typeof useSeparatorTheme>;

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

@@ -0,0 +1,4 @@
+export type { SeparatorProps, SeparatorRenderProps } from "./Separator";
+export { Separator, SeparatorRender } from "./Separator";
+export type { SeparatorTheme } from "./Separator.theme";
+export { useSeparatorTheme } from "./Separator.theme";

package/dist/components/StatusBar/StatusBar.d.ts

@@ -0,0 +1,4 @@
+import type { StatusBarProps, StatusBarRenderProps } from "./StatusBar.types";
+/** Compact status bar displayed at the bottom of the chat. */
+export declare function StatusBar({ status, error, strategyName, }: StatusBarProps): React.ReactElement;
+export declare function StatusBarRender({ status, error, strategyName, theme, debugRef, }: StatusBarRenderProps): React.ReactElement;

package/dist/components/StatusBar/StatusBar.theme.d.ts

@@ -0,0 +1,35 @@
+import type { ChatStatus } from "../../hooks/useChat/useChat.types";
+/** Display info for a single status value. */
+export interface StatusInfo {
+    readonly label: string;
+    readonly color: string;
+    readonly spinning: boolean;
+}
+/** Spread-ready style objects for the StatusBar component. */
+export interface StatusBarTheme {
+    /** Outer container. */
+    readonly container: {
+        readonly paddingX: number;
+        readonly flexDirection: "row";
+        readonly gap: number;
+    };
+    /** Status label text (bold). */
+    readonly statusLabel: {
+        readonly bold: boolean;
+    };
+    /** Strategy name text (dim). */
+    readonly strategyName: {
+        readonly dimColor: boolean;
+    };
+    /** Error text. */
+    readonly errorText: {
+        readonly color: string;
+    };
+    /** Mapping of chat statuses to display info (label, color, spinner). */
+    readonly statusMap: Record<ChatStatus, StatusInfo>;
+}
+/**
+ * Returns themed style objects for the StatusBar component.
+ * Consumes global tokens via `useTheme()`.
+ */
+export declare function useStatusBarTheme(): StatusBarTheme;

package/dist/components/StatusBar/StatusBar.types.d.ts

@@ -0,0 +1,24 @@
+import type { RefObject } from "react";
+import type { ChatStatus } from "../../hooks/useChat/useChat.types";
+import type { StatusBarTheme } from "./StatusBar.theme";
+/**
+ * Props for {@link StatusBar}.
+ */
+export interface StatusBarProps {
+    readonly status: ChatStatus;
+    readonly error: string | null;
+    readonly strategyName?: string;
+}
+/**
+ * Props for {@link StatusBarRender}.
+ *
+ * Pure render props — all hook-derived values are computed by the
+ * container and passed down.
+ */
+export interface StatusBarRenderProps {
+    readonly status: ChatStatus;
+    readonly error: string | null;
+    readonly strategyName?: string;
+    readonly theme: StatusBarTheme;
+    readonly debugRef: RefObject<unknown>;
+}

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

@@ -0,0 +1,2 @@
+export { StatusBar, StatusBarRender } from "./StatusBar";
+export type { StatusBarProps, StatusBarRenderProps } from "./StatusBar.types";

package/dist/components/TextAreaInput/TextAreaInput.d.ts

@@ -0,0 +1,68 @@
+import { type DOMElement } from "ink";
+import type React from "react";
+import { type CursorCell } from "./TextAreaInput.utils";
+export interface TextAreaInputProps {
+    /** Current text value (controlled). */
+    readonly value: string;
+    /** Called when the text value changes. */
+    readonly onChange: (value: string) => void;
+    /** Width — columns (number) or CSS-like string (e.g. "100%"). */
+    readonly width?: number | string;
+    /** Fixed visible row count. When set, disables auto-expanding. */
+    readonly height?: number;
+    /** Minimum visible rows when auto-expanding (default: 3). */
+    readonly minHeight?: number;
+    /** Maximum visible rows when auto-expanding (default: 5). */
+    readonly maxHeight?: number;
+    /** Placeholder shown when value is empty. */
+    readonly placeholder?: string;
+    /**
+     * Stable focus ID for programmatic focusing via `useFocusManager().focus(id)`.
+     * When omitted the component still participates in tab-order cycling.
+     */
+    readonly id?: string;
+    /** Called on Enter with the current value. Ctrl/Shift/Meta+Enter inserts a newline. */
+    readonly onSubmit?: (value: string) => void;
+}
+/**
+ * Multi-line text area input with an inline rendered cursor (a gray
+ * background on the character at `cursorIndex`). Controlled — parent owns
+ * `value`/`onChange`.
+ *
+ * The cursor's source of truth is `cursorIndex` (an offset into the
+ * normalized raw value). The wrapped display cell + scroll offset are
+ * derived from it each render via {@link computeNextCursorState}.
+ *
+ * Keybindings:
+ * - Enter                 → calls `onSubmit(value.trim())` if provided
+ * - Ctrl/Shift/Meta+Enter → inserts a newline at the cursor
+ * - Arrow keys            → move cursor (preserves column on up/down)
+ * - Backspace/Delete      → delete the character before the cursor
+ */
+export declare function TextAreaInput({ value, onChange, width, height, minHeight, maxHeight, placeholder, id, onSubmit, }: TextAreaInputProps): import("react/jsx-runtime").JSX.Element;
+export interface TextAreaInputRenderProps {
+    /** Ref forwarded to the outer Box for layout metrics + mouse wheel. */
+    readonly boxRef: React.RefObject<DOMElement>;
+    /** Width passed through to the outer Box. */
+    readonly width: number | string;
+    /** Visible row count. */
+    readonly height: number;
+    /** Pre-wrapped display rows. */
+    readonly rows: readonly string[];
+    /** Index of the first visible row. */
+    readonly rowDisplayOffset: number;
+    /** Cell of the cursor on the wrapped grid (absolute, not viewport-relative). */
+    readonly cursorCell: CursorCell;
+    /** Whether to render the cursor highlight. */
+    readonly showCursor: boolean;
+    /** Content width in columns (excludes scrollbar column when shown). */
+    readonly textAreaColumns: number;
+    /** Whether to render the scrollbar column. */
+    readonly showScrollbar: boolean;
+    /** Whether to render placeholder text in place of `rows`. */
+    readonly showPlaceholder: boolean;
+    /** Placeholder string. */
+    readonly placeholder: string;
+}
+/** Pure presentational form of {@link TextAreaInput}. */
+export declare function TextAreaInputRender({ boxRef, width, height, rows, rowDisplayOffset, cursorCell, showCursor, textAreaColumns, showScrollbar, showPlaceholder, placeholder, }: TextAreaInputRenderProps): React.ReactElement;

package/dist/components/TextAreaInput/TextAreaInput.theme.d.ts

@@ -0,0 +1,14 @@
+export declare const useTextAreaInputTheme: () => {
+    textAreaInput: {
+        backgroundColor: string;
+        flexDirection: "row";
+    };
+    textAreaInputContent: {
+        flexDirection: "column";
+        flexGrow: number;
+    };
+    textAreaPlaceholder: {
+        color: string;
+        wrap: "truncate";
+    };
+};

package/dist/components/TextAreaInput/TextAreaInput.utils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Cursor + scroll math for {@link TextAreaInput}.
+ *
+ * The single source of truth for the cursor is `cursorIndex` — an offset
+ * into the *normalized* (CRLF → LF) raw `value`. The wrapped display grid
+ * is a derived view; we map between the two with {@link buildIndexCellMap}.
+ *
+ * Movement intents (`left`, `right`, `up`, `down`) operate on the wrapped
+ * grid for natural visual navigation, then translate back to a raw index.
+ * `snapToCursor` keeps the index put and just (re)derives the cell + scroll
+ * offset — used after an edit changes `value` and/or `cursorIndex`.
+ */
+export type CursorIntent = {
+    readonly kind: "left";
+} | {
+    readonly kind: "right";
+} | {
+    readonly kind: "up";
+} | {
+    readonly kind: "down";
+} | {
+    readonly kind: "snapToCursor";
+};
+export interface CursorCell {
+    readonly x: number;
+    readonly y: number;
+}
+export interface CursorState {
+    readonly cursorIndex: number;
+    readonly cell: CursorCell;
+    readonly rowDisplayOffset: number;
+}
+export interface ComputeNextCursorStateParams {
+    readonly intent: CursorIntent;
+    /** Normalized raw text (LF only). */
+    readonly value: string;
+    /** Wrapped display rows derived from `value`. */
+    readonly rows: readonly string[];
+    /** Cursor offset into `value` before this update. */
+    readonly currentCursorIndex: number;
+    /** Scroll offset before this update. */
+    readonly currentRowDisplayOffset: number;
+    /** Visible row count of the textarea. */
+    readonly viewportHeight: number;
+    /**
+     * Width measurement function. Inject `stringWidth` at the call site;
+     * tests can pass `(text) => text.length` for ASCII fixtures.
+     */
+    readonly measureWidth: (text: string) => number;
+}
+/**
+ * Pure transition function for the textarea cursor index, derived cell, and
+ * scroll offset. Fully clamped to `value` / `rows` / viewport so callers can
+ * apply all three pieces of state on the same render tick.
+ */
+export declare function computeNextCursorState(params: ComputeNextCursorStateParams): CursorState;
+/**
+ * Map every raw-string index (0..value.length inclusive) to a cell on the
+ * wrapped grid.
+ *
+ * Strategy: walk `value` and the concatenation of `rows` in lockstep. When
+ * the next raw char matches the next wrapped char, advance both. When the
+ * wrapped grid moves to a new row that doesn't correspond to a `\n` in
+ * `value` (a soft wrap), absorb the row break without consuming a raw char.
+ * When `word-wrap` drops a space at a soft-wrap boundary, consume the raw
+ * space without advancing the cell. The trailing entry maps `value.length`
+ * to the cell *after* the last character.
+ */
+export declare function buildIndexCellMap(value: string, rows: readonly string[], measureWidth: (text: string) => number): readonly CursorCell[];

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

@@ -0,0 +1,2 @@
+export type { TextAreaInputProps, TextAreaInputRenderProps, } from "./TextAreaInput";
+export { TextAreaInput, TextAreaInputRender } from "./TextAreaInput";

package/dist/components/TitleIcon/TitleIcon.d.ts

@@ -0,0 +1,13 @@
+export interface TitleIconProps {
+    /** Whether the animation is playing. Defaults to `true`. */
+    readonly playing?: boolean;
+}
+/**
+ * Animated ASCII art title icon.
+ *
+ * The animation runs inside a `<DynamicContent>` boundary so frame ticks
+ * (16fps) repaint only a reserved region of the screen rather than the
+ * whole app. This eliminates the flicker that the title would otherwise
+ * induce in surrounding components on every tick.
+ */
+export declare function TitleIcon({ playing }: TitleIconProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/TitleIcon/TitleIcon.theme.d.ts

@@ -0,0 +1,19 @@
+/** Spread-ready style objects for the TitleIcon component. */
+export interface TitleIconTheme {
+    /** Outer container wrapping the ASCII art. */
+    readonly container: {
+        readonly flexDirection: "column";
+        readonly alignItems: "center";
+        readonly paddingY: number;
+    };
+    /** Each line of the ASCII frame. */
+    readonly frameLine: {
+        readonly color: string;
+        readonly dimColor: boolean;
+    };
+}
+/**
+ * Returns themed style objects for the TitleIcon component.
+ * Consumes global tokens via `useTheme()`.
+ */
+export declare function useTitleIconTheme(): TitleIconTheme;