@askdkc/dsh-cli 0.11.3

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+import './force-production-react.js';
+export * from './dsh-adapter/index.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,6BAA6B,CAAA;AAIpC,cAAc,wBAAwB,CAAA"}

package/lib/types/index.js

@@ -0,0 +1,4 @@
+import './force-production-react.js';
+// Re-export shim: the plugin factory lives in src/dsh-adapter/index.ts
+// (the only module tree allowed to import official @deepseek-ai/* packages).
+export * from './dsh-adapter/index.js';

package/lib/types/ink/Ansi.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type Props = {
+    children: string;
+    dimColor?: boolean;
+};
+/** Project parser actions onto text leaves; control-only input has no layout. */
+export declare const Ansi: React.MemoExoticComponent<({ children, dimColor }: Props) => React.JSX.Element | null>;
+export {};
+//# sourceMappingURL=Ansi.d.ts.map

package/lib/types/ink/Ansi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ansi.d.ts","sourceRoot":"","sources":["../../../src/ink/Ansi.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAyB,MAAM,OAAO,CAAA;AAM7C,KAAK,KAAK,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAoBrD,iFAAiF;AACjF,eAAO,MAAM,IAAI,qDAA4D,KAAK,8BAkBhF,CAAA"}

package/lib/types/ink/Ansi.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import Link from './components/Link.js';
+import Text from './components/Text.js';
+import { Parser } from './termio.js';
+function rendererColor(color) {
+    if (color.type === 'default')
+        return undefined;
+    if (color.type === 'rgb')
+        return `rgb(${color.r},${color.g},${color.b})`;
+    if (color.type === 'indexed')
+        return `ansi256(${color.index})`;
+    const name = color.name.startsWith('bright')
+        ? `${color.name.slice(6).toLowerCase()}Bright`
+        : color.name;
+    return `ansi:${name}`;
+}
+function styledRun(text, style, forceDim) {
+    const weight = forceDim || style.dim ? { dim: true }
+        : style.bold ? { bold: true } : {};
+    return _jsx(Text, { ...weight, color: rendererColor(style.fg), backgroundColor: rendererColor(style.bg), italic: style.italic, underline: style.underline !== 'none', strikethrough: style.strikethrough, inverse: style.inverse, children: text });
+}
+/** Project parser actions onto text leaves; control-only input has no layout. */
+export const Ansi = React.memo(function Ansi({ children, dimColor = false }) {
+    if (typeof children !== 'string')
+        return _jsx(Text, { dim: dimColor, children: String(children) });
+    if (!children)
+        return null;
+    if (!children.includes('\x1b'))
+        return _jsx(Text, { dim: dimColor, children: children });
+    const content = [];
+    let url;
+    for (const action of new Parser().feed(children)) {
+        if (action.type === 'link') {
+            url = action.action.type === 'start' ? action.action.url : undefined;
+        }
+        else if (action.type === 'text' && action.graphemes.length) {
+            const text = action.graphemes.map(part => part.value).join('');
+            const node = styledRun(text, action.style, dimColor);
+            content.push(url ? _jsx(Link, { url: url, children: node }, content.length)
+                : _jsx(React.Fragment, { children: node }, content.length));
+        }
+    }
+    return content.length ? _jsx(Text, { dim: dimColor, children: content }) : null;
+});

package/lib/types/ink/bidi.d.ts

@@ -0,0 +1,18 @@
+type ClusteredChar = {
+    value: string;
+    width: number;
+    styleId: number;
+    hyperlink: string | undefined;
+};
+/**
+ * Reorder an array of ClusteredChars from logical order to visual order
+ * using the Unicode Bidi Algorithm. Active on terminals that lack native
+ * bidi support (Windows Terminal, conhost, WSL).
+ *
+ * Returns the same array on bidi-capable terminals (no-op).
+ * @param characters - clustered chars in logical order.
+ * @returns the characters in visual order, or the same array when no reordering applies.
+ */
+export declare function reorderBidi(characters: ClusteredChar[]): ClusteredChar[];
+export {};
+//# sourceMappingURL=bidi.d.ts.map

package/lib/types/ink/bidi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bidi.d.ts","sourceRoot":"","sources":["../../../src/ink/bidi.ts"],"names":[],"mappings":"AAkBA,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B,CAAA;AAsBD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,aAAa,EAAE,GAAG,aAAa,EAAE,CAoDxE"}

package/lib/types/ink/bidi.js

@@ -0,0 +1,119 @@
+/**
+ * Bidirectional text reordering for terminal rendering.
+ *
+ * Terminals on Windows do not implement the Unicode Bidi Algorithm,
+ * so RTL text (Hebrew, Arabic, etc.) appears reversed. This module
+ * applies the bidi algorithm to reorder ClusteredChar arrays from
+ * logical order to visual order before Ink's LTR cell placement loop.
+ *
+ * On macOS terminals (Terminal.app, iTerm2) bidi works natively.
+ * Windows Terminal (including WSL) does not implement bidi
+ * (https://github.com/microsoft/terminal/issues/538).
+ *
+ * Detection: Windows Terminal sets WT_SESSION; native Windows cmd/conhost
+ * also lacks bidi. We enable bidi reordering when running on Windows or
+ * inside Windows Terminal (covers WSL).
+ */
+import bidiFactory from 'bidi-js';
+let bidiInstance;
+let needsSoftwareBidi;
+function needsBidi() {
+    if (needsSoftwareBidi === undefined) {
+        needsSoftwareBidi =
+            process.platform === 'win32' ||
+                typeof process.env['WT_SESSION'] === 'string' || // WSL in Windows Terminal
+                process.env['TERM_PROGRAM'] === 'vscode'; // VS Code integrated terminal (xterm.js)
+    }
+    return needsSoftwareBidi;
+}
+function getBidi() {
+    if (!bidiInstance) {
+        bidiInstance = bidiFactory();
+    }
+    return bidiInstance;
+}
+/**
+ * Reorder an array of ClusteredChars from logical order to visual order
+ * using the Unicode Bidi Algorithm. Active on terminals that lack native
+ * bidi support (Windows Terminal, conhost, WSL).
+ *
+ * Returns the same array on bidi-capable terminals (no-op).
+ * @param characters - clustered chars in logical order.
+ * @returns the characters in visual order, or the same array when no reordering applies.
+ */
+export function reorderBidi(characters) {
+    if (!needsBidi() || characters.length === 0) {
+        return characters;
+    }
+    // Build a plain string from the clustered chars to run through bidi
+    const plainText = characters.map(c => c.value).join('');
+    // Check if there are any RTL characters — skip bidi if pure LTR
+    if (!hasRTLCharacters(plainText)) {
+        return characters;
+    }
+    const bidi = getBidi();
+    const { levels } = bidi.getEmbeddingLevels(plainText, 'auto');
+    // Map bidi levels back to ClusteredChar indices.
+    // Each ClusteredChar may be multiple code units in the joined string.
+    const charLevels = [];
+    let offset = 0;
+    for (let i = 0; i < characters.length; i++) {
+        charLevels.push(levels[offset]);
+        offset += characters[i].value.length;
+    }
+    // Get reorder segments from bidi-js, but we need to work at the
+    // ClusteredChar level, not the string level. We'll implement the
+    // standard bidi reordering: find the max level, then for each level
+    // from max down to 1, reverse all contiguous runs >= that level.
+    const reordered = [...characters];
+    const maxLevel = Math.max(...charLevels);
+    for (let level = maxLevel; level >= 1; level--) {
+        let i = 0;
+        while (i < reordered.length) {
+            if (charLevels[i] >= level) {
+                // Find the end of this run
+                let j = i + 1;
+                while (j < reordered.length && charLevels[j] >= level) {
+                    j++;
+                }
+                // Reverse the run in both arrays
+                reverseRange(reordered, i, j - 1);
+                reverseRangeNumbers(charLevels, i, j - 1);
+                i = j;
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    return reordered;
+}
+function reverseRange(arr, start, end) {
+    while (start < end) {
+        const temp = arr[start];
+        arr[start] = arr[end];
+        arr[end] = temp;
+        start++;
+        end--;
+    }
+}
+function reverseRangeNumbers(arr, start, end) {
+    while (start < end) {
+        const temp = arr[start];
+        arr[start] = arr[end];
+        arr[end] = temp;
+        start++;
+        end--;
+    }
+}
+/**
+ * Quick check for RTL characters (Hebrew, Arabic, and related scripts).
+ * Avoids running the full bidi algorithm on pure-LTR text.
+ */
+function hasRTLCharacters(text) {
+    // Hebrew: U+0590-U+05FF, U+FB1D-U+FB4F
+    // Arabic: U+0600-U+06FF, U+0750-U+077F, U+08A0-U+08FF, U+FB50-U+FDFF, U+FE70-U+FEFF
+    // Thaana: U+0780-U+07BF
+    // Syriac: U+0700-U+074F
+    return /[\u0590-\u05FF\uFB1D-\uFB4F\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\u0780-\u07BF\u0700-\u074F]/u.test(text);
+}

package/lib/types/ink/clearTerminal.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cross-platform terminal clearing with scrollback support.
+ * Detects modern terminals that support ESC[3J for clearing scrollback.
+ */
+/**
+ * Returns the ANSI escape sequence to blank the screen while PRESERVING the
+ * scrollback (user-scrolled history).
+ *
+ * NOT using ESC[2J / ESC[3J: inside a DEC 2026 sync-output block (BSU/ESU)
+ * Windows Terminal snaps the viewport back to the top on those sequences
+ * and dsh-tui's full resets run inside sync blocks.
+ * Scrolling the content far above the viewport (CSI <n> S) blanks the
+ * screen the same way — everything is pushed into the scrollback, the
+ * viewport shows empty rows — without moving the viewport.
+ * @returns the escape sequence that pushes content into the scrollback and homes the cursor.
+ */
+export declare function getClearTerminalSequence(rows?: number): string;
+/**
+ * Clears the terminal screen. On supported terminals, also clears scrollback.
+ */
+export declare const clearTerminal: string;
+//# sourceMappingURL=clearTerminal.d.ts.map

package/lib/types/ink/clearTerminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearTerminal.d.ts","sourceRoot":"","sources":["../../../src/ink/clearTerminal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAmDH;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAiB9D;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,QAA6B,CAAA"}

package/lib/types/ink/clearTerminal.js

@@ -0,0 +1,72 @@
+/**
+ * Cross-platform terminal clearing with scrollback support.
+ * Detects modern terminals that support ESC[3J for clearing scrollback.
+ */
+import { CURSOR_HOME, csi, SGR_RESET, scrollUp, } from './termio/csi.js';
+// HVP (Horizontal Vertical Position) - legacy Windows cursor home
+const CURSOR_HOME_WINDOWS = csi(0, 'f');
+function isWindowsTerminal() {
+    return process.platform === 'win32' && !!process.env.WT_SESSION;
+}
+function isMintty() {
+    // mintty 3.1.5+ sets TERM_PROGRAM to 'mintty'
+    if (process.env.TERM_PROGRAM === 'mintty') {
+        return true;
+    }
+    // GitBash/MSYS2/MINGW use mintty and set MSYSTEM
+    if (process.platform === 'win32' && process.env.MSYSTEM) {
+        return true;
+    }
+    return false;
+}
+function isModernWindowsTerminal() {
+    // Windows Terminal sets WT_SESSION environment variable
+    if (isWindowsTerminal()) {
+        return true;
+    }
+    // VS Code integrated terminal on Windows with ConPTY support
+    if (process.platform === 'win32' &&
+        process.env.TERM_PROGRAM === 'vscode' &&
+        process.env.TERM_PROGRAM_VERSION) {
+        return true;
+    }
+    // mintty (GitBash/MSYS2/Cygwin) supports modern escape sequences
+    if (isMintty()) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns the ANSI escape sequence to blank the screen while PRESERVING the
+ * scrollback (user-scrolled history).
+ *
+ * NOT using ESC[2J / ESC[3J: inside a DEC 2026 sync-output block (BSU/ESU)
+ * Windows Terminal snaps the viewport back to the top on those sequences
+ * and dsh-tui's full resets run inside sync blocks.
+ * Scrolling the content far above the viewport (CSI <n> S) blanks the
+ * screen the same way — everything is pushed into the scrollback, the
+ * viewport shows empty rows — without moving the viewport.
+ * @returns the escape sequence that pushes content into the scrollback and homes the cursor.
+ */
+export function getClearTerminalSequence(rows) {
+    // SGR_RESET first: CSI S fills the scrolled-in rows with the CURRENT
+    // background color (BCE). Frame-end resets normally guarantee SGR=none,
+    // but a truncated frame (dropped bytes, interrupted write) can leave a
+    // colored background active — without the reset, this scroll floods the
+    // blanked viewport with that color (seen in the wild as a full-screen
+    // red wash, issue #10).
+    //
+    // Scroll by ONE viewport height, not a huge constant: blanking the screen
+    // only needs the visible rows pushed out. The former scrollUp(10000)
+    // overshot the terminal's finite scrollback capacity (Windows Terminal
+    // defaults to 9001 lines) and evicted the user's ENTIRE scroll history,
+    // replacing it with blank rows — the opposite of the "preserving the
+    // scrollback" intent documented above. xterm.js-family terminals splice
+    // on CSI S, so the overshoot also cost O(10000) buffer operations there.
+    const n = rows && rows > 0 ? rows : (process.stdout.rows ?? 80);
+    return SGR_RESET + scrollUp(n) + CURSOR_HOME;
+}
+/**
+ * Clears the terminal screen. On supported terminals, also clears scrollback.
+ */
+export const clearTerminal = getClearTerminalSequence();

package/lib/types/ink/colorize.d.ts

@@ -0,0 +1,43 @@
+import type { Color, TextStyles } from './styles.js';
+/** Whether chalk's color level was boosted to 3 for xterm.js terminals. */
+export declare const CHALK_BOOSTED_FOR_XTERMJS: boolean;
+/** Whether chalk's color level was clamped to 2 for tmux passthrough. */
+export declare const CHALK_CLAMPED_FOR_TMUX: boolean;
+/** Which part of a cell a color applies to: text or background. */
+export type ColorType = 'foreground' | 'background';
+/**
+ * Apply a raw color value to a string using chalk.
+ * @param str - the text to color.
+ * @param color - the raw color value (ansi:*, hex, ansi256, or rgb); empty or unparsable values leave `str` unchanged.
+ * @param type - whether the color applies to foreground or background.
+ * @returns `str` wrapped in the chalk color sequence, or `str` unchanged when no color applies.
+ */
+export declare const colorize: (str: string, color: string | undefined, type: ColorType) => string;
+/**
+ * Apply TextStyles to a string using chalk.
+ * This is the inverse of parsing ANSI codes - we generate them from structured styles.
+ * Theme resolution happens at component layer, not here.
+ * @param text - the text to style.
+ * @param styles - the structured styles to apply.
+ * @returns `text` wrapped in the chalk sequences for the enabled styles.
+ */
+export declare function applyTextStyles(text: string, styles: TextStyles): string;
+/**
+ * Apply a raw color value to text.
+ * Theme resolution should happen at component layer, not here.
+ * @param text - the text to color.
+ * @param color - the raw foreground color value; undefined or empty leaves `text` unchanged.
+ * @returns `text` wrapped in the foreground color sequence.
+ */
+export declare function applyColor(text: string, color: Color | undefined): string;
+/**
+ * The opening SGR sequence for a raw background color — no text, no reset.
+ *
+ * SixelGraphicsManager needs it to give Erase-Character the placement's surface
+ * color as its fill: the erased cells keep a "background-only" style in the cell
+ * model, so filling them with the terminal default would leave a black patch.
+ * @param color - the raw background color value; undefined or empty yields ''.
+ * @returns the opening SGR sequence, or '' when no color applies.
+ */
+export declare function backgroundOpenCode(color: Color | undefined): string;
+//# sourceMappingURL=colorize.d.ts.map

package/lib/types/ink/colorize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorize.d.ts","sourceRoot":"","sources":["../../../src/ink/colorize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AA0DpD,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,SAA8B,CAAA;AACpE,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,SAA2B,CAAA;AAE9D,mEAAmE;AACnE,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,YAAY,CAAA;AAKnD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GACnB,KAAK,MAAM,EACX,OAAO,MAAM,GAAG,SAAS,EACzB,MAAM,SAAS,KACd,MAgGF,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,MAAM,CA4CxE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,MAAM,CAKzE;AAQD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,MAAM,CAKnE"}

package/lib/types/ink/colorize.js

@@ -0,0 +1,233 @@
+import chalk from 'chalk';
+/**
+ * xterm.js (VS Code, Cursor, code-server, Coder) has supported truecolor
+ * since 2017, but code-server/Coder containers often don't set
+ * COLORTERM=truecolor. chalk's supports-color doesn't recognize
+ * TERM_PROGRAM=vscode (it only knows iTerm.app/Apple_Terminal), so it falls
+ * through to the -256color regex → level 2. At level 2, chalk.rgb()
+ * downgrades to the nearest 6×6×6 cube color: rgb(215,119,87) → idx 174 rgb(215,135,135) — washed-out salmon.
+ *
+ * Gated on level === 2 (not < 3) to respect NO_COLOR / FORCE_COLOR=0 —
+ * those yield level 0 and are an explicit "no colors" request. Desktop VS
+ * Code sets COLORTERM=truecolor itself, so this is a no-op there (already 3).
+ *
+ * Must run BEFORE the tmux clamp — if tmux is running inside a VS Code
+ * terminal, tmux's passthrough limitation wins and we want level 2.
+ */
+function boostChalkLevelForXtermJs() {
+    if (process.env.TERM_PROGRAM === 'vscode' && chalk.level === 2) {
+        chalk.level = 3;
+        return true;
+    }
+    return false;
+}
+/**
+ * tmux parses truecolor SGR (\e[48;2;r;g;bm) into its cell buffer correctly,
+ * but its client-side emitter only re-emits truecolor to the outer terminal if
+ * the outer terminal advertises Tc/RGB capability (via terminal-overrides).
+ * Default tmux config doesn't set this, so tmux emits the cell to iTerm2/etc
+ * WITHOUT the bg sequence — outer terminal's buffer has bg=default → black on
+ * dark profiles. Clamping to level 2 makes chalk emit 256-color (\e[48;5;Nm),
+ * which tmux passes through cleanly. grey93 (255) is visually identical to
+ * rgb(240,240,240).
+ *
+ * Users who HAVE set `terminal-overrides ,*:Tc` get a technically-unnecessary
+ * downgrade, but the visual difference is imperceptible. Querying
+ * `tmux show -gv terminal-overrides` to detect this would add a subprocess on
+ * startup — not worth it.
+ *
+ * $TMUX is a pty-lifecycle env var set by tmux itself; it never comes from
+ * globalSettings.env, so reading it here is correct. chalk is a singleton, so
+ * this clamps ALL truecolor output (fg+bg+hex) across the entire app.
+ */
+function clampChalkLevelForTmux() {
+    // A terminal wrapper may set terminal-overrides :Tc so truecolor passes
+    // through — skip the clamp. General escape hatch for anyone who's
+    // configured their tmux correctly.
+    if (process.env.DSH_TUI_TMUX_TRUECOLOR)
+        return false;
+    if (process.env.TMUX && chalk.level > 2) {
+        chalk.level = 2;
+        return true;
+    }
+    return false;
+}
+// Computed once at module load — terminal/tmux environment doesn't change mid-session.
+// Order matters: boost first so the tmux clamp can re-clamp if tmux is running
+// inside a VS Code terminal. Exported for debugging — tree-shaken if unused.
+/** Whether chalk's color level was boosted to 3 for xterm.js terminals. */
+export const CHALK_BOOSTED_FOR_XTERMJS = boostChalkLevelForXtermJs();
+/** Whether chalk's color level was clamped to 2 for tmux passthrough. */
+export const CHALK_CLAMPED_FOR_TMUX = clampChalkLevelForTmux();
+const RGB_REGEX = /^rgb\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
+const ANSI_REGEX = /^ansi256\(\s?(\d+)\s?\)$/;
+/**
+ * Apply a raw color value to a string using chalk.
+ * @param str - the text to color.
+ * @param color - the raw color value (ansi:*, hex, ansi256, or rgb); empty or unparsable values leave `str` unchanged.
+ * @param type - whether the color applies to foreground or background.
+ * @returns `str` wrapped in the chalk color sequence, or `str` unchanged when no color applies.
+ */
+export const colorize = (str, color, type) => {
+    if (!color) {
+        return str;
+    }
+    if (color.startsWith('ansi:')) {
+        const value = color.substring('ansi:'.length);
+        switch (value) {
+            case 'black':
+                return type === 'foreground' ? chalk.black(str) : chalk.bgBlack(str);
+            case 'red':
+                return type === 'foreground' ? chalk.red(str) : chalk.bgRed(str);
+            case 'green':
+                return type === 'foreground' ? chalk.green(str) : chalk.bgGreen(str);
+            case 'yellow':
+                return type === 'foreground' ? chalk.yellow(str) : chalk.bgYellow(str);
+            case 'blue':
+                return type === 'foreground' ? chalk.blue(str) : chalk.bgBlue(str);
+            case 'magenta':
+                return type === 'foreground' ? chalk.magenta(str) : chalk.bgMagenta(str);
+            case 'cyan':
+                return type === 'foreground' ? chalk.cyan(str) : chalk.bgCyan(str);
+            case 'white':
+                return type === 'foreground' ? chalk.white(str) : chalk.bgWhite(str);
+            case 'blackBright':
+                return type === 'foreground'
+                    ? chalk.blackBright(str)
+                    : chalk.bgBlackBright(str);
+            case 'redBright':
+                return type === 'foreground'
+                    ? chalk.redBright(str)
+                    : chalk.bgRedBright(str);
+            case 'greenBright':
+                return type === 'foreground'
+                    ? chalk.greenBright(str)
+                    : chalk.bgGreenBright(str);
+            case 'yellowBright':
+                return type === 'foreground'
+                    ? chalk.yellowBright(str)
+                    : chalk.bgYellowBright(str);
+            case 'blueBright':
+                return type === 'foreground'
+                    ? chalk.blueBright(str)
+                    : chalk.bgBlueBright(str);
+            case 'magentaBright':
+                return type === 'foreground'
+                    ? chalk.magentaBright(str)
+                    : chalk.bgMagentaBright(str);
+            case 'cyanBright':
+                return type === 'foreground'
+                    ? chalk.cyanBright(str)
+                    : chalk.bgCyanBright(str);
+            case 'whiteBright':
+                return type === 'foreground'
+                    ? chalk.whiteBright(str)
+                    : chalk.bgWhiteBright(str);
+        }
+    }
+    if (color.startsWith('#')) {
+        return type === 'foreground'
+            ? chalk.hex(color)(str)
+            : chalk.bgHex(color)(str);
+    }
+    if (color.startsWith('ansi256')) {
+        const matches = ANSI_REGEX.exec(color);
+        if (!matches) {
+            return str;
+        }
+        const value = Number(matches[1]);
+        return type === 'foreground'
+            ? chalk.ansi256(value)(str)
+            : chalk.bgAnsi256(value)(str);
+    }
+    if (color.startsWith('rgb')) {
+        const matches = RGB_REGEX.exec(color);
+        if (!matches) {
+            return str;
+        }
+        const firstValue = Number(matches[1]);
+        const secondValue = Number(matches[2]);
+        const thirdValue = Number(matches[3]);
+        return type === 'foreground'
+            ? chalk.rgb(firstValue, secondValue, thirdValue)(str)
+            : chalk.bgRgb(firstValue, secondValue, thirdValue)(str);
+    }
+    return str;
+};
+/**
+ * Apply TextStyles to a string using chalk.
+ * This is the inverse of parsing ANSI codes - we generate them from structured styles.
+ * Theme resolution happens at component layer, not here.
+ * @param text - the text to style.
+ * @param styles - the structured styles to apply.
+ * @returns `text` wrapped in the chalk sequences for the enabled styles.
+ */
+export function applyTextStyles(text, styles) {
+    let result = text;
+    // Apply styles in reverse order of desired nesting.
+    // chalk wraps text so later calls become outer wrappers.
+    // Desired order (outermost to innermost):
+    //   background > foreground > text modifiers
+    // So we apply: text modifiers first, then foreground, then background last.
+    if (styles.inverse) {
+        result = chalk.inverse(result);
+    }
+    if (styles.strikethrough) {
+        result = chalk.strikethrough(result);
+    }
+    if (styles.underline) {
+        result = chalk.underline(result);
+    }
+    if (styles.italic) {
+        result = chalk.italic(result);
+    }
+    if (styles.bold) {
+        result = chalk.bold(result);
+    }
+    if (styles.dim) {
+        result = chalk.dim(result);
+    }
+    if (styles.color) {
+        // Color is now always a raw color value (theme resolution happens at component layer)
+        result = colorize(result, styles.color, 'foreground');
+    }
+    if (styles.backgroundColor) {
+        // backgroundColor is now always a raw color value
+        result = colorize(result, styles.backgroundColor, 'background');
+    }
+    return result;
+}
+/**
+ * Apply a raw color value to text.
+ * Theme resolution should happen at component layer, not here.
+ * @param text - the text to color.
+ * @param color - the raw foreground color value; undefined or empty leaves `text` unchanged.
+ * @returns `text` wrapped in the foreground color sequence.
+ */
+export function applyColor(text, color) {
+    if (!color) {
+        return text;
+    }
+    return colorize(text, color, 'foreground');
+}
+/**
+ * Marker used to split chalk's open/close pair. No SGR sequence contains a NUL,
+ * so everything before it is the opening code.
+ */
+const SGR_OPEN_MARKER = '\u0000';
+/**
+ * The opening SGR sequence for a raw background color — no text, no reset.
+ *
+ * SixelGraphicsManager needs it to give Erase-Character the placement's surface
+ * color as its fill: the erased cells keep a "background-only" style in the cell
+ * model, so filling them with the terminal default would leave a black patch.
+ * @param color - the raw background color value; undefined or empty yields ''.
+ * @returns the opening SGR sequence, or '' when no color applies.
+ */
+export function backgroundOpenCode(color) {
+    if (!color)
+        return '';
+    const styled = colorize(SGR_OPEN_MARKER, color, 'background');
+    const end = styled.indexOf(SGR_OPEN_MARKER);
+    return end <= 0 ? '' : styled.slice(0, end);
+}

package/lib/types/ink/components/AlternateScreen.d.ts

@@ -0,0 +1,8 @@
+import React, { type PropsWithChildren } from 'react';
+type Props = PropsWithChildren<{
+    mouseTracking?: boolean;
+}>;
+/** Own the alternate buffer and its input modes for the lifetime of this subtree. */
+export declare function AlternateScreen({ children, mouseTracking }: Props): React.JSX.Element;
+export {};
+//# sourceMappingURL=AlternateScreen.d.ts.map

package/lib/types/ink/components/AlternateScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlternateScreen.d.ts","sourceRoot":"","sources":["../../../../src/ink/components/AlternateScreen.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAkC,MAAM,OAAO,CAAA;AAQrF,KAAK,KAAK,GAAG,iBAAiB,CAAC;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAE3D,qFAAqF;AACrF,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,aAAoB,EAAE,EAAE,KAAK,qBAkBxE"}

package/lib/types/ink/components/AlternateScreen.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useContext, useInsertionEffect } from 'react';
+import instances from '../instances.js';
+import { logMouseDebug } from '../../utils/debug.js';
+import { DISABLE_MOUSE_TRACKING, ENABLE_MOUSE_TRACKING, ENTER_ALT_SCREEN, EXIT_ALT_SCREEN } from '../termio/dec.js';
+import { TerminalWriteContext } from '../useTerminalNotification.js';
+import Box from './Box.js';
+import { TerminalSizeContext } from './TerminalSizeContext.js';
+/** Own the alternate buffer and its input modes for the lifetime of this subtree. */
+export function AlternateScreen({ children, mouseTracking = true }) {
+    const size = useContext(TerminalSizeContext);
+    const write = useContext(TerminalWriteContext);
+    useInsertionEffect(() => {
+        if (!write)
+            return;
+        // Custom streams are supported only when a single renderer can be identified.
+        const renderer = instances.get(process.stdout) ?? (instances.size === 1 ? instances.values().next().value : undefined);
+        logMouseDebug('alt-screen enter', { mouseTracking, inkFound: !!renderer });
+        write(ENTER_ALT_SCREEN + '\x1b[2J\x1b[H' + (mouseTracking ? ENABLE_MOUSE_TRACKING : ''));
+        renderer?.setAltScreenActive(true, mouseTracking);
+        return () => {
+            renderer?.setAltScreenActive(false);
+            renderer?.clearTextSelection();
+            write((mouseTracking ? DISABLE_MOUSE_TRACKING : '') + EXIT_ALT_SCREEN);
+            logMouseDebug('alt-screen exit', {});
+        };
+    }, [write, mouseTracking]);
+    return _jsx(Box, { flexDirection: "column", height: size?.rows ?? 24, width: "100%", flexShrink: 0, children: children });
+}