@kamilio/wire 0.1.8 → 0.1.10

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

@@ -1,10 +1,15 @@
+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 { renderContextPane } from "./components/context-pane.js";
+import { plainTerminalText } from "./ansi.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 { renderRunView } from "./components/run-view.js";
+import { createComposerState, editComposer } from "./composer.js";
+import { renderCompactStatsPane, renderStatsPane } from "./components/stats-pane.js";
 import { createKeymap } from "./keymap.js";
 import { computeDashboardLayout } from "./layout.js";
 import { createStore } from "./store.js";
@@ -20,6 +25,7 @@ export function createDashboard(opts = {}) {
     const title = opts.title ?? DEFAULT_TITLE;
     const statsTitle = opts.statsTitle ?? DEFAULT_STATS_TITLE;
     const rightPaneWidth = opts.rightPaneWidth ?? DEFAULT_RIGHT_PANE_WIDTH;
+    const conversation = opts.appearance === "conversation" || opts.onSubmit !== undefined;
     const commandHandlers = new Set();
     const fallbackLogger = createLogger((message) => {
         stdout.write(`${message}\n`);
@@ -32,6 +38,22 @@ export function createDashboard(opts = {}) {
     let unsubscribeResize;
     let started = false;
     let destroyed = false;
+    const performanceMonitor = createRenderPerformanceMonitor();
+    let showPerformance = false;
+    let scrollOffset = 0;
+    let outputViewportHeight = 0;
+    let heldOutput;
+    let heldAt;
+    let renderTimer;
+    let composer = opts.onSubmit ? createComposerState("message") : undefined;
+    let otherDraft = createComposerState("plan");
+    let submitting = false;
+    let showQueue = false;
+    let workOffset = 0;
+    let feedback;
+    let showDetails = false;
+    let lastActivePlanId;
+    let outputRect;
     function appendOutput(item) {
         if (destroyed) {
             return;
@@ -59,23 +81,175 @@ export function createDashboard(opts = {}) {
         driver.enterAltScreen();
         driver.disableLineWrap();
         driver.hideCursor();
+        if (opts.onSubmit)
+            driver.write("\u001b[?2004h");
         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) => {
+            performanceMonitor.request("input");
+            if (composer && !(event.ctrl && event.name === "c")) {
+                if (submitting)
+                    return;
+                if (event.ctrl && event.name === "p") {
+                    feedback = undefined;
+                    [composer, otherDraft] = [otherDraft, composer];
+                    composer.focused = true;
+                    render();
+                    return;
+                }
+                if (composer.focused && event.meta && (event.name === "up" || event.name === "down")) {
+                    feedback = undefined;
+                    const run = getStore().getState().stats.run;
+                    const plans = run?.queue?.filter((item) => item.kind === "plan") ?? [];
+                    const activeIndex = Math.max(0, plans.findIndex((item) => item.id === run?.activePlanId));
+                    const available = plans.slice(activeIndex);
+                    if (available.length > 0) {
+                        const index = available.findIndex((item) => item.id === composer.afterPlanId);
+                        const next = index < 0 ? 0 : (index + (event.name === "up" ? -1 : 1) + available.length) % available.length;
+                        composer = { ...composer, afterPlanId: available[next].id };
+                        render();
+                    }
+                    return;
+                }
+                if (!composer.focused && (event.ch === "i" || event.ch === "p" || event.name === "return")) {
+                    feedback = undefined;
+                    const kind = event.ch === "p" ? "plan" : "message";
+                    if (composer.kind !== kind)
+                        [composer, otherDraft] = [otherDraft, composer];
+                    composer.focused = true;
+                    render();
+                    return;
+                }
+                const edit = editComposer(composer, event, Math.max(1, (outputRect?.width ?? 80) - 3));
+                if (edit.handled) {
+                    feedback = undefined;
+                    composer = edit.state;
+                    if (edit.submit) {
+                        const submission = edit.submit;
+                        submitting = true;
+                        render();
+                        void (async () => {
+                            try {
+                                await opts.onSubmit(submission);
+                                const run = store?.getState().stats.run;
+                                const activeIndex = run?.queue?.findIndex((item) => item.id === run.activePlanId) ?? -1;
+                                const targetIndex = run?.queue?.findIndex((item) => item.id === submission.afterPlanId) ?? -1;
+                                const target = targetIndex < activeIndex ? run?.activePlanId : submission.afterPlanId;
+                                composer = createComposerState(submission.kind, target);
+                                const planNumber = (run?.queue?.filter((item) => item.kind === "plan").findIndex((item) => item.id === submission.afterPlanId) ?? -1) + 1;
+                                feedback = submission.kind === "plan" ? "Plan queued" : `Message queued${planNumber > 0 ? ` after plan ${planNumber}` : ""}`;
+                            }
+                            catch (error) {
+                                const message = error instanceof Error ? error.message : String(error);
+                                composer = { ...composer, error: message };
+                                if (destroyed)
+                                    fallbackLogger.error(`Could not queue ${submission.kind}: ${plainTerminalText(message)}`);
+                            }
+                            finally {
+                                submitting = false;
+                                render();
+                            }
+                        })();
+                    }
+                    else {
+                        renderTimer ??= setTimeout(render, 16);
+                    }
+                    return;
+                }
+            }
+            if (conversation && !composer?.focused && (event.ch === "v" || event.ch === "d")) {
+                if (event.ch === "v") {
+                    showQueue = !showQueue;
+                    if (showQueue)
+                        workOffset = undefined;
+                }
+                else
+                    showDetails = !showDetails;
+                render();
+                return;
+            }
+            if (showQueue && !composer?.focused && event.name === "home") {
+                workOffset = 0;
+                render();
+                return;
+            }
             const command = resolveCommand(event);
             if (command === undefined) {
                 return;
             }
+            if (command === "render-stats") {
+                showPerformance = !showPerformance;
+                render();
+                return;
+            }
+            if (command === "follow") {
+                if (showQueue) {
+                    workOffset = event.name === "end" ? Number.MAX_SAFE_INTEGER : undefined;
+                    render();
+                    return;
+                }
+                heldOutput = undefined;
+                heldAt = undefined;
+                scrollOffset = 0;
+                render();
+                return;
+            }
+            if (command === "scroll-up" ||
+                command === "scroll-down" ||
+                command === "page-up" ||
+                command === "page-down") {
+                const page = Math.max(1, outputRect?.height ?? outputViewportHeight);
+                const amount = command === "page-up" || command === "page-down" ? page : 1;
+                const direction = command === "scroll-up" || command === "page-up" ? 1 : -1;
+                if (showQueue) {
+                    workOffset = Math.max(0, (workOffset ?? 0) - amount * direction);
+                    renderTimer ??= setTimeout(render, 16);
+                    return;
+                }
+                if (direction > 0 && heldOutput === undefined) {
+                    heldOutput = getStore().getState().output;
+                    heldAt = Date.now();
+                }
+                scrollOffset = Math.max(0, scrollOffset + amount * direction);
+                if (scrollOffset === 0) {
+                    heldOutput = undefined;
+                    heldAt = 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?.();
@@ -86,6 +260,8 @@ export function createDashboard(opts = {}) {
             started = false;
             return;
         }
+        if (opts.onSubmit)
+            driver.write("\u001b[?2004l");
         driver.destroy();
         driver = undefined;
         previousBuffer = new ScreenBuffer(0, 0);
@@ -102,6 +278,10 @@ export function createDashboard(opts = {}) {
             return;
         }
         stop();
+        for (const draft of [composer, otherDraft]) {
+            if (draft?.error)
+                fallbackLogger.error(`Could not queue ${draft.kind}: ${plainTerminalText(draft.error)}`);
+        }
         commandHandlers.clear();
         store = undefined;
         destroyed = true;
@@ -111,26 +291,100 @@ 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 state = getStore().getState();
         const layout = computeDashboardLayout({
             totalWidth: cols,
             totalHeight: rows,
-            rightPaneWidth
+            rightPaneWidth,
+            footerHeight: state.stats.session ? 2 : 1
         });
         const nextBuffer = new ScreenBuffer(cols, rows);
-        const state = getStore().getState();
-        renderBorder(nextBuffer, layout, {
-            leftTitle: title,
-            rightTitle: statsTitle,
-            style: { dim: true }
-        });
-        renderOutputPane(nextBuffer, layout.leftPane, state.output);
-        renderStatsPane(nextBuffer, layout.rightPane, state.stats);
-        renderFooter(nextBuffer, layout.footer, footerHints);
-        driver.flush(diff(previousBuffer, nextBuffer));
+        let cursor;
+        if (conversation) {
+            const activePlanId = state.stats.run?.activePlanId;
+            if (activePlanId !== lastActivePlanId)
+                feedback = undefined;
+            if (composer && (composer.afterPlanId === undefined ||
+                (composer.text.length === 0 && composer.afterPlanId === lastActivePlanId))) {
+                composer = { ...composer, afterPlanId: activePlanId };
+            }
+            if (otherDraft.afterPlanId === undefined ||
+                (otherDraft.text.length === 0 && otherDraft.afterPlanId === lastActivePlanId)) {
+                otherDraft = { ...otherDraft, afterPlanId: activePlanId };
+            }
+            lastActivePlanId = activePlanId;
+            const view = renderRunView(nextBuffer, {
+                title, stats: state.stats, output: heldOutput ?? state.output, scrollOffset,
+                composer, submitting, showQueue, showDetails, workOffset, feedback, hints: opts.hints,
+                now: heldOutput === undefined ? Date.now() : heldAt
+            });
+            scrollOffset = view.scrollOffset;
+            workOffset = view.workOffset;
+            outputRect = view.outputRect;
+            cursor = view.cursor;
+        }
+        else {
+            renderBorder(nextBuffer, layout, {
+                leftTitle: title,
+                rightTitle: statsTitle,
+                style: { dim: true }
+            });
+            if (state.stats.context?.length) {
+                const contextRect = layout.summary ?? layout.leftPane;
+                // Context spans both panes on wide terminals.
+                const remaining = renderContextPane(nextBuffer, {
+                    x: contextRect.x, y: contextRect.y, width: Math.max(0, cols - 2),
+                    height: layout.summary ? layout.summary.height + layout.leftPane.height : layout.leftPane.height
+                }, state.stats.context);
+                const height = remaining.y - contextRect.y;
+                if (layout.summary) {
+                    layout.summary.y = remaining.y;
+                    layout.summary.height = Math.min(layout.summary.height, remaining.height);
+                    layout.leftPane.y = layout.summary.y + layout.summary.height;
+                    layout.leftPane.height = Math.max(0, remaining.height - layout.summary.height);
+                }
+                else {
+                    layout.leftPane.y += height;
+                    layout.leftPane.height -= height;
+                    layout.rightPane.y += height;
+                    layout.rightPane.height -= height;
+                }
+            }
+            outputViewportHeight = Math.max(0, layout.leftPane.height - (showPerformance ? 1 : 0));
+            scrollOffset = renderOutputPane(nextBuffer, { ...layout.leftPane, height: outputViewportHeight }, 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, state.stats.session);
+        }
+        if (scrollOffset === 0) {
+            heldOutput = undefined;
+            heldAt = undefined;
+        }
+        const performanceRect = outputRect ?? layout.leftPane;
+        if (showPerformance && performanceRect.height > 0) {
+            nextBuffer.putInRect(performanceRect, performanceRect.height - 1, formatRenderPerformance(performanceMonitor.snapshot(), performanceRect.width), { dim: true });
+        }
+        const changes = diff(previousBuffer, nextBuffer);
+        driver.flush(changes);
+        if (cursor) {
+            driver.moveTo(cursor.x, cursor.y);
+            driver.showCursor();
+        }
+        else {
+            driver.hideCursor();
+        }
+        performanceMonitor.end(startedAt, { changedCells: changes.length });
+        opts.onPerformance?.(performanceMonitor.snapshot());
         previousBuffer = nextBuffer;
     }
     function emitCommand(command) {
@@ -159,6 +413,7 @@ export function createDashboard(opts = {}) {
         appendOutput,
         updateStats,
         onCommand,
+        getPerformance: performanceMonitor.snapshot,
         destroy
     };
 }

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

@@ -0,0 +1 @@
+export declare function formatElapsed(ms: number): string;

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

@@ -0,0 +1,8 @@
+export function formatElapsed(ms) {
+    const safeMs = Number.isFinite(ms) ? ms : 0;
+    const totalSeconds = Math.max(0, Math.floor(safeMs / 1_000));
+    const hours = Math.floor(totalSeconds / 3_600);
+    const minutes = Math.floor((totalSeconds % 3_600) / 60);
+    const seconds = totalSeconds % 60;
+    return [hours, minutes, seconds].map((value) => value.toString().padStart(2, "0")).join(":");
+}

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

@@ -1,8 +1,11 @@
 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 type { DashboardSubmission } from "./composer.js";
 export { renderDashboardSnapshot } from "./snapshot.js";
 export type { SnapshotOptions } from "./snapshot.js";
-export type { OutputItem, OutputItemKind, DashboardStats, Command, DashboardState } from "./types.js";
+export type { OutputItem, OutputItemKind, DashboardStats, DashboardTask, DashboardRunState, DashboardQueueItem, DashboardWorkStatus, Command, DashboardState } from "./types.js";
 export { defaultHints } from "./components/footer.js";
 export type { FooterHint } from "./components/footer.js";

package/node_modules/toolcraft/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/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/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/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/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/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/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/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);
+        }
+    };
+}