@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/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/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,15 @@ 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 detail = item.detail === undefined ? undefined : limitOutputPreview(item.detail);
+        const retainedItem = preview === item.text && detail === item.detail ? item : { ...item, text: preview, detail };
+        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/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/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/node_modules/toolcraft-design/dist/dashboard/terminal-width.d.ts

@@ -2,3 +2,4 @@ export declare function graphemes(value: string): string[];
 export declare function displayWidth(value: string, startColumn?: number): number;
 export declare function expandTabs(value: string, startColumn?: number): string;
 export declare function graphemeWidth(segment: string): number;
+export declare function truncateToWidth(text: string, width: number): string;

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

@@ -1,6 +1,12 @@
 const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 export function graphemes(value) {
-    return Array.from(graphemeSegmenter.segment(value), ({ segment }) => segment);
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if ((code < 0x20 || code > 0x7e) && code !== 0x09 && code !== 0x0a && (code < 0x4e00 || code > 0x9fff)) {
+            return Array.from(graphemeSegmenter.segment(value), ({ segment }) => segment);
+        }
+    }
+    return value.split("");
 }
 export function displayWidth(value, startColumn = 0) {
     let column = startColumn;
@@ -14,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)) {
@@ -33,7 +41,24 @@ export function graphemeWidth(segment) {
     if (codePoint === undefined || isZeroWidthCodePoint(codePoint)) {
         return 0;
     }
-    return isWideCodePoint(codePoint) || isFlagSegment(segment) ? 2 : 1;
+    return isWideCodePoint(codePoint) || isFlagSegment(segment) || segment.includes("\ufe0f") ? 2 : 1;
+}
+export function truncateToWidth(text, width) {
+    if (width <= 0)
+        return "";
+    if (displayWidth(text) <= width)
+        return text;
+    const target = Math.max(0, width - 1);
+    let result = "";
+    let used = 0;
+    for (const segment of graphemes(text)) {
+        const segmentWidth = graphemeWidth(segment);
+        if (used + segmentWidth > target)
+            break;
+        result += segment;
+        used += segmentWidth;
+    }
+    return `${result}…`;
 }
 function isZeroWidthCodePoint(codePoint) {
     return (codePoint >= 0x0300 && codePoint <= 0x036f)

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

@@ -1,17 +1,18 @@
 import readline from "node:readline";
 import { PassThrough } from "node:stream";
+import { createInputParser } from "../terminal/input.js";
 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);
     const resizeListeners = new Set();
-    const keypressListeners = new Set();
+    const keypressListeners = new Map();
     let rawMode = false;
     let altScreen = false;
     let lineWrapEnabled = true;
     let cursorHidden = false;
     let destroyed = false;
-    readline.emitKeypressEvents(stdin);
     function enterRawMode() {
         if (destroyed || rawMode) {
             return;
@@ -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);
     }
@@ -118,27 +128,41 @@ export function createTerminalDriver(opts) {
         if (destroyed) {
             return () => { };
         }
-        const listener = (str, key) => {
-            const event = toKeypressEvent(str, key);
-            if (event !== undefined) {
-                handler(event);
+        const dispatch = (event) => {
+            if (event.type === "paste") {
+                handler({ name: "paste", ch: event.text, ctrl: false, meta: false, shift: false });
+            }
+            else if (event.type === "key") {
+                handler({
+                    ...(event.ch !== undefined ? { ch: event.ch } : { name: event.name === "enter" ? "return" : event.name }),
+                    ctrl: event.ctrl,
+                    meta: event.alt,
+                    shift: event.shift
+                });
             }
         };
-        keypressListeners.add(listener);
-        stdin.on("keypress", listener);
+        const parser = createInputParser({ onEvent: dispatch });
+        const listener = (chunk) => {
+            for (const event of parser.feed(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))
+                dispatch(event);
+        };
+        keypressListeners.set(listener, parser.destroy);
+        stdin.on("data", listener);
         return () => {
             if (!keypressListeners.delete(listener)) {
                 return;
             }
-            stdin.off("keypress", listener);
+            parser.destroy();
+            stdin.off("data", listener);
         };
     }
     function destroy() {
         if (destroyed) {
             return;
         }
-        for (const listener of keypressListeners) {
-            stdin.off("keypress", listener);
+        for (const [listener, cleanup] of keypressListeners) {
+            cleanup();
+            stdin.off("data", listener);
         }
         keypressListeners.clear();
         for (const listener of resizeListeners) {
@@ -173,6 +197,9 @@ export function parseKeypress(data) {
     if (data.length === 0) {
         return undefined;
     }
+    if (data.length === 1 && data[0] === 0x1b) {
+        return { name: "escape", ctrl: false, meta: false, shift: false };
+    }
     const stream = new PassThrough();
     const stdin = stream;
     let event;

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

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

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

@@ -0,0 +1,128 @@
+import { createDashboard } from "../dashboard.js";
+import { createDashboardLineBuffer } from "../line-buffer.js";
+// Fake output only: no agent, credentials, repository writes, or network requests.
+const scenario = process.argv[2] ?? "streaming";
+const labelControl = scenario === "label-controls" ? "\u001b]52;c;" + "HIDDEN_".repeat(100) + "\u0007" : "";
+const dashboard = createDashboard({
+    title: scenario === "unicode-title" ? "Pipeline · 界界 · 👩‍💻 · é · ".repeat(3) : `Pipeline · ${scenario}${labelControl}`,
+    statsTitle: scenario === "unicode-title" ? "Run · 界界 · 👩‍💻 · é" : `Run${labelControl}`,
+    rightPaneWidth: 44,
+    hints: [
+        { key: "q", label: `Quit${labelControl}` },
+        { key: "↑↓", label: "Scroll" },
+        { key: "F", label: "Follow" }
+    ]
+});
+let count = 0;
+let timer;
+const append = (kind, text) => {
+    dashboard.appendOutput({ kind, text, ts: count++ });
+};
+const shutdown = () => {
+    clearInterval(timer);
+    dashboard.destroy();
+};
+dashboard.onCommand((command) => {
+    if (command === "quit" || command === "forceQuit")
+        shutdown();
+});
+process.once("SIGINT", shutdown);
+process.once("SIGTERM", shutdown);
+dashboard.start();
+if (scenario !== "empty")
+    dashboard.updateStats({
+        status: "running",
+        iterationsLabel: `Tasks${labelControl}`,
+        iterations: scenario === "resumed" || scenario === "queue" ? 68 : 1,
+        iterationsTotal: scenario === "resumed" || scenario === "queue" ? 90 : 8,
+        context: scenario === "queue" ? ["Plan 1/3: docs/plans/improve-pipeline-task-counts-and-restart-progress.md", "Next 2/3: docs/plans/agent-conversation-recovery.md", "Next 3/3: docs/plans/界界-unicode-long-plan-title.md"] : ["Plan 1/1: docs/plans/improve-pipeline-task-counts-and-restart-progress.md"],
+        tokensIn: 24000,
+        tokensOut: 7000,
+        elapsedMs: 65000,
+        currentAction: scenario === "resumed" || scenario === "queue" ? "Task 69/90 · Improve persisted pipeline progress · implement · step 1/2" : "Improve streaming output (implement)"
+    });
+append("info", "Config · codex · model-example · docs/plans/fake-pipeline.md");
+if (scenario !== "empty")
+    append("status", scenario === "resumed" || scenario === "queue" ? "Task 69/90 · Improve persisted pipeline progress (implement)" : "Task 2/8 · Improve streaming output (implement)");
+if (scenario === "empty") {
+    dashboard.updateStats({
+        status: "done",
+        iterationsLabel: "Tasks",
+        iterations: 0,
+        tokensIn: 0,
+        tokensOut: 0,
+        elapsedMs: 0,
+        currentAction: "Nothing to run"
+    });
+    append("info", "All tasks are already complete.");
+}
+else if (scenario === "oversized") {
+    append("tool", "output word ".repeat(50000) + "LATEST RESULT");
+}
+else if (scenario === "newline-free") {
+    const output = createDashboardLineBuffer((line) => append("tool", line));
+    for (let index = 0; index < 1000; index += 1)
+        output.push("output word ".repeat(100));
+    output.push("LATEST RESULT");
+    output.flush();
+}
+else if (scenario === "execution-error") {
+    append("error", "Fake execution threw before producing a task result");
+    dashboard.updateStats({ status: "error", currentAction: undefined });
+}
+else if (scenario === "failure") {
+    append("tool", "npm test · checking streaming output");
+    append("error", "Tool exited with code 1\nExpected task result, received empty output\nRetry after correcting the task.");
+    dashboard.updateStats({ status: "error", currentAction: "Task 2/8 failed (implement)" });
+}
+else if (scenario === "unicode") {
+    append("info", "解析中 · 界界 · café · 👩‍💻 · é");
+    append("tool", "\u001b[31merror\u001b[0m normal \u001b[1;32msuccess\u001b[0m\nindented\tcolumn\nprogress 10%\rprogress 100%");
+    append("success", "Unicode and ANSI fixture ready");
+}
+else if (scenario === "label-controls") {
+    append("success", "Label control fixture ready");
+}
+else if (scenario === "unicode-title") {
+    append("success", "Unicode heading fixture ready");
+}
+else if (scenario === "cursor-controls") {
+    append("tool", "\u001b[32m界界\rA\u001b[0m\n😀\bX\n👩‍💻\bX\né\bX\na\tB\rX");
+    append("tool", "\u001b]52;c;HIDDEN_OSC_PAYLOAD\u0007Visible OSC result");
+    append("tool", "\u001bP HIDDEN_DCS_PAYLOAD\u001b\\Visible DCS result");
+    append("tool", "\u001b[2J\u001b[1;1HFrame preserved");
+    append("tool", "left\u007fright · \u009b2JC1 frame preserved");
+    append("tool", "\u009dHIDDEN_C1_OSC\u009cVisible C1 OSC result");
+    append("tool", "\u0090HIDDEN_FIRST\u0007HIDDEN_SECOND\u009cVisible C1 DCS result");
+    append("tool", "\u001bP" + "HIDDEN_LONG_".repeat(4_000) + "\u001b\\Visible long DCS result");
+    const output = createDashboardLineBuffer((line) => append("tool", line));
+    output.push("\u001b]HIDDEN_FIRST\n");
+    output.push("HIDDEN_SECOND\nHIDDEN_THIRD\u001b");
+    output.push("\\Visible multiline OSC result\n");
+    append("tool", "\u001b[" + "0;".repeat(20_000) + "mVisible long CSI result");
+    append("tool", "\u001bPHIDDEN_CANCELLED_DCS\u0018Visible cancelled DCS result");
+    append("tool", "\u001b]HIDDEN_CANCELLED_OSC\u001aVisible cancelled OSC result");
+    append("tool", "\u001b[0;\u001b[32mVisible restarted CSI result\u001b[0m");
+    append("tool", "Tab preservation fixture\nABCDEF\r\tX");
+    append("tool", "\u001b[31mABCDEF\u001b[0m\r\tX\n界界AB\r\tX");
+    append("tool", "Erase-line fixture\nprogress 100%\rprogress 50%\u001b[K\nABCDE\rXX\u001b[1K");
+    append("tool", "界界\b\u001b[KX\n界界AB\rXX\u001b[1K");
+    append("success", "Cursor control fixture ready");
+}
+else {
+    for (let index = 0; index < 200; index += 1) {
+        append("tool", `[implement] Inspecting source file ${index} and running focused checks`);
+    }
+    if (scenario === "burst") {
+        timer = setInterval(() => {
+            for (let index = 0; index < 100; index += 1)
+                append("tool", `burst output ${count}`);
+        }, 100);
+    }
+    else {
+        timer = setInterval(() => append("info", `Streaming response ${count} · working on the current task`), 500);
+    }
+}
+// Keep terminal state visible until QA sends q, including completed/error scenarios.
+if (timer === undefined)
+    timer = setInterval(() => { }, 1000);

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

@@ -1,19 +1,65 @@
 export type OutputItemKind = "info" | "success" | "error" | "tool" | "status";
 export type OutputItem = {
+    /** Reusing an id replaces its retained preview in place, without changing held history. */
+    id?: string;
     kind: OutputItemKind;
     text: string;
     ts: number;
+    role?: "agent" | "reasoning" | "action" | "user" | "plan";
+    detail?: string;
+};
+export type DashboardWorkStatus = "pending" | "running" | "completed" | "failed" | "cancelled" | "paused";
+export type DashboardQueueItem = Readonly<{
+    id: string;
+    status: DashboardWorkStatus;
+} & ({
+    kind: "plan";
+    path: string;
+} | {
+    kind: "message";
+    text: string;
+    afterPlanId: string;
+})>;
+export type DashboardTask = {
+    id: string;
+    title: string;
+    status: DashboardWorkStatus;
+    steps?: Array<{
+        name: string;
+        status: DashboardWorkStatus;
+    }>;
+};
+export type DashboardRunState = {
+    agent?: string;
+    model?: string;
+    cwd?: string;
+    phase?: string;
+    activity?: string;
+    activePlanId?: string;
+    activeTaskId?: string;
+    activeStep?: string;
+    queue?: readonly DashboardQueueItem[];
+    tasks?: readonly DashboardTask[];
 };
 export type DashboardStats = {
     status: "idle" | "running" | "paused" | "done" | "error";
     iterations: number;
     iterationsLabel?: string;
+    iterationsTotal?: number;
+    context?: string[];
     tokensIn: number;
     tokensOut: number;
     elapsedMs: number;
     currentAction?: string;
+    session?: {
+        cwd: string;
+        agent: string;
+        model?: string;
+    };
+    usageAvailable?: boolean;
+    run?: DashboardRunState;
 };
-export type Command = "quit" | "forceQuit" | "edit" | "pause" | "retry" | "view-log";
+export type Command = "quit" | "forceQuit" | "edit" | "pause" | "retry" | "view-log" | "scroll-up" | "scroll-down" | "page-up" | "page-down" | "follow" | "render-stats";
 export type DashboardState = {
     output: OutputItem[];
     stats: DashboardStats;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/escape-terminal-text.d.ts

@@ -0,0 +1 @@
+export { escapeTerminalText } from "@poe-code/terminal-text";

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/escape-terminal-text.js

@@ -0,0 +1 @@
+export { escapeTerminalText } from "@poe-code/terminal-text";

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/event-groups.d.ts

@@ -0,0 +1,19 @@
+export interface GroupEvent {
+    id: string;
+    text: string;
+    error?: boolean;
+}
+export interface EventGroupRow extends GroupEvent {
+    groupId: string;
+    header?: boolean;
+    expanded?: boolean;
+}
+export declare function createEventGroups({ capacity, children }: {
+    capacity: number;
+    children: number;
+}): {
+    append(groupId: string, event: GroupEvent): void;
+    toggle(groupId: string): void;
+    rows(offset: number, height: number): EventGroupRow[];
+};
+export declare function renderEventGroupRows(rows: readonly EventGroupRow[], width: number): string[];

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/event-groups.js

@@ -0,0 +1,49 @@
+import { plainTerminalText } from "./dashboard/ansi.js";
+import { fitToWidth } from "./explorer/render/text.js";
+import { limitOutputPreview } from "./dashboard/output-preview.js";
+export function createEventGroups({ capacity, children }) {
+    if (!Number.isInteger(capacity) || capacity < 1 || !Number.isInteger(children) || children < 1)
+        throw new RangeError("positive capacities required");
+    const groups = new Map();
+    return {
+        append(groupId, event) {
+            let group = groups.get(groupId);
+            if (!group) {
+                group = { events: new Map(), expanded: false };
+                groups.set(groupId, group);
+            }
+            group.events.set(event.id, { ...event, text: limitOutputPreview(event.text) });
+            if (group.events.size > children)
+                group.events.delete(group.events.keys().next().value);
+            if (event.error)
+                group.expanded = true;
+            if (groups.size > capacity)
+                groups.delete(groups.keys().next().value);
+        },
+        toggle(groupId) { const group = groups.get(groupId); if (group)
+            group.expanded = !group.expanded; },
+        rows(offset, height) {
+            const result = [];
+            let index = 0;
+            for (const [groupId, group] of groups) {
+                if (index++ >= offset)
+                    result.push({ id: groupId, text: groupId, groupId, header: true, expanded: group.expanded });
+                if (result.length >= height)
+                    break;
+                if (group.expanded)
+                    for (const event of group.events.values()) {
+                        if (index++ >= offset)
+                            result.push({ ...event, groupId });
+                        if (result.length >= height)
+                            break;
+                    }
+                if (result.length >= height)
+                    break;
+            }
+            return height > 0 ? result : [];
+        }
+    };
+}
+export function renderEventGroupRows(rows, width) {
+    return rows.map(row => fitToWidth(`${row.header ? row.expanded ? "▾" : "▸" : row.error ? "  ■" : "  │"} ${plainTerminalText(row.text)}`, width));
+}

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

@@ -1,14 +1,20 @@
 import type { ExplorerEvent } from "./events.js";
 import type { Action, ActionContext, ExplorerState, Row, Tone } from "./state.js";
-export type ActionSource = "row" | "detail";
+export type ActionSource = "row" | "detail" | "both";
 type ExplorerKeypressEvent = Extract<ExplorerEvent, {
     type: "key";
 }>["key"];
 export type ActionRuntimeHandles = {
     refresh: () => Promise<void>;
+    reloadDetail: (rowId?: string) => void;
     suspendAnd: <T>(fn: () => Promise<T>) => Promise<T>;
+    openModal: (content: {
+        title: string;
+        content: string;
+    }) => void;
     toast: (msg: string, tone?: Tone) => void;
-    confirm: (prompt: string) => Promise<boolean>;
+    confirm: ActionContext<unknown>["confirm"];
+    promptText: ActionContext<unknown>["promptText"];
     exit: (after?: () => void | Promise<void>) => void;
 };
 export declare function resolveAction<R>(state: ExplorerState, keyEvent: ExplorerKeypressEvent): Action<R> | null;