termux-dev 1.6.0 → 1.8.0

package/dist/cli/updater.js

@@ -37,20 +37,20 @@ export async function getCurrentVersion() {
 }
 export async function checkForUpdates(timeoutMs = 10000) {
     const currentVersion = await getCurrentVersion();
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    // One deadline for the whole check. The signal is passed to EVERY request: on a flaky
+    // mobile connection a stalled second request used to block devx at startup forever.
+    const signal = AbortSignal.timeout(timeoutMs);
     try {
         // 1. Try fetching latest package.json with cache-busting timestamp
         const cacheBusterUrl = `${REMOTE_PKG_URL}?t=${Date.now()}`;
         const res = await fetch(cacheBusterUrl, {
-            signal: controller.signal,
+            signal,
             headers: {
                 'User-Agent': 'devx-updater',
                 'Cache-Control': 'no-cache, no-store, must-revalidate',
                 'Pragma': 'no-cache'
             }
         });
-        clearTimeout(timer);
         let latestVersion = '';
         let releaseNotes = '';
         if (res.ok) {
@@ -60,6 +60,7 @@ export async function checkForUpdates(timeoutMs = 10000) {
         // 2. Also check latest GitHub release tag
         try {
             const relRes = await fetch(`${REMOTE_RELEASE_URL}?t=${Date.now()}`, {
+                signal,
                 headers: { 'User-Agent': 'devx-updater' }
             });
             if (relRes.ok) {
@@ -87,12 +88,12 @@ export async function checkForUpdates(timeoutMs = 10000) {
         };
     }
     catch (err) {
-        clearTimeout(timer);
+        const timedOut = err.name === 'AbortError' || err.name === 'TimeoutError';
         return {
             updateAvailable: false,
             currentVersion,
             latestVersion: currentVersion,
-            error: err.name === 'AbortError' ? 'Timeout (10s)' : err.message
+            error: timedOut ? `Timeout (${Math.round(timeoutMs / 1000)}s)` : err.message
         };
     }
 }
@@ -109,10 +110,10 @@ export async function performSelfUpdate(latestVersion) {
     const __filename = fileURLToPath(import.meta.url);
     const projectRoot = path.resolve(path.dirname(__filename), '../../');
     const isGit = await isGitRepository(projectRoot);
-    console.log('\n' + pc.bold(pc.cyan('─── 🚀 Starting devx Update ──────────────────────────')));
+    console.log('\n' + pc.bold(pc.cyan('─── Starting devx Update ──────────────────────────')));
     if (!isGit) {
         // 1. Installed via global npm package: termux-dev
-        process.stdout.write(`  ${pc.cyan('⚡')} [1/1] ${pc.white(`Updating termux-dev via npm (v${latestVersion})...`)}\n`);
+        process.stdout.write(`  ${pc.cyan('›')} [1/1] ${pc.white(`Updating termux-dev via npm (v${latestVersion})...`)}\n`);
         const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
         let fIdx = 0;
         const interval = setInterval(() => {
@@ -121,12 +122,12 @@ export async function performSelfUpdate(latestVersion) {
         try {
             execSync('npm install -g termux-dev@latest --prefer-online', { stdio: 'pipe' });
             clearInterval(interval);
-            process.stdout.write(`\r  ${pc.green('✔')} ${pc.bold(pc.white(`Successfully updated termux-dev to v${latestVersion} via npm!`))}\n`);
+            process.stdout.write(`\r  ${pc.green('✓')} ${pc.bold(pc.white(`Successfully updated termux-dev to v${latestVersion} via npm!`))}\n`);
         }
         catch (err) {
             clearInterval(interval);
             process.stdout.write(`\r  ${pc.red('✖')} ${pc.red(`Update failed: ${err.message}`)}\n`);
-            console.log(pc.yellow(`\n💡 To update manually, run: ${pc.bold('npm install -g termux-dev@latest')}`));
+            console.log(pc.yellow(`\nTo update manually, run: ${pc.bold('npm install -g termux-dev@latest')}`));
             return false;
         }
     }
@@ -134,20 +135,20 @@ export async function performSelfUpdate(latestVersion) {
         // 2. Installed via git clone (Developer mode)
         const steps = [
             {
-                title: '📦 Pulling latest updates from GitHub repository...',
+                title: 'Pulling latest updates from GitHub repository...',
                 action: () => {
                     execSync('git pull origin main', { cwd: projectRoot, stdio: 'pipe' });
                 }
             },
             {
-                title: '🔨 Building and compiling TypeScript sources...',
+                title: 'Building and compiling TypeScript sources...',
                 action: () => {
                     execSync('npm install', { cwd: projectRoot, stdio: 'pipe' });
                     execSync('npm run build', { cwd: projectRoot, stdio: 'pipe' });
                 }
             },
             {
-                title: '🔑 Ensuring binary execution permissions & linking...',
+                title: 'Ensuring binary execution permissions & linking...',
                 action: () => {
                     try {
                         execSync('npm link', { cwd: projectRoot, stdio: 'pipe' });
@@ -158,7 +159,7 @@ export async function performSelfUpdate(latestVersion) {
         ];
         for (let i = 0; i < steps.length; i++) {
             const step = steps[i];
-            process.stdout.write(`  ${pc.cyan('⚡')} [${i + 1}/${steps.length}] ${pc.white(step.title)}\n`);
+            process.stdout.write(`  ${pc.cyan('›')} [${i + 1}/${steps.length}] ${pc.white(step.title)}\n`);
             const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
             let fIdx = 0;
             const interval = setInterval(() => {
@@ -168,18 +169,18 @@ export async function performSelfUpdate(latestVersion) {
                 await new Promise(resolve => setTimeout(resolve, 200));
                 step.action();
                 clearInterval(interval);
-                process.stdout.write(`\r  ${pc.green('✔')} ${pc.bold(pc.white(step.title))}\n`);
+                process.stdout.write(`\r  ${pc.green('✓')} ${pc.bold(pc.white(step.title))}\n`);
             }
             catch (err) {
                 clearInterval(interval);
                 process.stdout.write(`\r  ${pc.red('✖')} ${pc.red(step.title)} - ${err.message}\n`);
                 console.log(pc.red(`\nUpdate failed during step ${i + 1}: ${err.message}`));
-                console.log(pc.yellow(`\n💡 To update manually, run: ${pc.bold('npm install -g termux-dev')}`));
+                console.log(pc.yellow(`\nTo update manually, run: ${pc.bold('npm install -g termux-dev')}`));
                 return false;
             }
         }
     }
-    console.log(pc.bold(pc.green(`\n✅ Successfully updated to v${latestVersion}! Restarting devx...\n`)));
+    console.log(pc.bold(pc.green(`\nSuccessfully updated to v${latestVersion}! Restarting devx...\n`)));
     console.log(pc.bold(pc.cyan('──────────────────────────────────────────────────────\n')));
     await new Promise(r => setTimeout(r, 1000));
     try {
@@ -218,21 +219,22 @@ export async function runStartupUpdateCheck(config) {
     if (result.updateAvailable) {
         console.log();
         console.log(pc.bold(pc.cyan('  ┌───────────────────────────────────────────────────────────┐')));
-        console.log(pc.bold(pc.cyan('  │')) + pc.bold(pc.yellow(`  🚀 A new update is available: `)) + pc.dim(`v${result.currentVersion}`) + pc.bold(pc.green(` ➔ v${result.latestVersion}`)) + ' '.repeat(Math.max(1, 23 - result.currentVersion.length - result.latestVersion.length)) + pc.bold(pc.cyan('│')));
+        console.log(pc.bold(pc.cyan('  │')) + pc.bold(pc.yellow(`  A new update is available: `)) + pc.dim(`v${result.currentVersion}`) + pc.bold(pc.green(` → v${result.latestVersion}`)) + ' '.repeat(Math.max(1, 23 - result.currentVersion.length - result.latestVersion.length)) + pc.bold(pc.cyan('│')));
         console.log(pc.bold(pc.cyan('  │')) + pc.dim(`  Repository: https://github.com/apvcode/Termux-Dev          `) + pc.bold(pc.cyan('│')));
         console.log(pc.bold(pc.cyan('  └───────────────────────────────────────────────────────────┘')));
         console.log();
         try {
             const choice = await select({
                 message: pc.bold('Do you want to update devx now?'),
+                loop: false,
                 choices: [
                     {
-                        name: `⚡ Update now (Pull v${result.latestVersion}, rebuild & restart)`,
+                        name: `Update now (Pull v${result.latestVersion}, rebuild & restart)`,
                         value: 'update',
                         description: 'Download latest code, compile TypeScript, and restart devx'
                     },
                     {
-                        name: '⏭  Skip for now (Continue to chat)',
+                        name: 'Skip for now (Continue to chat)',
                         value: 'skip',
                         description: 'Keep current version and start session'
                     }
@@ -248,7 +250,7 @@ export async function runStartupUpdateCheck(config) {
     }
     else {
         // Briefly show up to date message
-        process.stdout.write(`  ${pc.green('✔')} ${pc.dim(`devx is up to date (v${result.currentVersion})`)}\n`);
+        process.stdout.write(`  ${pc.green('✓')} ${pc.dim(`devx is up to date (v${result.currentVersion})`)}\n`);
         await new Promise(r => setTimeout(r, 450));
         // Clean up line
         process.stdout.write('\x1b[1A\x1b[2K');

package/dist/cli/usage-panel.js

@@ -0,0 +1,242 @@
+import { LiveBlock } from './liveblock.js';
+import { splitKeys } from './keys.js';
+import { palette, formatTokens } from './ui.js';
+import { displayWidth, padEndWidth, truncateWidth } from './width.js';
+import { formatMoney } from '../core/cost.js';
+const fmtTokens = (n) => (n < 1000 ? `${Math.round(n)}` : formatTokens(n));
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+const pct = (part, whole) => (whole > 0 ? (part / whole) * 100 : 0);
+function formatPct(value) {
+    if (value === 0)
+        return '0%';
+    if (value < 1)
+        return '<1%';
+    return `${Math.round(value)}%`;
+}
+function segmentsOf(c) {
+    return [
+        { key: 'system', label: 'System prompt', tokens: c.system, color: palette.accent },
+        { key: 'tools', label: `Tool schemas (${c.toolCount})`, tokens: c.tools, color: palette.plan },
+        { key: 'user', label: 'Your messages', tokens: c.user, color: palette.ok },
+        { key: 'assistant', label: 'Model replies', tokens: c.assistant, color: palette.text },
+        { key: 'tool', label: 'Tool results', tokens: c.toolResults, color: palette.warn },
+        { key: 'images', label: c.imageCount > 0 ? `Images (${c.imageCount})` : 'Images', tokens: c.images, color: palette.yolo },
+    ];
+}
+/**
+ * A bar of `width` cells, one coloured run per kind of content. Every non-empty kind gets at
+ * least one cell, so a small share does not disappear.
+ */
+export function renderBar(segments, limit, width) {
+    const cells = segments.map((s) => (s.tokens > 0 ? Math.max(1, Math.round((s.tokens / Math.max(1, limit)) * width)) : 0));
+    let used = cells.reduce((a, b) => a + b, 0);
+    // Rounding up the small ones can overshoot: take the cells back from the biggest.
+    while (used > width) {
+        const biggest = cells.indexOf(Math.max(...cells));
+        if (cells[biggest] <= 1)
+            break;
+        cells[biggest]--;
+        used--;
+    }
+    let bar = '';
+    segments.forEach((s, i) => {
+        if (cells[i] > 0)
+            bar += s.color('█'.repeat(cells[i]));
+    });
+    return bar + palette.faint('░'.repeat(Math.max(0, width - used)));
+}
+/** How the cost number is to be read, in a few words. */
+function costNote(session) {
+    const st = session.costState;
+    if ((st.unpriced ?? 0) > 0 && (st.priced ?? 0) === 0 && session.totalCost === 0)
+        return 'no price known for this model';
+    const parts = [];
+    if (st.estimated)
+        parts.push('catalogue prices, an estimate');
+    if ((st.unpriced ?? 0) > 0)
+        parts.push(`${st.unpriced} request${st.unpriced === 1 ? '' : 's'} not priced`);
+    return parts.join(', ');
+}
+/** The content as rows of text, without the frame. `iw` is the number of cells available. */
+function buildRows(d, iw, detail) {
+    const rows = [];
+    const line = (text) => rows.push({ kind: 'line', text });
+    const title = (text) => rows.push({ kind: 'title', text });
+    const blank = () => rows.push({ kind: 'blank', text: '' });
+    const pair = (label, value, labelWidth = 16) => {
+        const room = Math.max(4, Math.min(labelWidth, iw - 3 - displayWidth(value)));
+        const left = '  ' + palette.muted(padEndWidth(truncateWidth(label, room), room));
+        const gap = Math.max(1, iw - displayWidth(left) - displayWidth(value));
+        line(left + ' '.repeat(gap) + value);
+    };
+    const c = d.context;
+    const s = d.session;
+    const usedPct = pct(c.total, c.limit);
+    const usedColor = usedPct >= 85 ? palette.err : usedPct >= 70 ? palette.warn : palette.text;
+    // ── context
+    title('CONTEXT');
+    const summary = `${formatPct(usedPct)}  ${fmtTokens(c.total)} / ${fmtTokens(c.limit)}`;
+    const barWidth = Math.max(4, iw - 4 - displayWidth(summary) - 2);
+    line('  ' + renderBar(segmentsOf(c), c.limit, barWidth) + '  ' + usedColor(summary));
+    if (detail === 'full') {
+        const labelWidth = Math.max(6, Math.min(22, iw - 19));
+        for (const seg of segmentsOf(c)) {
+            if (seg.tokens === 0 && seg.key === 'images')
+                continue;
+            const left = '  ' + seg.color('■') + ' ' + (seg.tokens > 0 ? palette.text(padEndWidth(truncateWidth(seg.label, labelWidth), labelWidth)) : palette.faint(padEndWidth(truncateWidth(seg.label, labelWidth), labelWidth)));
+            const right = palette.text(fmtTokens(seg.tokens).padStart(6)) + palette.faint(('  ' + formatPct(pct(seg.tokens, c.limit))).padStart(6));
+            line(left + ' '.repeat(Math.max(1, iw - displayWidth(left) - displayWidth(right))) + right);
+        }
+        const freeLeft = '  ' + palette.faint('□') + ' ' + palette.faint(padEndWidth('Free', labelWidth));
+        const freeRight = palette.faint(fmtTokens(c.free).padStart(6) + ('  ' + formatPct(pct(c.free, c.limit))).padStart(6));
+        line(freeLeft + ' '.repeat(Math.max(1, iw - displayWidth(freeLeft) - displayWidth(freeRight))) + freeRight);
+    }
+    if (detail === 'full' && d.limitSource) {
+        const text = {
+            catalogue: 'Window size: from the models.dev catalogue.',
+            table: "Window size: from devx's table of models.",
+            rule: 'Window size: guessed from the model name.',
+            default: 'Window size: assumed, the model is unknown. Set contextLimits in the config.',
+            config: 'Window size: from contextLimits in your config.',
+            saved: 'Window size: saved when you chose the model.',
+        };
+        const warn = d.limitSource === 'default' || d.limitSource === 'rule';
+        line('  ' + (warn ? palette.warn : palette.faint)(truncateWidth(text[d.limitSource], iw - 2)));
+    }
+    if (detail !== 'min') {
+        line('  ' + palette.faint(truncateWidth(`Old messages are dropped above ${fmtTokens(c.compactAt)} (85%).`, iw - 2)));
+        if (d.compactions > 0) {
+            line('  ' + palette.faint(truncateWidth(`Happened ${d.compactions}x, ${d.dropped} message${d.dropped === 1 ? '' : 's'} dropped so far.`, iw - 2)));
+        }
+    }
+    if (detail === 'full' && s.lastPromptTokens > 0) {
+        line('  ' + palette.faint(truncateWidth(`Last request: the provider counted ${fmtTokens(s.lastPromptTokens)} input.`, iw - 2)));
+    }
+    if (d.noVision && c.imageCount > 0 && detail !== 'min')
+        line('  ' + palette.warn(truncateWidth('This model cannot read images: they are not sent.', iw - 2)));
+    // ── session
+    if (detail !== 'min')
+        blank();
+    title('SESSION');
+    pair('Cost', palette.bold(formatMoney(s.totalCost, s.costState)));
+    const note = costNote(s);
+    if (note && detail === 'full')
+        line('  ' + palette.faint(truncateWidth(note, iw - 2)));
+    const tokens = iw >= 40 ? `${fmtTokens(s.promptTokens)} in · ${fmtTokens(s.completionTokens)} out` : `${fmtTokens(s.promptTokens)}/${fmtTokens(s.completionTokens)}`;
+    pair('Tokens', palette.text(tokens));
+    if (s.cacheReadTokens > 0 && detail !== 'min')
+        pair('Cached input', palette.text(fmtTokens(s.cacheReadTokens)));
+    pair('Requests', palette.text(String(s.requestsCount)));
+    // ── traffic
+    if (detail === 'full') {
+        blank();
+        title('TRAFFIC');
+        pair('Sent / received', palette.text(iw >= 40 ? `${formatBytes(s.bytesSent)} / ${formatBytes(s.bytesReceived)}` : `${formatBytes(s.bytesSent)}/${formatBytes(s.bytesReceived)}`));
+        if (s.dataSaverLimitMB) {
+            const used = s.totalBytes / (1024 * 1024);
+            const share = Math.min(100, Math.round((used / s.dataSaverLimitMB) * 100));
+            const text = `${used.toFixed(1)} / ${s.dataSaverLimitMB} MB (${share}%)`;
+            pair('Data saver', share >= 90 ? palette.err(text) : palette.text(text));
+        }
+    }
+    return rows;
+}
+function keyHints(width) {
+    const variants = ['esc close', 'esc'];
+    for (const text of variants) {
+        const [key, ...rest] = text.split(' ');
+        const out = palette.text(key) + (rest.length ? ' ' + palette.faint(rest.join(' ')) : '');
+        if (displayWidth(out) <= width)
+            return out;
+    }
+    return '';
+}
+function renderCard(d, cols, rows) {
+    const W = Math.min(cols - 1, 76);
+    const iw = W - 4;
+    const rule = palette.rule;
+    const lines = [];
+    const box = (content) => rule('│') + ' ' + padEndWidth(content, iw) + ' ' + rule('│');
+    const heading = ' ' + palette.bold(palette.accent('usage')) + ' ';
+    const fmt = d.format === 'anthropic' ? 'anthropic' : 'openai';
+    const modelText = truncateWidth(`${d.model}${d.effort ? ` · ${d.effort}` : ''} · ${fmt}`, Math.max(8, W - 4 - displayWidth(heading) - 4));
+    const tag = ' ' + palette.faint(modelText) + ' ';
+    const fill = Math.max(0, W - 4 - displayWidth(heading) - displayWidth(tag));
+    lines.push(rule('╭─') + heading + rule('─'.repeat(fill)) + tag + rule('─╮'));
+    const body = buildRows(d, iw, 'full');
+    lines.push(box(''));
+    for (const row of body) {
+        if (row.kind === 'title')
+            lines.push(box('  ' + palette.faint(row.text)));
+        else if (row.kind === 'blank')
+            lines.push(box(''));
+        else
+            lines.push(box(row.text));
+    }
+    lines.push(box(''));
+    lines.push(rule('╰' + '─'.repeat(W - 2) + '╯'));
+    lines.push(' ' + keyHints(cols - 2));
+    return lines.length <= rows - 1 ? lines : null;
+}
+function renderPlain(d, cols, rows) {
+    const width = Math.max(20, cols - 1);
+    const head = ' ' + palette.bold(palette.accent('usage')) + palette.faint(' · ' + truncateWidth(d.model, Math.max(6, width - 10)));
+    for (const detail of ['full', 'brief', 'min']) {
+        const body = buildRows(d, width - 1, detail);
+        const lines = [head, ...body.map((r) => (r.kind === 'title' ? ' ' + palette.faint(r.text) : r.kind === 'blank' ? '' : ' ' + r.text)), ' ' + keyHints(width - 1)];
+        if (lines.length <= rows - 1 || detail === 'min') {
+            // On a very short screen drop the blank rows too.
+            return lines.length <= rows - 1 ? lines : lines.filter((l) => l !== '');
+        }
+    }
+    return [head];
+}
+/** The whole panel as terminal rows: a framed card on a wide screen, a plain list on a narrow or short one. */
+export function renderUsagePanel(d, cols, rows) {
+    if (cols >= 60) {
+        const card = renderCard(d, cols, rows);
+        if (card)
+            return card;
+    }
+    return renderPlain(d, cols, rows);
+}
+/** Shows the panel until Esc (or q, Enter, Ctrl+C) is pressed. The panel is erased on close. */
+export function runUsagePanel(data, options = {}) {
+    return new Promise((resolve) => {
+        const { input, output } = options.io ?? { input: process.stdin, output: process.stdout };
+        const block = new LiveBlock(output);
+        const draw = () => block.draw(renderUsagePanel(data, output.columns || 80, output.rows || 30));
+        const wasRaw = !!input.isRaw;
+        input.setRawMode?.(true);
+        input.resume();
+        let closed = false;
+        const close = () => {
+            if (closed)
+                return;
+            closed = true;
+            input.off('data', onData);
+            output.off?.('resize', draw);
+            block.erase();
+            if (!wasRaw)
+                input.setRawMode?.(false);
+            resolve();
+        };
+        const onData = (chunk) => {
+            for (const key of splitKeys(chunk.toString())) {
+                if (closed)
+                    return;
+                if (key === '\x1b' || key === 'q' || key === '\r' || key === '\n' || key === ' ' || key === '\x03')
+                    return close();
+            }
+        };
+        input.on('data', onData);
+        output.on?.('resize', draw);
+        draw();
+    });
+}

package/dist/cli/width.js

@@ -0,0 +1,178 @@
+/**
+ * Terminal display width helpers.
+ *
+ * `string.length` counts UTF-16 units, but a terminal counts cells: CJK characters and
+ * emoji take two cells, combining marks take none. Anything drawn inside a box
+ * (borders, padding, right-aligned labels) must be measured in cells, otherwise a single
+ * emoji in the input shifts the right border and wraps the whole line.
+ */
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI, '');
+}
+/** Width in terminal cells of a single code point. */
+export function codePointWidth(cp) {
+    if (cp === 0)
+        return 0;
+    if (cp < 32 || (cp >= 0x7f && cp < 0xa0))
+        return 0; // control characters
+    if ((cp >= 0x0300 && cp <= 0x036f) || // combining diacritics
+        (cp >= 0x200b && cp <= 0x200f) || // zero width space / joiners / marks
+        (cp >= 0x2060 && cp <= 0x2064) ||
+        (cp >= 0xfe00 && cp <= 0xfe0f) || // variation selectors
+        cp === 0xfeff ||
+        (cp >= 0xe0100 && cp <= 0xe01ef)) {
+        return 0;
+    }
+    if ((cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+        (cp >= 0x2e80 && cp <= 0x303e) || // CJK radicals, punctuation
+        (cp >= 0x3041 && cp <= 0x33ff) || // Hiragana, Katakana, CJK symbols
+        (cp >= 0x3400 && cp <= 0x4dbf) || // CJK extension A
+        (cp >= 0x4e00 && cp <= 0xa4cf) || // CJK unified, Yi
+        (cp >= 0xa960 && cp <= 0xa97f) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul syllables
+        (cp >= 0xf900 && cp <= 0xfaff) || // CJK compatibility
+        (cp >= 0xfe30 && cp <= 0xfe6f) ||
+        (cp >= 0xff00 && cp <= 0xff60) || // fullwidth forms
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1f64f) || // emoji: symbols, emoticons
+        (cp >= 0x1f680 && cp <= 0x1f6ff) || // transport
+        (cp >= 0x1f900 && cp <= 0x1f9ff) || // supplemental symbols
+        (cp >= 0x1fa70 && cp <= 0x1faff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd) // CJK extension B+
+    ) {
+        return 2;
+    }
+    return 1;
+}
+/** Display width of a string in terminal cells (ANSI escape sequences are ignored). */
+export function displayWidth(text) {
+    let width = 0;
+    for (const ch of stripAnsi(text)) {
+        width += codePointWidth(ch.codePointAt(0));
+    }
+    return width;
+}
+/**
+ * Cuts plain text (no ANSI) to at most `max` cells, never splitting a character.
+ * When it has to cut, the result ends with an ellipsis and still fits in `max` cells.
+ */
+export function truncateWidth(text, max) {
+    if (max <= 0)
+        return '';
+    if (displayWidth(text) <= max)
+        return text;
+    const budget = max - 1; // room for the ellipsis
+    let out = '';
+    let width = 0;
+    for (const ch of text) {
+        const w = codePointWidth(ch.codePointAt(0));
+        if (width + w > budget)
+            break;
+        out += ch;
+        width += w;
+    }
+    return out + '…';
+}
+/** Pads a (possibly colored) string with spaces on the right up to `width` cells. */
+export function padEndWidth(text, width) {
+    const missing = width - displayWidth(text);
+    return missing > 0 ? text + ' '.repeat(missing) : text;
+}
+/** Pads a (possibly colored) string with spaces on the left up to `width` cells. */
+export function padStartWidth(text, width) {
+    const missing = width - displayWidth(text);
+    return missing > 0 ? ' '.repeat(missing) + text : text;
+}
+/**
+ * Returns the slice of plain `text` that starts at character index `start` and fits
+ * into `maxCells`, together with how many characters were taken.
+ */
+export function sliceByWidth(text, start, maxCells) {
+    let out = '';
+    let cells = 0;
+    let length = 0;
+    let index = 0;
+    for (const ch of text) {
+        const units = ch.length;
+        if (index >= start) {
+            const w = codePointWidth(ch.codePointAt(0));
+            if (cells + w > maxCells)
+                break;
+            out += ch;
+            cells += w;
+            length += units;
+        }
+        index += units;
+    }
+    return { text: out, length, cells };
+}
+/** Hard-wraps plain text to lines of at most `width` cells (explicit newlines are kept). */
+export function wrapWidth(text, width) {
+    const lines = [];
+    for (const rawLine of text.split(/\r\n|\r|\n/)) {
+        if (rawLine === '') {
+            lines.push('');
+            continue;
+        }
+        let current = '';
+        let cells = 0;
+        for (const ch of rawLine) {
+            const w = codePointWidth(ch.codePointAt(0));
+            if (cells + w > width && current !== '') {
+                lines.push(current);
+                current = '';
+                cells = 0;
+            }
+            current += ch;
+            cells += w;
+        }
+        lines.push(current);
+    }
+    return lines;
+}
+/** Wraps text at word boundaries (a word longer than the line is cut). */
+export function wrapWords(text, width) {
+    const lines = [];
+    let current = '';
+    for (const word of text.split(/\s+/).filter(Boolean)) {
+        if (displayWidth(word) > width) {
+            if (current)
+                lines.push(current);
+            lines.push(truncateWidth(word, width));
+            current = '';
+        }
+        else if (current === '') {
+            current = word;
+        }
+        else if (displayWidth(current) + 1 + displayWidth(word) <= width) {
+            current += ' ' + word;
+        }
+        else {
+            lines.push(current);
+            current = word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines;
+}
+/** The last `maxCells` cells of a text (what a running line shows: the newest words). */
+export function tailWidth(text, maxCells) {
+    const chars = Array.from(text);
+    let cells = 0;
+    let start = chars.length;
+    while (start > 0) {
+        const w = codePointWidth(chars[start - 1].codePointAt(0));
+        if (cells + w > maxCells)
+            break;
+        cells += w;
+        start--;
+    }
+    return chars.slice(start).join('');
+}
+/** Wraps at word boundaries; text without spaces (Chinese, Japanese) is wrapped anywhere. */
+export function wrapText(text, width) {
+    const unbreakable = text.split(/\s+/).some((word) => displayWidth(word) > width);
+    return unbreakable ? wrapWidth(text, width) : wrapWords(text, width);
+}