@textui/terminal 0.1.0

package/dist/writer.js

@@ -0,0 +1,173 @@
+import { COLOR_DEFAULT, downsample, isRgb, unpackRgb } from '@textui/core';
+import { ATTR_BLINK, ATTR_BOLD, ATTR_DIM, ATTR_HIDDEN, ATTR_INVERSE, ATTR_ITALIC, ATTR_STRIKE, ATTR_UNDERLINE, } from '@textui/core';
+import * as ansi from './ansi.js';
+function freshState() {
+    return { fg: COLOR_DEFAULT, bg: COLOR_DEFAULT, attrs: 0, link: undefined, x: -1, y: -1, valid: false };
+}
+export function fgSequence(color, depth) {
+    const c = downsample(color, depth);
+    if (c === COLOR_DEFAULT)
+        return `${ansi.SGR.fgDefault}`;
+    if (isRgb(c)) {
+        const [r, g, b] = unpackRgb(c);
+        return `38;2;${r};${g};${b}`;
+    }
+    if (c < 8)
+        return `${30 + c}`;
+    if (c < 16)
+        return `${90 + (c - 8)}`;
+    return `38;5;${c}`;
+}
+export function bgSequence(color, depth) {
+    const c = downsample(color, depth);
+    if (c === COLOR_DEFAULT)
+        return `${ansi.SGR.bgDefault}`;
+    if (isRgb(c)) {
+        const [r, g, b] = unpackRgb(c);
+        return `48;2;${r};${g};${b}`;
+    }
+    if (c < 8)
+        return `${40 + c}`;
+    if (c < 16)
+        return `${100 + (c - 8)}`;
+    return `48;5;${c}`;
+}
+export const ATTR_ON = [
+    [ATTR_BOLD, SGRon(ansi.SGR.bold)],
+    [ATTR_DIM, SGRon(ansi.SGR.dim)],
+    [ATTR_ITALIC, SGRon(ansi.SGR.italic)],
+    [ATTR_UNDERLINE, SGRon(ansi.SGR.underline)],
+    [ATTR_BLINK, SGRon(ansi.SGR.blink)],
+    [ATTR_INVERSE, SGRon(ansi.SGR.inverse)],
+    [ATTR_HIDDEN, SGRon(ansi.SGR.hidden)],
+    [ATTR_STRIKE, SGRon(ansi.SGR.strike)],
+];
+function SGRon(code) {
+    return code;
+}
+export class Writer {
+    capabilities;
+    state = freshState();
+    constructor(capabilities) {
+        this.capabilities = capabilities;
+    }
+    setCapabilities(capabilities) {
+        this.capabilities = capabilities;
+        this.invalidate();
+    }
+    /** Forget what we believe the terminal's state to be. After a resize. */
+    invalidate() {
+        this.state = freshState();
+    }
+    /** Encode a frame. Returns an empty string when nothing changed. */
+    write(frame) {
+        if (frame.runs.length === 0 && !frame.cursor)
+            return '';
+        const out = [];
+        const sync = this.capabilities.synchronizedOutput;
+        if (sync)
+            out.push(ansi.syncStart);
+        // A frame is painted with the cursor hidden; showing it once at the end
+        // is the difference between a steady caret and one that streaks.
+        const hideForPaint = this.capabilities.cursor && frame.runs.length > 0;
+        if (hideForPaint)
+            out.push(ansi.cursorHide);
+        for (const run of frame.runs)
+            out.push(this.encodeRun(run));
+        if (this.state.link !== undefined) {
+            out.push(ansi.linkClose);
+            this.state.link = undefined;
+        }
+        if (frame.cursor && this.capabilities.cursor) {
+            out.push(ansi.cursorTo(frame.cursor.x, frame.cursor.y));
+            this.state.x = frame.cursor.x;
+            this.state.y = frame.cursor.y;
+            if (frame.cursor.visible)
+                out.push(ansi.cursorShow);
+        }
+        if (sync)
+            out.push(ansi.syncEnd);
+        return out.join('');
+    }
+    encodeRun(run) {
+        const out = [];
+        const s = this.state;
+        // Move only when we are not already where this run starts.
+        if (!s.valid || s.y !== run.y || s.x !== run.x) {
+            out.push(s.valid && s.y === run.y ? ansi.cursorColumn(run.x) : ansi.cursorTo(run.x, run.y));
+        }
+        out.push(this.encodeStyle(run));
+        if (this.capabilities.hyperlinks && run.link !== s.link) {
+            out.push(run.link === undefined ? ansi.linkClose : ansi.linkOpen(run.link));
+            s.link = run.link;
+        }
+        out.push(run.text);
+        s.x = run.x + [...run.text].length;
+        s.y = run.y;
+        s.valid = true;
+        return out.join('');
+    }
+    encodeStyle(run) {
+        const s = this.state;
+        const codes = [];
+        const attrsChanged = s.attrs !== run.attrs;
+        if (attrsChanged) {
+            const removed = s.attrs & ~run.attrs;
+            // Turning several attributes off individually costs more than one reset
+            // followed by re-stating what is still on.
+            if (removed !== 0 && popcount(removed) > 1) {
+                codes.push(ansi.SGR.reset);
+                s.fg = COLOR_DEFAULT;
+                s.bg = COLOR_DEFAULT;
+                s.attrs = 0;
+            }
+            else if (removed !== 0) {
+                if (removed & ATTR_BOLD)
+                    codes.push(ansi.SGR.noBold);
+                if (removed & ATTR_DIM)
+                    codes.push(ansi.SGR.noBold);
+                if (removed & ATTR_ITALIC)
+                    codes.push(ansi.SGR.noItalic);
+                if (removed & ATTR_UNDERLINE)
+                    codes.push(ansi.SGR.noUnderline);
+                if (removed & ATTR_BLINK)
+                    codes.push(ansi.SGR.noBlink);
+                if (removed & ATTR_INVERSE)
+                    codes.push(ansi.SGR.noInverse);
+                if (removed & ATTR_HIDDEN)
+                    codes.push(ansi.SGR.noHidden);
+                if (removed & ATTR_STRIKE)
+                    codes.push(ansi.SGR.noStrike);
+            }
+            const added = run.attrs & ~s.attrs;
+            for (const [bit, code] of ATTR_ON) {
+                if (added & bit)
+                    codes.push(code);
+            }
+            s.attrs = run.attrs;
+        }
+        if (this.capabilities.colorDepth > 0) {
+            if (s.fg !== run.fg) {
+                codes.push(fgSequence(run.fg, this.capabilities.colorDepth));
+                s.fg = run.fg;
+            }
+            if (s.bg !== run.bg) {
+                codes.push(bgSequence(run.bg, this.capabilities.colorDepth));
+                s.bg = run.bg;
+            }
+        }
+        return codes.length === 0 ? '' : `${ansi.CSI}${codes.join(';')}m`;
+    }
+}
+function popcount(n) {
+    let count = 0;
+    let v = n;
+    while (v) {
+        v &= v - 1;
+        count++;
+    }
+    return count;
+}
+export function createWriter(capabilities) {
+    return new Writer(capabilities);
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@textui/terminal",
+  "version": "0.1.0",
+  "description": "Terminal adapters, capability detection, ANSI writing and input decoding for TextUI",
+  "keywords": [
+    "terminal",
+    "tui",
+    "ansi",
+    "tty",
+    "capabilities",
+    "kitty-keyboard",
+    "input",
+    "escape-codes"
+  ],
+  "homepage": "https://softov.github.io/textui/",
+  "bugs": {
+    "url": "https://github.com/softov/textui/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/softov/textui.git",
+    "directory": "packages/terminal"
+  },
+  "license": "MIT",
+  "author": "Softov <softov@brbyte.com>",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
+    "./virtual": {
+      "types": "./dist/virtual.d.ts",
+      "import": "./dist/virtual.js"
+    }
+  },
+  "dependencies": {
+    "@textui/core": "^0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json",
+    "test": "vitest run"
+  }
+}

package/src/ansi.ts

@@ -0,0 +1,120 @@
+/**
+ * ANSI escape sequences.
+ *
+ * Everything the writer can emit is named here, so a capability check happens
+ * once - at the adapter - rather than scattered through the render path.
+ * Sequences are written with `\x1b` escapes rather than literal bytes so this
+ * file stays readable in a diff.
+ */
+export const ESC = '\x1b';
+export const CSI = '\x1b[';
+export const OSC = '\x1b]';
+export const ST = '\x1b\\';
+export const BEL = '\x07';
+
+// --- cursor ---
+export const cursorTo = (x: number, y: number): string => `${CSI}${y + 1};${x + 1}H`;
+export const cursorHome = `${CSI}H`;
+export const cursorHide = `${CSI}?25l`;
+export const cursorShow = `${CSI}?25h`;
+export const cursorSave = `${ESC}7`;
+export const cursorRestore = `${ESC}8`;
+export const cursorUp = (n = 1): string => `${CSI}${n}A`;
+export const cursorDown = (n = 1): string => `${CSI}${n}B`;
+export const cursorForward = (n = 1): string => `${CSI}${n}C`;
+export const cursorBack = (n = 1): string => `${CSI}${n}D`;
+export const cursorColumn = (x: number): string => `${CSI}${x + 1}G`;
+
+/** Cursor shapes, for a text field that wants a bar rather than a block. */
+export const cursorShape = (
+  shape: 'block' | 'underline' | 'bar',
+  blinking = true,
+): string => {
+  const base = shape === 'block' ? 1 : shape === 'underline' ? 3 : 5;
+  return `${CSI}${blinking ? base : base + 1} q`;
+};
+
+// --- erasing ---
+export const eraseLine = `${CSI}2K`;
+export const eraseLineRight = `${CSI}0K`;
+export const eraseScreen = `${CSI}2J`;
+export const eraseDown = `${CSI}0J`;
+export const scrollUp = (n = 1): string => `${CSI}${n}S`;
+
+// --- modes ---
+export const altScreenEnter = `${CSI}?1049h`;
+export const altScreenLeave = `${CSI}?1049l`;
+export const bracketedPasteOn = `${CSI}?2004h`;
+export const bracketedPasteOff = `${CSI}?2004l`;
+export const focusEventsOn = `${CSI}?1004h`;
+export const focusEventsOff = `${CSI}?1004l`;
+
+/** SGR mouse reporting: any-event tracking plus extended coordinates. */
+export const mouseOn = `${CSI}?1000h${CSI}?1002h${CSI}?1003h${CSI}?1006h`;
+export const mouseOff = `${CSI}?1006l${CSI}?1003l${CSI}?1002l${CSI}?1000l`;
+/** Click and drag only - no motion events, which are noisy over ssh. */
+export const mouseButtonsOn = `${CSI}?1000h${CSI}?1002h${CSI}?1006h`;
+export const mouseButtonsOff = `${CSI}?1006l${CSI}?1002l${CSI}?1000l`;
+
+/** DEC 2026: draw the whole frame before showing any of it. */
+export const syncStart = `${CSI}?2026h`;
+export const syncEnd = `${CSI}?2026l`;
+
+/** Kitty keyboard protocol - disambiguates ctrl+i from tab, and so on. */
+export const kittyKeyboardPush = `${CSI}>1u`;
+export const kittyKeyboardPop = `${CSI}<u`;
+
+export const wrapOff = `${CSI}?7l`;
+export const wrapOn = `${CSI}?7h`;
+
+// --- queries ---
+export const queryDeviceAttributes = `${CSI}c`;
+export const queryCursorPosition = `${CSI}6n`;
+/** XTGETTCAP for truecolor support. */
+export const queryTruecolor = `${ESC}P+q524742${ESC}\\`;
+export const querySync = `${CSI}?2026$p`;
+
+// --- osc ---
+export const setTitle = (title: string): string => `${OSC}0;${sanitizeOsc(title)}${BEL}`;
+export const link = (url: string, text: string): string =>
+  `${OSC}8;;${sanitizeOsc(url)}${ST}${text}${OSC}8;;${ST}`;
+export const linkOpen = (url: string): string => `${OSC}8;;${sanitizeOsc(url)}${ST}`;
+export const linkClose = `${OSC}8;;${ST}`;
+
+/** OSC 52: put text on the system clipboard, base64-encoded. */
+export const clipboardWrite = (text: string): string => {
+  const b64 = typeof globalThis.btoa === 'function'
+    ? globalThis.btoa(unescape(encodeURIComponent(text)))
+    : Buffer.from(text, 'utf8').toString('base64');
+  return `${OSC}52;c;${b64}${BEL}`;
+};
+
+/** A string inside an OSC must not contain a terminator of its own. */
+function sanitizeOsc(text: string): string {
+  // eslint-disable-next-line no-control-regex
+  return text.replace(/[\x00-\x1f\x7f]/g, '');
+}
+
+// --- SGR ---
+export const reset = `${CSI}0m`;
+
+export const SGR = {
+  reset: 0,
+  bold: 1,
+  dim: 2,
+  italic: 3,
+  underline: 4,
+  blink: 5,
+  inverse: 7,
+  hidden: 8,
+  strike: 9,
+  noBold: 22,
+  noItalic: 23,
+  noUnderline: 24,
+  noBlink: 25,
+  noInverse: 27,
+  noHidden: 28,
+  noStrike: 29,
+  fgDefault: 39,
+  bgDefault: 49,
+} as const;

package/src/capabilities.ts

@@ -0,0 +1,140 @@
+import type { CapabilityOverrides, TerminalCapabilities, ColorDepth, UnicodeLevel } from '@textui/core';
+import { MINIMAL_CAPABILITIES } from '@textui/core';
+
+export interface DetectionInput {
+  env: Record<string, string | undefined>;
+  isTTY: boolean;
+  columns?: number;
+  rows?: number;
+  platform?: string;
+}
+
+/**
+ * Capability detection.
+ *
+ * Detection is best-effort and deliberately conservative: claiming a
+ * capability the terminal lacks corrupts the frame, while missing one only
+ * costs polish. Anything detection cannot settle, an adapter override can.
+ */
+export function detectColorDepth(env: Record<string, string | undefined>, isTTY: boolean): ColorDepth {
+  if (env.NO_COLOR !== undefined && env.NO_COLOR !== '') return 0;
+  if (env.FORCE_COLOR !== undefined) {
+    const level = Number.parseInt(env.FORCE_COLOR, 10);
+    if (env.FORCE_COLOR === 'true') return 24;
+    if (level === 0) return 0;
+    if (level === 1) return 4;
+    if (level === 2) return 8;
+    if (level >= 3) return 24;
+  }
+  if (!isTTY) return 0;
+
+  const term = env.TERM ?? '';
+  if (term === 'dumb') return 0;
+
+  const colorterm = (env.COLORTERM ?? '').toLowerCase();
+  if (colorterm === 'truecolor' || colorterm === '24bit') return 24;
+
+  const program = env.TERM_PROGRAM ?? '';
+  if (['iTerm.app', 'WezTerm', 'vscode', 'Hyper', 'ghostty'].includes(program)) return 24;
+  if (env.WT_SESSION) return 24;
+  if (env.KITTY_WINDOW_ID) return 24;
+  if (env.ALACRITTY_LOG || term.startsWith('alacritty')) return 24;
+
+  if (term.includes('256')) return 8;
+  if (term.includes('color') || term.startsWith('xterm') || term.startsWith('screen')) return 4;
+  if (term === '') return 0;
+  return 4;
+}
+
+export function detectUnicode(env: Record<string, string | undefined>): UnicodeLevel {
+  const locale = env.LC_ALL ?? env.LC_CTYPE ?? env.LANG ?? '';
+  if (!/utf-?8/i.test(locale)) {
+    // Windows Terminal and modern macOS terminals are UTF-8 without saying so.
+    if (env.WT_SESSION || env.TERM_PROGRAM === 'iTerm.app' || env.TERM_PROGRAM === 'Apple_Terminal') {
+      return 'full';
+    }
+    return 'ascii';
+  }
+  const term = env.TERM ?? '';
+  if (term === 'linux') return 'bmp';
+  return 'full';
+}
+
+/**
+ * Some terminals report a TERM their multiplexer chose. tmux and screen pass
+ * most sequences through but swallow a few, so they are treated as capable
+ * with the known gaps closed.
+ */
+function inMultiplexer(env: Record<string, string | undefined>): boolean {
+  return Boolean(env.TMUX) || (env.TERM ?? '').startsWith('screen');
+}
+
+export function detectCapabilities(input: DetectionInput): TerminalCapabilities {
+  const { env, isTTY } = input;
+  const term = env.TERM ?? '';
+
+  if (!isTTY || term === 'dumb') {
+    return { ...MINIMAL_CAPABILITIES, colorDepth: detectColorDepth(env, isTTY) };
+  }
+
+  const colorDepth = detectColorDepth(env, isTTY);
+  const unicode = detectUnicode(env);
+  const mux = inMultiplexer(env);
+  const program = env.TERM_PROGRAM ?? '';
+
+  // Terminals that speak the kitty keyboard protocol, which is what makes
+  // `ctrl+enter` a different key from `enter` rather than the same byte.
+  //
+  // VS Code belongs here: its terminal is xterm.js, which has implemented the
+  // protocol since 6.1, and `terminal.integrated.enableKittyKeyboardProtocol`
+  // defaults to on. Without it in this list nothing ever pushes `CSI > 1 u`,
+  // so the terminal keeps sending legacy codes and every modified enter,
+  // tab and escape arrives as its unmodified twin.
+  const kitty = Boolean(env.KITTY_WINDOW_ID) || program === 'WezTerm'
+    || program === 'ghostty' || program === 'vscode';
+  const modern =
+    kitty || program === 'iTerm.app' || Boolean(env.WT_SESSION) ||
+    term.startsWith('alacritty') || program === 'vscode';
+
+  return {
+    colorDepth,
+    unicode,
+    wideChars: unicode !== 'ascii',
+    mouse: true,
+    wheel: true,
+    focusEvents: true,
+    paste: true,
+    // tmux rewrites OSC 8, and Apple Terminal ignores it.
+    hyperlinks: modern && !mux && program !== 'Apple_Terminal',
+    clipboard: modern || mux,
+    altScreen: true,
+    cursor: true,
+    // Synchronized output is safe when supported and harmless when not, but
+    // tmux below 3.4 mangles it, so it is off inside a multiplexer.
+    synchronizedOutput: modern && !mux,
+    title: true,
+    kittyKeyboard: kitty && !mux,
+  };
+}
+
+export function applyOverrides(
+  base: TerminalCapabilities,
+  overrides: CapabilityOverrides | undefined,
+): TerminalCapabilities {
+  return overrides ? { ...base, ...overrides } : base;
+}
+
+/** Describe the environment, for `textui doctor` and the inspector. */
+export function describeEnvironment(input: DetectionInput): Record<string, string> {
+  const { env } = input;
+  return {
+    TERM: env.TERM ?? '(unset)',
+    COLORTERM: env.COLORTERM ?? '(unset)',
+    TERM_PROGRAM: env.TERM_PROGRAM ?? '(unset)',
+    LANG: env.LC_ALL ?? env.LANG ?? '(unset)',
+    multiplexer: env.TMUX ? 'tmux' : (env.TERM ?? '').startsWith('screen') ? 'screen' : 'none',
+    ssh: env.SSH_TTY || env.SSH_CONNECTION ? 'yes' : 'no',
+    tty: String(input.isTTY),
+    size: `${input.columns ?? '?'}x${input.rows ?? '?'}`,
+  };
+}

package/src/capture.ts

@@ -0,0 +1,101 @@
+import type { CellBuffer, ColorDepth, TerminalCapabilities } from '@textui/core';
+import { COLOR_DEFAULT, packColor } from '@textui/core';
+import { ATTR_ON, bgSequence, fgSequence } from './writer.js';
+import * as ansi from './ansi.js';
+
+/**
+ * A frame, as a string you can keep.
+ *
+ * This is not what `Writer` does. The writer's job is to get from the frame on
+ * screen to the next one in as few bytes as it can, so what it emits is cursor
+ * moves and the differences between them - correct on a live terminal and
+ * meaningless in a file. A capture is the opposite: every cell, in order, rows
+ * separated by newlines and no cursor control at all, so it can be written to
+ * a file, piped, pasted into a bug report, or `cat`ed back with nothing else
+ * on screen having to be true.
+ *
+ * A terminal application cannot show you what it looked like when it went
+ * wrong - the screen is the output, and the next redraw destroys the evidence.
+ * This is how it hands you the evidence instead.
+ */
+export interface CaptureOptions {
+  /** Emit SGR colour. Off gives plain text, which is what a diff can read. */
+  colors?: boolean;
+  /** Reduce colour to this depth. Defaults to what the terminal reported. */
+  colorDepth?: ColorDepth;
+}
+
+export function captureBuffer(
+  buffer: CellBuffer,
+  capabilities: TerminalCapabilities,
+  options: CaptureOptions = {},
+): string {
+  const depth = options.colorDepth ?? capabilities.colorDepth;
+  const colors = (options.colors ?? true) && depth > 0;
+  const rows: string[] = [];
+
+  for (let y = 0; y < buffer.height; y++) {
+    let row = '';
+    let fg = COLOR_DEFAULT;
+    let bg = COLOR_DEFAULT;
+    let attrs = 0;
+    // Where the row last stopped being blank. A run of default-styled spaces
+    // at the end is trailing whitespace; the same run with a background is a
+    // part of the picture, so only the first kind is trimmed.
+    let end = 0;
+    let plain = '';
+
+    for (let x = 0; x < buffer.width; x++) {
+      const cell = buffer.get(x, y);
+      if (!cell || cell.continuation === true) continue;
+
+      const cellFg = packColor(cell.fg);
+      const cellBg = packColor(cell.bg);
+      const cellAttrs = cell.attrs;
+
+      if (colors && (cellFg !== fg || cellBg !== bg || cellAttrs !== attrs)) {
+        const codes: (string | number)[] = [];
+        // One reset and a restatement, rather than eight ways to turn things
+        // off - the same trade the writer makes, for the same reason.
+        if ((attrs & ~cellAttrs) !== 0) {
+          codes.push(ansi.SGR.reset);
+          fg = COLOR_DEFAULT;
+          bg = COLOR_DEFAULT;
+          attrs = 0;
+        }
+        for (const [bit, code] of ATTR_ON) {
+          if (cellAttrs & bit & ~attrs) codes.push(code);
+        }
+        if (cellFg !== fg) codes.push(fgSequence(cellFg, depth));
+        if (cellBg !== bg) codes.push(bgSequence(cellBg, depth));
+        if (codes.length > 0) row += `${ansi.CSI}${codes.join(';')}m`;
+        fg = cellFg;
+        bg = cellBg;
+        attrs = cellAttrs;
+      }
+
+      row += cell.char;
+      plain += cell.char;
+      if (cell.char !== ' ' || cellBg !== COLOR_DEFAULT || cellAttrs !== 0) end = plain.length;
+    }
+
+    const styled = colors && (fg !== COLOR_DEFAULT || bg !== COLOR_DEFAULT || attrs !== 0);
+    if (end < plain.length) {
+      // Nothing after the last real cell, so drop it - and reset first, or the
+      // last colour bleeds to the edge of whatever terminal shows this.
+      row = trimTail(row, plain.length - end);
+      if (styled) row += `${ansi.CSI}${ansi.SGR.reset}m`;
+    } else if (styled) {
+      row += `${ansi.CSI}${ansi.SGR.reset}m`;
+    }
+
+    rows.push(row);
+  }
+
+  return rows.join('\n');
+}
+
+/** Drop `count` characters from the end, which are known to be plain spaces. */
+function trimTail(row: string, count: number): string {
+  return count <= 0 ? row : row.slice(0, row.length - count);
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export * as ansi from './ansi.js';
+export { Writer, createWriter } from './writer.js';
+export { captureBuffer } from './capture.js';
+export type { CaptureOptions } from './capture.js';
+export { bufferToSvg } from './svg.js';
+export type { SvgOptions } from './svg.js';
+export {
+  detectCapabilities, detectColorDepth, detectUnicode,
+  applyOverrides, describeEnvironment,
+} from './capabilities.js';
+export type { DetectionInput } from './capabilities.js';
+export { InputDecoder, createDecoder } from './input.js';
+export type { DecoderOptions } from './input.js';
+export { NodeTerminalAdapter, createNodeTerminal } from './node.js';
+export type { NodeAdapterOptions, TerminalInput, TerminalOutput, TerminalSignal } from './node.js';
+export { VirtualTerminalAdapter, createVirtualTerminal } from './virtual.js';
+export type { VirtualAdapterOptions } from './virtual.js';