toolcraft 0.0.232 → 0.0.233

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

@@ -1,10 +1,11 @@
+import { createRenderPerformanceMonitor, formatRenderPerformance } from "../render-performance.js";
 import { createLogger } from "../components/logger.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { ScreenBuffer, diff } from "./buffer.js";
 import { renderBorder } from "./components/border.js";
 import { defaultHints, renderFooter } from "./components/footer.js";
 import { renderOutputPane } from "./components/output-pane.js";
-import { renderStatsPane } from "./components/stats-pane.js";
+import { renderCompactStatsPane, renderStatsPane } from "./components/stats-pane.js";
 import { createKeymap } from "./keymap.js";
 import { computeDashboardLayout } from "./layout.js";
 import { createStore } from "./store.js";
@@ -32,6 +33,11 @@ export function createDashboard(opts = {}) {
     let unsubscribeResize;
     let started = false;
     let destroyed = false;
+    const performanceMonitor = createRenderPerformanceMonitor();
+    let showPerformance = false;
+    let scrollOffset = 0;
+    let heldOutput;
+    let renderTimer;
     function appendOutput(item) {
         if (destroyed) {
             return;
@@ -61,21 +67,74 @@ export function createDashboard(opts = {}) {
         driver.hideCursor();
         render();
         const activeStore = getStore();
+        let previousStats = activeStore.getState().stats;
+        let lastStatsPaint = -Infinity;
         unsubscribeStore = activeStore.onChange(() => {
-            render();
+            performanceMonitor.request("update");
+            const stats = activeStore.getState().stats;
+            if (stats !== previousStats) {
+                const statusChanged = stats.status !== previousStats.status;
+                previousStats = stats;
+                if (statusChanged || Date.now() - lastStatsPaint >= 16) {
+                    lastStatsPaint = Date.now();
+                    render();
+                }
+                else {
+                    renderTimer ??= setTimeout(render, 16);
+                }
+            }
+            else if (heldOutput === undefined && renderTimer === undefined) {
+                renderTimer = setTimeout(render, 16);
+            }
         });
         unsubscribeKeypress = driver.onKeypress((event) => {
             const command = resolveCommand(event);
             if (command === undefined) {
                 return;
             }
+            performanceMonitor.request("input");
+            if (command === "render-stats") {
+                showPerformance = !showPerformance;
+                render();
+                return;
+            }
+            if (command === "follow") {
+                heldOutput = undefined;
+                scrollOffset = 0;
+                render();
+                return;
+            }
+            if (command === "scroll-up" ||
+                command === "scroll-down" ||
+                command === "page-up" ||
+                command === "page-down") {
+                const page = Math.max(1, computeDashboardLayout({
+                    totalWidth: driver.getSize().cols,
+                    totalHeight: driver.getSize().rows,
+                    rightPaneWidth
+                }).leftPane.height);
+                const amount = command === "page-up" || command === "page-down" ? page : 1;
+                const direction = command === "scroll-up" || command === "page-up" ? 1 : -1;
+                if (direction > 0)
+                    heldOutput ??= getStore().getState().output;
+                scrollOffset = Math.max(0, scrollOffset + amount * direction);
+                if (scrollOffset === 0)
+                    heldOutput = undefined;
+                renderTimer ??= setTimeout(render, 16);
+                return;
+            }
             emitCommand(command);
         });
         unsubscribeResize = driver.onResize(() => {
+            performanceMonitor.request("resize");
+            previousBuffer = new ScreenBuffer(0, 0);
+            driver?.write("\u001b[2J");
             render();
         });
     }
     function stop() {
+        clearTimeout(renderTimer);
+        renderTimer = undefined;
         unsubscribeStore?.();
         unsubscribeKeypress?.();
         unsubscribeResize?.();
@@ -111,9 +170,12 @@ export function createDashboard(opts = {}) {
         return store;
     }
     function render() {
+        clearTimeout(renderTimer);
+        renderTimer = undefined;
         if (driver === undefined) {
             return;
         }
+        const startedAt = performanceMonitor.begin();
         const { cols, rows } = driver.getSize();
         const layout = computeDashboardLayout({
             totalWidth: cols,
@@ -127,10 +189,20 @@ export function createDashboard(opts = {}) {
             rightTitle: statsTitle,
             style: { dim: true }
         });
-        renderOutputPane(nextBuffer, layout.leftPane, state.output);
+        scrollOffset = renderOutputPane(nextBuffer, { ...layout.leftPane, height: Math.max(0, layout.leftPane.height - (showPerformance ? 1 : 0)) }, heldOutput ?? state.output, scrollOffset);
+        if (scrollOffset === 0)
+            heldOutput = undefined;
         renderStatsPane(nextBuffer, layout.rightPane, state.stats);
+        if (layout.summary)
+            renderCompactStatsPane(nextBuffer, layout.summary, state.stats);
         renderFooter(nextBuffer, layout.footer, footerHints);
-        driver.flush(diff(previousBuffer, nextBuffer));
+        if (showPerformance && layout.leftPane.height > 0) {
+            nextBuffer.putInRect(layout.leftPane, layout.leftPane.height - 1, formatRenderPerformance(performanceMonitor.snapshot(), layout.leftPane.width), { dim: true });
+        }
+        const changes = diff(previousBuffer, nextBuffer);
+        driver.flush(changes);
+        performanceMonitor.end(startedAt, { changedCells: changes.length });
+        opts.onPerformance?.(performanceMonitor.snapshot());
         previousBuffer = nextBuffer;
     }
     function emitCommand(command) {
@@ -159,6 +231,7 @@ export function createDashboard(opts = {}) {
         appendOutput,
         updateStats,
         onCommand,
+        getPerformance: performanceMonitor.snapshot,
         destroy
     };
 }

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

@@ -1,4 +1,6 @@
 export { createDashboard } from "./dashboard.js";
+export { createDashboardLineBuffer, createStreamingDashboardLineBuffer } from "./line-buffer.js";
+export { limitOutputPreview, createOutputPreviewBuffer } from "./output-preview.js";
 export { shouldUseInteractiveDashboard } from "./should-use-dashboard.js";
 export type { Dashboard, DashboardOptions } from "./dashboard.js";
 export { renderDashboardSnapshot } from "./snapshot.js";

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

@@ -1,4 +1,6 @@
 export { createDashboard } from "./dashboard.js";
+export { createDashboardLineBuffer, createStreamingDashboardLineBuffer } from "./line-buffer.js";
+export { limitOutputPreview, createOutputPreviewBuffer } from "./output-preview.js";
 export { shouldUseInteractiveDashboard } from "./should-use-dashboard.js";
 export { renderDashboardSnapshot } from "./snapshot.js";
 export { defaultHints } from "./components/footer.js";

package/node_modules/toolcraft-design/dist/dashboard/keymap.js

@@ -1,11 +1,30 @@
-const commands = ["forceQuit", "quit", "edit", "pause", "retry", "view-log"];
+const commands = [
+    "forceQuit",
+    "quit",
+    "edit",
+    "pause",
+    "retry",
+    "view-log",
+    "scroll-up",
+    "scroll-down",
+    "page-up",
+    "page-down",
+    "follow",
+    "render-stats"
+];
 const defaultBindings = {
     forceQuit: ["Ctrl+C"],
     quit: ["q"],
     edit: ["e"],
     pause: ["p"],
     retry: ["r"],
-    "view-log": ["l"]
+    "view-log": ["l"],
+    "scroll-up": ["up"],
+    "scroll-down": ["down"],
+    "page-up": ["pageup"],
+    "page-down": ["pagedown"],
+    follow: ["f", "F", "end"],
+    "render-stats": ["Ctrl+g"]
 };
 export function createKeymap(overrides, options) {
     const resolvedCommands = options?.commands ?? commands;
@@ -85,7 +104,10 @@ function parseBinding(binding) {
     if (value.length === 0) {
         return undefined;
     }
-    const parts = value.split("+").map((part) => part.trim()).filter(Boolean);
+    const parts = value
+        .split("+")
+        .map((part) => part.trim())
+        .filter(Boolean);
     if (parts.length === 0) {
         return undefined;
     }
@@ -146,9 +168,7 @@ function matchesSingleKey(binding, event) {
     if (binding.sequence !== undefined) {
         return false;
     }
-    if (binding.ctrl !== event.ctrl ||
-        binding.meta !== event.meta ||
-        binding.shift !== event.shift) {
+    if (binding.ctrl !== event.ctrl || binding.meta !== event.meta || binding.shift !== event.shift) {
         return false;
     }
     if (binding.ch !== undefined) {

package/node_modules/toolcraft-design/dist/dashboard/layout.d.ts

@@ -7,6 +7,7 @@ export type LayoutOptions = {
     borderWidth?: number;
 };
 export type DashboardLayout = {
+    summary?: Rect;
     outerBorder: Rect;
     leftPane: Rect;
     rightPane: Rect;

package/node_modules/toolcraft-design/dist/dashboard/layout.js

@@ -2,6 +2,7 @@ const DEFAULT_RIGHT_PANE_WIDTH = 25;
 const DEFAULT_FOOTER_HEIGHT = 1;
 const DEFAULT_BORDER_WIDTH = 1;
 const MIN_LEFT_PANE_WIDTH = 20;
+const MIN_READABLE_OUTPUT_WIDTH = 40;
 export function computeDashboardLayout(opts) {
     const totalWidth = normalizeSize(opts.totalWidth);
     const totalHeight = normalizeSize(opts.totalHeight);
@@ -11,8 +12,8 @@ export function computeDashboardLayout(opts) {
     const maxX = Math.max(0, totalWidth - 1);
     const maxY = Math.max(0, totalHeight - 1);
     const outerBorder = { x: 0, y: 0, width: totalWidth, height: totalHeight };
-    const innerWidth = Math.max(0, totalWidth - (borderWidth * 2));
-    const innerHeight = Math.max(0, totalHeight - (borderWidth * 2));
+    const innerWidth = Math.max(0, totalWidth - borderWidth * 2);
+    const innerHeight = Math.max(0, totalHeight - borderWidth * 2);
     const innerX = clampCoordinate(borderWidth, maxX);
     const innerY = clampCoordinate(borderWidth, maxY);
     const dividerWidth = innerWidth > 0 ? 1 : 0;
@@ -41,7 +42,7 @@ export function computeDashboardLayout(opts) {
     const footerY = clampCoordinate(footerDividerY + footerDividerHeight, maxY);
     const footerDividerLeft = innerX;
     const footerDividerRight = clampCoordinate(Math.max(innerX, totalWidth - borderWidth - 1), maxX);
-    return {
+    const layout = {
         outerBorder,
         leftPane,
         rightPane,
@@ -62,6 +63,21 @@ export function computeDashboardLayout(opts) {
             right: footerDividerRight
         }
     };
+    if (innerWidth > 0 &&
+        requestedRightPaneWidth > 0 &&
+        availablePaneWidth < MIN_READABLE_OUTPUT_WIDTH + requestedRightPaneWidth) {
+        const summaryHeight = Math.min(2, contentHeight);
+        layout.summary = { x: innerX, y: innerY, width: innerWidth, height: summaryHeight };
+        layout.leftPane = {
+            x: innerX,
+            y: innerY + summaryHeight,
+            width: innerWidth,
+            height: Math.max(0, contentHeight - summaryHeight)
+        };
+        layout.rightPane = { x: maxX, y: innerY, width: 0, height: 0 };
+        layout.divider = { x: maxX, top: innerY, bottom: innerY };
+    }
+    return layout;
 }
 function computeLeftPaneWidth(availablePaneWidth, requestedRightPaneWidth) {
     if (availablePaneWidth <= 0) {

package/node_modules/toolcraft-design/dist/dashboard/line-buffer.d.ts

@@ -0,0 +1,9 @@
+export declare function createDashboardLineBuffer(emit: (line: string) => void): {
+    push(chunk: string): void;
+    flush(): void;
+    preview(): string;
+};
+export declare function createStreamingDashboardLineBuffer(emit: (line: string, id: string) => void): {
+    push(chunk: string): void;
+    flush(): void;
+};

package/node_modules/toolcraft-design/dist/dashboard/line-buffer.js

@@ -0,0 +1,63 @@
+import { randomUUID } from "node:crypto";
+import { limitOutputPreview, MAX_OUTPUT_PREVIEW_CHARS, OUTPUT_TRUNCATION_NOTICE, retainOutputTail } from "./output-preview.js";
+import { createTerminalStringFilter } from "./terminal-strings.js";
+export function createDashboardLineBuffer(emit) {
+    let pending = "";
+    let omitted = false;
+    const strings = createTerminalStringFilter();
+    return {
+        preview() {
+            const line = pending.endsWith("\r") ? pending.slice(0, -1) : pending;
+            return (omitted ? OUTPUT_TRUNCATION_NOTICE : "") + line;
+        },
+        push(chunk) {
+            const text = pending + strings.push(chunk);
+            let start = 0;
+            let newline = text.indexOf("\n");
+            while (newline !== -1) {
+                const raw = text.slice(start, newline);
+                const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+                emit(limitOutputPreview((omitted ? OUTPUT_TRUNCATION_NOTICE : "") + line));
+                omitted = false;
+                start = newline + 1;
+                newline = text.indexOf("\n", start);
+            }
+            const remaining = text.slice(start);
+            if (remaining.length > MAX_OUTPUT_PREVIEW_CHARS)
+                omitted = true;
+            const budget = MAX_OUTPUT_PREVIEW_CHARS - (omitted ? OUTPUT_TRUNCATION_NOTICE.length : 0);
+            pending = retainOutputTail(remaining, budget);
+        },
+        flush() {
+            if (pending.length === 0)
+                return;
+            const line = pending.endsWith("\r") ? pending.slice(0, -1) : pending;
+            emit((omitted ? OUTPUT_TRUNCATION_NOTICE : "") + line);
+            pending = "";
+            omitted = false;
+        }
+    };
+}
+export function createStreamingDashboardLineBuffer(emit) {
+    let id = randomUUID();
+    let lastPreview = "";
+    const lines = createDashboardLineBuffer(line => {
+        if (line.length === 0 || line !== lastPreview)
+            emit(line, id);
+        id = randomUUID();
+        lastPreview = "";
+    });
+    return {
+        push(chunk) {
+            if (chunk.length === 0)
+                return;
+            lines.push(chunk);
+            const preview = lines.preview();
+            if (preview.length > 0 && preview !== lastPreview) {
+                lastPreview = preview;
+                emit(preview, id);
+            }
+        },
+        flush: lines.flush
+    };
+}

package/node_modules/toolcraft-design/dist/dashboard/output-preview.d.ts

@@ -0,0 +1,9 @@
+export declare const MAX_OUTPUT_PREVIEW_CHARS = 16384;
+export declare const OUTPUT_TRUNCATION_NOTICE = "[Output truncated: showing latest text]\n";
+export declare function retainOutputTail(text: string, maxChars: number): string;
+export declare function limitOutputPreview(text: string): string;
+/** Keep live deltas bounded without rebuilding the complete preview for every delta. */
+export declare function createOutputPreviewBuffer(): {
+    push(text: string): void;
+    text(): string;
+};

package/node_modules/toolcraft-design/dist/dashboard/output-preview.js

@@ -0,0 +1,70 @@
+import { Buffer } from "node:buffer";
+import { createTerminalStringFilter, terminalControlTailStart } from "./terminal-strings.js";
+export const MAX_OUTPUT_PREVIEW_CHARS = 16_384;
+export const OUTPUT_TRUNCATION_NOTICE = "[Output truncated: showing latest text]\n";
+export function retainOutputTail(text, maxChars) {
+    let start = Math.max(0, text.length - maxChars);
+    if (start > 0) {
+        const newline = text.indexOf("\n", start);
+        if (newline !== -1 && newline < text.length - 1)
+            start = newline + 1;
+        start = terminalControlTailStart(text, start);
+        const firstCodeUnit = text.charCodeAt(start);
+        if (firstCodeUnit >= 0xdc00 && firstCodeUnit <= 0xdfff)
+            start += 1;
+    }
+    // Materialize the bounded tail rather than retaining a large substring backing store.
+    // UTF-16 preserves lone surrogate code units as well as complete Unicode text.
+    return Buffer.from(text.slice(start), "utf16le").toString("utf16le");
+}
+export function limitOutputPreview(text) {
+    text = createTerminalStringFilter().push(text);
+    if (text.length <= MAX_OUTPUT_PREVIEW_CHARS)
+        return text;
+    return (OUTPUT_TRUNCATION_NOTICE +
+        retainOutputTail(text, MAX_OUTPUT_PREVIEW_CHARS - OUTPUT_TRUNCATION_NOTICE.length));
+}
+/** Keep live deltas bounded without rebuilding the complete preview for every delta. */
+export function createOutputPreviewBuffer() {
+    const strings = createTerminalStringFilter();
+    const chunks = [];
+    let chars = 0;
+    let omitted = false;
+    const tailBudget = MAX_OUTPUT_PREVIEW_CHARS - OUTPUT_TRUNCATION_NOTICE.length + 1;
+    return {
+        push(text) {
+            text = strings.push(text);
+            if (text.length === 0)
+                return;
+            if (text.length > MAX_OUTPUT_PREVIEW_CHARS) {
+                chunks.length = 0;
+                chars = 0;
+                omitted = true;
+                text = retainOutputTail(text, tailBudget);
+            }
+            chunks.push(text);
+            chars += text.length;
+            if (chars > MAX_OUTPUT_PREVIEW_CHARS)
+                omitted = true;
+            if (!omitted)
+                return;
+            while (chars > tailBudget) {
+                const first = chunks[0];
+                const excess = chars - tailBudget;
+                if (first.length <= excess) {
+                    chars -= first.length;
+                    chunks.shift();
+                }
+                else {
+                    const start = terminalControlTailStart(first, excess);
+                    chunks[0] = first.slice(start);
+                    chars -= start;
+                }
+            }
+        },
+        text() {
+            const text = chunks.join("");
+            return limitOutputPreview((omitted ? OUTPUT_TRUNCATION_NOTICE : "") + text);
+        }
+    };
+}

package/node_modules/toolcraft-design/dist/dashboard/snapshot.js

@@ -2,7 +2,7 @@ import { ScreenBuffer, cellToAnsi } from "./buffer.js";
 import { renderBorder } from "./components/border.js";
 import { defaultHints, renderFooter } from "./components/footer.js";
 import { renderOutputPane } from "./components/output-pane.js";
-import { renderStatsPane } from "./components/stats-pane.js";
+import { renderCompactStatsPane, renderStatsPane } from "./components/stats-pane.js";
 import { computeDashboardLayout } from "./layout.js";
 const SNAPSHOT_WIDTH = 80;
 const SNAPSHOT_HEIGHT = 20;
@@ -27,6 +27,8 @@ export function renderDashboardSnapshot(opts = {}) {
     });
     renderOutputPane(buffer, layout.leftPane, items);
     renderStatsPane(buffer, layout.rightPane, stats);
+    if (layout.summary)
+        renderCompactStatsPane(buffer, layout.summary, stats);
     renderFooter(buffer, layout.footer, defaultHints());
     return bufferToAnsi(buffer);
 }

package/node_modules/toolcraft-design/dist/dashboard/store.js

@@ -1,3 +1,4 @@
+import { limitOutputPreview } from "./output-preview.js";
 const MAX_RETAINED_OUTPUT = 256;
 export function createStore() {
     let state = {
@@ -20,9 +21,14 @@ export function createStore() {
         return state;
     }
     function appendOutput(item) {
-        const next = state.output.length >= MAX_RETAINED_OUTPUT
-            ? [...state.output.slice(state.output.length - MAX_RETAINED_OUTPUT + 1), item]
-            : [...state.output, item];
+        const preview = limitOutputPreview(item.text);
+        const retainedItem = preview === item.text ? item : { ...item, text: preview };
+        const existing = item.id === undefined ? -1 : state.output.findIndex((entry) => entry.id === item.id);
+        const next = existing !== -1
+            ? state.output.map((entry, index) => index === existing ? retainedItem : entry)
+            : state.output.length >= MAX_RETAINED_OUTPUT
+                ? [...state.output.slice(state.output.length - MAX_RETAINED_OUTPUT + 1), retainedItem]
+                : [...state.output, retainedItem];
         state = { ...state, output: next };
         notify();
     }

package/node_modules/toolcraft-design/dist/dashboard/terminal-strings.d.ts

@@ -0,0 +1,6 @@
+/** Remove nonprinting strings and retain complete CSI controls before presentation trims them. */
+export declare function createTerminalStringFilter(): {
+    push(text: string): string;
+};
+/** Advance a tail boundary past a control if it would retain only its parameters. */
+export declare function terminalControlTailStart(text: string, start: number): number;

package/node_modules/toolcraft-design/dist/dashboard/terminal-strings.js

@@ -0,0 +1,108 @@
+// Normal SGR/cursor sequences are short; malformed controls must not grow retained state.
+const MAX_CONTROL_SEQUENCE_CHARS = 1_024;
+/** Remove nonprinting strings and retain complete CSI controls before presentation trims them. */
+export function createTerminalStringFilter() {
+    let hidden = false;
+    let allowBell = false;
+    let escape = false;
+    let csi;
+    let oversizedCsi = false;
+    return {
+        push(text) {
+            if (!hidden && !escape && csi === undefined && !text.includes("\u001b") && !text.includes("\u009b") && !text.includes("\u0090") &&
+                !text.includes("\u0098") && !text.includes("\u009d") && !text.includes("\u009e") && !text.includes("\u009f"))
+                return text;
+            let output = "";
+            for (const ch of text) {
+                if ((ch === "\u0018" || ch === "\u001a") && (hidden || escape || csi !== undefined)) {
+                    hidden = false;
+                    escape = false;
+                    csi = undefined;
+                    oversizedCsi = false;
+                    continue;
+                }
+                if (csi !== undefined) {
+                    if (ch === "\u001b") {
+                        csi = undefined;
+                        oversizedCsi = false;
+                        escape = true;
+                        continue;
+                    }
+                    if (!oversizedCsi) {
+                        csi += ch;
+                        if (csi.length > MAX_CONTROL_SEQUENCE_CHARS) {
+                            oversizedCsi = true;
+                            csi = "";
+                        }
+                    }
+                    const code = ch.charCodeAt(0);
+                    if (code >= 0x40 && code <= 0x7e) {
+                        if (!oversizedCsi)
+                            output += csi;
+                        csi = undefined;
+                        oversizedCsi = false;
+                    }
+                    continue;
+                }
+                if (hidden) {
+                    if (ch === "\u009c" || (allowBell && ch === "\u0007") || (escape && ch === "\\")) {
+                        hidden = false;
+                        escape = false;
+                    }
+                    else
+                        escape = ch === "\u001b";
+                    continue;
+                }
+                if (escape) {
+                    escape = false;
+                    if (ch === "[") {
+                        csi = "\u001b[";
+                        continue;
+                    }
+                    if (ch === "]" || ch === "P" || ch === "X" || ch === "^" || ch === "_") {
+                        hidden = true;
+                        allowBell = ch === "]";
+                        continue;
+                    }
+                    output += "\u001b";
+                }
+                if (ch === "\u001b")
+                    escape = true;
+                else if (ch === "\u009b")
+                    csi = ch;
+                else if (ch === "\u0090" || ch === "\u0098" || ch === "\u009d" || ch === "\u009e" || ch === "\u009f") {
+                    hidden = true;
+                    allowBell = ch === "\u009d";
+                }
+                else
+                    output += ch;
+            }
+            return output;
+        }
+    };
+}
+/** Advance a tail boundary past a control if it would retain only its parameters. */
+export function terminalControlTailStart(text, start) {
+    if (!text.includes("\u001b") && !text.includes("\u009b"))
+        return start;
+    for (let index = 0; index < start; index++) {
+        const ch = text[index];
+        if (ch !== "\u001b" && ch !== "\u009b")
+            continue;
+        let end = index + 1;
+        if (ch === "\u009b" || text[end] === "[") {
+            if (ch === "\u001b")
+                end++;
+            while (end < text.length) {
+                const code = text.charCodeAt(end);
+                if (code >= 0x40 && code <= 0x7e)
+                    break;
+                end++;
+            }
+        }
+        if (start <= end)
+            return Math.min(end + 1, text.length);
+        index = end;
+    }
+    return start;
+}

package/node_modules/toolcraft-design/dist/dashboard/terminal-width.js

@@ -2,7 +2,7 @@ const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme
 export function graphemes(value) {
     for (let index = 0; index < value.length; index += 1) {
         const code = value.charCodeAt(index);
-        if (code < 0x20 || code > 0x7e) {
+        if ((code < 0x20 || code > 0x7e) && (code < 0x4e00 || code > 0x9fff)) {
             return Array.from(graphemeSegmenter.segment(value), ({ segment }) => segment);
         }
     }
@@ -20,6 +20,8 @@ export function displayWidth(value, startColumn = 0) {
     return column - startColumn;
 }
 export function expandTabs(value, startColumn = 0) {
+    if (!value.includes("\t"))
+        return value;
     let column = startColumn;
     let expanded = "";
     for (const segment of graphemes(value)) {

package/node_modules/toolcraft-design/dist/dashboard/terminal.js

@@ -1,6 +1,7 @@
 import readline from "node:readline";
 import { PassThrough } from "node:stream";
 import { cellToAnsi } from "./buffer.js";
+import { graphemeWidth } from "./terminal-width.js";
 export function createTerminalDriver(opts) {
     const stdin = (opts?.stdin ?? process.stdin);
     const stdout = (opts?.stdout ?? process.stdout);
@@ -87,8 +88,17 @@ export function createTerminalDriver(opts) {
             return;
         }
         let output = "";
+        let cursorX;
+        let cursorY;
         for (const change of changes) {
-            output += `${cursorPositionAnsi(change.x, change.y)}${cellToAnsi(change.cell)}`;
+            if (change.cell.ch.length === 0)
+                continue;
+            if (change.x !== cursorX || change.y !== cursorY) {
+                output += cursorPositionAnsi(change.x, change.y);
+            }
+            output += cellToAnsi(change.cell);
+            cursorX = change.x + graphemeWidth(change.cell.ch);
+            cursorY = change.y;
         }
         write(output);
     }

package/node_modules/toolcraft-design/dist/dashboard/testing/pipeline-scenario.d.ts

@@ -0,0 +1 @@
+export {};