@thegitai/cli 1.0.0-beta.9 → 1.0.0-preview.10

package/dist/src/ui/tui/markdown-render.js

@@ -1,6 +1,8 @@
-import { line, plainLine, span, wrapText } from './text.js';
-const TABLE_BORDER_WIDTH = 2;
-const TABLE_CELL_OVERHEAD_WIDTH = 3;
+import { displayWidth, line, padToWidth, plainLine, sliceToWidth, span, wrapText, wrapToWidth, } from './text.js';
+const MIN_TABLE_COLUMN_WIDTH = 3;
+function tableRowOverhead(columnCount) {
+    return 3 * columnCount + 1;
+}
 function parseInlineSegments(text) {
     const source = String(text ?? '');
     const segments = [];
@@ -110,45 +112,37 @@ function stripInlineFormattingForWidth(text) {
         .replace(/\*\*([^*]+)\*\*/g, '$1');
 }
 function fitTableColumnWidths(columnWidths, maxWidth) {
-    const widths = columnWidths.map((width) => Math.max(3, Math.floor(width)));
-    if (widths.length === 0)
-        return widths;
-    const overhead = TABLE_BORDER_WIDTH + widths.length * TABLE_CELL_OVERHEAD_WIDTH;
-    const budget = Math.max(widths.length * 3, maxWidth - overhead);
-    const total = widths.reduce((sum, width) => sum + width, 0);
-    if (total <= budget)
-        return widths;
-    let remaining = budget;
-    const scaled = widths.map((width) => {
-        const next = Math.max(3, Math.floor((width / total) * budget));
-        remaining -= next;
-        return next;
-    });
-    while (remaining > 0) {
-        let targetIndex = 0;
-        for (let index = 1; index < widths.length; index++) {
-            if (widths[index] - scaled[index] > widths[targetIndex] - scaled[targetIndex]) {
-                targetIndex = index;
-            }
-        }
-        scaled[targetIndex]++;
-        remaining--;
+    const columnCount = columnWidths.length;
+    if (columnCount === 0)
+        return [];
+    const natural = columnWidths.map((width) => Math.max(1, Math.floor(width)));
+    const budget = Math.floor(maxWidth) - tableRowOverhead(columnCount);
+    const total = natural.reduce((sum, width) => sum + width, 0);
+    if (budget >= total)
+        return natural;
+    const floorWidth = Math.max(1, Math.min(MIN_TABLE_COLUMN_WIDTH, Math.floor(budget / columnCount)));
+    const widths = natural.map((width) => Math.min(width, floorWidth));
+    let used = widths.reduce((sum, width) => sum + width, 0);
+    if (used > budget) {
+        const share = Math.max(1, Math.floor(budget / columnCount));
+        for (let index = 0; index < columnCount; index++)
+            widths[index] = share;
+        used = share * columnCount;
     }
-    while (remaining < 0) {
-        let targetIndex = -1;
-        for (let index = 0; index < scaled.length; index++) {
-            if (scaled[index] <= 3)
+    let remaining = budget - used;
+    while (remaining > 0) {
+        let grew = false;
+        for (let index = 0; index < columnCount && remaining > 0; index++) {
+            if (widths[index] >= natural[index])
                 continue;
-            if (targetIndex === -1 || scaled[index] > scaled[targetIndex]) {
-                targetIndex = index;
-            }
+            widths[index]++;
+            remaining--;
+            grew = true;
         }
-        if (targetIndex === -1)
+        if (!grew)
             break;
-        scaled[targetIndex]--;
-        remaining++;
     }
-    return scaled;
+    return widths;
 }
 function normalizeMarkdownTableCells(cells, columnCount) {
     return Array.from({ length: columnCount }, (_, index) => cells[index] ?? '');
@@ -176,7 +170,7 @@ function parseMarkdownTableBlock(lines, startIndex) {
     const normalizedHeaders = normalizeMarkdownTableCells(headers, columnCount);
     const columnWidths = normalizedHeaders.map((header, columnIndex) => {
         const values = [header, ...rows.map((row) => row[columnIndex] ?? '')];
-        return Math.max(3, ...values.map((value) => stripInlineFormattingForWidth(value).length));
+        return Math.max(MIN_TABLE_COLUMN_WIDTH, ...values.map((value) => displayWidth(stripInlineFormattingForWidth(value))));
     });
     return {
         nextIndex,
@@ -280,24 +274,33 @@ function wrapInlineToLines(text, width, bodyColor, prefix = '') {
         rowWidth = 0;
     };
     const appendSpan = (part) => {
-        const current = rows[rows.length - 1];
-        const limit = safeWidth - (indent ? prefix.length : 0);
+        let current = rows[rows.length - 1];
+        const limit = safeWidth - (rows.length === 1 && indent ? displayWidth(prefix) : 0);
         let remaining = part.text;
         while (remaining.length > 0) {
             const room = limit - rowWidth;
             if (room <= 0) {
                 startRow();
+                current = rows[rows.length - 1];
                 continue;
             }
-            if (remaining.length <= room) {
+            const width = displayWidth(remaining);
+            if (width <= room) {
                 current.push(span(remaining, styleFromSpan(part)));
-                rowWidth += remaining.length;
+                rowWidth += width;
                 remaining = '';
                 break;
             }
-            current.push(span(remaining.slice(0, room), styleFromSpan(part)));
-            remaining = remaining.slice(room);
+            const head = sliceToWidth(remaining, room);
+            if (displayWidth(head) > room && current.length > 0) {
+                startRow();
+                current = rows[rows.length - 1];
+                continue;
+            }
+            current.push(span(head, styleFromSpan(part)));
+            remaining = remaining.slice(head.length);
             startRow();
+            current = rows[rows.length - 1];
         }
     };
     for (const segment of segments) {
@@ -316,36 +319,35 @@ function wrapInlineToLines(text, width, bodyColor, prefix = '') {
         return line(...bodySpans);
     });
 }
-function padCell(text, width) {
-    const plain = stripInlineFormattingForWidth(text);
-    if (plain.length >= width)
-        return plain.slice(0, width);
-    return plain + ' '.repeat(width - plain.length);
-}
 function renderTableLines(table, width) {
     const columnWidths = fitTableColumnWidths(table.columnWidths, width);
+    const border = (left, joint, right) => line(span(left +
+        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join(joint) +
+        right, { color: 'cyan', dim: true }));
     const renderRow = (cells, bold) => {
-        const parts = columnWidths.map((colWidth, index) => span(` ${padCell(cells[index] ?? '', colWidth)} `, {
-            color: 'cyan',
-            bold,
-        }));
-        return line(span('│', { color: 'cyan' }), ...parts, span('│', { color: 'cyan' }));
+        const wrapped = columnWidths.map((colWidth, index) => wrapToWidth(stripInlineFormattingForWidth(cells[index] ?? ''), colWidth));
+        const height = Math.max(1, ...wrapped.map((cellLines) => cellLines.length));
+        const rows = [];
+        for (let row = 0; row < height; row++) {
+            const spans = [span('│', { color: 'cyan' })];
+            for (let column = 0; column < columnWidths.length; column++) {
+                const text = wrapped[column]?.[row] ?? '';
+                spans.push(span(` ${padToWidth(text, columnWidths[column])} `, {
+                    color: 'cyan',
+                    bold,
+                }));
+                spans.push(span('│', { color: 'cyan' }));
+            }
+            rows.push(line(...spans));
+        }
+        return rows;
     };
-    const separator = line(span('├' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┼') +
-        '┤', { color: 'cyan', dim: true }));
-    const top = line(span('┌' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┬') +
-        '┐', { color: 'cyan', dim: true }));
-    const bottom = line(span('└' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┴') +
-        '┘', { color: 'cyan', dim: true }));
     return [
-        top,
-        renderRow(table.headers, true),
-        separator,
-        ...table.rows.map((row) => renderRow(row, false)),
-        bottom,
+        border('┌', '┬', '┐'),
+        ...renderRow(table.headers, true),
+        border('├', '┼', '┤'),
+        ...table.rows.flatMap((row) => renderRow(row, false)),
+        border('└', '┴', '┘'),
     ];
 }
 function getEntryColor(kind) {
@@ -410,10 +412,7 @@ export function renderFormattedBodyLines(body, width, kind) {
         }
         if (formattedLine.kind === 'table' && formattedLine.table) {
             output.push(...renderTableLines(formattedLine.table, bodyWidth).map((tableLine) => {
-                const spans = tableLine.spans.map((part) => ({
-                    ...part,
-                    text: `  ${part.text}`,
-                }));
+                const spans = tableLine.spans.map((part, index) => index === 0 ? { ...part, text: `  ${part.text}` } : part);
                 return { spans };
             }));
             continue;

package/dist/src/ui/tui/shell-input.js

@@ -9,9 +9,21 @@ function isClipboardImagePasteKey(key) {
     }
     return key.ctrl && key.input === 'v' && !key.shift && !key.meta;
 }
+function composerIsEmpty(state) {
+    return (!state.input &&
+        state.cursor === 0 &&
+        state.pastedChunks.length === 0 &&
+        state.promptHistoryCursor === null);
+}
+function composerHasDiscardableDraft(state) {
+    if (!composerIsEmpty(state))
+        return true;
+    return !state.busy && state.imageAttachments.length > 0;
+}
 function shouldShowCommandPalette(state) {
     if (state.busy ||
         state.exiting ||
+        state.jobsPickerOpen ||
         state.modelPickerOpen ||
         state.resumePickerOpen) {
         return false;
@@ -57,6 +69,7 @@ function pasteTextFromClipboard(store, handlers) {
     const current = store.getState();
     if (current.exiting ||
         current.approvalPrompt ||
+        current.jobsPickerOpen ||
         current.modelPickerOpen ||
         current.resumePickerOpen ||
         current.sudoPrompt) {
@@ -130,11 +143,41 @@ export function handleShellKeyEvent(store, handlers, event) {
         return;
     const key = event;
     const state = store.getState();
+    const commandPaletteActive = shouldShowCommandPalette(state);
+    const commandSuggestions = commandPaletteActive
+        ? getSlashCommandSuggestions(state.input)
+        : [];
+    const prepareForComposerInputChange = (current, nextInput) => {
+        if (shouldRemountLiveFrameForComposerInputChange(current, nextInput)) {
+            handlers.onLiveFrameShapeChange();
+        }
+    };
     if (key.ctrl && key.input === 'c') {
         if (state.sudoPrompt) {
             handlers.onSudoPasswordInput({ kind: 'cancel' });
             return;
         }
+        if (state.queuedMessage) {
+            handlers.onLiveFrameShapeChange();
+            store.update((current) => ({ ...current, queuedMessage: null }));
+            return;
+        }
+        if (composerHasDiscardableDraft(state)) {
+            store.update((current) => {
+                prepareForComposerInputChange(current, '');
+                return {
+                    ...current,
+                    commandCursor: 0,
+                    cursor: 0,
+                    imageAttachments: current.busy ? current.imageAttachments : [],
+                    input: '',
+                    pastedChunks: [],
+                    promptHistoryCursor: null,
+                    promptHistoryDraft: '',
+                };
+            });
+            return;
+        }
         if (handlers.onCtrlC) {
             handlers.onCtrlC();
             return;
@@ -142,15 +185,6 @@ export function handleShellKeyEvent(store, handlers, event) {
         handlers.onRequestExit();
         return;
     }
-    const commandPaletteActive = shouldShowCommandPalette(state);
-    const commandSuggestions = commandPaletteActive
-        ? getSlashCommandSuggestions(state.input)
-        : [];
-    const prepareForComposerInputChange = (current, nextInput) => {
-        if (shouldRemountLiveFrameForComposerInputChange(current, nextInput)) {
-            handlers.onLiveFrameShapeChange();
-        }
-    };
     if (state.sudoPrompt) {
         if (key.escape) {
             handlers.onSudoPasswordInput({ kind: 'cancel' });
@@ -210,6 +244,37 @@ export function handleShellKeyEvent(store, handlers, event) {
         });
         return;
     }
+    if (state.jobsPickerOpen) {
+        if (key.escape) {
+            store.update((current) => ({
+                ...current,
+                jobsPickerExpandedId: null,
+                jobsPickerOpen: false,
+                status: 'Ready',
+            }));
+            return;
+        }
+        if (key.upArrow || key.downArrow) {
+            store.update((current) => {
+                const count = (current.backgroundJobs ?? []).length;
+                const next = current.jobsPickerIndex + (key.upArrow ? -1 : 1);
+                return {
+                    ...current,
+                    jobsPickerExpandedId: null,
+                    jobsPickerIndex: Math.max(0, Math.min(next, Math.max(count - 1, 0))),
+                };
+            });
+            return;
+        }
+        if (key.returnKey) {
+            void handlers.onJobsPickerOutput();
+            return;
+        }
+        if (key.input === 'k' && !key.ctrl && !key.meta && !key.shift) {
+            void handlers.onJobsPickerKill();
+        }
+        return;
+    }
     if (state.modelPickerOpen) {
         if (key.escape) {
             store.update((current) => ({ ...current, modelPickerOpen: false }));
@@ -275,8 +340,6 @@ export function handleShellKeyEvent(store, handlers, event) {
     }
     if (key.escape) {
         if (state.busy) {
-            // With a queued message, Esc clears the queue only (turn keeps running).
-            // With nothing queued, Esc cancels the turn (Ctrl+C also cancels).
             if (state.queuedMessage) {
                 handlers.onLiveFrameShapeChange();
                 store.update((current) => ({ ...current, queuedMessage: null }));
@@ -286,10 +349,7 @@ export function handleShellKeyEvent(store, handlers, event) {
             return;
         }
         store.update((current) => {
-            if (!current.input &&
-                current.cursor === 0 &&
-                current.pastedChunks.length === 0 &&
-                current.promptHistoryCursor === null) {
+            if (composerIsEmpty(current)) {
                 return current;
             }
             prepareForComposerInputChange(current, '');
@@ -317,8 +377,6 @@ export function handleShellKeyEvent(store, handlers, event) {
         return;
     }
     if (key.upArrow) {
-        // While busy with an empty composer, Up recalls and dequeues the queued
-        // message for editing; otherwise it walks prompt history as usual.
         if (state.busy && state.input.trim() === '' && state.queuedMessage) {
             handlers.onLiveFrameShapeChange();
             store.update((current) => {

package/dist/src/ui/tui/terminal-title.js

@@ -0,0 +1,84 @@
+import { isTuiMode } from '../../runtime-mode.js';
+const BRAILLE_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴'];
+const TITLE_BRAND = 'TheGitAI';
+const TITLE_MARK_PREFIX = '❯_';
+export const TERMINAL_TITLE_SPINNER_MS = 500;
+export function resolveTerminalTitleState(input) {
+    if (input.awaitingReview)
+        return 'review';
+    if (input.busy)
+        return 'wip';
+    return 'clean';
+}
+export function formatTerminalTitle(state, spinnerFrame = 0) {
+    if (state === 'review')
+        return `${TITLE_MARK_PREFIX}▸ ${TITLE_BRAND}`;
+    if (state === 'wip') {
+        const frame = BRAILLE_SPINNER_FRAMES[spinnerFrame % BRAILLE_SPINNER_FRAMES.length];
+        return `${TITLE_MARK_PREFIX}${frame} ${TITLE_BRAND}`;
+    }
+    return `${TITLE_MARK_PREFIX}● ${TITLE_BRAND}`;
+}
+export function writeTerminalTitle(title, stream = process.stdout) {
+    if (isTuiMode())
+        return;
+    if (!('isTTY' in stream) || !stream.isTTY)
+        return;
+    stream.write(`\x1b]0;${title}\x07`);
+}
+export function createTerminalTitleController(options) {
+    const write = options?.write ?? writeTerminalTitle;
+    let currentState = 'clean';
+    let spinnerFrame = 0;
+    let lastTitle = '';
+    let timer = null;
+    const paint = () => {
+        const title = formatTerminalTitle(currentState, spinnerFrame);
+        if (title === lastTitle)
+            return;
+        lastTitle = title;
+        write(title);
+    };
+    const stopTimer = () => {
+        if (!timer)
+            return;
+        clearInterval(timer);
+        timer = null;
+    };
+    const startTimer = () => {
+        if (timer)
+            return;
+        timer = setInterval(() => {
+            spinnerFrame = (spinnerFrame + 1) % BRAILLE_SPINNER_FRAMES.length;
+            paint();
+        }, TERMINAL_TITLE_SPINNER_MS);
+    };
+    return {
+        sync(input) {
+            const next = resolveTerminalTitleState(input);
+            if (next !== currentState) {
+                currentState = next;
+                if (next === 'wip') {
+                    spinnerFrame = 0;
+                    startTimer();
+                }
+                else {
+                    stopTimer();
+                }
+            }
+            else if (next === 'wip') {
+                startTimer();
+            }
+            else {
+                stopTimer();
+            }
+            paint();
+        },
+        dispose() {
+            stopTimer();
+            currentState = 'clean';
+            spinnerFrame = 0;
+            paint();
+        },
+    };
+}

package/dist/src/ui/tui/terminal-writes.js

@@ -0,0 +1,48 @@
+const MAX_CAPTURED_CHARS = 1_000_000;
+let restore = null;
+let captured = [];
+let capturedChars = 0;
+function chunkToString(chunk, encoding) {
+    if (typeof chunk === 'string')
+        return chunk;
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk).toString(typeof encoding === 'string' ? encoding : 'utf8');
+    }
+    return String(chunk ?? '');
+}
+export function captureTerminalWrites() {
+    if (restore)
+        return;
+    const streams = [process.stdout, process.stderr];
+    const originals = streams.map((stream) => stream.write.bind(stream));
+    for (const stream of streams) {
+        stream.write = (chunk, encoding, callback) => {
+            if (capturedChars < MAX_CAPTURED_CHARS) {
+                const text = chunkToString(chunk, encoding);
+                captured.push(text);
+                capturedChars += text.length;
+            }
+            const done = typeof encoding === 'function' ? encoding : callback;
+            if (typeof done === 'function')
+                done();
+            return true;
+        };
+    }
+    restore = () => {
+        streams.forEach((stream, index) => {
+            stream.write = originals[index];
+        });
+    };
+}
+export function releaseTerminalWrites() {
+    if (!restore)
+        return;
+    restore();
+    restore = null;
+    if (captured.length > 0) {
+        const text = captured.join('');
+        captured = [];
+        capturedChars = 0;
+        process.stderr.write(text);
+    }
+}

package/dist/src/ui/tui/text.js

@@ -1,5 +1,14 @@
+const CSI_PATTERN = /\u001B\[[0-9;?]*[ -\/]*[@-~]/g;
+const OSC_PATTERN = /\u001B\][^\u0007\u001B]*(?:\u0007|\u001B\\)?/g;
+const CONTROL_CHAR_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/g;
+export function stripControlCharacters(text) {
+    return String(text ?? '')
+        .replace(OSC_PATTERN, '')
+        .replace(CSI_PATTERN, '')
+        .replace(CONTROL_CHAR_PATTERN, '');
+}
 export function span(text, style = {}) {
-    return { text, ...style };
+    return { text: stripControlCharacters(text), ...style };
 }
 export function line(...spans) {
     return { spans };
@@ -14,10 +23,11 @@ export function wrapText(text, width) {
     const lines = [];
     for (const rawLine of text.split('\n')) {
         let remaining = rawLine;
-        while (remaining.length > safeWidth) {
-            let breakAt = remaining.lastIndexOf(' ', safeWidth);
+        while (displayWidth(remaining) > safeWidth) {
+            const head = sliceToWidth(remaining, safeWidth);
+            let breakAt = head.lastIndexOf(' ');
             if (breakAt <= 0)
-                breakAt = safeWidth;
+                breakAt = head.length;
             lines.push(remaining.slice(0, breakAt).trimEnd());
             remaining = remaining.slice(breakAt).trimStart();
         }
@@ -28,3 +38,147 @@ export function wrapText(text, width) {
 export function joinLines(blocks) {
     return blocks.flat();
 }
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint === 0x200d ||
+        (codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x231a ||
+        codePoint === 0x231b ||
+        (codePoint >= 0x23e9 && codePoint <= 0x23ec) ||
+        codePoint === 0x23f0 ||
+        codePoint === 0x23f3 ||
+        (codePoint >= 0x25fd && codePoint <= 0x25fe) ||
+        (codePoint >= 0x2614 && codePoint <= 0x2615) ||
+        (codePoint >= 0x2648 && codePoint <= 0x2653) ||
+        codePoint === 0x267f ||
+        codePoint === 0x2693 ||
+        codePoint === 0x26a1 ||
+        (codePoint >= 0x26aa && codePoint <= 0x26ab) ||
+        (codePoint >= 0x26bd && codePoint <= 0x26be) ||
+        (codePoint >= 0x26c4 && codePoint <= 0x26c5) ||
+        codePoint === 0x26ce ||
+        codePoint === 0x26d4 ||
+        codePoint === 0x26ea ||
+        (codePoint >= 0x26f2 && codePoint <= 0x26f3) ||
+        codePoint === 0x26f5 ||
+        codePoint === 0x26fa ||
+        codePoint === 0x26fd ||
+        codePoint === 0x2705 ||
+        (codePoint >= 0x270a && codePoint <= 0x270b) ||
+        codePoint === 0x2728 ||
+        codePoint === 0x274c ||
+        codePoint === 0x274e ||
+        (codePoint >= 0x2753 && codePoint <= 0x2755) ||
+        codePoint === 0x2757 ||
+        (codePoint >= 0x2795 && codePoint <= 0x2797) ||
+        codePoint === 0x27b0 ||
+        codePoint === 0x27bf ||
+        (codePoint >= 0x2b1b && codePoint <= 0x2b1c) ||
+        codePoint === 0x2b50 ||
+        codePoint === 0x2b55 ||
+        (codePoint >= 0x2e80 && codePoint <= 0x303e) ||
+        (codePoint >= 0x3041 && codePoint <= 0x33ff) ||
+        (codePoint >= 0x3400 && codePoint <= 0x4dbf) ||
+        (codePoint >= 0x4e00 && codePoint <= 0x9fff) ||
+        (codePoint >= 0xa000 && codePoint <= 0xa4cf) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+        (codePoint >= 0x1f680 && codePoint <= 0x1f6ff) ||
+        (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+        (codePoint >= 0x1fa70 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}
+export function displayWidth(text) {
+    const chars = [...String(text ?? '')];
+    let width = 0;
+    for (let index = 0; index < chars.length; index++) {
+        const codePoint = chars[index].codePointAt(0);
+        if (isZeroWidthCodePoint(codePoint))
+            continue;
+        const next = chars[index + 1]?.codePointAt(0);
+        if (next === 0xfe0f) {
+            width += 2;
+            index++;
+            continue;
+        }
+        if (next === 0xfe0e) {
+            width += 1;
+            index++;
+            continue;
+        }
+        width += isWideCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+export function sliceToWidth(text, width) {
+    const limit = Math.max(1, Math.floor(width));
+    const chars = [...String(text ?? '')];
+    let out = '';
+    let used = 0;
+    for (let index = 0; index < chars.length; index++) {
+        const char = chars[index];
+        const next = chars[index + 1];
+        const selector = next === '️' || next === '︎';
+        const cluster = selector ? `${char}${next}` : char;
+        const clusterWidth = displayWidth(cluster);
+        if (used + clusterWidth > limit)
+            break;
+        out += cluster;
+        used += clusterWidth;
+        if (selector)
+            index++;
+    }
+    if (!out)
+        return chars[0] ?? '';
+    return out;
+}
+export function padToWidth(text, width) {
+    const current = displayWidth(text);
+    if (current >= width)
+        return text;
+    return text + ' '.repeat(width - current);
+}
+export function wrapToWidth(text, width) {
+    const limit = Math.max(1, Math.floor(width));
+    const out = [];
+    for (const rawLine of String(text ?? '').split('\n')) {
+        let current = '';
+        const flush = () => {
+            out.push(current);
+            current = '';
+        };
+        for (const token of rawLine.split(/\s+/).filter(Boolean)) {
+            let rest = token;
+            while (displayWidth(rest) > limit) {
+                if (current)
+                    flush();
+                const head = sliceToWidth(rest, limit);
+                out.push(head);
+                rest = rest.slice(head.length);
+            }
+            if (!rest)
+                continue;
+            const candidate = current ? `${current} ${rest}` : rest;
+            if (displayWidth(candidate) > limit) {
+                flush();
+                current = rest;
+            }
+            else {
+                current = candidate;
+            }
+        }
+        flush();
+    }
+    return out.length > 0 ? out : [''];
+}