@kamilio/wire 0.1.9 → 0.1.11

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

@@ -1,4 +1,16 @@
+import { graphemes, graphemeWidth } from "./terminal-width.js";
+import { createTerminalStringFilter } from "./terminal-strings.js";
 const ESC = "\u001b";
+/** Visible text for a plain screen row; styles are supplied by the caller. */
+export function plainTerminalText(text) {
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if ((code < 0x20 && code !== 0x09) || (code >= 0x7f && code <= 0x9f)) {
+            return parseAnsi(text).map(line => line.segments.map(segment => segment.text).join("")).join(" ");
+        }
+    }
+    return text;
+}
 export function hasAnsi(text) {
     return text.includes(ESC);
 }
@@ -11,12 +23,38 @@ export function hasAnsi(text) {
  * `baseStyle` is used as the initial style and as the restore target for SGR reset / default color.
  */
 export function parseAnsi(text, baseStyle) {
+    text = createTerminalStringFilter().push(text);
     const base = normalizeStyle(baseStyle);
     let style = { ...base };
     let concealed = false;
     const lines = [];
     let cells = [];
     let column = 0;
+    const clearCell = (position) => {
+        if (cells[position]?.ch === "" && position > 0) {
+            cells[position - 1] = { ch: " ", style: { ...style } };
+        }
+        if (cells[position + 1]?.ch === "") {
+            cells[position + 1] = { ch: " ", style: { ...style } };
+        }
+        cells[position] = undefined;
+    };
+    const writeGrapheme = (ch) => {
+        const width = graphemeWidth(ch);
+        if (width === 0) {
+            const previous = cells[column - 1]?.ch === "" ? column - 2 : column - 1;
+            if (!concealed && cells[previous])
+                cells[previous].ch += ch;
+            return;
+        }
+        clearCell(column);
+        if (width === 2)
+            clearCell(column + 1);
+        cells[column] = { ch: concealed ? " " : ch, style: { ...style } };
+        if (width === 2)
+            cells[column + 1] = { ch: concealed ? " " : "", style: { ...style } };
+        column += width;
+    };
     const finishLine = () => {
         lines.push({ segments: cellsToSegments(cells) });
         cells = [];
@@ -25,8 +63,8 @@ export function parseAnsi(text, baseStyle) {
     let index = 0;
     while (index < text.length) {
         const ch = text[index];
-        if (ch === ESC && text[index + 1] === "[") {
-            const paramsStart = index + 2;
+        if ((ch === ESC && text[index + 1] === "[") || ch === "\u009b") {
+            const paramsStart = index + (ch === ESC ? 2 : 1);
             let cursor = paramsStart;
             while (cursor < text.length && !isCsiFinalByte(text[cursor])) {
                 cursor += 1;
@@ -42,18 +80,30 @@ export function parseAnsi(text, baseStyle) {
                 style = sgr.style;
                 concealed = sgr.concealed;
             }
-            else if (finalByte === "K" && parseParams(params)[0] === 2) {
-                cells = [];
+            else if (finalByte === "K") {
+                const mode = parseParams(params)[0];
+                if (mode === 0) {
+                    clearCell(column);
+                    cells.length = Math.min(cells.length, column);
+                }
+                else if (mode === 1) {
+                    const end = Math.min(column, cells.length - 1);
+                    for (let position = 0; position <= end; position += 1)
+                        clearCell(position);
+                }
+                else if (mode === 2) {
+                    cells = [];
+                }
             }
             index = cursor + 1;
             continue;
         }
+        if (ch === "\u0085") {
+            finishLine();
+            index += 1;
+            continue;
+        }
         if (ch === ESC) {
-            const next = text[index + 1];
-            if (next === "]" || next === "P" || next === "X" || next === "^" || next === "_") {
-                index = skipStringTerminated(text, index + 2);
-                continue;
-            }
             index += 2;
             continue;
         }
@@ -72,14 +122,32 @@ export function parseAnsi(text, baseStyle) {
             index += 1;
             continue;
         }
+        if (ch === "\t") {
+            const spaces = 8 - (column % 8);
+            for (let offset = 0; offset < spaces; offset++) {
+                if (cells[column] === undefined)
+                    writeGrapheme(" ");
+                else
+                    column += 1;
+            }
+            index += 1;
+            continue;
+        }
         const code = ch.charCodeAt(0);
-        if (code < 0x20 && ch !== "\t") {
+        if (code < 0x20 || (code >= 0x7f && code <= 0x9f)) {
             index += 1;
             continue;
         }
-        cells[column] = { ch: concealed ? " " : ch, style: { ...style } };
-        column += 1;
-        index += 1;
+        let end = index + 1;
+        while (end < text.length) {
+            const next = text.charCodeAt(end);
+            if (next < 0x20 || (next >= 0x7f && next <= 0x9f))
+                break;
+            end += 1;
+        }
+        for (const grapheme of graphemes(text.slice(index, end)))
+            writeGrapheme(grapheme);
+        index = end;
     }
     finishLine();
     return lines;
@@ -102,20 +170,6 @@ function isCsiFinalByte(ch) {
     const code = ch.charCodeAt(0);
     return code >= 0x40 && code <= 0x7e;
 }
-function skipStringTerminated(text, start) {
-    let index = start;
-    while (index < text.length) {
-        const ch = text[index];
-        if (ch === "\u0007") {
-            return index + 1;
-        }
-        if (ch === ESC && text[index + 1] === "\\") {
-            return index + 2;
-        }
-        index += 1;
-    }
-    return index;
-}
 function parseParams(params) {
     if (params.length === 0) {
         return [0];

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

@@ -1,5 +1,6 @@
 import { color } from "../components/color.js";
 import { expandTabs, graphemes, graphemeWidth } from "./terminal-width.js";
+import { parseAnsi } from "./ansi.js";
 const EMPTY_CELL = { ch: " ", style: {} };
 export class ScreenBuffer {
     _width;
@@ -22,17 +23,19 @@ export class ScreenBuffer {
         }
         const normalizedStyle = normalizeStyle(style);
         let offset = 0;
-        for (const ch of graphemes(expandTabs(text, Math.max(0, x)))) {
-            const targetX = x + offset;
-            const width = graphemeWidth(ch);
-            offset += width;
-            if (!this.isInBoundsX(targetX)) {
-                continue;
-            }
-            this._cells[this.index(targetX, y)] = { ch, style: normalizedStyle };
-            for (let continuation = 1; continuation < width; continuation += 1) {
-                if (this.isInBoundsX(targetX + continuation)) {
-                    this._cells[this.index(targetX + continuation, y)] = { ch: "", style: normalizedStyle };
+        for (const segment of screenSegments(text, normalizedStyle)) {
+            for (const ch of graphemes(expandTabs(segment.text, Math.max(0, x + offset)))) {
+                const targetX = x + offset;
+                const width = graphemeWidth(ch);
+                offset += width;
+                if (!this.isInBoundsX(targetX)) {
+                    continue;
+                }
+                this._cells[this.index(targetX, y)] = { ch, style: segment.style };
+                for (let continuation = 1; continuation < width; continuation += 1) {
+                    if (this.isInBoundsX(targetX + continuation)) {
+                        this._cells[this.index(targetX + continuation, y)] = { ch: "", style: segment.style };
+                    }
                 }
             }
         }
@@ -84,20 +87,22 @@ export class ScreenBuffer {
         const normalizedStyle = normalizeStyle(style);
         const rectEndX = rect.x + rect.width;
         let offset = 0;
-        for (const ch of graphemes(expandTabs(text))) {
-            const targetX = rect.x + offset;
-            const width = graphemeWidth(ch);
-            offset += width;
-            if (targetX + width > rectEndX) {
-                break;
-            }
-            if (!this.isInBoundsX(targetX)) {
-                continue;
-            }
-            this._cells[this.index(targetX, y)] = { ch, style: normalizedStyle };
-            for (let continuation = 1; continuation < width; continuation += 1) {
-                if (this.isInBoundsX(targetX + continuation)) {
-                    this._cells[this.index(targetX + continuation, y)] = { ch: "", style: normalizedStyle };
+        for (const segment of screenSegments(text, normalizedStyle)) {
+            for (const ch of graphemes(expandTabs(segment.text, offset))) {
+                const targetX = rect.x + offset;
+                const width = graphemeWidth(ch);
+                offset += width;
+                if (targetX + width > rectEndX) {
+                    break;
+                }
+                if (!this.isInBoundsX(targetX)) {
+                    continue;
+                }
+                this._cells[this.index(targetX, y)] = { ch, style: segment.style };
+                for (let continuation = 1; continuation < width; continuation += 1) {
+                    if (this.isInBoundsX(targetX + continuation)) {
+                        this._cells[this.index(targetX + continuation, y)] = { ch: "", style: segment.style };
+                    }
                 }
             }
         }
@@ -115,6 +120,15 @@ export class ScreenBuffer {
         return y >= 0 && y < this._height;
     }
 }
+function screenSegments(text, style) {
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if ((code < 0x20 && code !== 0x09) || (code >= 0x7f && code <= 0x9f)) {
+            return parseAnsi(text, style).flatMap((line, row) => row === 0 ? line.segments : [{ text: " ", style }, ...line.segments]);
+        }
+    }
+    return [{ text, style }];
+}
 export function diff(prev, next) {
     const changes = [];
     const width = Math.max(prev.width, next.width);

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

@@ -1,3 +1,5 @@
+import { plainTerminalText } from "../ansi.js";
+import { displayWidth, truncateToWidth } from "../terminal-width.js";
 export function renderBorder(buffer, layout, opts) {
     const outer = layout.outerBorder;
     if (outer.width <= 0 || outer.height <= 0) {
@@ -100,17 +102,16 @@ function renderFooterDivider(buffer, left, right, bottom, layout, style) {
     }
 }
 function renderTopSegment(width, title) {
+    if (title !== undefined)
+        title = plainTerminalText(title);
     if (width <= 0) {
         return "";
     }
     if (!title) {
         return "─".repeat(width);
     }
-    const content = `─ ${title} `;
-    if (content.length >= width) {
-        return content.slice(0, width);
-    }
-    return `${content}${"─".repeat(width - content.length)}`;
+    const content = truncateToWidth(`─ ${title} `, width);
+    return `${content}${"─".repeat(width - displayWidth(content))}`;
 }
 function hasInteriorRows(top, bottom) {
     return (bottom - top) > 1;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/dashboard/components/context-pane.d.ts

@@ -0,0 +1,4 @@
+import { ScreenBuffer } from "../buffer.js";
+import type { Rect } from "../types.js";
+/** Reserve fixed plan context while keeping room for the live output. */
+export declare function renderContextPane(buffer: ScreenBuffer, rect: Rect, context: string[]): Rect;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/dashboard/components/context-pane.js

@@ -0,0 +1,22 @@
+import { plainTerminalText } from "../ansi.js";
+import { computeVisualLines } from "./output-pane.js";
+import { truncateToWidth } from "../terminal-width.js";
+/** Reserve fixed plan context while keeping room for the live output. */
+export function renderContextPane(buffer, rect, context) {
+    if (context.length === 0 || rect.width <= 0 || rect.height <= 1)
+        return rect;
+    const available = Math.max(1, Math.floor(rect.height / 2));
+    const entries = context.map(text => computeVisualLines([{ kind: "info", text, ts: 0 }], rect.width + 3));
+    const lines = entries.flat();
+    const visible = lines.slice(0, available);
+    if (lines.length > available) {
+        const last = visible[available - 1];
+        const text = entries[0].length >= available
+            ? truncateToWidth(`${available === 1 ? plainTerminalText(context[0]) : last.text}…`, rect.width)
+            : truncateToWidth(`… more plans (${context.length - 1} queued)`, rect.width);
+        visible[available - 1] = { ...last, text };
+    }
+    buffer.clearRect({ ...rect, height: visible.length });
+    visible.forEach((line, row) => buffer.putInRect(rect, row, line.text, { dim: row > 0 }));
+    return { ...rect, y: rect.y + visible.length, height: rect.height - visible.length };
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/dashboard/components/footer.d.ts

@@ -1,8 +1,8 @@
 import { ScreenBuffer } from "../buffer.js";
-import type { Rect } from "../types.js";
+import type { DashboardStats, Rect } from "../types.js";
 export type FooterHint = {
     key: string;
     label: string;
 };
-export declare function renderFooter(buffer: ScreenBuffer, rect: Rect, hints: FooterHint[]): void;
+export declare function renderFooter(buffer: ScreenBuffer, rect: Rect, hints: FooterHint[], session?: DashboardStats["session"]): void;
 export declare function defaultHints(): FooterHint[];

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

@@ -1,14 +1,49 @@
 import { getTheme } from "../../internal/theme-detect.js";
-export function renderFooter(buffer, rect, hints) {
+import { displayWidth, graphemes, graphemeWidth, truncateToWidth } from "../terminal-width.js";
+import { plainTerminalText } from "../ansi.js";
+export function renderFooter(buffer, rect, hints, session) {
     buffer.clearRect(rect);
-    if (rect.width <= 0 || rect.height <= 0 || hints.length === 0) {
+    if (rect.width <= 0 || rect.height <= 0)
         return;
+    if (session) {
+        const directory = plainTerminalText(session.cwd);
+        const agentModel = plainTerminalText(`${session.agent} · ${session.model ?? "default model"}`);
+        const gap = Math.min(2, rect.width);
+        const available = Math.max(0, rect.width - gap);
+        const agentWidth = Math.min(displayWidth(agentModel), Math.ceil(available / 2));
+        const directoryWidth = Math.max(0, available - agentWidth);
+        const style = getTheme().styles.muted;
+        const y = rect.y + rect.height - 1;
+        buffer.put(rect.x, y, truncateToWidth(directory, directoryWidth || rect.width), style);
+        if (agentWidth > 0) {
+            const text = truncateToWidth(agentModel, agentWidth);
+            buffer.put(rect.x + rect.width - displayWidth(text), y, text, style);
+        }
+    }
+    if (hints.length === 0 || (session && rect.height === 1)) {
+        return;
+    }
+    const fitted = [];
+    hints = hints.map(hint => ({ key: plainTerminalText(hint.key), label: plainTerminalText(hint.label) }));
+    let width = 0;
+    for (const hint of hints) {
+        const nextWidth = displayWidth(`${hint.key} ${hint.label}`) + (fitted.length > 0 ? 2 : 0);
+        if (width + nextWidth > rect.width)
+            break;
+        fitted.push(hint);
+        width += nextWidth;
+    }
+    if (fitted.length === 0) {
+        const key = truncateToWidth(hints[0].key, rect.width);
+        fitted.push({ key, label: "" });
+        width = displayWidth(key);
     }
-    const cells = truncateCells(hintsToCells(hints), rect.width);
-    const startX = rect.x + Math.floor((rect.width - cells.length) / 2);
-    const y = rect.y + Math.floor(rect.height / 2);
-    cells.forEach((cell, index) => {
-        buffer.put(startX + index, y, cell.ch, cell.style);
+    const cells = hintsToCells(fitted);
+    let x = rect.x + Math.floor((rect.width - width) / 2);
+    const y = session ? rect.y : rect.y + Math.floor(rect.height / 2);
+    cells.forEach((cell) => {
+        buffer.put(x, y, cell.ch, cell.style);
+        x += graphemeWidth(cell.ch);
     });
 }
 export function defaultHints() {
@@ -27,30 +62,17 @@ function hintsToCells(hints) {
         if (hintIndex > 0) {
             cells.push({ ch: " ", style: {} }, { ch: " ", style: {} });
         }
-        for (const ch of hint.key) {
+        for (const ch of graphemes(hint.key)) {
             cells.push({ ch, style: accentStyle });
         }
-        cells.push({ ch: " ", style: {} });
-        for (const ch of hint.label) {
+        if (hint.label.length > 0)
+            cells.push({ ch: " ", style: {} });
+        for (const ch of graphemes(hint.label)) {
             cells.push({ ch, style: {} });
         }
     });
     return cells;
 }
-function truncateCells(cells, width) {
-    if (cells.length <= width) {
-        return cells;
-    }
-    if (width <= 3) {
-        return Array.from({ length: Math.max(0, width) }, () => ({ ch: ".", style: {} }));
-    }
-    return [
-        ...cells.slice(0, width - 3),
-        { ch: ".", style: {} },
-        { ch: ".", style: {} },
-        { ch: ".", style: {} }
-    ];
-}
 function getAccentStyle() {
     return getTheme().styles.accent;
 }

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

@@ -8,5 +8,9 @@ export type VisualLine = {
     prefixStyle: CellStyle;
     segments?: StyledSegment[];
 };
-export declare function renderOutputPane(buffer: ScreenBuffer, rect: Rect, items: OutputItem[]): void;
-export declare function computeVisualLines(items: OutputItem[], width: number): VisualLine[];
+export declare function renderOutputPane(buffer: ScreenBuffer, rect: Rect, items: OutputItem[], scrollOffset?: number, options?: {
+    conversation?: boolean;
+    details?: boolean;
+    now?: number;
+}): number;
+export declare function computeVisualLines(items: OutputItem[], width: number, preformatted?: boolean): VisualLine[];

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/dashboard/components/output-pane.js

@@ -1,15 +1,56 @@
+import { selectViewportTail } from "../../viewport.js";
 import { getTheme } from "../../internal/theme-detect.js";
+import { supportsColor } from "../../internal/color-support.js";
+import { parse, render } from "../../terminal-markdown/index.js";
 import { hasAnsi, parseAnsi } from "../ansi.js";
+import { formatElapsed } from "../elapsed.js";
 import { displayWidth, expandTabs, graphemes, graphemeWidth } from "../terminal-width.js";
 const TEXT_OFFSET = 3;
 const CONTINUATION_PREFIX = "│";
-export function renderOutputPane(buffer, rect, items) {
+const agentLines = new WeakMap();
+export function renderOutputPane(buffer, rect, items, scrollOffset = 0, options = {}) {
     buffer.clearRect(rect);
     if (rect.width <= 0 || rect.height <= 0) {
-        return;
+        return 0;
     }
-    const visualLines = computeVisualLines(items, rect.width);
-    const startLine = Math.max(visualLines.length - rect.height, 0);
+    const { rows: visualLines, offset: actualOffset } = selectViewportTail(options.conversation && !options.details ? foldCompletedActions(items) : items, rect.height, scrollOffset, item => {
+        if (options.conversation && item.role === "reasoning" && !options.details)
+            return [];
+        let label = item.text;
+        const elapsed = options.now === undefined ? 0 : options.now - item.ts;
+        if (options.conversation && item.role === "action" && item.kind === "tool" && Number.isFinite(elapsed) && elapsed >= 1000) {
+            const duration = formatElapsed(elapsed);
+            label += ` · ${elapsed >= 3_600_000 ? duration : duration.slice(3)}`;
+        }
+        const text = options.details && item.detail ? item.role === "plan" ? item.detail : `${label}\n${item.detail}` : label;
+        const agentReply = options.conversation && item.role === "agent"
+            ? renderAgentLines(item, rect.width, rect.height + scrollOffset + 4) : undefined;
+        const lines = agentReply?.lines ?? computeVisualLines([text === item.text ? item : { ...item, text }], rect.width);
+        if (!options.conversation)
+            return lines;
+        const prose = item.role === "agent" || item.role === "user";
+        if (prose) {
+            while (lines.length > 0 && lines.at(-1).text.trim().length === 0)
+                lines.pop();
+            while (lines.length > 0 && lines[0].text.trim().length === 0)
+                lines.shift();
+        }
+        const style = item.kind === "error" ? getTheme().styles.error
+            : prose ? {} : getTheme().styles.muted;
+        const prefix = item.role === "user" ? "›" : item.role === "agent" ? "•"
+            : item.kind === "tool" ? "›" : item.kind === "success" ? "✓"
+                : item.kind === "error" ? "!" : "·";
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            line.prefix = index === 0 && agentReply?.complete !== false ? prefix : "";
+            line.prefixStyle = style;
+            line.style = style;
+        }
+        if (prose && lines.length > 0) {
+            lines.push({ text: "", prefix: "", style: {}, prefixStyle: {} });
+        }
+        return lines;
+    });
     const textRect = {
         x: rect.x + TEXT_OFFSET,
         y: rect.y,
@@ -17,7 +58,7 @@ export function renderOutputPane(buffer, rect, items) {
         height: rect.height
     };
     for (let row = 0; row < rect.height; row += 1) {
-        const line = visualLines[startLine + row];
+        const line = visualLines[row];
         if (line === undefined) {
             continue;
         }
@@ -44,8 +85,75 @@ export function renderOutputPane(buffer, rect, items) {
         }
         buffer.putInRect(textRect, row, line.text, line.style);
     }
+    return actualOffset;
+}
+function renderAgentLines(item, width, budget) {
+    const theme = getTheme();
+    const color = supportsColor();
+    const cached = agentLines.get(item);
+    if (cached?.text === item.text && cached.width === width && cached.theme === theme && cached.color === color
+        && (cached.complete || cached.budget >= budget)) {
+        return { lines: cached.lines.map((line) => ({ ...line })), complete: cached.complete };
+    }
+    let lines;
+    let complete = true;
+    try {
+        const ast = parse(item.text).ast;
+        const options = { width: Math.max(1, width - TEXT_OFFSET), showFrontmatter: true };
+        let text;
+        if (ast.type !== "root" || containsFootnotes(ast))
+            text = render(ast, options);
+        else {
+            const fragments = [];
+            let rows = 0;
+            let index = ast.children.length - 1;
+            for (; index >= 0 && rows < budget; index--) {
+                const fragment = render(ast.children[index], options);
+                fragments.push(fragment);
+                rows += fragment.split("\n").length - 1;
+            }
+            complete = index < 0;
+            text = fragments.reverse().join("");
+        }
+        lines = computeVisualLines([{ ...item, text }], width, true);
+    }
+    catch {
+        // A partially streamed document can contain invalid frontmatter or syntax.
+        lines = computeVisualLines([item], width);
+    }
+    agentLines.set(item, { text: item.text, width, theme, color, budget, complete, lines });
+    return { lines: lines.map((line) => ({ ...line })), complete };
 }
-export function computeVisualLines(items, width) {
+function containsFootnotes(node) {
+    return node.type === "footnoteDefinition" || node.type === "footnoteReference"
+        || ("children" in node && node.children.some(containsFootnotes));
+}
+function foldCompletedActions(items) {
+    const result = [];
+    let completed = [];
+    const flush = () => {
+        if (completed.length >= 4) {
+            result.push({ role: "action", kind: "status", ts: completed[0].ts,
+                text: `${completed.length - 2} earlier actions · d Details` }, ...completed.slice(-2));
+        }
+        else
+            result.push(...completed);
+        completed = [];
+    };
+    for (const item of items) {
+        if (item.role === "reasoning")
+            continue;
+        if (item.role === "action" && item.kind === "success")
+            completed.push(item);
+        else {
+            flush();
+            result.push(item);
+        }
+    }
+    flush();
+    return result;
+}
+export function computeVisualLines(items, width, preformatted = false) {
     if (width <= 0) {
         return [];
     }
@@ -54,8 +162,8 @@ export function computeVisualLines(items, width) {
     const visualLines = [];
     for (const item of items) {
         const itemStyle = getItemStyle(item.kind);
-        if (hasAnsi(item.text) || hasCursorControls(item.text)) {
-            const styledLines = parseAnsi(item.text, hasAnsi(item.text) ? {} : itemStyle);
+        if (preformatted || hasAnsi(item.text) || hasCursorControls(item.text)) {
+            const styledLines = parseAnsi(item.text, preformatted || hasAnsi(item.text) ? {} : itemStyle);
             let firstRow = true;
             for (const styledLine of styledLines) {
                 const rows = hardWrapSegments(styledLine.segments, textWidth);
@@ -85,7 +193,12 @@ export function computeVisualLines(items, width) {
     return visualLines;
 }
 function hasCursorControls(text) {
-    return text.includes("\r") || text.includes("\b");
+    for (let index = 0; index < text.length; index += 1) {
+        const code = text.charCodeAt(index);
+        if ((code < 0x20 && code !== 0x0a && code !== 0x09) || (code >= 0x7f && code <= 0x9f))
+            return true;
+    }
+    return false;
 }
 function hardWrapSegments(segments, width) {
     if (width <= 0) {
@@ -171,10 +284,12 @@ function wrapParagraph(value, width) {
     const tokens = tokenize(value);
     const lines = [];
     let currentLine = "";
+    let currentWidth = 0;
     let pendingSpace = "";
     const flushLine = () => {
         lines.push(currentLine);
         currentLine = "";
+        currentWidth = 0;
         pendingSpace = "";
     };
     for (const token of tokens) {
@@ -188,13 +303,16 @@ function wrapParagraph(value, width) {
         for (let index = 0; index < chunks.length; index += 1) {
             const chunk = chunks[index] ?? "";
             const gap = index === 0 ? pendingSpace : "";
-            if (currentLine.length > 0 && displayWidth(`${currentLine}${gap}${chunk}`) > width) {
+            const chunkWidth = displayWidth(chunk);
+            if (currentLine.length > 0 && currentWidth + gap.length + chunkWidth > width) {
                 flushLine();
             }
             if (currentLine.length > 0 && gap.length > 0) {
                 currentLine += gap;
+                currentWidth += gap.length;
             }
             currentLine += chunk;
+            currentWidth += chunkWidth;
             pendingSpace = "";
             if (index < chunks.length - 1) {
                 flushLine();

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/dashboard/components/run-view.d.ts

@@ -0,0 +1,27 @@
+import type { ScreenBuffer } from "../buffer.js";
+import type { ComposerState } from "../composer.js";
+import type { DashboardStats, OutputItem, Rect } from "../types.js";
+import type { FooterHint } from "./footer.js";
+export type RunViewOptions = {
+    title: string;
+    stats: DashboardStats;
+    output: OutputItem[];
+    scrollOffset: number;
+    composer?: ComposerState;
+    submitting?: boolean;
+    showQueue?: boolean;
+    showDetails?: boolean;
+    workOffset?: number;
+    feedback?: string;
+    hints?: FooterHint[];
+    now?: number;
+};
+export declare function renderRunView(buffer: ScreenBuffer, options: RunViewOptions): {
+    scrollOffset: number;
+    outputRect: Rect;
+    workOffset: number;
+    cursor?: {
+        x: number;
+        y: number;
+    };
+};