@cjhyy/code-shell 0.1.0-alpha.0

package/dist/ink/termio/csi.d.ts

@@ -0,0 +1,165 @@
+/**
+ * CSI (Control Sequence Introducer) Types
+ *
+ * Enums and types for CSI command parameters.
+ */
+export declare const CSI_PREFIX: string;
+/**
+ * CSI parameter byte ranges
+ */
+export declare const CSI_RANGE: {
+    readonly PARAM_START: 48;
+    readonly PARAM_END: 63;
+    readonly INTERMEDIATE_START: 32;
+    readonly INTERMEDIATE_END: 47;
+    readonly FINAL_START: 64;
+    readonly FINAL_END: 126;
+};
+/** Check if a byte is a CSI parameter byte */
+export declare function isCSIParam(byte: number): boolean;
+/** Check if a byte is a CSI intermediate byte */
+export declare function isCSIIntermediate(byte: number): boolean;
+/** Check if a byte is a CSI final byte (@ through ~) */
+export declare function isCSIFinal(byte: number): boolean;
+/**
+ * Generate a CSI sequence: ESC [ p1;p2;...;pN final
+ * Single arg: treated as raw body
+ * Multiple args: last is final byte, rest are params joined by ;
+ */
+export declare function csi(...args: (string | number)[]): string;
+/**
+ * CSI final bytes - the command identifier
+ */
+export declare const CSI: {
+    readonly CUU: 65;
+    readonly CUD: 66;
+    readonly CUF: 67;
+    readonly CUB: 68;
+    readonly CNL: 69;
+    readonly CPL: 70;
+    readonly CHA: 71;
+    readonly CUP: 72;
+    readonly CHT: 73;
+    readonly VPA: 100;
+    readonly HVP: 102;
+    readonly ED: 74;
+    readonly EL: 75;
+    readonly ECH: 88;
+    readonly IL: 76;
+    readonly DL: 77;
+    readonly ICH: 64;
+    readonly DCH: 80;
+    readonly SU: 83;
+    readonly SD: 84;
+    readonly SM: 104;
+    readonly RM: 108;
+    readonly SGR: 109;
+    readonly DSR: 110;
+    readonly DECSCUSR: 113;
+    readonly DECSTBM: 114;
+    readonly SCOSC: 115;
+    readonly SCORC: 117;
+    readonly CBT: 90;
+};
+/**
+ * Erase in Display regions (ED command parameter)
+ */
+export declare const ERASE_DISPLAY: readonly ["toEnd", "toStart", "all", "scrollback"];
+/**
+ * Erase in Line regions (EL command parameter)
+ */
+export declare const ERASE_LINE_REGION: readonly ["toEnd", "toStart", "all"];
+/**
+ * Cursor styles (DECSCUSR)
+ */
+export type CursorStyle = 'block' | 'underline' | 'bar';
+export declare const CURSOR_STYLES: Array<{
+    style: CursorStyle;
+    blinking: boolean;
+}>;
+/** Move cursor up n lines (CSI n A) */
+export declare function cursorUp(n?: number): string;
+/** Move cursor down n lines (CSI n B) */
+export declare function cursorDown(n?: number): string;
+/** Move cursor forward n columns (CSI n C) */
+export declare function cursorForward(n?: number): string;
+/** Move cursor back n columns (CSI n D) */
+export declare function cursorBack(n?: number): string;
+/** Move cursor to column n (1-indexed) (CSI n G) */
+export declare function cursorTo(col: number): string;
+/** Move cursor to column 1 (CSI G) */
+export declare const CURSOR_LEFT: string;
+/** Move cursor to row, col (1-indexed) (CSI row ; col H) */
+export declare function cursorPosition(row: number, col: number): string;
+/** Move cursor to home position (CSI H) */
+export declare const CURSOR_HOME: string;
+/**
+ * Move cursor relative to current position
+ * Positive x = right, negative x = left
+ * Positive y = down, negative y = up
+ */
+export declare function cursorMove(x: number, y: number): string;
+/** Save cursor position (CSI s) */
+export declare const CURSOR_SAVE: string;
+/** Restore cursor position (CSI u) */
+export declare const CURSOR_RESTORE: string;
+/** Erase from cursor to end of line (CSI K) */
+export declare function eraseToEndOfLine(): string;
+/** Erase from cursor to start of line (CSI 1 K) */
+export declare function eraseToStartOfLine(): string;
+/** Erase entire line (CSI 2 K) */
+export declare function eraseLine(): string;
+/** Erase entire line - constant form */
+export declare const ERASE_LINE: string;
+/** Erase from cursor to end of screen (CSI J) */
+export declare function eraseToEndOfScreen(): string;
+/** Erase from cursor to start of screen (CSI 1 J) */
+export declare function eraseToStartOfScreen(): string;
+/** Erase entire screen (CSI 2 J) */
+export declare function eraseScreen(): string;
+/** Erase entire screen - constant form */
+export declare const ERASE_SCREEN: string;
+/** Erase scrollback buffer (CSI 3 J) */
+export declare const ERASE_SCROLLBACK: string;
+/**
+ * Erase n lines starting from cursor line, moving cursor up
+ * This erases each line and moves up, ending at column 1
+ */
+export declare function eraseLines(n: number): string;
+/** Scroll up n lines (CSI n S) */
+export declare function scrollUp(n?: number): string;
+/** Scroll down n lines (CSI n T) */
+export declare function scrollDown(n?: number): string;
+/** Set scroll region (DECSTBM, CSI top;bottom r). 1-indexed, inclusive. */
+export declare function setScrollRegion(top: number, bottom: number): string;
+/** Reset scroll region to full screen (DECSTBM, CSI r). Homes the cursor. */
+export declare const RESET_SCROLL_REGION: string;
+/** Sent by terminal before pasted content (CSI 200 ~) */
+export declare const PASTE_START: string;
+/** Sent by terminal after pasted content (CSI 201 ~) */
+export declare const PASTE_END: string;
+/** Sent by terminal when it gains focus (CSI I) */
+export declare const FOCUS_IN: string;
+/** Sent by terminal when it loses focus (CSI O) */
+export declare const FOCUS_OUT: string;
+/**
+ * Enable Kitty keyboard protocol with basic modifier reporting
+ * CSI > 1 u - pushes mode with flags=1 (disambiguate escape codes)
+ * This makes Shift+Enter send CSI 13;2 u instead of just CR
+ */
+export declare const ENABLE_KITTY_KEYBOARD: string;
+/**
+ * Disable Kitty keyboard protocol
+ * CSI < u - pops the keyboard mode stack
+ */
+export declare const DISABLE_KITTY_KEYBOARD: string;
+/**
+ * Enable xterm modifyOtherKeys level 2.
+ * tmux accepts this (not the kitty stack) to enable extended keys — when
+ * extended-keys-format is csi-u, tmux then emits keys in kitty format.
+ */
+export declare const ENABLE_MODIFY_OTHER_KEYS: string;
+/**
+ * Disable xterm modifyOtherKeys (reset to default).
+ */
+export declare const DISABLE_MODIFY_OTHER_KEYS: string;

package/dist/ink/termio/dec.d.ts

@@ -0,0 +1,37 @@
+/**
+ * DEC (Digital Equipment Corporation) Private Mode Sequences
+ *
+ * DEC private modes use CSI ? N h (set) and CSI ? N l (reset) format.
+ * These are terminal-specific extensions to the ANSI standard.
+ */
+/**
+ * DEC private mode numbers
+ */
+export declare const DEC: {
+    readonly CURSOR_VISIBLE: 25;
+    readonly ALT_SCREEN: 47;
+    readonly ALT_SCREEN_CLEAR: 1049;
+    readonly MOUSE_NORMAL: 1000;
+    readonly MOUSE_BUTTON: 1002;
+    readonly MOUSE_ANY: 1003;
+    readonly MOUSE_SGR: 1006;
+    readonly FOCUS_EVENTS: 1004;
+    readonly BRACKETED_PASTE: 2004;
+    readonly SYNCHRONIZED_UPDATE: 2026;
+};
+/** Generate CSI ? N h sequence (set mode) */
+export declare function decset(mode: number): string;
+/** Generate CSI ? N l sequence (reset mode) */
+export declare function decreset(mode: number): string;
+export declare const BSU: string;
+export declare const ESU: string;
+export declare const EBP: string;
+export declare const DBP: string;
+export declare const EFE: string;
+export declare const DFE: string;
+export declare const SHOW_CURSOR: string;
+export declare const HIDE_CURSOR: string;
+export declare const ENTER_ALT_SCREEN: string;
+export declare const EXIT_ALT_SCREEN: string;
+export declare const ENABLE_MOUSE_TRACKING: string;
+export declare const DISABLE_MOUSE_TRACKING: string;

package/dist/ink/termio/esc.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ESC Sequence Parser
+ *
+ * Handles simple escape sequences: ESC + one or two characters
+ */
+import type { Action } from './types.js';
+/**
+ * Parse a simple ESC sequence
+ *
+ * @param chars - Characters after ESC (not including ESC itself)
+ */
+export declare function parseEsc(chars: string): Action | null;

package/dist/ink/termio/osc.d.ts

@@ -0,0 +1,173 @@
+/**
+ * OSC (Operating System Command) Types and Parser
+ */
+import type { Action, Color, TabStatusAction } from './types.js';
+export declare const OSC_PREFIX: string;
+/** String Terminator (ESC \) - alternative to BEL for terminating OSC */
+export declare const ST: string;
+/** Generate an OSC sequence: ESC ] p1;p2;...;pN <terminator>
+ * Uses ST terminator for Kitty (avoids beeps), BEL for others */
+export declare function osc(...parts: (string | number)[]): string;
+/**
+ * Wrap an escape sequence for terminal multiplexer passthrough.
+ * tmux and GNU screen intercept escape sequences; DCS passthrough
+ * tunnels them to the outer terminal unmodified.
+ *
+ * tmux 3.3+ gates this behind `allow-passthrough` (default off). When off,
+ * tmux silently drops the whole DCS — no junk, no worse than unwrapped OSC.
+ * Users who want passthrough set it in their .tmux.conf; we don't mutate it.
+ *
+ * Do NOT wrap BEL: raw \x07 triggers tmux's bell-action (window flag);
+ * wrapped \x07 is opaque DCS payload and tmux never sees the bell.
+ */
+export declare function wrapForMultiplexer(sequence: string): string;
+/**
+ * Which path setClipboard() will take, based on env state. Synchronous so
+ * callers can show an honest toast without awaiting the copy itself.
+ *
+ * - 'native': pbcopy (or equivalent) will run — high-confidence system
+ *   clipboard write. tmux buffer may also be loaded as a bonus.
+ * - 'tmux-buffer': tmux load-buffer will run, but no native tool — paste
+ *   with prefix+] works. System clipboard depends on tmux's set-clipboard
+ *   option + outer terminal OSC 52 support; can't know from here.
+ * - 'osc52': only the raw OSC 52 sequence will be written to stdout.
+ *   Best-effort; iTerm2 disables OSC 52 by default.
+ *
+ * pbcopy gating uses SSH_CONNECTION specifically, not SSH_TTY — tmux panes
+ * inherit SSH_TTY forever even after local reattach, but SSH_CONNECTION is
+ * in tmux's default update-environment set and gets cleared.
+ */
+export type ClipboardPath = 'native' | 'tmux-buffer' | 'osc52';
+export declare function getClipboardPath(): ClipboardPath;
+/**
+ * Load text into tmux's paste buffer via `tmux load-buffer`.
+ * -w (tmux 3.2+) propagates to the outer terminal's clipboard via tmux's
+ * own OSC 52 emission. -w is dropped for iTerm2: tmux's OSC 52 emission
+ * crashes the iTerm2 session over SSH.
+ *
+ * Returns true if the buffer was loaded successfully.
+ */
+export declare function tmuxLoadBuffer(text: string): Promise<boolean>;
+/**
+ * OSC 52 clipboard write: ESC ] 52 ; c ; <base64> BEL/ST
+ * 'c' selects the clipboard (vs 'p' for primary selection on X11).
+ *
+ * When inside tmux ($TMUX set), `tmux load-buffer -w -` is the primary
+ * path. tmux's buffer is always reachable — works over SSH, survives
+ * detach/reattach, immune to stale env vars. The -w flag (tmux 3.2+) tells
+ * tmux to also propagate to the outer terminal via its own OSC 52 path,
+ * which tmux wraps correctly for the attached client. On older tmux, -w is
+ * ignored and the buffer is still loaded. -w is dropped for iTerm2 (#22432)
+ * because tmux's own OSC 52 emission (empty selection param: ESC]52;;b64)
+ * crashes iTerm2 over SSH.
+ *
+ * After load-buffer succeeds, we ALSO return a DCS-passthrough-wrapped
+ * OSC 52 for the caller to write to stdout. Our sequence uses explicit `c`
+ * (not tmux's crashy empty-param variant), so it sidesteps the #22432 path.
+ * With `allow-passthrough on` + an OSC-52-capable outer terminal, selection
+ * reaches the system clipboard; with either off, tmux silently drops the
+ * DCS and prefix+] still works. See Greg Smith's "free pony" in
+ * https://anthropic.slack.com/archives/C07VBSHV7EV/p1773177228548119.
+ *
+ * If load-buffer fails entirely, fall through to raw OSC 52.
+ *
+ * Outside tmux, write raw OSC 52 to stdout (caller handles the write).
+ *
+ * Local (no SSH_CONNECTION): also shell out to a native clipboard utility.
+ * OSC 52 and tmux -w both depend on terminal settings — iTerm2 disables
+ * OSC 52 by default, VS Code shows a permission prompt on first use. Native
+ * utilities (pbcopy/wl-copy/xclip/xsel/clip.exe) always work locally. Over
+ * SSH these would write to the remote clipboard — OSC 52 is the right path there.
+ *
+ * Returns the sequence for the caller to write to stdout (raw OSC 52
+ * outside tmux, DCS-wrapped inside).
+ */
+export declare function setClipboard(text: string): Promise<string>;
+/** @internal test-only */
+export declare function _resetLinuxCopyCache(): void;
+/**
+ * OSC command numbers
+ */
+export declare const OSC: {
+    readonly SET_TITLE_AND_ICON: 0;
+    readonly SET_ICON: 1;
+    readonly SET_TITLE: 2;
+    readonly SET_COLOR: 4;
+    readonly SET_CWD: 7;
+    readonly HYPERLINK: 8;
+    readonly ITERM2: 9;
+    readonly SET_FG_COLOR: 10;
+    readonly SET_BG_COLOR: 11;
+    readonly SET_CURSOR_COLOR: 12;
+    readonly CLIPBOARD: 52;
+    readonly KITTY: 99;
+    readonly RESET_COLOR: 104;
+    readonly RESET_FG_COLOR: 110;
+    readonly RESET_BG_COLOR: 111;
+    readonly RESET_CURSOR_COLOR: 112;
+    readonly SEMANTIC_PROMPT: 133;
+    readonly GHOSTTY: 777;
+    readonly TAB_STATUS: 21337;
+};
+/**
+ * Parse an OSC sequence into an action
+ *
+ * @param content - The sequence content (without ESC ] and terminator)
+ */
+export declare function parseOSC(content: string): Action | null;
+/**
+ * Parse an XParseColor-style color spec into an RGB Color.
+ * Accepts `#RRGGBB` and `rgb:R/G/B` (1–4 hex digits per component, scaled
+ * to 8-bit). Returns null on parse failure.
+ */
+export declare function parseOscColor(spec: string): Color | null;
+/** Start a hyperlink (OSC 8). Auto-assigns an id= param derived from the URL
+ *  so terminals group wrapped lines of the same link together (the spec says
+ *  cells with matching URI *and* nonempty id are joined; without an id each
+ *  wrapped line is a separate link — inconsistent hover, partial tooltips).
+ *  Empty url = close sequence (empty params per spec). */
+export declare function link(url: string, params?: Record<string, string>): string;
+/** End a hyperlink (OSC 8) */
+export declare const LINK_END: string;
+/** iTerm2 OSC 9 subcommand numbers */
+export declare const ITERM2: {
+    readonly NOTIFY: 0;
+    readonly BADGE: 2;
+    readonly PROGRESS: 4;
+};
+/** Progress operation codes (for use with ITERM2.PROGRESS) */
+export declare const PROGRESS: {
+    readonly CLEAR: 0;
+    readonly SET: 1;
+    readonly ERROR: 2;
+    readonly INDETERMINATE: 3;
+};
+/**
+ * Clear iTerm2 progress bar sequence (OSC 9;4;0;BEL)
+ * Uses BEL terminator since this is for cleanup (not runtime notification)
+ * and we want to ensure it's always sent regardless of terminal type.
+ */
+export declare const CLEAR_ITERM2_PROGRESS: string;
+/**
+ * Clear terminal title sequence (OSC 0 with empty string + BEL).
+ * Uses BEL terminator for cleanup — safe on all terminals.
+ */
+export declare const CLEAR_TERMINAL_TITLE: string;
+/** Clear all three OSC 21337 tab-status fields. Used on exit. */
+export declare const CLEAR_TAB_STATUS: string;
+/**
+ * Gate for emitting OSC 21337 (tab-status indicator). Ant-only while the
+ * spec is unstable. Terminals that don't recognize it discard silently, so
+ * emission is safe unconditionally — we don't gate on terminal detection
+ * since support is expected across several terminals.
+ *
+ * Callers must wrap output with wrapForMultiplexer() so tmux/screen
+ * DCS-passthrough carries the sequence to the outer terminal.
+ */
+export declare function supportsTabStatus(): boolean;
+/**
+ * Emit an OSC 21337 tab-status sequence. Omitted fields are left unchanged
+ * by the receiving terminal; `null` sends an empty value to clear.
+ * `;` and `\` in status text are escaped per the spec.
+ */
+export declare function tabStatus(fields: TabStatusAction): string;

package/dist/ink/termio/parser.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ANSI Parser - Semantic Action Generator
+ *
+ * A streaming parser for ANSI escape sequences that produces semantic actions.
+ * Uses the tokenizer for escape sequence boundary detection, then interprets
+ * each sequence to produce structured actions.
+ *
+ * Key design decisions:
+ * - Streaming: can process input incrementally
+ * - Semantic output: produces structured actions, not string tokens
+ * - Style tracking: maintains current text style state
+ */
+import type { Action, TextStyle } from './types.js';
+/**
+ * Parser class - maintains state for streaming/incremental parsing
+ *
+ * Usage:
+ * ```typescript
+ * const parser = new Parser()
+ * const actions1 = parser.feed('partial\x1b[')
+ * const actions2 = parser.feed('31mred')  // state maintained internally
+ * ```
+ */
+export declare class Parser {
+    private tokenizer;
+    style: TextStyle;
+    inLink: boolean;
+    linkUrl: string | undefined;
+    reset(): void;
+    /** Feed input and get resulting actions */
+    feed(input: string): Action[];
+    private processToken;
+    private processText;
+    private processSequence;
+}

package/dist/ink/termio/sgr.d.ts

@@ -0,0 +1,8 @@
+/**
+ * SGR (Select Graphic Rendition) Parser
+ *
+ * Parses SGR parameters and applies them to a TextStyle.
+ * Handles both semicolon (;) and colon (:) separated parameters.
+ */
+import type { TextStyle } from './types.js';
+export declare function applySGR(paramStr: string, style: TextStyle): TextStyle;

package/dist/ink/termio/tokenize.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Input Tokenizer - Escape sequence boundary detection
+ *
+ * Splits terminal input into tokens: text chunks and raw escape sequences.
+ * Unlike the Parser which interprets sequences semantically, this just
+ * identifies boundaries for use by keyboard input parsing.
+ */
+export type Token = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'sequence';
+    value: string;
+};
+export type Tokenizer = {
+    /** Feed input and get resulting tokens */
+    feed(input: string): Token[];
+    /** Flush any buffered incomplete sequences */
+    flush(): Token[];
+    /** Reset tokenizer state */
+    reset(): void;
+    /** Get any buffered incomplete sequence */
+    buffer(): string;
+};
+type TokenizerOptions = {
+    /**
+     * Treat `CSI M` as an X10 mouse event prefix and consume 3 payload bytes.
+     * Only enable for stdin input — `\x1b[M` is also CSI DL (Delete Lines) in
+     * output streams, and enabling this there swallows display text. Default false.
+     */
+    x10Mouse?: boolean;
+};
+/**
+ * Create a streaming tokenizer for terminal input.
+ *
+ * Usage:
+ * ```typescript
+ * const tokenizer = createTokenizer()
+ * const tokens1 = tokenizer.feed('hello\x1b[')
+ * const tokens2 = tokenizer.feed('A')  // completes the escape sequence
+ * const remaining = tokenizer.flush()  // force output incomplete sequences
+ * ```
+ */
+export declare function createTokenizer(options?: TokenizerOptions): Tokenizer;
+export {};

package/dist/ink/termio/types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * ANSI Parser - Semantic Types
+ *
+ * These types represent the semantic meaning of ANSI escape sequences,
+ * not their string representation. Inspired by ghostty's action-based design.
+ */
+/** Named colors from the 16-color palette */
+export type NamedColor = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'brightBlack' | 'brightRed' | 'brightGreen' | 'brightYellow' | 'brightBlue' | 'brightMagenta' | 'brightCyan' | 'brightWhite';
+/** Color specification - can be named, indexed (256), or RGB */
+export type Color = {
+    type: 'named';
+    name: NamedColor;
+} | {
+    type: 'indexed';
+    index: number;
+} | {
+    type: 'rgb';
+    r: number;
+    g: number;
+    b: number;
+} | {
+    type: 'default';
+};
+/** Underline style variants */
+export type UnderlineStyle = 'none' | 'single' | 'double' | 'curly' | 'dotted' | 'dashed';
+/** Text style attributes - represents current styling state */
+export type TextStyle = {
+    bold: boolean;
+    dim: boolean;
+    italic: boolean;
+    underline: UnderlineStyle;
+    blink: boolean;
+    inverse: boolean;
+    hidden: boolean;
+    strikethrough: boolean;
+    overline: boolean;
+    fg: Color;
+    bg: Color;
+    underlineColor: Color;
+};
+/** Create a default (reset) text style */
+export declare function defaultStyle(): TextStyle;
+/** Check if two styles are equal */
+export declare function stylesEqual(a: TextStyle, b: TextStyle): boolean;
+/** Check if two colors are equal */
+export declare function colorsEqual(a: Color, b: Color): boolean;
+export type CursorDirection = 'up' | 'down' | 'forward' | 'back';
+export type CursorAction = {
+    type: 'move';
+    direction: CursorDirection;
+    count: number;
+} | {
+    type: 'position';
+    row: number;
+    col: number;
+} | {
+    type: 'column';
+    col: number;
+} | {
+    type: 'row';
+    row: number;
+} | {
+    type: 'save';
+} | {
+    type: 'restore';
+} | {
+    type: 'show';
+} | {
+    type: 'hide';
+} | {
+    type: 'style';
+    style: 'block' | 'underline' | 'bar';
+    blinking: boolean;
+} | {
+    type: 'nextLine';
+    count: number;
+} | {
+    type: 'prevLine';
+    count: number;
+};
+export type EraseAction = {
+    type: 'display';
+    region: 'toEnd' | 'toStart' | 'all' | 'scrollback';
+} | {
+    type: 'line';
+    region: 'toEnd' | 'toStart' | 'all';
+} | {
+    type: 'chars';
+    count: number;
+};
+export type ScrollAction = {
+    type: 'up';
+    count: number;
+} | {
+    type: 'down';
+    count: number;
+} | {
+    type: 'setRegion';
+    top: number;
+    bottom: number;
+};
+export type ModeAction = {
+    type: 'alternateScreen';
+    enabled: boolean;
+} | {
+    type: 'bracketedPaste';
+    enabled: boolean;
+} | {
+    type: 'mouseTracking';
+    mode: 'off' | 'normal' | 'button' | 'any';
+} | {
+    type: 'focusEvents';
+    enabled: boolean;
+};
+export type LinkAction = {
+    type: 'start';
+    url: string;
+    params?: Record<string, string>;
+} | {
+    type: 'end';
+};
+export type TitleAction = {
+    type: 'windowTitle';
+    title: string;
+} | {
+    type: 'iconName';
+    name: string;
+} | {
+    type: 'both';
+    title: string;
+};
+/**
+ * Per-tab chrome metadata. Tristate for each field:
+ *  - property absent → not mentioned in sequence, no change
+ *  - null → explicitly cleared (bare key or key= with empty value)
+ *  - value → set to this
+ */
+export type TabStatusAction = {
+    indicator?: Color | null;
+    status?: string | null;
+    statusColor?: Color | null;
+};
+/** A segment of styled text */
+export type TextSegment = {
+    type: 'text';
+    text: string;
+    style: TextStyle;
+};
+/** A grapheme (visual character unit) with width info */
+export type Grapheme = {
+    value: string;
+    width: 1 | 2;
+};
+/** All possible parsed actions */
+export type Action = {
+    type: 'text';
+    graphemes: Grapheme[];
+    style: TextStyle;
+} | {
+    type: 'cursor';
+    action: CursorAction;
+} | {
+    type: 'erase';
+    action: EraseAction;
+} | {
+    type: 'scroll';
+    action: ScrollAction;
+} | {
+    type: 'mode';
+    action: ModeAction;
+} | {
+    type: 'link';
+    action: LinkAction;
+} | {
+    type: 'title';
+    action: TitleAction;
+} | {
+    type: 'tabStatus';
+    action: TabStatusAction;
+} | {
+    type: 'sgr';
+    params: string;
+} | {
+    type: 'bell';
+} | {
+    type: 'reset';
+} | {
+    type: 'unknown';
+    sequence: string;
+};

package/dist/ink/termio.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ANSI Parser Module
+ *
+ * A semantic ANSI escape sequence parser inspired by ghostty, tmux, and iTerm2.
+ *
+ * Key features:
+ * - Semantic output: produces structured actions, not string tokens
+ * - Streaming: can parse input incrementally via Parser class
+ * - Style tracking: maintains text style state across parse calls
+ * - Comprehensive: supports SGR, CSI, OSC, ESC sequences
+ *
+ * Usage:
+ *
+ * ```typescript
+ * import { Parser } from './termio.js'
+ *
+ * const parser = new Parser()
+ * const actions = parser.feed('\x1b[31mred\x1b[0m')
+ * // => [{ type: 'text', graphemes: [...], style: { fg: { type: 'named', name: 'red' }, ... } }]
+ * ```
+ */
+export { Parser } from './termio/parser.js';
+export type { Action, Color, CursorAction, CursorDirection, EraseAction, Grapheme, LinkAction, ModeAction, NamedColor, ScrollAction, TextSegment, TextStyle, TitleAction, UnderlineStyle, } from './termio/types.js';
+export { colorsEqual, defaultStyle, stylesEqual } from './termio/types.js';