@armadra/agent 0.0.0-stage → 0.3.0

package/dist/tui/tui.js

@@ -0,0 +1,363 @@
+/**
+ * TUI 主类（设计 §12.1、§12.2，主屏 regular 模式）。[B4]
+ *
+ * 组件树（自身是纵向 Container）+ 焦点 + 覆盖层 + 差分渲染：
+ * 1. `requestRender()` 合并到 `process.nextTick`，两帧最小间隔 16 ms；键盘输入触发的渲染绕过节流。
+ * 2. 渲染组件树 → 合成覆盖层 → 提取并剔除 CURSOR_MARKER → 每行截断到宽度、含样式的行尾补重置。
+ * 3. 首帧全量；宽度 / 高度变化全量（回到屏幕左上清屏，只画最后一屏）。
+ * 4. 否则找首末变化行只重写该区间；首变化行已滚出视口 → 从视口顶清到屏底重画视口。
+ *    已滚出终端顶部的历史行不再重绘（它们在终端回滚里）。
+ * 5. 每帧写入包在同步输出 `?2026h … ?2026l` 内，按 64 KiB 分块写。
+ * 6. 记录硬件光标所在内容行；最后把硬件光标移到获焦组件的光标处（便于输入法候选窗）。
+ * 7. `stop()`：光标移到内容末尾下一行、显示光标、交还终端（关括号粘贴、cooked 模式）；不清屏。
+ *
+ * 首帧前把当前行滚到屏幕顶（输出 height-1 个换行再上移），原屏内容进入回滚而不是被清掉；
+ * 这样内容起点与屏幕顶对齐，相对光标移动不会越过屏幕顶部。
+ */
+import { CURSOR_MARKER, isFocusable } from "./component.js";
+import { SGR_RESET, truncateToWidth, visibleWidth } from "./ansi.js";
+import { Container } from "./components/container.js";
+import { compositeOverlays } from "./components/overlay.js";
+import { HIDE_CURSOR, SHOW_CURSOR } from "./terminal.js";
+export const SYNC_BEGIN = "\x1b[?2026h";
+export const SYNC_END = "\x1b[?2026l";
+export const WRITE_CHUNK_SIZE = 64 * 1024;
+export const MIN_RENDER_INTERVAL_MS = 16;
+/** 按 64 KiB 分块写；不切开代理对。 */
+class ChunkWriter {
+    terminal;
+    buffer = "";
+    constructor(terminal) {
+        this.terminal = terminal;
+    }
+    push(data) {
+        this.buffer += data;
+        while (this.buffer.length >= WRITE_CHUNK_SIZE) {
+            let end = WRITE_CHUNK_SIZE;
+            const code = this.buffer.charCodeAt(end - 1);
+            if (code >= 0xd800 && code <= 0xdbff)
+                end--;
+            this.terminal.write(this.buffer.slice(0, end));
+            this.buffer = this.buffer.slice(end);
+        }
+    }
+    flush() {
+        if (this.buffer.length > 0)
+            this.terminal.write(this.buffer);
+        this.buffer = "";
+    }
+}
+export class TUI extends Container {
+    terminal;
+    options;
+    stats = { renders: 0, fullRedraws: 0 };
+    started = false;
+    focused = null;
+    overlays = [];
+    listeners = [];
+    minInterval;
+    now;
+    tickScheduled = false;
+    renderGeneration = 0;
+    timer = null;
+    lastRenderAt = Number.NEGATIVE_INFINITY;
+    // 差分状态（内容行坐标）
+    prevLines = null;
+    prevWidth = 0;
+    prevHeight = 0;
+    /** 硬件光标所在内容行。 */
+    hwRow = 0;
+    /** 终端上已存在的内容行数（自上次全量起写到过的最大行 + 1）。 */
+    bufferRows = 0;
+    /** 可达的最小内容行（更早的行在回滚里或从未画过）。 */
+    topLimit = 0;
+    cursorShown = null;
+    constructor(terminal, options = {}) {
+        super();
+        this.terminal = terminal;
+        this.options = options;
+        this.minInterval = options.minRenderIntervalMs ?? MIN_RENDER_INTERVAL_MS;
+        this.now = options.now ?? Date.now;
+    }
+    get isStarted() {
+        return this.started;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.terminal.start((data) => this.handleInput(data), () => this.requestRender(true));
+        this.requestRender(true);
+    }
+    /** 画完最后一帧，光标移到内容末尾下一行，交还终端；不清屏。 */
+    stop() {
+        if (!this.started)
+            return;
+        this.cancelScheduled();
+        this.doRender();
+        this.started = false;
+        const out = new ChunkWriter(this.terminal);
+        if (this.prevLines !== null && this.prevLines.length > 0) {
+            out.push(this.moveTo(this.prevLines.length - 1));
+            out.push("\r\n");
+        }
+        out.push(SHOW_CURSOR);
+        out.flush();
+        this.terminal.stop();
+    }
+    getFocus() {
+        return this.focused;
+    }
+    setFocus(component) {
+        if (this.focused === component)
+            return;
+        if (this.focused && isFocusable(this.focused))
+            this.focused.focused = false;
+        this.focused = component;
+        if (component && isFocusable(component))
+            component.focused = true;
+        this.requestRender();
+    }
+    /** 全局输入监听（先于获焦组件）；返回取消函数。 */
+    addInputListener(listener) {
+        this.listeners.push(listener);
+        return () => {
+            const index = this.listeners.indexOf(listener);
+            if (index !== -1)
+                this.listeners.splice(index, 1);
+        };
+    }
+    showOverlay(component, options = {}) {
+        const entry = { component, options, previousFocus: this.focused };
+        this.overlays.push(entry);
+        this.setFocus(component);
+        this.requestRender();
+        const tui = this;
+        return {
+            hide() {
+                const index = tui.overlays.indexOf(entry);
+                if (index === -1)
+                    return;
+                tui.overlays.splice(index, 1);
+                if (tui.focused === component)
+                    tui.setFocus(entry.previousFocus);
+                tui.requestRender();
+            },
+            focus() {
+                if (tui.overlays.includes(entry))
+                    tui.setFocus(component);
+            },
+            get visible() {
+                return tui.overlays.includes(entry);
+            },
+        };
+    }
+    get hasOverlay() {
+        return this.overlays.length > 0;
+    }
+    /** 原始输入：监听器 → 获焦组件 → 立即渲染（绕过节流）。 */
+    handleInput(data) {
+        for (const listener of [...this.listeners]) {
+            if (listener(data) === true) {
+                this.requestRender(true);
+                return;
+            }
+        }
+        this.focused?.handleInput?.(data);
+        this.requestRender(true);
+    }
+    /** 请求渲染；同一 tick 内合并。immediate 用于键盘输入与 resize，不受 16 ms 节流。 */
+    requestRender(immediate = false) {
+        if (!this.started || this.tickScheduled)
+            return;
+        const elapsed = this.now() - this.lastRenderAt;
+        if (immediate || elapsed >= this.minInterval) {
+            if (this.timer !== null) {
+                clearTimeout(this.timer);
+                this.timer = null;
+            }
+            this.tickScheduled = true;
+            const generation = ++this.renderGeneration;
+            process.nextTick(() => {
+                if (generation !== this.renderGeneration)
+                    return;
+                this.tickScheduled = false;
+                this.doRender();
+            });
+            return;
+        }
+        if (this.timer !== null)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.requestRender(true);
+        }, this.minInterval - elapsed);
+    }
+    /** 同步渲染一帧（测试与需要立刻落屏的场合）。 */
+    renderNow() {
+        this.cancelScheduled();
+        this.doRender();
+    }
+    /** 丢弃差分状态，下一帧按 resize 方式全量重画（例如外部程序写乱了屏幕）。 */
+    forceFullRedraw() {
+        if (this.prevLines !== null)
+            this.prevWidth = -1;
+        this.requestRender(true);
+    }
+    cancelScheduled() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.tickScheduled = false;
+        this.renderGeneration++;
+    }
+    /** 组件树 + 覆盖层 → 规范化行与光标位置。 */
+    compose(width, height) {
+        let lines = this.render(width);
+        if (this.overlays.length > 0)
+            lines = compositeOverlays(lines, this.overlays, width, height);
+        let cursor = null;
+        const out = new Array(lines.length);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            let line = lines[i];
+            const at = line.indexOf(CURSOR_MARKER);
+            if (at !== -1) {
+                if (cursor === null)
+                    cursor = { row: i, col: visibleWidth(line.slice(0, at)) };
+                line = line.split(CURSOR_MARKER).join("");
+            }
+            if (visibleWidth(line) > width)
+                line = truncateToWidth(line, width, "");
+            if (line.includes("\x1b") && !line.endsWith(SGR_RESET))
+                line += SGR_RESET;
+            out[i] = line;
+        }
+        return { lines: out, cursor };
+    }
+    viewportTop(height) {
+        return Math.max(this.topLimit, this.bufferRows - height);
+    }
+    /** 从 hwRow 移到内容行 row 的行首；越过已有行时用换行（会滚屏）。 */
+    moveTo(row) {
+        let seq = "";
+        if (row < this.hwRow) {
+            seq += `\x1b[${this.hwRow - row}A`;
+        }
+        else if (row > this.hwRow) {
+            const lastExisting = Math.max(this.hwRow, this.bufferRows - 1);
+            const down = Math.min(row, lastExisting) - this.hwRow;
+            if (down > 0)
+                seq += `\x1b[${down}B`;
+            const extra = row - lastExisting;
+            if (extra > 0) {
+                seq += "\r\n".repeat(extra);
+                this.bufferRows = row + 1;
+            }
+        }
+        this.hwRow = row;
+        return seq + "\r";
+    }
+    doRender() {
+        if (!this.started)
+            return;
+        const width = this.terminal.columns;
+        const height = this.terminal.rows;
+        const { lines, cursor } = this.compose(width, height);
+        const out = new ChunkWriter(this.terminal);
+        out.push(SYNC_BEGIN);
+        const prev = this.prevLines;
+        if (prev === null) {
+            this.fullFirst(out, lines, height);
+        }
+        else if (width !== this.prevWidth || height !== this.prevHeight) {
+            this.fullResize(out, lines, height);
+        }
+        else {
+            this.diff(out, prev, lines, height);
+        }
+        this.placeCursor(out, cursor, lines.length, height);
+        out.push(SYNC_END);
+        out.flush();
+        this.prevLines = lines;
+        this.prevWidth = width;
+        this.prevHeight = height;
+        this.lastRenderAt = this.now();
+        this.stats.renders++;
+    }
+    writeRows(out, lines, from) {
+        for (let i = from; i < lines.length; i++) {
+            if (i > from)
+                out.push("\r\n");
+            out.push("\x1b[2K" + lines[i]);
+        }
+    }
+    fullFirst(out, lines, height) {
+        this.stats.fullRedraws++;
+        if (this.options.anchorToTop !== false && height > 1) {
+            out.push("\r" + "\n".repeat(height - 1) + `\x1b[${height - 1}A`);
+        }
+        out.push("\r");
+        this.writeRows(out, lines, 0);
+        this.topLimit = 0;
+        this.bufferRows = Math.max(1, lines.length);
+        this.hwRow = Math.max(0, lines.length - 1);
+    }
+    fullResize(out, lines, height) {
+        this.stats.fullRedraws++;
+        const start = Math.max(0, lines.length - height);
+        out.push("\x1b[H\x1b[2J");
+        this.writeRows(out, lines, start);
+        this.topLimit = start;
+        this.bufferRows = Math.max(start + 1, lines.length);
+        this.hwRow = Math.max(start, lines.length - 1);
+    }
+    /** 首变化行在视口之上：从视口顶清到屏底，重画视口（更早的行留在回滚里）。 */
+    fullViewport(out, lines, height) {
+        this.stats.fullRedraws++;
+        const top = this.viewportTop(height);
+        out.push(this.moveTo(top) + "\x1b[J");
+        const start = lines.length > top ? top : Math.max(0, lines.length - height);
+        // 内容缩到视口顶以上：视口顶的屏幕行改为对应 start
+        this.writeRows(out, lines, start);
+        this.topLimit = start;
+        this.bufferRows = Math.max(start + 1, lines.length);
+        this.hwRow = Math.max(start, lines.length - 1);
+    }
+    diff(out, prev, lines, height) {
+        let first = -1;
+        let last = -1;
+        const max = Math.max(prev.length, lines.length);
+        for (let i = 0; i < max; i++) {
+            if ((prev[i] ?? "") !== (lines[i] ?? "") || i >= prev.length !== i >= lines.length) {
+                if (first === -1)
+                    first = i;
+                last = i;
+            }
+        }
+        if (first === -1)
+            return;
+        if (first < this.viewportTop(height)) {
+            this.fullViewport(out, lines, height);
+            return;
+        }
+        const renderEnd = Math.min(last, lines.length - 1);
+        for (let i = first; i <= renderEnd; i++)
+            out.push(this.moveTo(i) + "\x1b[2K" + lines[i]);
+        // 内容变短：清掉多出来的旧行（它们仍在屏幕上）
+        for (let i = Math.max(first, lines.length); i < prev.length; i++) {
+            out.push(this.moveTo(i) + "\x1b[2K");
+        }
+    }
+    placeCursor(out, cursor, total, height) {
+        const visible = cursor !== null && cursor.row < total && cursor.row >= this.viewportTop(height);
+        if (visible) {
+            out.push(this.moveTo(cursor.row) + `\x1b[${cursor.col + 1}G`);
+        }
+        const show = visible && this.options.showHardwareCursor === true;
+        if (this.cursorShown !== show) {
+            out.push(show ? SHOW_CURSOR : HIDE_CURSOR);
+            this.cursorShown = show;
+        }
+    }
+}

package/dist/tui/vt-screen.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 极简终端屏幕模拟（供 MemoryTerminal 还原屏幕、做帧黄金测试）。[B4]
+ *
+ * 只实现 TUI 实际会写出的子集：可打印字素（按列宽占格，含延迟换行语义）、`\r` `\n` `\b`、
+ * CSI A/B/C/D/E/F/G/H/f/J/K/m、`?25` `?2004` `?2026` 模式开关；OSC / APC / DCS 跳过；样式不记录。
+ * 滚出屏幕顶部的行进入回滚区（scrollback）。改尺寸不做重排：行截断 / 补齐，高度缩小时顶部行进回滚。
+ */
+export interface ScreenModes {
+    cursorVisible: boolean;
+    bracketedPaste: boolean;
+    /** 当前未闭合的同步输出层数（?2026h 计 +1，?2026l 归零）。 */
+    synchronized: boolean;
+}
+export declare class VirtualScreen {
+    private cols;
+    private rows;
+    private grid;
+    private history;
+    private x;
+    private y;
+    private pendingWrap;
+    readonly modes: ScreenModes;
+    constructor(cols: number, rows: number);
+    get columns(): number;
+    get height(): number;
+    get cursor(): {
+        row: number;
+        col: number;
+    };
+    /** 可见屏幕各行（右侧空白去掉）。 */
+    viewport(): string[];
+    /** 已滚出顶部的行（旧 → 新）。 */
+    scrollback(): string[];
+    /** 回滚 + 屏幕，去掉屏幕底部的空行。 */
+    transcript(): string[];
+    resize(cols: number, rows: number): void;
+    write(data: string): void;
+    private blankRow;
+    private lineFeed;
+    private print;
+    private control;
+    private escape;
+    private privateMode;
+    private eraseLine;
+    private eraseDisplay;
+}

package/dist/tui/vt-screen.js

@@ -0,0 +1,251 @@
+/**
+ * 极简终端屏幕模拟（供 MemoryTerminal 还原屏幕、做帧黄金测试）。[B4]
+ *
+ * 只实现 TUI 实际会写出的子集：可打印字素（按列宽占格，含延迟换行语义）、`\r` `\n` `\b`、
+ * CSI A/B/C/D/E/F/G/H/f/J/K/m、`?25` `?2004` `?2026` 模式开关；OSC / APC / DCS 跳过；样式不记录。
+ * 滚出屏幕顶部的行进入回滚区（scrollback）。改尺寸不做重排：行截断 / 补齐，高度缩小时顶部行进回滚。
+ */
+import { escapeLengthAt, graphemeWidth } from "./ansi.js";
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export class VirtualScreen {
+    cols;
+    rows;
+    grid = [];
+    history = [];
+    x = 0;
+    y = 0;
+    pendingWrap = false;
+    modes = { cursorVisible: true, bracketedPaste: false, synchronized: false };
+    constructor(cols, rows) {
+        this.cols = cols;
+        this.rows = rows;
+        for (let i = 0; i < rows; i++)
+            this.grid.push(this.blankRow());
+    }
+    get columns() {
+        return this.cols;
+    }
+    get height() {
+        return this.rows;
+    }
+    get cursor() {
+        return { row: this.y, col: this.x };
+    }
+    /** 可见屏幕各行（右侧空白去掉）。 */
+    viewport() {
+        return this.grid.map(rowText);
+    }
+    /** 已滚出顶部的行（旧 → 新）。 */
+    scrollback() {
+        return [...this.history];
+    }
+    /** 回滚 + 屏幕，去掉屏幕底部的空行。 */
+    transcript() {
+        const all = [...this.history, ...this.viewport()];
+        while (all.length > 0 && all[all.length - 1] === "")
+            all.pop();
+        return all;
+    }
+    resize(cols, rows) {
+        for (let i = 0; i < this.grid.length; i++) {
+            const row = this.grid[i];
+            if (cols < row.length) {
+                row.length = cols;
+                // 被截断的宽字符首格
+                if (cols > 0 && graphemeWidth(row[cols - 1]) === 2)
+                    row[cols - 1] = " ";
+            }
+            else
+                while (row.length < cols)
+                    row.push(" ");
+        }
+        this.cols = cols;
+        if (rows < this.rows) {
+            const overflow = Math.max(0, this.y - (rows - 1));
+            for (let i = 0; i < overflow; i++)
+                this.history.push(rowText(this.grid.shift()));
+            this.grid.length = rows;
+            this.y -= overflow;
+        }
+        else {
+            while (this.grid.length < rows)
+                this.grid.push(this.blankRow());
+        }
+        this.rows = rows;
+        this.x = Math.min(this.x, cols - 1);
+        this.pendingWrap = false;
+    }
+    write(data) {
+        let i = 0;
+        while (i < data.length) {
+            const c = data.charCodeAt(i);
+            if (c === 0x1b) {
+                const len = escapeLengthAt(data, i);
+                this.escape(data.slice(i, i + len));
+                i += len;
+                continue;
+            }
+            if (c < 0x20 || c === 0x7f) {
+                this.control(c);
+                i++;
+                continue;
+            }
+            let j = i;
+            while (j < data.length) {
+                const cc = data.charCodeAt(j);
+                if (cc === 0x1b || cc < 0x20 || cc === 0x7f)
+                    break;
+                j++;
+            }
+            for (const { segment } of segmenter.segment(data.slice(i, j)))
+                this.print(segment);
+            i = j;
+        }
+    }
+    blankRow() {
+        return new Array(this.cols).fill(" ");
+    }
+    lineFeed() {
+        if (this.y < this.rows - 1) {
+            this.y++;
+            return;
+        }
+        this.history.push(rowText(this.grid.shift()));
+        this.grid.push(this.blankRow());
+    }
+    print(grapheme) {
+        const w = graphemeWidth(grapheme);
+        if (w === 0) {
+            // 组合字符：附到前一格
+            const row = this.grid[this.y];
+            const at = Math.max(0, this.pendingWrap ? this.x : this.x - 1);
+            row[at] = (row[at] === " " ? "" : row[at]) + grapheme;
+            return;
+        }
+        if (this.pendingWrap || this.x + w > this.cols) {
+            this.x = 0;
+            this.lineFeed();
+            this.pendingWrap = false;
+        }
+        const row = this.grid[this.y];
+        row[this.x] = grapheme;
+        if (w === 2 && this.x + 1 < this.cols)
+            row[this.x + 1] = "";
+        this.x += w;
+        if (this.x >= this.cols) {
+            this.x = this.cols - 1;
+            this.pendingWrap = true;
+        }
+    }
+    control(c) {
+        switch (c) {
+            case 0x0d:
+                this.x = 0;
+                this.pendingWrap = false;
+                break;
+            case 0x0a:
+                this.lineFeed();
+                this.pendingWrap = false;
+                break;
+            case 0x08:
+                this.x = Math.max(0, this.x - 1);
+                this.pendingWrap = false;
+                break;
+            default:
+                break;
+        }
+    }
+    escape(seq) {
+        if (!seq.startsWith("\x1b["))
+            return;
+        const final = seq[seq.length - 1];
+        const body = seq.slice(2, -1);
+        if (body.startsWith("?")) {
+            this.privateMode(body.slice(1), final === "h");
+            return;
+        }
+        const params = body.split(";").map((p) => (p === "" ? undefined : Number(p)));
+        const n = params[0] ?? 1;
+        this.pendingWrap = false;
+        switch (final) {
+            case "A":
+                this.y = Math.max(0, this.y - n);
+                break;
+            case "B":
+                this.y = Math.min(this.rows - 1, this.y + n);
+                break;
+            case "C":
+                this.x = Math.min(this.cols - 1, this.x + n);
+                break;
+            case "D":
+                this.x = Math.max(0, this.x - n);
+                break;
+            case "E":
+                this.y = Math.min(this.rows - 1, this.y + n);
+                this.x = 0;
+                break;
+            case "F":
+                this.y = Math.max(0, this.y - n);
+                this.x = 0;
+                break;
+            case "G":
+                this.x = clamp(n - 1, 0, this.cols - 1);
+                break;
+            case "H":
+            case "f":
+                this.y = clamp((params[0] ?? 1) - 1, 0, this.rows - 1);
+                this.x = clamp((params[1] ?? 1) - 1, 0, this.cols - 1);
+                break;
+            case "J":
+                this.eraseDisplay(params[0] ?? 0);
+                break;
+            case "K":
+                this.eraseLine(params[0] ?? 0);
+                break;
+            default:
+                break;
+        }
+    }
+    privateMode(body, on) {
+        for (const p of body.split(";")) {
+            if (p === "25")
+                this.modes.cursorVisible = on;
+            else if (p === "2004")
+                this.modes.bracketedPaste = on;
+            else if (p === "2026")
+                this.modes.synchronized = on;
+        }
+    }
+    eraseLine(mode) {
+        const row = this.grid[this.y];
+        const [from, to] = mode === 0 ? [this.x, this.cols] : mode === 1 ? [0, this.x + 1] : [0, this.cols];
+        for (let i = from; i < to; i++)
+            row[i] = " ";
+    }
+    eraseDisplay(mode) {
+        if (mode === 3) {
+            this.history = [];
+            return;
+        }
+        if (mode === 2) {
+            for (let r = 0; r < this.rows; r++)
+                this.grid[r] = this.blankRow();
+            return;
+        }
+        if (mode === 0) {
+            this.eraseLine(0);
+            for (let r = this.y + 1; r < this.rows; r++)
+                this.grid[r] = this.blankRow();
+            return;
+        }
+        this.eraseLine(1);
+        for (let r = 0; r < this.y; r++)
+            this.grid[r] = this.blankRow();
+    }
+}
+function clamp(v, lo, hi) {
+    return Math.max(lo, Math.min(hi, v));
+}
+function rowText(row) {
+    return row.join("").replace(/ +$/, "");
+}

package/dist/tui.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `@armadra/agent/tui` 子路径：组件库再导出（设计 D1、§12.1）。[B0] 所有。
+ *
+ * B0 只导出组件模型契约；B4 完成组件库后在本文件末尾追加各组件的再导出
+ * （TUI、ProcessTerminal / MemoryTerminal、Container、Text、Markdown、Editor、SelectList、Box、
+ * Spacer、Loader、Overlay、主题与 ansi 工具）——这是 B4 唯一允许改动的 B0 文件。
+ */
+export { CURSOR_MARKER, isFocusable } from "./tui/component.js";
+export type * from "./tui/component.js";
+export { TUI, SYNC_BEGIN, SYNC_END, WRITE_CHUNK_SIZE, MIN_RENDER_INTERVAL_MS, type TuiOptions, type OverlayHandle, type InputListener, type RenderStats, } from "./tui/tui.js";
+export { ProcessTerminal, MemoryTerminal, BRACKETED_PASTE_ON, BRACKETED_PASTE_OFF, SHOW_CURSOR, HIDE_CURSOR, type Terminal, type ProcessTerminalOptions, type MemoryTerminalOptions, } from "./tui/terminal.js";
+export { VirtualScreen, type ScreenModes } from "./tui/vt-screen.js";
+export { StdinBuffer, defaultEscTimeout, type StdinBufferOptions } from "./tui/stdin-buffer.js";
+export { parseKey, matchesKey, normalizeKeyId, isPasteData, unwrapPaste, isPrintableText, PASTE_START, PASTE_END, type KeyEvent, } from "./tui/keys.js";
+export { visibleWidth, truncateToWidth, sliceByColumn, wrapTextWithAnsi, padToWidth, stripAnsi, codePointWidth, graphemeWidth, SGR_RESET, } from "./tui/ansi.js";
+export { createTheme, plainTheme, detectCapabilities, detectColorDepth, colorCode, rgbTo256, rgbTo16, THEME_PALETTES, type ThemeName, type CreateThemeOptions, } from "./tui/theme.js";
+export { Keybindings, defaultKeybindings, DEFAULT_KEYBINDINGS, parseKeybindings, loadKeybindingsFile, isActionId, type ActionId, type KeybindingOverrides, type ParsedKeybindings, } from "./tui/keybindings.js";
+export { Container } from "./tui/components/container.js";
+export { Text, TruncatedText, type TextOptions } from "./tui/components/text.js";
+export { Markdown, parseMarkdown, renderInline, renderBlock, type MarkdownOptions, type MarkdownBlock, type ListItem, } from "./tui/components/markdown.js";
+export { EditorBuffer, type Position, type EditorBufferOptions, } from "./tui/components/editor-buffer.js";
+export { Editor, loadHistoryFile, type EditorOptions, type AutocompleteProvider, type AutocompleteItem, type AutocompleteResult, type AutocompleteContext, } from "./tui/components/editor.js";
+export { PasteStore, shouldCollapse, formatMarker, PASTE_LINE_THRESHOLD, PASTE_CHAR_THRESHOLD, } from "./tui/components/editor-paste.js";
+export { SelectList, filterItems, type SelectItem, type SelectListOptions, } from "./tui/components/select-list.js";
+export { Box, type BoxOptions } from "./tui/components/box.js";
+export { Spacer } from "./tui/components/spacer.js";
+export { Loader, LOADER_FRAMES, formatElapsed, type LoaderOptions, } from "./tui/components/loader.js";
+export { compositeOverlays, type OverlayAnchor, type OverlayOptions, type OverlayLayer, } from "./tui/components/overlay.js";
+export { KeyValue, type KeyValueRow, type KeyValueOptions } from "./tui/components/key-value.js";
+export { Meter, METER_FULL, METER_EMPTY, type MeterOptions } from "./tui/components/meter.js";