terminal-pilot 0.0.50 → 0.0.52

package/node_modules/toolcraft-design/dist/explorer/state.d.ts

@@ -1,5 +1,12 @@
 import { type ResolvedBindings } from "./keymap.js";
 export type Tone = "success" | "warning" | "error" | "info" | "muted";
+export interface ConfirmPromptOptions {
+    title: string;
+    message: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    destructive?: boolean;
+}
 export interface Row {
     id: string;
     title: string;
@@ -37,7 +44,9 @@ export interface Action<R> {
     id: string;
     label: string | (() => string);
     key?: string | string[];
+    accelerator?: string;
     predicate?: (ctx: ActionContext<R>) => boolean;
+    visible?: (row: Row) => boolean;
     handler: (ctx: ActionContext<R>) => void | Promise<void>;
     destructive?: boolean;
     primary?: boolean;
@@ -57,8 +66,40 @@ export interface ActionContext<R> {
         content: string;
     }) => void;
     toast: (msg: string, tone?: Tone) => void;
-    confirm: (prompt: string) => Promise<boolean>;
+    confirm: (prompt: string | ConfirmPromptOptions) => Promise<boolean>;
+    promptText: (options: {
+        title: string;
+        label: string;
+        initialValue?: string;
+        placeholder?: string;
+    }) => Promise<string | null>;
     exit: (after?: () => void | Promise<void>) => void;
+    activePane?: PaneRuntimeState;
+    inactivePane?: PaneRuntimeState;
+}
+export interface ListPaneConfig {
+    id: string;
+    kind: "list";
+    title: string;
+    rows: () => Promise<Row[]>;
+    emptyHint?: string;
+    multiSelect?: boolean;
+}
+export interface DetailPaneConfig {
+    id: string;
+    kind: "detail";
+    title: string;
+    titleForRow?: (row: Row | undefined) => string;
+    render: (row: Row | undefined, ctx: DetailCtx) => string | Promise<string>;
+}
+export type PaneConfig = ListPaneConfig | DetailPaneConfig;
+export interface PaneRuntimeState {
+    id: string;
+    title: string;
+    rows: Row[];
+    cursor: number;
+    selected: Set<string>;
+    filter: string;
 }
 export interface ReorderContext {
     refresh: () => Promise<void>;
@@ -66,9 +107,10 @@ export interface ReorderContext {
 }
 export interface ExplorerConfig<R> {
     title: string;
-    rows: () => Promise<Row[]>;
-    refresh?: () => Promise<void>;
-    detail: Detail<R>;
+    panes?: PaneConfig[];
+    rows?: () => Promise<Row[]>;
+    refresh?: () => void | Promise<void>;
+    detail?: Detail<R>;
     actions: Action<R>[];
     reorder?: {
         onReorder: (orderedIds: string[], ctx?: ReorderContext) => void | Promise<void>;
@@ -79,7 +121,14 @@ export interface ExplorerConfig<R> {
     initialFilter?: string;
     /** Synchronous first paint rows; still refreshed via `rows()` after start. */
     initialRows?: Row[];
+    /** Disable terminal mouse reporting when native text selection is more useful than wheel input. */
+    mouse?: boolean;
 }
+export type NormalizedExplorerConfig<R> = ExplorerConfig<R> & {
+    rows: () => Promise<Row[]>;
+    detail: Detail<R>;
+};
+export declare function normalizeExplorerConfig<R>(config: ExplorerConfig<R>): NormalizedExplorerConfig<R>;
 export declare const REGION_HEADER: number;
 export declare const REGION_LIST: number;
 export declare const REGION_DETAIL: number;
@@ -97,6 +146,7 @@ export interface ExplorerState {
     title: string;
     emptyHint: string;
     rows: Row[];
+    rowsLoading: boolean;
     filtered: number[];
     matchPositions: Map<number, number[]>;
     cursor: number;
@@ -106,6 +156,8 @@ export interface ExplorerState {
     detail: {
         rowId: string | null;
         items: DetailItem[] | null;
+        allItems?: DetailItem[] | null;
+        filter?: string;
         cursor: number;
         scroll: number;
         token: number;
@@ -117,9 +169,21 @@ export interface ExplorerState {
         kind: "help";
     } | {
         kind: "confirm";
-        action: Action<unknown>;
-        rows: Row[];
+        title: string;
+        message: string;
+        confirmLabel: string;
+        cancelLabel: string;
+        destructive: boolean;
         resolver: (ok: boolean) => void;
+        action?: Action<unknown>;
+        rows?: Row[];
+    } | {
+        kind: "input";
+        title: string;
+        label: string;
+        value: string;
+        placeholder?: string;
+        resolver: (value: string | null) => void;
     } | {
         kind: "palette";
         query: string;
@@ -140,13 +204,20 @@ export interface ExplorerState {
     layout: ExplorerLayoutMode;
     bindings: ResolvedBindings;
     actionState: Map<string, ActionStateEntry>;
+    suspended: boolean;
+    paneDefinitions: Array<{
+        id: string;
+        title: string;
+        kind: "list" | "detail";
+        titleForRow?: (row: Row | undefined) => string;
+    }>;
 }
 export interface ActionStateEntry {
     available: boolean;
     label: string;
     running?: boolean;
     action?: Action<unknown>;
-    source?: "row" | "detail";
+    source?: "row" | "detail" | "both";
 }
 export declare function createInitialState<R>(config: ExplorerConfig<R>, size: ExplorerSize): ExplorerState;
-export declare function resolveExplorerLayoutMode(cols: number): ExplorerLayoutMode;
+export declare function resolveExplorerLayoutMode(cols: number, rows?: number): ExplorerLayoutMode;

package/node_modules/toolcraft-design/dist/explorer/state.js

@@ -1,29 +1,61 @@
 import { resolveBindings } from "./keymap.js";
+export function normalizeExplorerConfig(config) {
+    if (config.panes === undefined) {
+        if (config.rows === undefined || config.detail === undefined)
+            throw new Error("Explorer requires panes");
+        return config;
+    }
+    if (config.panes.length < 1 || config.panes.length > 3)
+        throw new Error("Explorer requires 1 to 3 panes");
+    const list = config.panes.find((pane) => pane.kind === "list");
+    if (list === undefined)
+        throw new Error("Explorer requires a list pane");
+    const companion = config.panes.find((pane) => pane !== list);
+    const detail = companion?.kind === "detail"
+        ? {
+            items: async (row, ctx) => {
+                const content = await companion.render(row, ctx);
+                if (ctx.signal.aborted)
+                    return [];
+                return [{ id: row.id, render: () => content, renderedContent: content }];
+            }
+        }
+        : companion?.kind === "list"
+            ? {
+                items: async () => (await companion.rows()).map((row) => ({ ...row, render: () => "" })),
+                actions: config.actions
+            }
+            : { items: async () => [] };
+    return {
+        ...config,
+        rows: list.rows,
+        detail,
+        multiSelect: list.multiSelect ?? config.multiSelect,
+        emptyHint: list.emptyHint ?? config.emptyHint
+    };
+}
 export const REGION_HEADER = 1 << 0;
 export const REGION_LIST = 1 << 1;
 export const REGION_DETAIL = 1 << 2;
 export const REGION_FOOTER = 1 << 3;
 export const REGION_MODAL = 1 << 4;
 export const REGION_TOAST = 1 << 5;
-export const REGION_ALL = REGION_HEADER |
-    REGION_LIST |
-    REGION_DETAIL |
-    REGION_FOOTER |
-    REGION_MODAL |
-    REGION_TOAST;
+export const REGION_ALL = REGION_HEADER | REGION_LIST | REGION_DETAIL | REGION_FOOTER | REGION_MODAL | REGION_TOAST;
 export function createInitialState(config, size) {
+    const normalizedConfig = normalizeExplorerConfig(config);
     const normalizedSize = {
         cols: normalizeSize(size.cols),
         rows: normalizeSize(size.rows)
     };
-    const multiSelect = config.multiSelect ?? true;
-    const initialRows = config.initialRows ?? [];
-    const initialFilter = config.initialFilter ?? "";
+    const multiSelect = normalizedConfig.multiSelect ?? true;
+    const initialRows = normalizedConfig.initialRows ?? [];
+    const initialFilter = normalizedConfig.initialFilter ?? "";
     // Defer filtering to first rowsLoaded when empty; seed list immediately when provided.
     return {
-        title: config.title,
-        emptyHint: config.emptyHint ?? "No detail",
+        title: normalizedConfig.title,
+        emptyHint: normalizedConfig.emptyHint ?? "No detail",
         rows: initialRows,
+        rowsLoading: true,
         filtered: initialRows.map((_, index) => index),
         matchPositions: new Map(),
         cursor: 0,
@@ -33,6 +65,8 @@ export function createInitialState(config, size) {
         detail: {
             rowId: initialRows[0]?.id ?? null,
             items: null,
+            allItems: null,
+            filter: "",
             cursor: 0,
             scroll: 0,
             token: initialRows.length > 0 ? 1 : 0,
@@ -44,17 +78,35 @@ export function createInitialState(config, size) {
         toast: null,
         dirty: REGION_ALL,
         size: normalizedSize,
-        layout: resolveExplorerLayoutMode(normalizedSize.cols),
-        bindings: resolveBindings(config),
-        actionState: createInitialActionState(config)
+        layout: resolveExplorerLayoutMode(normalizedSize.cols, normalizedSize.rows),
+        bindings: resolveBindings(normalizedConfig),
+        actionState: createInitialActionState(normalizedConfig),
+        suspended: false,
+        paneDefinitions: normalizedConfig.panes?.map(({ id, title, kind, ...pane }) => ({
+            id,
+            title,
+            kind,
+            ...(kind === "detail" && "titleForRow" in pane ? { titleForRow: pane.titleForRow } : {})
+        })) ?? [
+            { id: "list", title: normalizedConfig.title, kind: "list" },
+            { id: "detail", title: "Preview", kind: "detail" }
+        ]
     };
 }
 function createInitialActionState(config) {
     const state = new Map();
-    for (const [source, actions] of [["row", config.actions], ["detail", config.detail.actions ?? []]]) {
+    for (const [source, actions] of [
+        ["row", config.actions],
+        ["detail", config.detail?.actions ?? []]
+    ]) {
         for (const action of actions) {
             if (state.has(action.id)) {
-                throw new Error(`Duplicate explorer action id: ${action.id}`);
+                const isSharedListAction = config.panes?.some((pane) => pane.kind === "list" && pane !== config.panes?.[0]) === true;
+                if (!isSharedListAction)
+                    throw new Error(`Duplicate explorer action id: ${action.id}`);
+                const existing = state.get(action.id);
+                state.set(action.id, { ...existing, source: "both" });
+                continue;
             }
             state.set(action.id, {
                 available: true,
@@ -66,8 +118,8 @@ function createInitialActionState(config) {
     }
     return state;
 }
-export function resolveExplorerLayoutMode(cols) {
-    if (cols < 40) {
+export function resolveExplorerLayoutMode(cols, rows = 24) {
+    if (cols < 60 || rows < 8) {
         return "too-narrow";
     }
     if (cols < 80) {

package/node_modules/toolcraft-design/dist/index.d.ts

@@ -37,8 +37,8 @@ export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 export type { Dashboard, DashboardOptions } from "./dashboard/index.js";
 export * as explorer from "./explorer/index.js";
-export { runExplorer, runTwoPaneExplorer, singleDetail } from "./explorer/index.js";
-export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, TwoPaneAction, TwoPaneActionContext, TwoPaneDefinition, TwoPaneExplorerConfig, TwoPanePaneState, TwoPaneRow, ExplorerConfig, ReorderContext, Tone } from "./explorer/index.js";
+export { runExplorer, singleDetail, normalizeExplorerConfig } from "./explorer/index.js";
+export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, ConfirmPromptOptions, ExplorerConfig, PaneConfig, ListPaneConfig, DetailPaneConfig, PaneRuntimeState, ReorderContext, Tone } from "./explorer/index.js";
 export * as prompts from "./prompts/index.js";
 export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";
 export type { SelectOptions, MultiselectOptions, TextOptions, ConfirmOptions, PasswordOptions, SpinnerOptions, WithSpinnerOptions } from "./prompts/index.js";
@@ -54,3 +54,9 @@ export { configureTheme, getThemeConfig, resetTheme } from "./internal/theme-sta
 export { stripAnsi } from "./internal/strip-ansi.js";
 export { resolveOutputFormat, resetOutputFormatCache, withOutputFormat } from "./internal/output-format.js";
 export type { OutputFormat } from "./internal/output-format.js";
+export { createTerminalDriver } from "./terminal/driver.js";
+export type { TerminalDriver, TerminalInputEvent, Size as TerminalSize } from "./terminal/driver.js";
+export { Screen } from "./screen/screen.js";
+export type { Cell as ScreenCell, ScreenSize, ScreenSurface } from "./screen/screen.js";
+export { packStyle, styleToSgrDelta } from "./screen/style.js";
+export type { PackedStyle } from "./screen/style.js";

package/node_modules/toolcraft-design/dist/index.js

@@ -29,7 +29,7 @@ export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 // Explorer
 export * as explorer from "./explorer/index.js";
-export { runExplorer, runTwoPaneExplorer, singleDetail } from "./explorer/index.js";
+export { runExplorer, singleDetail, normalizeExplorerConfig } from "./explorer/index.js";
 // Prompts
 export * as prompts from "./prompts/index.js";
 export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";
@@ -44,3 +44,7 @@ export { getTheme, resolveThemeName, resetThemeCache } from "./internal/theme-de
 export { configureTheme, getThemeConfig, resetTheme } from "./internal/theme-state.js";
 export { stripAnsi } from "./internal/strip-ansi.js";
 export { resolveOutputFormat, resetOutputFormatCache, withOutputFormat } from "./internal/output-format.js";
+// Terminal and screen primitives
+export { createTerminalDriver } from "./terminal/driver.js";
+export { Screen } from "./screen/screen.js";
+export { packStyle, styleToSgrDelta } from "./screen/style.js";

package/node_modules/toolcraft-design/dist/screen/ansi-text.d.ts

@@ -0,0 +1,2 @@
+import type { Cell } from "./screen.js";
+export declare function ansiToCells(text: string): Cell[];

package/node_modules/toolcraft-design/dist/screen/ansi-text.js

@@ -0,0 +1,35 @@
+import { parseAnsi } from "../dashboard/ansi.js";
+import { graphemes, graphemeWidth } from "../dashboard/terminal-width.js";
+import { packStyle } from "./style.js";
+const COLORS = new Map([
+    ["black", 1], ["red", 1], ["green", 2], ["yellow", 3], ["blue", 4],
+    ["magenta", 5], ["cyan", 6], ["white", 7], ["gray", 8]
+]);
+export function ansiToCells(text) {
+    const output = [];
+    const lines = parseAnsi(text);
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        if (lineIndex > 0)
+            output.push(cell("\n", 1, 0));
+        for (const segment of lines[lineIndex].segments) {
+            const style = packed(segment.style);
+            for (const grapheme of graphemes(segment.text))
+                output.push(cell(grapheme, graphemeWidth(grapheme) > 1 ? 2 : 1, style));
+        }
+    }
+    return output;
+}
+function packed(style) {
+    return packStyle({
+        bold: style.bold,
+        dim: style.dim,
+        underline: style.underline,
+        inverse: style.inverse,
+        fg: colorNumber(style.fg),
+        bg: colorNumber(style.bg)
+    });
+}
+function colorNumber(value) { return value === undefined ? 0 : (COLORS.get(value) ?? 0); }
+function cell(ch, width, style) {
+    return { ch, width, style, fg: (style >> 8) & 0xff, bg: (style >> 16) & 0xff };
+}

package/node_modules/toolcraft-design/dist/screen/screen.d.ts

@@ -0,0 +1,40 @@
+import type { CellStyle, Rect } from "../dashboard/types.js";
+import { type PackedStyle } from "./style.js";
+export interface Cell {
+    ch: string;
+    width: 1 | 2;
+    style: PackedStyle;
+    fg: number;
+    bg: number;
+}
+export interface ScreenSize {
+    cols: number;
+    rows: number;
+}
+export interface ScreenSurface {
+    readonly width: number;
+    readonly height: number;
+    put(x: number, y: number, text: string, style?: CellStyle | PackedStyle): void;
+    clearRect(rect: Rect, style?: CellStyle | PackedStyle): void;
+}
+export declare class Screen {
+    private cols;
+    private rows;
+    private front;
+    private back;
+    private outputStyle;
+    private readonly colors;
+    constructor(size?: ScreenSize, options?: {
+        colors?: boolean;
+    });
+    get width(): number;
+    get height(): number;
+    resize(size: ScreenSize): void;
+    cell(x: number, y: number, ch: string, style?: PackedStyle): void;
+    text(x: number, y: number, text: string, style?: PackedStyle): void;
+    put(x: number, y: number, text: string, style?: CellStyle | PackedStyle): void;
+    clearRect(rect: Rect, style?: CellStyle | PackedStyle): void;
+    flush(): string;
+    private index;
+    private inBounds;
+}

package/node_modules/toolcraft-design/dist/screen/screen.js

@@ -0,0 +1,122 @@
+import { graphemes, graphemeWidth } from "../dashboard/terminal-width.js";
+import { background, foreground, styleToSgrDelta } from "./style.js";
+const EMPTY = { ch: " ", width: 1, style: 0, fg: 0, bg: 0 };
+export class Screen {
+    cols = 0;
+    rows = 0;
+    front = [];
+    back = [];
+    outputStyle = 0;
+    colors;
+    constructor(size = { cols: 0, rows: 0 }, options = {}) {
+        this.colors = options.colors ?? (process.env.NO_COLOR === undefined && process.env.TERM !== "dumb");
+        this.resize(size);
+    }
+    get width() { return this.cols; }
+    get height() { return this.rows; }
+    resize(size) {
+        this.cols = normalize(size.cols);
+        this.rows = normalize(size.rows);
+        this.front = cells(this.cols * this.rows);
+        this.back = cells(this.cols * this.rows);
+    }
+    cell(x, y, ch, style = 0) {
+        if (!this.inBounds(x, y) || ch.length === 0)
+            return;
+        const segment = graphemes(ch)[0];
+        if (segment === undefined)
+            return;
+        const measured = graphemeWidth(segment);
+        const width = measured > 1 ? 2 : 1;
+        this.back[this.index(x, y)] = makeCell(segment, width, style);
+        if (width === 2 && this.inBounds(x + 1, y))
+            this.back[this.index(x + 1, y)] = makeCell("", 1, style);
+    }
+    text(x, y, text, style = 0) {
+        let offset = 0;
+        for (const segment of graphemes(text)) {
+            const width = Math.max(0, graphemeWidth(segment));
+            if (width > 0)
+                this.cell(x + offset, y, segment, style);
+            offset += width;
+        }
+    }
+    put(x, y, text, style = 0) {
+        this.text(x, y, text, typeof style === "number" ? style : packLegacyStyle(style));
+    }
+    clearRect(rect, style = 0) {
+        const packed = typeof style === "number" ? style : packLegacyStyle(style);
+        const startX = Math.max(0, rect.x);
+        const startY = Math.max(0, rect.y);
+        const endX = Math.min(this.cols, rect.x + Math.max(0, rect.width));
+        const endY = Math.min(this.rows, rect.y + Math.max(0, rect.height));
+        for (let y = startY; y < endY; y += 1)
+            for (let x = startX; x < endX; x += 1)
+                this.cell(x, y, " ", packed);
+    }
+    flush() {
+        const changed = new Set();
+        for (let index = 0; index < this.back.length; index += 1) {
+            if (!equal(this.front[index], this.back[index])) {
+                changed.add(index);
+                const old = this.front[index];
+                const next = this.back[index];
+                if ((old.width === 2 || next.width === 2) && (index % this.cols) + 1 < this.cols)
+                    changed.add(index + 1);
+                if (old.ch === "" && index % this.cols > 0)
+                    changed.add(index - 1);
+            }
+        }
+        let output = "";
+        let currentStyle = this.outputStyle;
+        const ordered = [...changed].sort((left, right) => left - right);
+        let cursor = 0;
+        while (cursor < ordered.length) {
+            const start = ordered[cursor];
+            const y = Math.floor(start / this.cols);
+            let end = start;
+            while (cursor + 1 < ordered.length && ordered[cursor + 1] === end + 1 && Math.floor(ordered[cursor + 1] / this.cols) === y) {
+                cursor += 1;
+                end += 1;
+            }
+            output += `\u001b[${y + 1};${(start % this.cols) + 1}H`;
+            for (let index = start; index <= end; index += 1) {
+                const cell = this.back[index];
+                const delta = styleToSgrDelta(currentStyle, cell.style, this.colors);
+                output += delta;
+                currentStyle = cell.style;
+                output += cell.ch.length === 0 ? "" : cell.ch;
+            }
+            cursor += 1;
+        }
+        this.front = this.back;
+        this.back = cells(this.cols * this.rows);
+        this.outputStyle = currentStyle;
+        return output;
+    }
+    index(x, y) { return y * this.cols + x; }
+    inBounds(x, y) { return x >= 0 && y >= 0 && x < this.cols && y < this.rows; }
+}
+function makeCell(ch, width, style) {
+    return { ch, width, style, fg: foreground(style), bg: background(style) };
+}
+function cells(length) { return Array.from({ length }, () => ({ ...EMPTY })); }
+function equal(left, right) { return left.ch === right.ch && left.width === right.width && left.style === right.style; }
+function normalize(value) { return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0; }
+function packLegacyStyle(style) {
+    return (style.bold ? 1 : 0)
+        | (style.dim ? 2 : 0)
+        | (style.underline ? 4 : 0)
+        | (style.inverse ? 8 : 0)
+        | (legacyColor(style.fg) << 8)
+        | (legacyColor(style.bg) << 16);
+}
+function legacyColor(value) {
+    if (value === undefined)
+        return 0;
+    const names = ["", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray"];
+    const exact = names.indexOf(value);
+    if (exact >= 0)
+        return exact;
+    return value.startsWith("#") ? 7 : 0;
+}

package/node_modules/toolcraft-design/dist/screen/style.d.ts

@@ -0,0 +1,16 @@
+export declare const STYLE_BOLD: number;
+export declare const STYLE_DIM: number;
+export declare const STYLE_UNDERLINE: number;
+export declare const STYLE_INVERSE: number;
+export type PackedStyle = number;
+export declare function packStyle(style: {
+    bold?: boolean;
+    dim?: boolean;
+    underline?: boolean;
+    inverse?: boolean;
+    fg?: number;
+    bg?: number;
+}): PackedStyle;
+export declare function foreground(style: PackedStyle): number;
+export declare function background(style: PackedStyle): number;
+export declare function styleToSgrDelta(previous: PackedStyle, next: PackedStyle, colors?: boolean): string;

package/node_modules/toolcraft-design/dist/screen/style.js

@@ -0,0 +1,55 @@
+export const STYLE_BOLD = 1 << 0;
+export const STYLE_DIM = 1 << 1;
+export const STYLE_UNDERLINE = 1 << 2;
+export const STYLE_INVERSE = 1 << 3;
+const FG_SHIFT = 8;
+const BG_SHIFT = 16;
+const COLOR_MASK = 0xff;
+export function packStyle(style) {
+    let packed = 0;
+    if (style.bold)
+        packed |= STYLE_BOLD;
+    if (style.dim)
+        packed |= STYLE_DIM;
+    if (style.underline)
+        packed |= STYLE_UNDERLINE;
+    if (style.inverse)
+        packed |= STYLE_INVERSE;
+    packed |= ((style.fg ?? 0) & COLOR_MASK) << FG_SHIFT;
+    packed |= ((style.bg ?? 0) & COLOR_MASK) << BG_SHIFT;
+    return packed;
+}
+export function foreground(style) { return (style >> FG_SHIFT) & COLOR_MASK; }
+export function background(style) { return (style >> BG_SHIFT) & COLOR_MASK; }
+export function styleToSgrDelta(previous, next, colors = process.env.NO_COLOR === undefined && process.env.TERM !== "dumb") {
+    if (!colors)
+        return "";
+    if (previous === next)
+        return "";
+    const codes = [];
+    const previousIntensity = previous & (STYLE_BOLD | STYLE_DIM);
+    const nextIntensity = next & (STYLE_BOLD | STYLE_DIM);
+    if (previousIntensity !== nextIntensity) {
+        if ((previousIntensity & ~nextIntensity) !== 0)
+            codes.push(22);
+        if ((nextIntensity & STYLE_BOLD) !== 0 && ((previousIntensity & ~nextIntensity) !== 0 || (previousIntensity & STYLE_BOLD) === 0))
+            codes.push(1);
+        if ((nextIntensity & STYLE_DIM) !== 0 && ((previousIntensity & ~nextIntensity) !== 0 || (previousIntensity & STYLE_DIM) === 0))
+            codes.push(2);
+    }
+    flagDelta(codes, previous, next, STYLE_UNDERLINE, 4, 24);
+    flagDelta(codes, previous, next, STYLE_INVERSE, 7, 27);
+    const previousFg = foreground(previous);
+    const nextFg = foreground(next);
+    if (previousFg !== nextFg)
+        codes.push(nextFg === 0 ? 39 : 30 + nextFg);
+    const previousBg = background(previous);
+    const nextBg = background(next);
+    if (previousBg !== nextBg)
+        codes.push(nextBg === 0 ? 49 : 40 + nextBg);
+    return codes.length === 0 ? "" : `\u001b[${[...new Set(codes)].join(";")}m`;
+}
+function flagDelta(codes, previous, next, flag, on, off) {
+    if ((previous & flag) !== (next & flag))
+        codes.push((next & flag) === 0 ? off : on);
+}

package/node_modules/toolcraft-design/dist/terminal/driver.d.ts

@@ -0,0 +1,34 @@
+import { type TerminalInputEvent } from "./input.js";
+export interface Size {
+    cols: number;
+    rows: number;
+}
+export interface TerminalDriver {
+    start(): void;
+    stop(): void;
+    onEvent(fn: (event: TerminalInputEvent) => void): () => void;
+    onResize(fn: (size: Size) => void): () => void;
+    getSize(): Size;
+    writeFrame(ansi: string): void;
+}
+interface InputStream {
+    setRawMode?: (enabled: boolean) => void;
+    resume(): void;
+    pause(): void;
+    on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+    off(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+}
+interface OutputStream {
+    columns?: number;
+    rows?: number;
+    write(value: string): boolean;
+    on(event: "resize", listener: () => void): unknown;
+    off(event: "resize", listener: () => void): unknown;
+}
+export declare function createTerminalDriver(options?: {
+    input?: InputStream;
+    output?: OutputStream;
+    escTimeoutMs?: number;
+    mouse?: boolean;
+}): TerminalDriver;
+export type { TerminalInputEvent } from "./input.js";