terminal-pilot 0.0.48 → 0.0.50

package/node_modules/toolcraft-design/dist/acp/components.js

@@ -25,8 +25,13 @@ function colorForKind(kind) {
 function writeLine(line) {
     getAcpWriter()(line);
 }
-function agentPrefix() {
-    return `${color.green.bold("✓")} agent: `;
+const STATE_GLYPHS = {
+    streaming: () => color.dim("·"),
+    success: () => color.green.bold("✓"),
+    error: () => color.red.bold("✗")
+};
+function agentPrefix(state) {
+    return `${STATE_GLYPHS[state]()} agent: `;
 }
 function formatCost(costUsd) {
     return new Intl.NumberFormat("en-US", {
@@ -36,7 +41,7 @@ function formatCost(costUsd) {
         maximumFractionDigits: 6
     }).format(costUsd);
 }
-export function renderAgentMessage(text) {
+export function renderAgentMessage(text, state = "streaming") {
     const format = resolveOutputFormat();
     if (format === "markdown") {
         writeLine(`- **agent:** ${text}`);
@@ -47,7 +52,7 @@ export function renderAgentMessage(text) {
         return;
     }
     const rendered = renderMarkdown(text).trimEnd();
-    writeLine(`${agentPrefix()}${rendered}`);
+    writeLine(`${agentPrefix(state)}${rendered}`);
 }
 export function renderToolStart(kind, title) {
     const format = resolveOutputFormat();
@@ -85,7 +90,7 @@ export function renderReasoning(text) {
         writeLine(JSON.stringify({ event: "reasoning", text }));
         return;
     }
-    writeLine(color.dim(`  ✓ ${truncate(text, 80)}`));
+    writeLine(color.dim(`  · ${truncate(text, 80)}`));
 }
 export function renderUsage(tokens) {
     const format = resolveOutputFormat();
@@ -109,7 +114,7 @@ export function renderUsage(tokens) {
         return;
     }
     writeLine("");
-    writeLine(color.green(`✓ tokens: ${tokens.input} in${cached} → ${tokens.output} out${cost}`));
+    writeLine(color.dim(`· tokens: ${tokens.input} in${cached} → ${tokens.output} out${cost}`));
 }
 export function renderPermissionRejected(title) {
     const format = resolveOutputFormat();

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

@@ -1,3 +1,4 @@
 export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasoning, renderUsage, renderError, renderPermissionRejected } from "./components.js";
+export type { AcpOutputState } from "./components.js";
 export { getAcpWriter, withAcpWriter } from "./writer.js";
 export type { AcpLineWriter } from "./writer.js";

package/node_modules/toolcraft-design/dist/components/command-errors.d.ts

@@ -1,6 +1,7 @@
 export declare function formatCommandNotFound(input: {
     unknownCommand: string;
     helpCommand: string;
+    suggestions?: readonly string[];
 }): {
     label: string;
     hint: string;
@@ -8,6 +9,7 @@ export declare function formatCommandNotFound(input: {
 export declare function formatCommandNotFoundPanel(input: {
     unknownCommand: string;
     helpCommand: string;
+    suggestions?: readonly string[];
     title?: string;
 }): {
     title: string;

package/node_modules/toolcraft-design/dist/components/command-errors.js

@@ -5,15 +5,21 @@ export function formatCommandNotFound(input) {
     const unknown = unknownInput.length > 0
         ? unknownInput
         : "<command>";
+    const suggestions = input.suggestions ?? [];
+    const didYouMean = suggestions.length > 0
+        ? `
+${text.muted("Did you mean:")} ${suggestions.map((suggestion) => text.command(suggestion)).join(text.muted(", "))}${text.muted("?")}`
+        : "";
     return {
-        label: `${typography.bold("Unknown command:")} ${text.command(unknown)}`,
+        label: `${typography.bold("Unknown command:")} ${text.command(unknown)}${didYouMean}`,
         hint: `${text.muted("Run")} ${text.usageCommand(input.helpCommand)} ${text.muted("for available commands.")}`
     };
 }
 export function formatCommandNotFoundPanel(input) {
     const message = formatCommandNotFound({
         unknownCommand: input.unknownCommand,
-        helpCommand: input.helpCommand
+        helpCommand: input.helpCommand,
+        suggestions: input.suggestions
     });
     return {
         title: input.title ?? "command not found",

package/node_modules/toolcraft-design/dist/components/help-formatter-plain.js

@@ -1,3 +1,4 @@
+import { joinHelpTokens } from "./help-formatter.js";
 export function stripAnsi(value) {
     let output = "";
     for (let index = 0; index < value.length; index += 1) {
@@ -54,26 +55,49 @@ function splitWords(value) {
     }
     return words;
 }
-function wrapWords(value, width) {
-    const words = splitWords(value);
+function leadingWhitespace(value) {
+    let index = 0;
+    while (index < value.length && isWhitespace(value[index])) {
+        index += 1;
+    }
+    return { prefix: value.slice(0, index), rest: value.slice(index) };
+}
+function takePrefix(value, width) {
+    return { prefix: value.slice(0, width), rest: value.slice(width) };
+}
+function wrapWords(value, width, continuationWidth = width) {
+    // Preserve leading whitespace only on the first wrapped line so hang-indented
+    // left cells (command depth prefixes) do not re-indent every continuation.
+    const { prefix, rest } = leadingWhitespace(value);
+    const firstContentWidth = Math.max(1, width - prefix.length);
+    const words = splitWords(rest);
     if (words.length === 0) {
-        return [""];
+        return [prefix];
     }
     const lines = [];
     let line = "";
+    let isFirstLine = true;
     for (const word of words) {
-        if (!line) {
-            line = word;
-            continue;
-        }
-        if (line.length + 1 + word.length <= width) {
+        const limit = isFirstLine ? firstContentWidth : continuationWidth;
+        if (line && line.length + 1 + word.length <= limit) {
             line += ` ${word}`;
             continue;
         }
-        lines.push(line);
-        line = word;
+        if (line) {
+            lines.push(isFirstLine ? `${prefix}${line}` : line);
+            isFirstLine = false;
+            line = "";
+        }
+        let remaining = word;
+        while (remaining.length > (isFirstLine ? firstContentWidth : continuationWidth)) {
+            const chunk = takePrefix(remaining, isFirstLine ? firstContentWidth : continuationWidth);
+            lines.push(isFirstLine ? `${prefix}${chunk.prefix}` : chunk.prefix);
+            isFirstLine = false;
+            remaining = chunk.rest;
+        }
+        line = remaining;
     }
-    lines.push(line);
+    lines.push(isFirstLine ? `${prefix}${line}` : line);
     return lines;
 }
 export function formatColumns(opts) {
@@ -91,33 +115,43 @@ export function formatColumns(opts) {
     const indent = opts.indent ?? 2;
     const maxLeftContentWidth = Math.max(...rows.map((row) => row.left.length));
     const leftWidth = clamp(maxLeftContentWidth + gap, minLeftWidth, maxLeftWidth);
-    const rightWidth = Math.max(20, totalWidth - leftWidth - indent);
+    const rightWidth = Math.max(1, totalWidth - leftWidth - indent);
+    const leftWrapWidth = Math.max(1, totalWidth - indent);
     const firstIndent = " ".repeat(indent);
     const continuationIndent = " ".repeat(indent + leftWidth);
     return rows
         .flatMap((row) => {
+        let leftLeadingWidth = 0;
+        while (leftLeadingWidth < row.left.length && isWhitespace(row.left[leftLeadingWidth])) {
+            leftLeadingWidth += 1;
+        }
+        // Continuations hang under the left cell start (including depth prefix) by +2.
+        const leftHangIndent = " ".repeat(indent + leftLeadingWidth + 2);
+        const leftLines = wrapWords(row.left, leftWrapWidth, Math.max(1, totalWidth - leftHangIndent.length));
         if (row.right.length === 0) {
-            return [`${firstIndent}${row.left}`];
+            return leftLines.map((line, index) => index === 0 ? `${firstIndent}${line}` : `${leftHangIndent}${line}`);
         }
         const rightLines = wrapWords(row.right, rightWidth);
-        if (row.left.length >= leftWidth) {
-            return [
-                `${firstIndent}${row.left}`,
-                ...rightLines.map((line) => `${continuationIndent}${line}`)
-            ];
+        const leftFitsInColumn = row.left.length < leftWidth;
+        if (leftFitsInColumn && leftLines.length === 1) {
+            const firstLine = `${firstIndent}${padEndVisible(leftLines[0] ?? "", leftWidth)}${rightLines[0]}`;
+            const continuationLines = rightLines
+                .slice(1)
+                .map((line) => `${continuationIndent}${line}`);
+            return [firstLine, ...continuationLines];
         }
-        const firstLine = `${firstIndent}${padEndVisible(row.left, leftWidth)}${rightLines[0]}`;
-        const continuationLines = rightLines
-            .slice(1)
-            .map((line) => `${continuationIndent}${line}`);
-        return [firstLine, ...continuationLines];
+        const renderedLeft = leftLines.map((line, index) => index === 0 ? `${firstIndent}${line}` : `${leftHangIndent}${line}`);
+        const renderedRight = rightLines.map((line) => `${continuationIndent}${line}`);
+        return [...renderedLeft, ...renderedRight];
     })
         .join("\n");
 }
 export function formatCommandList(commands) {
     return formatColumns({
         rows: commands.map((cmd) => ({
-            left: `${" ".repeat((cmd.depth ?? 0) * 2)}${cmd.name}`,
+            left: `${" ".repeat((cmd.depth ?? 0) * 2)}${cmd.nameTokens !== undefined && cmd.nameTokens.length > 0
+                ? joinHelpTokens(cmd.nameTokens)
+                : cmd.name}`,
             right: cmd.description
         }))
     });
@@ -125,7 +159,9 @@ export function formatCommandList(commands) {
 export function formatOptionList(options) {
     return formatColumns({
         rows: options.map((opt) => ({
-            left: opt.flags,
+            left: opt.flagTokens !== undefined && opt.flagTokens.length > 0
+                ? joinHelpTokens(opt.flagTokens)
+                : opt.flags,
             right: opt.description
         }))
     });

package/node_modules/toolcraft-design/dist/components/help-formatter.d.ts

@@ -1,11 +1,20 @@
+export type HelpTokenRole = "command" | "argument" | "option" | "literal" | "dim";
+export interface HelpToken {
+    text: string;
+    role: HelpTokenRole;
+}
 export interface CommandInfo {
     name: string;
+    /** Structured tokens for TTY/markdown styling. Plain `name` is used when absent. */
+    nameTokens?: HelpToken[];
     description: string;
     /** Nesting depth relative to the help target. Depth 0 is a direct child. */
     depth?: number;
 }
 export interface OptionInfo {
     flags: string;
+    /** Structured tokens for TTY/markdown styling. Plain `flags` is used when absent. */
+    flagTokens?: HelpToken[];
     description: string;
 }
 export interface FormatColumnsOptions {
@@ -20,6 +29,9 @@ export interface FormatColumnsOptions {
     indent?: number;
 }
 export declare function formatColumns(opts: FormatColumnsOptions): string;
+export declare function styleHelpToken(token: HelpToken): string;
+export declare function joinHelpTokens(tokens: HelpToken[]): string;
+export declare function renderHelpTokens(tokens: HelpToken[]): string;
 export declare function formatCommand(name: string, description: string): string;
 export declare function formatUsage(command: string, args?: string): string;
 export declare function formatOption(flags: string, description: string): string;
@@ -32,4 +44,7 @@ export declare const helpFormatter: {
     readonly formatOption: typeof formatOption;
     readonly formatCommandList: typeof formatCommandList;
     readonly formatOptionList: typeof formatOptionList;
+    readonly styleHelpToken: typeof styleHelpToken;
+    readonly joinHelpTokens: typeof joinHelpTokens;
+    readonly renderHelpTokens: typeof renderHelpTokens;
 };

package/node_modules/toolcraft-design/dist/components/help-formatter.js

@@ -1,3 +1,5 @@
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { typography } from "../tokens/typography.js";
 import { text } from "./text.js";
 const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 function normalizeInline(value) {
@@ -103,26 +105,67 @@ function splitWords(value) {
     }
     return words;
 }
-function wrapWords(value, width) {
-    const words = splitWords(value);
+function leadingWhitespaceWidth(value) {
+    let index = 0;
+    while (index < value.length && isWhitespace(value[index])) {
+        index += 1;
+    }
+    return { prefix: value.slice(0, index), rest: value.slice(index) };
+}
+function takeVisiblePrefix(value, width) {
+    let visible = 0;
+    let index = 0;
+    while (index < value.length) {
+        const controlEnd = readControlSequence(value, index);
+        if (controlEnd !== undefined) {
+            index = controlEnd;
+            continue;
+        }
+        const segment = graphemeSegmenter.segment(value.slice(index))[Symbol.iterator]().next().value;
+        const cluster = segment?.segment ?? value[index] ?? "";
+        const nextWidth = clusterWidth(cluster);
+        if (visible > 0 && visible + nextWidth > width) {
+            break;
+        }
+        visible += nextWidth;
+        index += cluster.length || 1;
+    }
+    return { prefix: value.slice(0, index), rest: value.slice(index) };
+}
+function wrapWords(value, width, continuationWidth = width) {
+    // Preserve leading whitespace only on the first wrapped line so hang-indented
+    // left cells (command depth prefixes) do not re-indent every continuation.
+    const { prefix, rest } = leadingWhitespaceWidth(value);
+    const prefixWidth = visibleWidth(prefix);
+    const firstContentWidth = Math.max(1, width - prefixWidth);
+    const words = splitWords(rest);
     if (words.length === 0) {
-        return [""];
+        return [prefix];
     }
     const lines = [];
     let line = "";
+    let isFirstLine = true;
     for (const word of words) {
-        if (!line) {
-            line = word;
-            continue;
-        }
-        if (visibleWidth(line) + 1 + visibleWidth(word) <= width) {
+        const limit = isFirstLine ? firstContentWidth : continuationWidth;
+        if (line && visibleWidth(line) + 1 + visibleWidth(word) <= limit) {
             line += ` ${word}`;
             continue;
         }
-        lines.push(line);
-        line = word;
+        if (line) {
+            lines.push(isFirstLine ? `${prefix}${line}` : line);
+            isFirstLine = false;
+            line = "";
+        }
+        let remaining = word;
+        while (visibleWidth(remaining) > (isFirstLine ? firstContentWidth : continuationWidth)) {
+            const chunk = takeVisiblePrefix(remaining, isFirstLine ? firstContentWidth : continuationWidth);
+            lines.push(isFirstLine ? `${prefix}${chunk.prefix}` : chunk.prefix);
+            isFirstLine = false;
+            remaining = chunk.rest;
+        }
+        line = remaining;
     }
-    lines.push(line);
+    lines.push(isFirstLine ? `${prefix}${line}` : line);
     return lines;
 }
 function validateLayoutValue(value, name) {
@@ -150,29 +193,74 @@ export function formatColumns(opts) {
     validateLayoutValue(indent, "indent");
     const maxLeftContentWidth = Math.max(...rows.map((row) => visibleWidth(row.left)));
     const leftWidth = clamp(maxLeftContentWidth + gap, minLeftWidth, maxLeftWidth);
-    const rightWidth = Math.max(20, totalWidth - leftWidth - indent);
+    const rightWidth = Math.max(1, totalWidth - leftWidth - indent);
+    const leftWrapWidth = Math.max(1, totalWidth - indent);
     const firstIndent = " ".repeat(indent);
     const continuationIndent = " ".repeat(indent + leftWidth);
     return rows
         .flatMap((row) => {
+        const leftLeading = leadingWhitespaceWidth(row.left).prefix;
+        // Continuations hang under the left cell start (including depth prefix) by +2.
+        const leftHangIndent = " ".repeat(indent + visibleWidth(leftLeading) + 2);
+        const leftLines = wrapWords(row.left, leftWrapWidth, Math.max(1, totalWidth - visibleWidth(leftHangIndent)));
         if (row.right.length === 0) {
-            return [`${firstIndent}${row.left}`];
+            return leftLines.map((line, index) => index === 0 ? `${firstIndent}${line}` : `${leftHangIndent}${line}`);
         }
         const rightLines = wrapWords(row.right, rightWidth);
-        if (visibleWidth(row.left) >= leftWidth) {
-            return [
-                `${firstIndent}${row.left}`,
-                ...rightLines.map((line) => `${continuationIndent}${line}`)
-            ];
+        const leftFitsInColumn = visibleWidth(row.left) < leftWidth;
+        if (leftFitsInColumn && leftLines.length === 1) {
+            const firstLine = `${firstIndent}${padEndVisible(leftLines[0] ?? "", leftWidth)}${rightLines[0]}`;
+            const continuationLines = rightLines
+                .slice(1)
+                .map((line) => `${continuationIndent}${line}`);
+            return [firstLine, ...continuationLines];
         }
-        const firstLine = `${firstIndent}${padEndVisible(row.left, leftWidth)}${rightLines[0]}`;
-        const continuationLines = rightLines
-            .slice(1)
-            .map((line) => `${continuationIndent}${line}`);
-        return [firstLine, ...continuationLines];
+        const renderedLeft = leftLines.map((line, index) => index === 0 ? `${firstIndent}${line}` : `${leftHangIndent}${line}`);
+        const renderedRight = rightLines.map((line) => `${continuationIndent}${line}`);
+        return [...renderedLeft, ...renderedRight];
     })
         .join("\n");
 }
+export function styleHelpToken(token) {
+    switch (token.role) {
+        case "command":
+            return text.command(token.text);
+        case "argument":
+            return styleArgumentToken(token.text);
+        case "option":
+            return text.option(token.text);
+        case "dim":
+            return styleDim(token.text);
+        case "literal":
+            return token.text;
+    }
+}
+function styleArgumentToken(content) {
+    // Token text already includes angle brackets. text.argument re-wraps in markdown,
+    // so strip first there; terminal/json keep the full `<value>` form.
+    const format = resolveOutputFormat();
+    if (format === "markdown" && content.startsWith("<") && content.endsWith(">")) {
+        return text.argument(content.slice(1, -1));
+    }
+    if (format === "json") {
+        return content;
+    }
+    return text.argument(content);
+}
+function styleDim(content) {
+    // Structural brackets stay unstyled in markdown/json; italicizing them as muted is wrong.
+    const format = resolveOutputFormat();
+    if (format === "json" || format === "markdown") {
+        return content;
+    }
+    return typography.dim(content);
+}
+export function joinHelpTokens(tokens) {
+    return tokens.map((token) => token.text).join("");
+}
+export function renderHelpTokens(tokens) {
+    return tokens.map((token) => styleHelpToken(token)).join("");
+}
 export function formatCommand(name, description) {
     return formatColumns({
         rows: [{ left: text.command(name), right: description }]
@@ -189,16 +277,24 @@ export function formatOption(flags, description) {
 }
 export function formatCommandList(commands) {
     return formatColumns({
-        rows: commands.map((cmd) => ({
-            left: `${" ".repeat((cmd.depth ?? 0) * 2)}${text.command(cmd.name)}`,
-            right: cmd.description
-        }))
+        rows: commands.map((cmd) => {
+            const depthPrefix = " ".repeat((cmd.depth ?? 0) * 2);
+            const styledName = cmd.nameTokens !== undefined && cmd.nameTokens.length > 0
+                ? renderHelpTokens(cmd.nameTokens)
+                : text.command(cmd.name);
+            return {
+                left: `${depthPrefix}${styledName}`,
+                right: cmd.description
+            };
+        })
     });
 }
 export function formatOptionList(options) {
     return formatColumns({
         rows: options.map((opt) => ({
-            left: text.option(opt.flags),
+            left: opt.flagTokens !== undefined && opt.flagTokens.length > 0
+                ? renderHelpTokens(opt.flagTokens)
+                : text.option(opt.flags),
             right: opt.description
         }))
     });
@@ -209,5 +305,8 @@ export const helpFormatter = {
     formatUsage,
     formatOption,
     formatCommandList,
-    formatOptionList
+    formatOptionList,
+    styleHelpToken,
+    joinHelpTokens,
+    renderHelpTokens
 };

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

@@ -4,11 +4,11 @@ export type { Color } from "./color.js";
 export { symbols } from "./symbols.js";
 export { createLogger, logger } from "./logger.js";
 export type { LoggerOutput } from "./logger.js";
-export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./help-formatter.js";
-export type { CommandInfo, OptionInfo, FormatColumnsOptions } from "./help-formatter.js";
+export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList, styleHelpToken, joinHelpTokens, renderHelpTokens } from "./help-formatter.js";
+export type { CommandInfo, OptionInfo, FormatColumnsOptions, HelpToken, HelpTokenRole } from "./help-formatter.js";
 export { formatCommandNotFound } from "./command-errors.js";
 export { formatCommandNotFoundPanel } from "./command-errors.js";
-export { renderTable } from "./table.js";
+export { loggerTableWidth, renderTable } from "./table.js";
 export type { TableColumn, RenderTableOptions } from "./table.js";
 export { renderFileChanges } from "./file-changes.js";
 export type { FileChange, FileChangeDisplayMode, FileChangeKind, FileChangeOutputFormat, RenderFileChangesOptions } from "./file-changes.js";

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

@@ -2,10 +2,10 @@ export { text } from "./text.js";
 export { color } from "./color.js";
 export { symbols } from "./symbols.js";
 export { createLogger, logger } from "./logger.js";
-export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./help-formatter.js";
+export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList, styleHelpToken, joinHelpTokens, renderHelpTokens } from "./help-formatter.js";
 export { formatCommandNotFound } from "./command-errors.js";
 export { formatCommandNotFoundPanel } from "./command-errors.js";
-export { renderTable } from "./table.js";
+export { loggerTableWidth, renderTable } from "./table.js";
 export { renderFileChanges } from "./file-changes.js";
 export { renderCatalog } from "./catalog.js";
 export { getTemplatePartialNames, renderTemplate, resolveTemplatePartials } from "./template.js";

package/node_modules/toolcraft-design/dist/components/table.d.ts

@@ -12,4 +12,5 @@ export interface RenderTableOptions {
     variant?: "table" | "detail";
     maxWidth?: number;
 }
+export declare function loggerTableWidth(): number | undefined;
 export declare function renderTable(options: RenderTableOptions): string;

package/node_modules/toolcraft-design/dist/components/table.js

@@ -3,6 +3,7 @@ import { resolveOutputFormat } from "../internal/output-format.js";
 import { stripAnsi } from "../internal/strip-ansi.js";
 const reset = "\x1b[0m";
 const ellipsis = "…";
+const minCellWidth = 4;
 const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 function getCell(row, name) {
     return Object.prototype.hasOwnProperty.call(row, name) ? row[name] ?? "" : "";
@@ -161,6 +162,51 @@ function computeColumns(columns) {
         width: getColumnWidth(column)
     }));
 }
+// Each column is framed as "│ cell ", plus the closing "│".
+function frameWidth(columnCount) {
+    return columnCount * 3 + 1;
+}
+// Log output indents every line with a "│  " guide, so a table emitted through the
+// logger has that much less room than the terminal. Undefined without a terminal:
+// piped output has no width to fit.
+export function loggerTableWidth() {
+    const columns = process.stdout.columns;
+    return columns === undefined ? undefined : columns - 3;
+}
+// Without an explicit budget or a TTY there is no width to fit: the consumer of the
+// piped output decides, so columns keep their declared widths.
+function budgetColumns(columns, maxWidth) {
+    if (maxWidth === undefined) {
+        return columns;
+    }
+    const available = maxWidth - frameWidth(columns.length);
+    const contentWidth = (cap) => columns.reduce((total, column) => total + Math.min(column.width, cap), 0);
+    if (columns.reduce((total, column) => total + column.width, 0) <= available) {
+        return columns;
+    }
+    // Widest-first: raise a shared cap as far as the budget allows, so narrow columns
+    // keep their declared width and only the columns above the cap lose room.
+    let cap = minCellWidth;
+    while (contentWidth(cap + 1) <= available) {
+        cap += 1;
+    }
+    const budgeted = columns.map((column) => ({ ...column, width: Math.min(column.width, cap) }));
+    let slack = available - contentWidth(cap);
+    while (slack > 0) {
+        const growable = budgeted.filter((column, index) => column.width < columns[index].width);
+        if (growable.length === 0) {
+            break;
+        }
+        for (const column of growable) {
+            if (slack === 0) {
+                break;
+            }
+            column.width += 1;
+            slack -= 1;
+        }
+    }
+    return budgeted;
+}
 function renderBorder(columns, theme, parts) {
     const horizontal = theme.muted("─");
     const segments = columns.map((column) => horizontal.repeat(column.width + 2));
@@ -247,16 +293,17 @@ function renderTableTerminal(options) {
     }
     const separatorOptions = options;
     const includeRowSeparators = separatorOptions.rowSeparator === true || separatorOptions.rowSeparators === true;
-    const top = renderBorder(computedColumns, theme, { left: "┌", mid: "┬", right: "┐" });
-    const header = renderTerminalRow(computedColumns.map((column) => theme.header(column.title)), computedColumns, theme);
-    const headerBottom = renderBorder(computedColumns, theme, { left: "├", mid: "┼", right: "┤" });
-    const bottom = renderBorder(computedColumns, theme, { left: "└", mid: "┴", right: "┘" });
+    const budgetedColumns = budgetColumns(computedColumns, options.maxWidth ?? process.stdout.columns);
+    const top = renderBorder(budgetedColumns, theme, { left: "┌", mid: "┬", right: "┐" });
+    const header = renderTerminalRow(budgetedColumns.map((column) => theme.header(column.title)), budgetedColumns, theme);
+    const headerBottom = renderBorder(budgetedColumns, theme, { left: "├", mid: "┼", right: "┤" });
+    const bottom = renderBorder(budgetedColumns, theme, { left: "└", mid: "┴", right: "┘" });
     const renderedRows = [];
     for (const [index, row] of rows.entries()) {
         if (includeRowSeparators && index > 0) {
             renderedRows.push(headerBottom);
         }
-        renderedRows.push(renderTerminalRow(computedColumns.map((column) => getCell(row, column.name)), computedColumns, theme));
+        renderedRows.push(renderTerminalRow(budgetedColumns.map((column) => getCell(row, column.name)), budgetedColumns, theme));
     }
     return [top, header, headerBottom, ...renderedRows, bottom].join("\n");
 }

package/node_modules/toolcraft-design/dist/components/template.d.ts

@@ -5,6 +5,15 @@ export interface RenderTemplateOptions {
     validate?: boolean;
     yield?: string;
 }
+export declare class TemplateParseError extends Error {
+    readonly description: string;
+    readonly line: number;
+    readonly column: number;
+    constructor(description: string, position: {
+        line: number;
+        column: number;
+    });
+}
 export declare function renderTemplate(template: string, view: Record<string, unknown>, options?: RenderTemplateOptions): string;
 export declare function getTemplatePartialNames(template: string): string[];
 export declare function resolveTemplatePartials(template: string, partials: Record<string, string>): string;