@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/components/ManagedSettingsSecurityDialog/utils.js

@@ -1,105 +0,0 @@
-import { DANGEROUS_SHELL_SETTINGS, SAFE_ENV_VARS, } from '../../utils/managedEnvConstants.js';
-import { jsonStringify } from '../../utils/slowOperations.js';
-/**
- * Extract dangerous settings from a settings object.
- *
- * Dangerous env vars are determined by checking against SAFE_ENV_VARS -
- * any env var NOT in SAFE_ENV_VARS is considered dangerous.
- * See managedEnv.ts for the authoritative list and threat categories.
- */
-export function extractDangerousSettings(settings) {
-    if (!settings) {
-        return {
-            shellSettings: {},
-            envVars: {},
-            hasHooks: false,
-        };
-    }
-    // Extract dangerous shell settings
-    const shellSettings = {};
-    for (const key of DANGEROUS_SHELL_SETTINGS) {
-        const value = settings[key];
-        if (typeof value === 'string' && value.length > 0) {
-            shellSettings[key] = value;
-        }
-    }
-    // Extract dangerous env vars - any var NOT in SAFE_ENV_VARS is dangerous
-    const envVars = {};
-    if (settings.env && typeof settings.env === 'object') {
-        for (const [key, value] of Object.entries(settings.env)) {
-            if (typeof value === 'string' && value.length > 0) {
-                // Check if this env var is NOT in the safe list
-                if (!SAFE_ENV_VARS.has(key.toUpperCase())) {
-                    envVars[key] = value;
-                }
-            }
-        }
-    }
-    // Check for hooks
-    const hasHooks = settings.hooks !== undefined &&
-        settings.hooks !== null &&
-        typeof settings.hooks === 'object' &&
-        Object.keys(settings.hooks).length > 0;
-    return {
-        shellSettings,
-        envVars,
-        hasHooks,
-        hooks: hasHooks ? settings.hooks : undefined,
-    };
-}
-/**
- * Check if settings contain any dangerous settings
- */
-export function hasDangerousSettings(dangerous) {
-    return (Object.keys(dangerous.shellSettings).length > 0 ||
-        Object.keys(dangerous.envVars).length > 0 ||
-        dangerous.hasHooks);
-}
-/**
- * Compare two sets of dangerous settings to see if the new settings
- * have changed or added dangerous settings compared to the old settings
- */
-export function hasDangerousSettingsChanged(oldSettings, newSettings) {
-    const oldDangerous = extractDangerousSettings(oldSettings);
-    const newDangerous = extractDangerousSettings(newSettings);
-    // If new settings don't have any dangerous settings, no prompt needed
-    if (!hasDangerousSettings(newDangerous)) {
-        return false;
-    }
-    // If old settings didn't have dangerous settings but new does, prompt needed
-    if (!hasDangerousSettings(oldDangerous)) {
-        return true;
-    }
-    // Compare the dangerous settings - any change triggers a prompt
-    const oldJson = jsonStringify({
-        shellSettings: oldDangerous.shellSettings,
-        envVars: oldDangerous.envVars,
-        hooks: oldDangerous.hooks,
-    });
-    const newJson = jsonStringify({
-        shellSettings: newDangerous.shellSettings,
-        envVars: newDangerous.envVars,
-        hooks: newDangerous.hooks,
-    });
-    return oldJson !== newJson;
-}
-/**
- * Format dangerous settings as a human-readable list for the UI
- * Only returns setting names, not values
- */
-export function formatDangerousSettingsList(dangerous) {
-    const items = [];
-    // Shell settings (names only)
-    for (const key of Object.keys(dangerous.shellSettings)) {
-        items.push(key);
-    }
-    // Env vars (names only)
-    for (const key of Object.keys(dangerous.envVars)) {
-        items.push(key);
-    }
-    // Hooks
-    if (dangerous.hasHooks) {
-        items.push('hooks');
-    }
-    return items;
-}

package/dist/src/components/Markdown.js

@@ -1,217 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { c as _c } from "react/compiler-runtime";
-import { marked } from 'marked';
-import { Suspense, use, useRef } from 'react';
-import { useSettings } from '../hooks/useSettings.js';
-import { Ansi, Box, useTheme } from '../ink.js';
-import { getCliHighlightPromise } from '../utils/cliHighlight.js';
-import { hashContent } from '../utils/hash.js';
-import { configureMarked, formatToken } from '../utils/markdown.js';
-import { stripPromptXMLTags } from '../utils/messages.js';
-import { MarkdownTable } from './MarkdownTable.js';
-// Module-level token cache — marked.lexer is the hot cost on virtual-scroll
-// remounts (~3ms per message). useMemo doesn't survive unmount→remount, so
-// scrolling back to a previously-visible message re-parses. Messages are
-// immutable in history; same content → same tokens. Keyed by hash to avoid
-// retaining full content strings (turn50→turn99 RSS regression, #24180).
-const TOKEN_CACHE_MAX = 500;
-const tokenCache = new Map();
-// Characters that indicate markdown syntax. If none are present, skip the
-// ~3ms marked.lexer call entirely — render as a single paragraph. Covers
-// the majority of short assistant responses and user prompts that are
-// plain sentences. Checked via indexOf (not regex) for speed.
-// Single regex: matches any MD marker or ordered-list start (N. at line start).
-// One pass instead of 10× includes scans.
-const MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
-function hasMarkdownSyntax(s) {
-    // Sample first 500 chars — if markdown exists it's usually early (headers,
-    // code fence, list). Long tool outputs are mostly plain text tails.
-    return MD_SYNTAX_RE.test(s.length > 500 ? s.slice(0, 500) : s);
-}
-function cachedLexer(content) {
-    // Fast path: plain text with no markdown syntax → single paragraph token.
-    // Skips marked.lexer's full GFM parse (~3ms on long content). Not cached —
-    // reconstruction is a single object allocation, and caching would retain
-    // 4× content in raw/text fields plus the hash key for zero benefit.
-    if (!hasMarkdownSyntax(content)) {
-        return [{
-                type: 'paragraph',
-                raw: content,
-                text: content,
-                tokens: [{
-                        type: 'text',
-                        raw: content,
-                        text: content
-                    }]
-            }];
-    }
-    const key = hashContent(content);
-    const hit = tokenCache.get(key);
-    if (hit) {
-        // Promote to MRU — without this the eviction is FIFO (scrolling back to
-        // an early message evicts the very item you're looking at).
-        tokenCache.delete(key);
-        tokenCache.set(key, hit);
-        return hit;
-    }
-    const tokens = marked.lexer(content);
-    if (tokenCache.size >= TOKEN_CACHE_MAX) {
-        // LRU-ish: drop oldest. Map preserves insertion order.
-        const first = tokenCache.keys().next().value;
-        if (first !== undefined)
-            tokenCache.delete(first);
-    }
-    tokenCache.set(key, tokens);
-    return tokens;
-}
-/**
- * Renders markdown content using a hybrid approach:
- * - Tables are rendered as React components with proper flexbox layout
- * - Other content is rendered as ANSI strings via formatToken
- */
-export function Markdown(props) {
-    const $ = _c(4);
-    const settings = useSettings();
-    if (settings.syntaxHighlightingDisabled) {
-        let t0;
-        if ($[0] !== props) {
-            t0 = _jsx(MarkdownBody, { ...props, highlight: null });
-            $[0] = props;
-            $[1] = t0;
-        }
-        else {
-            t0 = $[1];
-        }
-        return t0;
-    }
-    let t0;
-    if ($[2] !== props) {
-        t0 = _jsx(Suspense, { fallback: _jsx(MarkdownBody, { ...props, highlight: null }), children: _jsx(MarkdownWithHighlight, { ...props }) });
-        $[2] = props;
-        $[3] = t0;
-    }
-    else {
-        t0 = $[3];
-    }
-    return t0;
-}
-function MarkdownWithHighlight(props) {
-    const $ = _c(4);
-    let t0;
-    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-        t0 = getCliHighlightPromise();
-        $[0] = t0;
-    }
-    else {
-        t0 = $[0];
-    }
-    const highlight = use(t0);
-    let t1;
-    if ($[1] !== highlight || $[2] !== props) {
-        t1 = _jsx(MarkdownBody, { ...props, highlight: highlight });
-        $[1] = highlight;
-        $[2] = props;
-        $[3] = t1;
-    }
-    else {
-        t1 = $[3];
-    }
-    return t1;
-}
-function MarkdownBody(t0) {
-    const $ = _c(7);
-    const { children, dimColor, highlight } = t0;
-    const [theme] = useTheme();
-    configureMarked();
-    let elements;
-    if ($[0] !== children || $[1] !== dimColor || $[2] !== highlight || $[3] !== theme) {
-        const tokens = cachedLexer(stripPromptXMLTags(children));
-        elements = [];
-        let nonTableContent = "";
-        const flushNonTableContent = function flushNonTableContent() {
-            if (nonTableContent) {
-                elements.push(_jsx(Ansi, { dimColor: dimColor, children: nonTableContent.trim() }, elements.length));
-                nonTableContent = "";
-            }
-        };
-        for (const token of tokens) {
-            if (token.type === "table") {
-                flushNonTableContent();
-                elements.push(_jsx(MarkdownTable, { token: token, highlight: highlight }, elements.length));
-            }
-            else {
-                nonTableContent = nonTableContent + formatToken(token, theme, 0, null, null, highlight);
-                nonTableContent;
-            }
-        }
-        flushNonTableContent();
-        $[0] = children;
-        $[1] = dimColor;
-        $[2] = highlight;
-        $[3] = theme;
-        $[4] = elements;
-    }
-    else {
-        elements = $[4];
-    }
-    const elements_0 = elements;
-    let t1;
-    if ($[5] !== elements_0) {
-        t1 = _jsx(Box, { flexDirection: "column", gap: 1, children: elements_0 });
-        $[5] = elements_0;
-        $[6] = t1;
-    }
-    else {
-        t1 = $[6];
-    }
-    return t1;
-}
-/**
- * Renders markdown during streaming by splitting at the last top-level block
- * boundary: everything before is stable (memoized, never re-parsed), only the
- * final block is re-parsed per delta. marked.lexer() correctly handles
- * unclosed code fences as a single token, so block boundaries are always safe.
- *
- * The stable boundary only advances (monotonic), so ref mutation during render
- * is idempotent and safe under StrictMode double-rendering. Component unmounts
- * between turns (streamingText → null), resetting the ref.
- */
-export function StreamingMarkdown({ children }) {
-    // React Compiler: this component reads and writes stablePrefixRef.current
-    // during render by design. The boundary only advances (monotonic), so
-    // the ref mutation is idempotent under StrictMode double-render — but the
-    // compiler can't prove that, and memoizing around the ref reads would
-    // break the algorithm (stale boundary). Opt out.
-    'use no memo';
-    configureMarked();
-    // Strip before boundary tracking so it matches <Markdown>'s stripping
-    // (line 29). When a closing tag arrives, stripped(N+1) is not a prefix
-    // of stripped(N), but the startsWith reset below handles that with a
-    // one-time re-lex on the smaller stripped string.
-    const stripped = stripPromptXMLTags(children);
-    const stablePrefixRef = useRef('');
-    // Reset if text was replaced (defensive; normally unmount handles this)
-    if (!stripped.startsWith(stablePrefixRef.current)) {
-        stablePrefixRef.current = '';
-    }
-    // Lex only from current boundary — O(unstable length), not O(full text)
-    const boundary = stablePrefixRef.current.length;
-    const tokens = marked.lexer(stripped.substring(boundary));
-    // Last non-space token is the growing block; everything before is final
-    let lastContentIdx = tokens.length - 1;
-    while (lastContentIdx >= 0 && tokens[lastContentIdx].type === 'space') {
-        lastContentIdx--;
-    }
-    let advance = 0;
-    for (let i = 0; i < lastContentIdx; i++) {
-        advance += tokens[i].raw.length;
-    }
-    if (advance > 0) {
-        stablePrefixRef.current = stripped.substring(0, boundary + advance);
-    }
-    const stablePrefix = stablePrefixRef.current;
-    const unstableSuffix = stripped.substring(stablePrefix.length);
-    // stablePrefix is memoized inside <Markdown> via useMemo([children, ...])
-    // so it never re-parses as the unstable suffix grows
-    return _jsxs(Box, { flexDirection: "column", gap: 1, children: [stablePrefix && _jsx(Markdown, { children: stablePrefix }), unstableSuffix && _jsx(Markdown, { children: unstableSuffix })] });
-}

package/dist/src/components/MarkdownTable.js

@@ -1,279 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import stripAnsi from 'strip-ansi';
-import { useTerminalSize } from '../hooks/useTerminalSize.js';
-import { stringWidth } from '../ink/stringWidth.js';
-import { wrapAnsi } from '../ink/wrapAnsi.js';
-import { Ansi, useTheme } from '../ink.js';
-import { formatToken, padAligned } from '../utils/markdown.js';
-/** Accounts for parent indentation (e.g. message dot prefix) and terminal
- *  resize races. Without enough margin the table overflows its layout box
- *  and Ink's clip truncates differently on alternating frames, causing an
- *  infinite flicker loop in scrollback. */
-const SAFETY_MARGIN = 4;
-/** Minimum column width to prevent degenerate layouts */
-const MIN_COLUMN_WIDTH = 3;
-/**
- * Maximum number of lines per row before switching to vertical format.
- * When wrapping would make rows taller than this, vertical (key-value)
- * format provides better readability.
- */
-const MAX_ROW_LINES = 4;
-/** ANSI escape codes for text formatting */
-const ANSI_BOLD_START = '\x1b[1m';
-const ANSI_BOLD_END = '\x1b[22m';
-/**
- * Wrap text to fit within a given width, returning array of lines.
- * ANSI-aware: preserves styling across line breaks.
- *
- * @param hard - If true, break words that exceed width (needed when columns
- *               are narrower than the longest word). Default false.
- */
-function wrapText(text, width, options) {
-    if (width <= 0)
-        return [text];
-    // Strip trailing whitespace/newlines before wrapping.
-    // formatToken() adds EOL to paragraphs and other token types,
-    // which would otherwise create extra blank lines in table cells.
-    const trimmedText = text.trimEnd();
-    const wrapped = wrapAnsi(trimmedText, width, {
-        hard: options?.hard ?? false,
-        trim: false,
-        wordWrap: true
-    });
-    // Filter out empty lines that result from trailing newlines or
-    // multiple consecutive newlines in the source content.
-    const lines = wrapped.split('\n').filter(line => line.length > 0);
-    // Ensure we always return at least one line (empty string for empty cells)
-    return lines.length > 0 ? lines : [''];
-}
-/**
- * Renders a markdown table using Ink's Box layout.
- * Handles terminal width by:
- * 1. Calculating minimum column widths based on longest word
- * 2. Distributing available space proportionally
- * 3. Wrapping text within cells (no truncation)
- * 4. Properly aligning multi-line rows with borders
- */
-export function MarkdownTable({ token, highlight, forceWidth }) {
-    const [theme] = useTheme();
-    const { columns: actualTerminalWidth } = useTerminalSize();
-    const terminalWidth = forceWidth ?? actualTerminalWidth;
-    // Format cell content to ANSI string
-    function formatCell(tokens) {
-        return tokens?.map(_ => formatToken(_, theme, 0, null, null, highlight)).join('') ?? '';
-    }
-    // Get plain text (stripped of ANSI codes)
-    function getPlainText(tokens_0) {
-        return stripAnsi(formatCell(tokens_0));
-    }
-    // Get the longest word width in a cell (minimum width to avoid breaking words)
-    function getMinWidth(tokens_1) {
-        const text = getPlainText(tokens_1);
-        const words = text.split(/\s+/).filter(w => w.length > 0);
-        if (words.length === 0)
-            return MIN_COLUMN_WIDTH;
-        return Math.max(...words.map(w_0 => stringWidth(w_0)), MIN_COLUMN_WIDTH);
-    }
-    // Get ideal width (full content without wrapping)
-    function getIdealWidth(tokens_2) {
-        return Math.max(stringWidth(getPlainText(tokens_2)), MIN_COLUMN_WIDTH);
-    }
-    // Calculate column widths
-    // Step 1: Get minimum (longest word) and ideal (full content) widths
-    const minWidths = token.header.map((header, colIndex) => {
-        let maxMinWidth = getMinWidth(header.tokens);
-        for (const row of token.rows) {
-            maxMinWidth = Math.max(maxMinWidth, getMinWidth(row[colIndex]?.tokens));
-        }
-        return maxMinWidth;
-    });
-    const idealWidths = token.header.map((header_0, colIndex_0) => {
-        let maxIdeal = getIdealWidth(header_0.tokens);
-        for (const row_0 of token.rows) {
-            maxIdeal = Math.max(maxIdeal, getIdealWidth(row_0[colIndex_0]?.tokens));
-        }
-        return maxIdeal;
-    });
-    // Step 2: Calculate available space
-    // Border overhead: │ content │ content │ = 1 + (width + 3) per column
-    const numCols = token.header.length;
-    const borderOverhead = 1 + numCols * 3; // │ + (2 padding + 1 border) per col
-    // Account for SAFETY_MARGIN to avoid triggering the fallback safety check
-    const availableWidth = Math.max(terminalWidth - borderOverhead - SAFETY_MARGIN, numCols * MIN_COLUMN_WIDTH);
-    // Step 3: Calculate column widths that fit available space
-    const totalMin = minWidths.reduce((sum, w_1) => sum + w_1, 0);
-    const totalIdeal = idealWidths.reduce((sum_0, w_2) => sum_0 + w_2, 0);
-    // Track whether columns are narrower than longest words (needs hard wrap)
-    let needsHardWrap = false;
-    let columnWidths;
-    if (totalIdeal <= availableWidth) {
-        // Everything fits - use ideal widths
-        columnWidths = idealWidths;
-    }
-    else if (totalMin <= availableWidth) {
-        // Need to shrink - give each column its min, distribute remaining space
-        const extraSpace = availableWidth - totalMin;
-        const overflows = idealWidths.map((ideal, i) => ideal - minWidths[i]);
-        const totalOverflow = overflows.reduce((sum_1, o) => sum_1 + o, 0);
-        columnWidths = minWidths.map((min, i_0) => {
-            if (totalOverflow === 0)
-                return min;
-            const extra = Math.floor(overflows[i_0] / totalOverflow * extraSpace);
-            return min + extra;
-        });
-    }
-    else {
-        // Table wider than terminal at minimum widths
-        // Shrink columns proportionally to fit, allowing word breaks
-        needsHardWrap = true;
-        const scaleFactor = availableWidth / totalMin;
-        columnWidths = minWidths.map(w_3 => Math.max(Math.floor(w_3 * scaleFactor), MIN_COLUMN_WIDTH));
-    }
-    // Step 4: Calculate max row lines to determine if vertical format is needed
-    function calculateMaxRowLines() {
-        let maxLines = 1;
-        // Check header
-        for (let i_1 = 0; i_1 < token.header.length; i_1++) {
-            const content = formatCell(token.header[i_1].tokens);
-            const wrapped = wrapText(content, columnWidths[i_1], {
-                hard: needsHardWrap
-            });
-            maxLines = Math.max(maxLines, wrapped.length);
-        }
-        // Check rows
-        for (const row_1 of token.rows) {
-            for (let i_2 = 0; i_2 < row_1.length; i_2++) {
-                const content_0 = formatCell(row_1[i_2]?.tokens);
-                const wrapped_0 = wrapText(content_0, columnWidths[i_2], {
-                    hard: needsHardWrap
-                });
-                maxLines = Math.max(maxLines, wrapped_0.length);
-            }
-        }
-        return maxLines;
-    }
-    // Use vertical format if wrapping would make rows too tall
-    const maxRowLines = calculateMaxRowLines();
-    const useVerticalFormat = maxRowLines > MAX_ROW_LINES;
-    // Render a single row with potential multi-line cells
-    // Returns an array of strings, one per line of the row
-    function renderRowLines(cells, isHeader) {
-        // Get wrapped lines for each cell (preserving ANSI formatting)
-        const cellLines = cells.map((cell, colIndex_1) => {
-            const formattedText = formatCell(cell.tokens);
-            const width = columnWidths[colIndex_1];
-            return wrapText(formattedText, width, {
-                hard: needsHardWrap
-            });
-        });
-        // Find max number of lines in this row
-        const maxLines_0 = Math.max(...cellLines.map(lines => lines.length), 1);
-        // Calculate vertical offset for each cell (to center vertically)
-        const verticalOffsets = cellLines.map(lines_0 => Math.floor((maxLines_0 - lines_0.length) / 2));
-        // Build each line of the row as a single string
-        const result = [];
-        for (let lineIdx = 0; lineIdx < maxLines_0; lineIdx++) {
-            let line = '│';
-            for (let colIndex_2 = 0; colIndex_2 < cells.length; colIndex_2++) {
-                const lines_1 = cellLines[colIndex_2];
-                const offset = verticalOffsets[colIndex_2];
-                const contentLineIdx = lineIdx - offset;
-                const lineText = contentLineIdx >= 0 && contentLineIdx < lines_1.length ? lines_1[contentLineIdx] : '';
-                const width_0 = columnWidths[colIndex_2];
-                // Headers always centered; data uses table alignment
-                const align = isHeader ? 'center' : token.align?.[colIndex_2] ?? 'left';
-                line += ' ' + padAligned(lineText, stringWidth(lineText), width_0, align) + ' │';
-            }
-            result.push(line);
-        }
-        return result;
-    }
-    // Render horizontal border as a single string
-    function renderBorderLine(type) {
-        const [left, mid, cross, right] = {
-            top: ['┌', '─', '┬', '┐'],
-            middle: ['├', '─', '┼', '┤'],
-            bottom: ['└', '─', '┴', '┘']
-        }[type];
-        let line_0 = left;
-        columnWidths.forEach((width_1, colIndex_3) => {
-            line_0 += mid.repeat(width_1 + 2);
-            line_0 += colIndex_3 < columnWidths.length - 1 ? cross : right;
-        });
-        return line_0;
-    }
-    // Render vertical format (key-value pairs) for extra-narrow terminals
-    function renderVerticalFormat() {
-        const lines_2 = [];
-        const headers = token.header.map(h => getPlainText(h.tokens));
-        const separatorWidth = Math.min(terminalWidth - 1, 40);
-        const separator = '─'.repeat(separatorWidth);
-        // Small indent for wrapped lines (just 2 spaces)
-        const wrapIndent = '  ';
-        token.rows.forEach((row_2, rowIndex) => {
-            if (rowIndex > 0) {
-                lines_2.push(separator);
-            }
-            row_2.forEach((cell_0, colIndex_4) => {
-                const label = headers[colIndex_4] || `Column ${colIndex_4 + 1}`;
-                // Clean value: trim, remove extra internal whitespace/newlines
-                const rawValue = formatCell(cell_0.tokens).trimEnd();
-                const value = rawValue.replace(/\n+/g, ' ').replace(/\s+/g, ' ').trim();
-                // Wrap value to fit terminal, accounting for label on first line
-                const firstLineWidth = terminalWidth - stringWidth(label) - 3;
-                const subsequentLineWidth = terminalWidth - wrapIndent.length - 1;
-                // Two-pass wrap: first line is narrower (label takes space),
-                // continuation lines get the full width minus indent.
-                const firstPassLines = wrapText(value, Math.max(firstLineWidth, 10));
-                const firstLine = firstPassLines[0] || '';
-                let wrappedValue;
-                if (firstPassLines.length <= 1 || subsequentLineWidth <= firstLineWidth) {
-                    wrappedValue = firstPassLines;
-                }
-                else {
-                    // Re-join remaining text and re-wrap to the wider continuation width
-                    const remainingText = firstPassLines.slice(1).map(l => l.trim()).join(' ');
-                    const rewrapped = wrapText(remainingText, subsequentLineWidth);
-                    wrappedValue = [firstLine, ...rewrapped];
-                }
-                // First line: bold label + value
-                lines_2.push(`${ANSI_BOLD_START}${label}:${ANSI_BOLD_END} ${wrappedValue[0] || ''}`);
-                // Subsequent lines with small indent (skip empty lines)
-                for (let i_3 = 1; i_3 < wrappedValue.length; i_3++) {
-                    const line_1 = wrappedValue[i_3];
-                    if (!line_1.trim())
-                        continue;
-                    lines_2.push(`${wrapIndent}${line_1}`);
-                }
-            });
-        });
-        return lines_2.join('\n');
-    }
-    // Choose format based on available width
-    if (useVerticalFormat) {
-        return _jsx(Ansi, { children: renderVerticalFormat() });
-    }
-    // Build the complete horizontal table as an array of strings
-    const tableLines = [];
-    tableLines.push(renderBorderLine('top'));
-    tableLines.push(...renderRowLines(token.header, true));
-    tableLines.push(renderBorderLine('middle'));
-    token.rows.forEach((row_3, rowIndex_0) => {
-        tableLines.push(...renderRowLines(row_3, false));
-        if (rowIndex_0 < token.rows.length - 1) {
-            tableLines.push(renderBorderLine('middle'));
-        }
-    });
-    tableLines.push(renderBorderLine('bottom'));
-    // Safety check: verify no line exceeds terminal width.
-    // This catches edge cases during terminal resize where calculations
-    // were based on a different width than the current render target.
-    const maxLineWidth = Math.max(...tableLines.map(line_2 => stringWidth(stripAnsi(line_2))));
-    // If we're within SAFETY_MARGIN characters of the edge, use vertical format
-    // to account for terminal resize race conditions.
-    if (maxLineWidth > terminalWidth - SAFETY_MARGIN) {
-        return _jsx(Ansi, { children: renderVerticalFormat() });
-    }
-    // Render as a single Ansi block to prevent Ink from wrapping mid-row
-    return _jsx(Ansi, { children: tableLines.join('\n') });
-}

package/dist/src/components/MemoryUsageIndicator.js

@@ -1,27 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useMemoryUsage } from '../hooks/useMemoryUsage.js';
-import { Box, Text } from '../ink.js';
-import { formatFileSize } from '../utils/format.js';
-export function MemoryUsageIndicator() {
-    // Ant-only: the /heapdump link is an internal debugging aid. Gating before
-    // the hook means the 10s polling interval is never set up in external builds.
-    // USER_TYPE is a build-time constant, so the hook call below is either always
-    // reached or dead-code-eliminated — never conditional at runtime.
-    if ("external" !== 'ant') {
-        return null;
-    }
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    // biome-ignore lint/correctness/useHookAtTopLevel: USER_TYPE is a build-time constant
-    const memoryUsage = useMemoryUsage();
-    if (!memoryUsage) {
-        return null;
-    }
-    const { heapUsed, status } = memoryUsage;
-    // Only show indicator when memory usage is high or critical
-    if (status === 'normal') {
-        return null;
-    }
-    const formattedSize = formatFileSize(heapUsed);
-    const color = status === 'critical' ? 'error' : 'warning';
-    return _jsx(Box, { children: _jsxs(Text, { color: color, wrap: "truncate", children: ["High memory usage (", formattedSize, ") \u00B7 /heapdump"] }) });
-}