@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/terminal.js

@@ -0,0 +1,268 @@
+import { coerce } from 'semver';
+import { appendFileSync } from 'node:fs';
+import { env } from '../utils/env.js';
+import { gte } from '../utils/semver.js';
+import { getClearTerminalSequence } from './clearTerminal.js';
+import { cursorMove, cursorTo, eraseLines, SGR_RESET } from './termio/csi.js';
+import { BSU, ESU, HIDE_CURSOR, SHOW_CURSOR } from './termio/dec.js';
+import { link } from './termio/osc.js';
+/**
+ * Checks if the terminal supports OSC 9;4 progress reporting.
+ * Supported terminals:
+ * - ConEmu (Windows) - all versions
+ * - Ghostty 1.2.0+
+ * - iTerm2 3.6.6+
+ *
+ * Note: Windows Terminal interprets OSC 9;4 as notifications, not progress.
+ * @returns true when the terminal supports OSC 9;4 progress reporting.
+ */
+export function isProgressReportingAvailable() {
+    // Only available if we have a TTY (not piped)
+    if (!process.stdout.isTTY) {
+        return false;
+    }
+    // Explicitly exclude Windows Terminal, which interprets OSC 9;4 as
+    // notifications rather than progress indicators
+    if (process.env.WT_SESSION) {
+        return false;
+    }
+    // ConEmu supports OSC 9;4 for progress (all versions)
+    if (process.env.ConEmuANSI ||
+        process.env.ConEmuPID ||
+        process.env.ConEmuTask) {
+        return true;
+    }
+    const version = coerce(process.env.TERM_PROGRAM_VERSION);
+    if (!version) {
+        return false;
+    }
+    // Ghostty 1.2.0+ supports OSC 9;4 for progress
+    // https://ghostty.org/docs/install/release-notes/1-2-0
+    if (process.env.TERM_PROGRAM === 'ghostty') {
+        return gte(version.version, '1.2.0');
+    }
+    // iTerm2 3.6.6+ supports OSC 9;4 for progress
+    // https://iterm2.com/downloads.html
+    if (process.env.TERM_PROGRAM === 'iTerm.app') {
+        return gte(version.version, '3.6.6');
+    }
+    return false;
+}
+/**
+ * Checks if the terminal supports DEC mode 2026 (synchronized output).
+ * When supported, BSU/ESU sequences prevent visible flicker during redraws.
+ * @returns true when the terminal supports DEC 2026.
+ */
+export function isSynchronizedOutputSupported() {
+    // tmux parses and proxies every byte but doesn't implement DEC 2026.
+    // BSU/ESU pass through to the outer terminal but tmux has already
+    // broken atomicity by chunking. Skip to save 16 bytes/frame + parser work.
+    if (process.env.TMUX)
+        return false;
+    const termProgram = process.env.TERM_PROGRAM;
+    const term = process.env.TERM;
+    // Modern terminals with known DEC 2026 support
+    if (termProgram === 'iTerm.app' ||
+        termProgram === 'WezTerm' ||
+        termProgram === 'WarpTerminal' ||
+        termProgram === 'ghostty' ||
+        termProgram === 'contour' ||
+        termProgram === 'vscode' ||
+        termProgram === 'alacritty') {
+        return true;
+    }
+    // kitty sets TERM=xterm-kitty or KITTY_WINDOW_ID
+    if (term?.includes('kitty') || process.env.KITTY_WINDOW_ID)
+        return true;
+    // Ghostty may set TERM=xterm-ghostty without TERM_PROGRAM
+    if (term === 'xterm-ghostty')
+        return true;
+    // foot sets TERM=foot or TERM=foot-extra
+    if (term?.startsWith('foot'))
+        return true;
+    // Alacritty may set TERM containing 'alacritty'
+    if (term?.includes('alacritty'))
+        return true;
+    // Zed uses the alacritty_terminal crate which supports DEC 2026
+    if (process.env.ZED_TERM)
+        return true;
+    // Windows Terminal
+    if (process.env.WT_SESSION)
+        return true;
+    // VTE-based terminals (GNOME Terminal, Tilix, etc.) since VTE 0.68
+    const vteVersion = process.env.VTE_VERSION;
+    if (vteVersion) {
+        const version = parseInt(vteVersion, 10);
+        if (version >= 6800)
+            return true;
+    }
+    return false;
+}
+// -- XTVERSION-detected terminal name (populated async at startup) --
+//
+// TERM_PROGRAM is not forwarded over SSH by default, so env-based detection
+// fails when claude runs remotely inside a VS Code integrated terminal.
+// XTVERSION (CSI > 0 q → DCS > | name ST) goes through the pty — the query
+// reaches the *client* terminal and the reply comes back through stdin.
+// App.tsx fires the query when raw mode enables; setXtversionName() is called
+// from the response handler. Readers should treat undefined as "not yet known"
+// and fall back to env-var detection.
+let xtversionName;
+/**
+ * Record the XTVERSION response. Called once from App.tsx when the reply
+ * arrives on stdin. No-op if already set (defend against re-probe).
+ * @param name - the terminal name reported by the XTVERSION reply.
+ */
+export function setXtversionName(name) {
+    if (xtversionName === undefined)
+        xtversionName = name;
+}
+/**
+ * True if running in an xterm.js-based terminal (VS Code, Cursor, Windsurf
+ * integrated terminals). Combines TERM_PROGRAM env check (fast, sync, but
+ * not forwarded over SSH) with the XTVERSION probe result (async, survives
+ * SSH — query/reply goes through the pty). Early calls may miss the probe
+ * reply — call lazily (e.g. in an event handler) if SSH detection matters.
+ * @returns true when the terminal is xterm.js-based.
+ */
+export function isXtermJs() {
+    if (process.env.TERM_PROGRAM === 'vscode')
+        return true;
+    return xtversionName?.startsWith('xterm.js') ?? false;
+}
+// Terminals known to correctly implement the Kitty keyboard protocol
+// (CSI >1u) and/or xterm modifyOtherKeys (CSI >4;2m) for ctrl+shift+<letter>
+// disambiguation. We previously enabled unconditionally (#23350), assuming
+// terminals silently ignore unknown CSI — but some terminals honor the enable
+// and emit codepoints our input parser doesn't handle (notably over SSH and
+// in xterm.js-based terminals like VS Code). tmux is allowlisted because it
+// accepts modifyOtherKeys and doesn't forward the kitty sequence to the outer
+// terminal.
+const EXTENDED_KEYS_TERMINALS = [
+    'iTerm.app',
+    'kitty',
+    'WezTerm',
+    'ghostty',
+    'tmux',
+    'windows-terminal',
+];
+/**
+ * True if this terminal correctly handles extended key reporting
+ * (Kitty keyboard protocol + xterm modifyOtherKeys).
+ * @returns true when the terminal is on the extended-keys allowlist.
+ */
+export function supportsExtendedKeys() {
+    return EXTENDED_KEYS_TERMINALS.includes(env.terminal ?? '');
+}
+/**
+ * True if the terminal scrolls the viewport when it receives cursor-up
+ * sequences that reach above the visible area. On Windows, conhost's
+ * SetConsoleCursorPosition follows the cursor into scrollback
+ * (microsoft/terminal#14774), yanking users to the top of their buffer
+ * mid-stream. WT_SESSION catches WSL-in-Windows-Terminal where platform
+ * is linux but output still routes through conhost.
+ * @returns true when the cursor-up viewport-yank bug applies.
+ */
+export function hasCursorUpViewportYankBug() {
+    return process.platform === 'win32' || !!process.env.WT_SESSION;
+}
+/**
+ * Whether synchronized output (DEC 2026) is available, computed once at
+ * module load — terminal capabilities don't change mid-session. Exported
+ * so callers can pass a sync-skip hint gated to specific modes.
+ */
+export const SYNC_OUTPUT_SUPPORTED = isSynchronizedOutputSupported();
+/**
+ * Render forensics: when DSH_CC_RENDER_LOG names a file path, every painted
+ * frame's raw ANSI bytes append to it (one JSON-escaped line per frame,
+ * prefixed with a timestamp header). Real-terminal rendering corruption
+ * (missing rows, stale attributes) cannot be reproduced in headless xterm
+ * harnesses — this captures the exact byte stream the terminal received so
+ * the corrupt frame can be diffed against the expected screen. Opt-in and
+ * zero-cost when unset: the env read happens once at module load.
+ */
+const RENDER_LOG_PATH = process.env.DSH_CC_RENDER_LOG ?? '';
+function dumpFrame(buffer) {
+    if (RENDER_LOG_PATH === '')
+        return;
+    try {
+        appendFileSync(RENDER_LOG_PATH, `\n===== frame ${new Date().toISOString()} (${buffer.length} bytes) =====\n${JSON.stringify(buffer)}\n`);
+    }
+    catch {
+        // Forensics must never break rendering: an unwritable log path (bad
+        // directory, permissions) drops the dump, not the frame.
+    }
+}
+/**
+ * Write a frame diff to the terminal as a single buffered write. Wraps
+ * the output in BSU/ESU synchronized-update markers unless skipSyncMarkers
+ * is set. No-op when the diff contains no patches.
+ * @param terminal - the terminal to write to.
+ * @param diff - the frame diff patches to render.
+ * @param skipSyncMarkers - when true, omit the BSU/ESU wrapping.
+ */
+export function writeDiffToTerminal(terminal, diff, skipSyncMarkers = false) {
+    // No output if there are no patches
+    if (diff.length === 0) {
+        return;
+    }
+    // BSU/ESU wrapping is opt-out to keep main-screen behavior unchanged.
+    // Callers pass skipSyncMarkers=true when the terminal doesn't support
+    // DEC 2026 (e.g. tmux) AND the cost matters (high-frequency alt-screen).
+    const useSync = !skipSyncMarkers;
+    // Buffer all writes into a single string to avoid multiple write calls.
+    // SGR_RESET + link('') head every frame: the diff engine computes style
+    // and hyperlink transitions from a frame-start baseline of none — normally
+    // guaranteed by the previous frame's tail resets, but a truncated frame
+    // (interrupted write, dropped PTY bytes) leaves the terminal stuck with a
+    // colored SGR / an open hyperlink. Every erase, hardware scroll, and LF
+    // scroll fills blank cells with the CURRENT background (BCE), so one stuck
+    // red background floods whole regions (issue #10). ~12 bytes per frame
+    // turn the baseline assumption into a per-frame guarantee; on healthy
+    // frames both sequences are idempotent no-ops.
+    let buffer = (useSync ? BSU : '') + SGR_RESET + link('');
+    for (const patch of diff) {
+        switch (patch.type) {
+            case 'stdout':
+                buffer += patch.content;
+                break;
+            case 'clear':
+                if (patch.count > 0) {
+                    buffer += eraseLines(patch.count);
+                }
+                break;
+            case 'clearTerminal':
+                // Pass the live row count: the blank only needs one viewport worth
+                // of scroll (see getClearTerminalSequence on why overshooting
+                // evicts the user's real scrollback).
+                buffer += getClearTerminalSequence(terminal.stdout.rows);
+                break;
+            case 'cursorHide':
+                buffer += HIDE_CURSOR;
+                break;
+            case 'cursorShow':
+                buffer += SHOW_CURSOR;
+                break;
+            case 'cursorMove':
+                buffer += cursorMove(patch.x, patch.y);
+                break;
+            case 'cursorTo':
+                buffer += cursorTo(patch.col);
+                break;
+            case 'carriageReturn':
+                buffer += '\r';
+                break;
+            case 'hyperlink':
+                buffer += link(patch.uri);
+                break;
+            case 'styleStr':
+                buffer += patch.str;
+                break;
+        }
+    }
+    // Add synchronized update end and flush buffer
+    if (useSync)
+        buffer += ESU;
+    dumpFrame(buffer);
+    terminal.stdout.write(buffer);
+}

package/lib/types/ink/termio/ansi.d.ts

@@ -0,0 +1,75 @@
+/**
+ * ANSI Control Characters and Escape Sequence Introducers
+ *
+ * Based on ECMA-48 / ANSI X3.64 standards.
+ */
+/**
+ * C0 (7-bit) control characters
+ */
+export declare const C0: {
+    readonly NUL: 0;
+    readonly SOH: 1;
+    readonly STX: 2;
+    readonly ETX: 3;
+    readonly EOT: 4;
+    readonly ENQ: 5;
+    readonly ACK: 6;
+    readonly BEL: 7;
+    readonly BS: 8;
+    readonly HT: 9;
+    readonly LF: 10;
+    readonly VT: 11;
+    readonly FF: 12;
+    readonly CR: 13;
+    readonly SO: 14;
+    readonly SI: 15;
+    readonly DLE: 16;
+    readonly DC1: 17;
+    readonly DC2: 18;
+    readonly DC3: 19;
+    readonly DC4: 20;
+    readonly NAK: 21;
+    readonly SYN: 22;
+    readonly ETB: 23;
+    readonly CAN: 24;
+    readonly EM: 25;
+    readonly SUB: 26;
+    readonly ESC: 27;
+    readonly FS: 28;
+    readonly GS: 29;
+    readonly RS: 30;
+    readonly US: 31;
+    readonly DEL: 127;
+};
+/** ESC control character (0x1B), the introducer of every escape sequence. */
+export declare const ESC = "\u001B";
+/** BEL control character (0x07), the common OSC sequence terminator. */
+export declare const BEL = "\u0007";
+/** Parameter separator used inside CSI and OSC sequences. */
+export declare const SEP = ";";
+/**
+ * Escape sequence type introducers (byte after ESC)
+ */
+export declare const ESC_TYPE: {
+    readonly CSI: 91;
+    readonly OSC: 93;
+    readonly DCS: 80;
+    readonly APC: 95;
+    readonly PM: 94;
+    readonly SOS: 88;
+    readonly ST: 92;
+};
+/**
+ * Check if a byte is a C0 control character.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the C0 range (0x00-0x1F) or is DEL (0x7F).
+ */
+export declare function isC0(byte: number): boolean;
+/**
+ * Check if a byte is an ESC sequence final byte (0-9, :, ;, <, =, >, ?, @ through ~).
+ * ESC sequences have a wider final byte range than CSI.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the final-byte range (0x30-0x7E).
+ */
+export declare function isEscFinal(byte: number): boolean;
+//# sourceMappingURL=ansi.d.ts.map

package/lib/types/ink/termio/ansi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ansi.d.ts","sourceRoot":"","sources":["../../../../src/ink/termio/ansi.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCL,CAAA;AAIV,6EAA6E;AAC7E,eAAO,MAAM,GAAG,WAAS,CAAA;AAEzB,wEAAwE;AACxE,eAAO,MAAM,GAAG,WAAS,CAAA;AAEzB,6DAA6D;AAC7D,eAAO,MAAM,GAAG,MAAM,CAAA;AAEtB;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;CAQX,CAAA;AAEV;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD"}

package/lib/types/ink/termio/ansi.js

@@ -0,0 +1,79 @@
+/**
+ * ANSI Control Characters and Escape Sequence Introducers
+ *
+ * Based on ECMA-48 / ANSI X3.64 standards.
+ */
+/**
+ * C0 (7-bit) control characters
+ */
+export const C0 = {
+    NUL: 0x00,
+    SOH: 0x01,
+    STX: 0x02,
+    ETX: 0x03,
+    EOT: 0x04,
+    ENQ: 0x05,
+    ACK: 0x06,
+    BEL: 0x07,
+    BS: 0x08,
+    HT: 0x09,
+    LF: 0x0a,
+    VT: 0x0b,
+    FF: 0x0c,
+    CR: 0x0d,
+    SO: 0x0e,
+    SI: 0x0f,
+    DLE: 0x10,
+    DC1: 0x11,
+    DC2: 0x12,
+    DC3: 0x13,
+    DC4: 0x14,
+    NAK: 0x15,
+    SYN: 0x16,
+    ETB: 0x17,
+    CAN: 0x18,
+    EM: 0x19,
+    SUB: 0x1a,
+    ESC: 0x1b,
+    FS: 0x1c,
+    GS: 0x1d,
+    RS: 0x1e,
+    US: 0x1f,
+    DEL: 0x7f,
+};
+// String constants for output generation
+/** ESC control character (0x1B), the introducer of every escape sequence. */
+export const ESC = '\x1b';
+/** BEL control character (0x07), the common OSC sequence terminator. */
+export const BEL = '\x07';
+/** Parameter separator used inside CSI and OSC sequences. */
+export const SEP = ';';
+/**
+ * Escape sequence type introducers (byte after ESC)
+ */
+export const ESC_TYPE = {
+    CSI: 0x5b, // [ - Control Sequence Introducer
+    OSC: 0x5d, // ] - Operating System Command
+    DCS: 0x50, // P - Device Control String
+    APC: 0x5f, // _ - Application Program Command
+    PM: 0x5e, // ^ - Privacy Message
+    SOS: 0x58, // X - Start of String
+    ST: 0x5c, // \ - String Terminator
+};
+/**
+ * Check if a byte is a C0 control character.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the C0 range (0x00-0x1F) or is DEL (0x7F).
+ */
+export function isC0(byte) {
+    return byte < 0x20 || byte === 0x7f;
+}
+/**
+ * Check if a byte is an ESC sequence final byte (0-9, :, ;, <, =, >, ?, @ through ~).
+ * ESC sequences have a wider final byte range than CSI.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the final-byte range (0x30-0x7E).
+ */
+export function isEscFinal(byte) {
+    return byte >= 0x30 && byte <= 0x7e;
+}

package/lib/types/ink/termio/csi.d.ts

@@ -0,0 +1,253 @@
+/**
+ * CSI (Control Sequence Introducer) Types
+ *
+ * Enums and types for CSI command parameters.
+ */
+/** CSI introducer prefix: ESC followed by `[`. */
+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.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the parameter range (0x30-0x3F).
+ */
+export declare function isCSIParam(byte: number): boolean;
+/**
+ * Check if a byte is a CSI intermediate byte.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the intermediate range (0x20-0x2F).
+ */
+export declare function isCSIIntermediate(byte: number): boolean;
+/**
+ * Check if a byte is a CSI final byte (@ through ~).
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the final range (0x40-0x7E).
+ */
+export declare function isCSIFinal(byte: number): boolean;
+/**
+ * Generate a CSI sequence: ESC [ p1;p2;...;pN final.
+ * With a single argument it is treated as the raw body; with multiple
+ * arguments the last is the final byte and the rest are parameters joined
+ * by semicolons.
+ * @param args - the sequence parts.
+ * @returns the complete CSI sequence string.
+ */
+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';
+/**
+ * Cursor style lookup table for DECSCUSR parameter 0-6, pairing each cursor
+ * shape with its blinking flag.
+ */
+export declare const CURSOR_STYLES: Array<{
+    style: CursorStyle;
+    blinking: boolean;
+}>;
+/**
+ * Move cursor up n lines (CSI n A).
+ * @param n - number of lines to move; defaults to 1.
+ * @returns the CSI sequence, or an empty string when n is 0.
+ */
+export declare function cursorUp(n?: number): string;
+/**
+ * Move cursor down n lines (CSI n B).
+ * @param n - number of lines to move; defaults to 1.
+ * @returns the CSI sequence, or an empty string when n is 0.
+ */
+export declare function cursorDown(n?: number): string;
+/**
+ * Move cursor forward n columns (CSI n C).
+ * @param n - number of columns to move; defaults to 1.
+ * @returns the CSI sequence, or an empty string when n is 0.
+ */
+export declare function cursorForward(n?: number): string;
+/**
+ * Move cursor back n columns (CSI n D).
+ * @param n - number of columns to move; defaults to 1.
+ * @returns the CSI sequence, or an empty string when n is 0.
+ */
+export declare function cursorBack(n?: number): string;
+/**
+ * Move cursor to column n (1-indexed) (CSI n G).
+ * @param col - the 1-indexed target column.
+ * @returns the CSI sequence.
+ */
+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).
+ * @param row - the 1-indexed target row.
+ * @param col - the 1-indexed target column.
+ * @returns the CSI sequence.
+ */
+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.
+ * @param x - horizontal delta in columns.
+ * @param y - vertical delta in rows.
+ * @returns the concatenated CSI sequences, or an empty string when both deltas are 0.
+ */
+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).
+ * @returns the CSI sequence.
+ */
+export declare function eraseToEndOfLine(): string;
+/**
+ * Erase from cursor to start of line (CSI 1 K).
+ * @returns the CSI sequence.
+ */
+export declare function eraseToStartOfLine(): string;
+/**
+ * Erase entire line (CSI 2 K).
+ * @returns the CSI sequence.
+ */
+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).
+ * @returns the CSI sequence.
+ */
+export declare function eraseToEndOfScreen(): string;
+/**
+ * Erase from cursor to start of screen (CSI 1 J).
+ * @returns the CSI sequence.
+ */
+export declare function eraseToStartOfScreen(): string;
+/**
+ * Erase entire screen (CSI 2 J).
+ * @returns the CSI sequence.
+ */
+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 the cursor line, moving the cursor up.
+ * This erases each line and moves up, ending at column 1.
+ * @param n - the number of lines to erase.
+ * @returns the combined erase and cursor sequences, or an empty string when
+ *   n is 0 or negative.
+ */
+export declare function eraseLines(n: number): string;
+/** Reset all SGR attributes (CSI 0 m). Erase/scroll sequences fill blank
+ *  cells with the CURRENT background color (BCE) — prefix this before any
+ *  such sequence that must not inherit a possibly-stuck background (e.g.
+ *  after a truncated frame left a colored SGR active). */
+export declare const SGR_RESET: string;
+/**
+ * Scroll up n lines (CSI n S).
+ * @param n - number of lines to scroll; defaults to 1.
+ * @returns the CSI sequence, or an empty string when n is 0.
+ */
+export declare function scrollUp(n?: number): string;
+/**
+ * Scroll down n lines (CSI n T).
+ * @param n - number of lines to scroll; defaults to 1.
+ * @returns the CSI sequence, or an empty string when n is 0.
+ */
+export declare function scrollDown(n?: number): string;
+/**
+ * Set scroll region (DECSTBM, CSI top;bottom r). 1-indexed, inclusive.
+ * @param top - the 1-indexed first row of the region.
+ * @param bottom - the 1-indexed last row of the region.
+ * @returns the CSI sequence.
+ */
+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;
+//# sourceMappingURL=csi.d.ts.map

package/lib/types/ink/termio/csi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csi.d.ts","sourceRoot":"","sources":["../../../../src/ink/termio/csi.ts"],"names":[],"mappings":"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"}