@bubblebrain-ai/bubble 0.0.52 → 0.0.53

package/dist/tui-ink/markdown.js

@@ -1,747 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * Lightweight Markdown renderer for Ink TUI.
- * Supports code blocks, inline formatting, and tables.
- */
-import React from "react";
-import { Box, Text } from "ink";
-import { ambiguousIsWide, visualWidth, graphemeWidth } from "./width.js";
-import { useTerminalSize } from "./use-terminal-size.js";
-import { useTheme } from "./theme.js";
-import { highlightCode, highlightCodeSync } from "./code-highlight.js";
-const graphemeSegmenter = typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
-    ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
-    : null;
-function splitGraphemes(text) {
-    if (!text)
-        return [];
-    if (graphemeSegmenter) {
-        const out = [];
-        for (const { segment } of graphemeSegmenter.segment(text))
-            out.push(segment);
-        return out;
-    }
-    return Array.from(text);
-}
-export function parseMarkdownBlocks(text) {
-    const lines = text.split("\n");
-    const blocks = [];
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        // Code block
-        if (line.startsWith("```")) {
-            const lang = line.slice(3).trim();
-            i++;
-            const codeLines = [];
-            while (i < lines.length && !lines[i].startsWith("```")) {
-                codeLines.push(lines[i]);
-                i++;
-            }
-            blocks.push({ type: "code", lang, lines: codeLines });
-            i++;
-            continue;
-        }
-        // Table
-        if (line.trim().startsWith("|")) {
-            const tableLines = [];
-            while (i < lines.length && lines[i].trim().startsWith("|")) {
-                tableLines.push(lines[i]);
-                i++;
-            }
-            if (tableLines.length >= 2) {
-                const headers = parseTableRow(tableLines[0]);
-                if (headers.length > 0 && isTableSeparatorRow(tableLines[1], headers.length)) {
-                    const rows = tableLines.slice(2).map((rowLine) => normalizeTableRow(parseTableRow(rowLine), headers.length));
-                    blocks.push({ type: "table", headers, rows });
-                }
-                else {
-                    blocks.push({ type: "paragraph", lines: tableLines });
-                }
-            }
-            else {
-                blocks.push({ type: "paragraph", lines: tableLines });
-            }
-            continue;
-        }
-        // Heading
-        const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
-        if (headingMatch) {
-            blocks.push({ type: "heading", level: headingMatch[1].length, text: headingMatch[2].trim() });
-            i++;
-            continue;
-        }
-        // Empty line -> skip
-        if (line.trim() === "") {
-            i++;
-            continue;
-        }
-        // Paragraph
-        const paraLines = [];
-        while (i < lines.length &&
-            lines[i].trim() !== "" &&
-            !lines[i].startsWith("```") &&
-            !lines[i].trim().startsWith("|")) {
-            paraLines.push(lines[i]);
-            i++;
-        }
-        blocks.push({ type: "paragraph", lines: paraLines });
-    }
-    return blocks;
-}
-/**
- * Return the byte offset where the LAST markdown block begins in `text`.
- *
- * Used by the streaming renderer to split incoming content into a "stable
- * prefix" (everything before the in-flight block — already-closed blocks)
- * and an "unstable suffix" (the block currently being typed by the model).
- * Mirrors parseMarkdownBlocks's lexing rules so the boundary it produces is
- * compatible with how MarkdownContent will later parse the prefix.
- *
- * Returns `text.length` when no blocks are present (empty / whitespace-only
- * input), and `0` when the entire text is a single in-flight block.
- */
-export function findLastBlockStart(text) {
-    if (text.length === 0)
-        return 0;
-    const lines = text.split("\n");
-    // `split("\n")` on "abc\n" yields ["abc", ""]; on "abc" yields ["abc"]. The
-    // trailing newline only contributes a length-1 separator for every line
-    // except the final element produced by split.
-    const lineLengthWithSeparator = (idx) => {
-        const len = lines[idx].length;
-        return idx < lines.length - 1 ? len + 1 : len;
-    };
-    let i = 0;
-    let offset = 0;
-    let lastBlockStart = text.length;
-    while (i < lines.length) {
-        const line = lines[i];
-        // Code block (fenced). Unclosed fences extend through EOF — that's exactly
-        // what we want for streaming, since marked-lexer-style "single token until
-        // close" keeps the in-flight code in the unstable suffix.
-        if (line.startsWith("```")) {
-            lastBlockStart = offset;
-            offset += lineLengthWithSeparator(i);
-            i++;
-            while (i < lines.length && !lines[i].startsWith("```")) {
-                offset += lineLengthWithSeparator(i);
-                i++;
-            }
-            if (i < lines.length) {
-                offset += lineLengthWithSeparator(i);
-                i++;
-            }
-            continue;
-        }
-        // Table — same shape as parseMarkdownBlocks: consume consecutive `|` lines.
-        if (line.trim().startsWith("|")) {
-            lastBlockStart = offset;
-            while (i < lines.length && lines[i].trim().startsWith("|")) {
-                offset += lineLengthWithSeparator(i);
-                i++;
-            }
-            continue;
-        }
-        // Heading.
-        if (/^#{1,6}\s+/.test(line)) {
-            lastBlockStart = offset;
-            offset += lineLengthWithSeparator(i);
-            i++;
-            continue;
-        }
-        // Blank line — does not start a block; just advances the offset.
-        if (line.trim() === "") {
-            offset += lineLengthWithSeparator(i);
-            i++;
-            continue;
-        }
-        // Paragraph — runs until blank line or start of another block.
-        lastBlockStart = offset;
-        while (i < lines.length &&
-            lines[i].trim() !== "" &&
-            !lines[i].startsWith("```") &&
-            !lines[i].trim().startsWith("|")) {
-            offset += lineLengthWithSeparator(i);
-            i++;
-        }
-    }
-    return lastBlockStart;
-}
-function parseTableRow(line) {
-    let body = line.trim();
-    if (body.startsWith("|"))
-        body = body.slice(1);
-    if (endsWithUnescapedPipe(body))
-        body = body.slice(0, -1);
-    const cells = [];
-    let current = "";
-    let inCode = false;
-    for (let i = 0; i < body.length; i++) {
-        const char = body[i];
-        if (char === "\\" && i + 1 < body.length) {
-            current += body[i + 1];
-            i++;
-            continue;
-        }
-        if (char === "`") {
-            inCode = !inCode;
-            current += char;
-            continue;
-        }
-        if (char === "|" && !inCode) {
-            cells.push(current.trim());
-            current = "";
-            continue;
-        }
-        current += char;
-    }
-    cells.push(current.trim());
-    return cells;
-}
-function endsWithUnescapedPipe(text) {
-    if (!text.endsWith("|"))
-        return false;
-    let slashCount = 0;
-    for (let i = text.length - 2; i >= 0 && text[i] === "\\"; i--)
-        slashCount++;
-    return slashCount % 2 === 0;
-}
-function isTableSeparatorRow(line, expectedColumns) {
-    const cells = parseTableRow(line);
-    if (cells.length !== expectedColumns)
-        return false;
-    return cells.every((cell) => /^:?-{3,}:?$/.test(cell.replace(/\s+/g, "")));
-}
-function normalizeTableRow(row, colCount) {
-    const normalized = row.slice(0, colCount);
-    while (normalized.length < colCount)
-        normalized.push("");
-    return normalized;
-}
-// Inline formatting: bold, italic, inline code
-export function parseMarkdownInlineSegments(text, style = {}) {
-    const segments = [];
-    let buffer = "";
-    let i = 0;
-    const flush = () => {
-        appendInlineSegment(segments, buffer, style);
-        buffer = "";
-    };
-    while (i < text.length) {
-        const char = text[i];
-        if (char === "\\" && i + 1 < text.length) {
-            buffer += text[i + 1];
-            i += 2;
-            continue;
-        }
-        if (char === "`") {
-            const close = findClosingMarker(text, "`", i + 1);
-            if (close !== -1) {
-                flush();
-                appendInlineSegment(segments, text.slice(i + 1, close), { ...style, code: true });
-                i = close + 1;
-                continue;
-            }
-        }
-        const marker = inlineMarkerAt(text, i);
-        if (marker) {
-            const close = findClosingMarker(text, marker, i + marker.length);
-            if (close !== -1 && close > i + marker.length) {
-                flush();
-                const inner = text.slice(i + marker.length, close);
-                const nextStyle = marker === "***"
-                    ? { ...style, bold: true, italic: true }
-                    : marker === "**" || marker === "__"
-                        ? { ...style, bold: true }
-                        : { ...style, italic: true };
-                for (const segment of parseMarkdownInlineSegments(inner, nextStyle)) {
-                    appendInlineSegment(segments, segment.text, segment);
-                }
-                i = close + marker.length;
-                continue;
-            }
-        }
-        buffer += char;
-        i++;
-    }
-    flush();
-    return segments.length > 0 ? segments : [{ text, ...style }];
-}
-function inlineMarkerAt(text, index) {
-    for (const marker of ["***", "**", "__", "*", "_"]) {
-        if (!text.startsWith(marker, index))
-            continue;
-        if (marker.includes("_") && isIntraWordUnderscore(text, index, marker.length))
-            continue;
-        return marker;
-    }
-    return null;
-}
-function findClosingMarker(text, marker, start) {
-    for (let i = start; i <= text.length - marker.length; i++) {
-        if (text[i] === "\\") {
-            i++;
-            continue;
-        }
-        if (!text.startsWith(marker, i))
-            continue;
-        if (marker.includes("_") && isIntraWordUnderscore(text, i, marker.length))
-            continue;
-        return i;
-    }
-    return -1;
-}
-function isIntraWordUnderscore(text, index, markerLength) {
-    const before = text[index - 1];
-    const after = text[index + markerLength];
-    return isWordChar(before) && isWordChar(after);
-}
-function isWordChar(char) {
-    return !!char && /[A-Za-z0-9]/.test(char);
-}
-function appendInlineSegment(segments, text, style) {
-    if (!text)
-        return;
-    const previous = segments[segments.length - 1];
-    const next = {
-        text,
-        bold: style.bold || undefined,
-        italic: style.italic || undefined,
-        code: style.code || undefined,
-    };
-    if (previous &&
-        previous.bold === next.bold &&
-        previous.italic === next.italic &&
-        previous.code === next.code) {
-        previous.text += text;
-    }
-    else {
-        segments.push(next);
-    }
-}
-function renderSegmentNodes(segments, keyPrefix, codeColor) {
-    return segments.map((segment, index) => (_jsx(Text, { bold: segment.bold, italic: segment.italic, color: segment.code ? codeColor : undefined, children: segment.text }, `${keyPrefix}-${index}`)));
-}
-function renderInlineSegments(text, keyPrefix, codeColor, style = {}) {
-    return renderSegmentNodes(parseMarkdownInlineSegments(text, style), keyPrefix, codeColor);
-}
-function inlinePlainText(text) {
-    return parseMarkdownInlineSegments(text).map((segment) => segment.text).join("");
-}
-function InlineText({ text, maxWidth }) {
-    const theme = useTheme();
-    const { columns } = useTerminalSize();
-    // Pre-wrap CJK-aware so Ink's space-only wrap-ansi can't chop "、"-joined runs
-    // mid-token. A caller-supplied maxWidth is exact (it already nets out the
-    // gutter); otherwise fall back to the terminal width minus a generous margin
-    // for borders/padding so a nested card never over-estimates and overflows —
-    // wrapping a few cells early is invisible, a mid-token chop is not.
-    const effectiveWidth = maxWidth ?? (columns ? Math.max(20, columns - 10) : undefined);
-    if (effectiveWidth === undefined) {
-        return _jsx(Text, { children: renderInlineSegments(text, "inline", theme.inlineCode) });
-    }
-    const wrapped = wrapInlineSegments(parseMarkdownInlineSegments(text), effectiveWidth);
-    return (_jsx(_Fragment, { children: wrapped.map((segments, li) => (_jsx(Text, { children: segments.length ? renderSegmentNodes(segments, `inline-${li}`, theme.inlineCode) : " " }, li))) }));
-}
-function CodeBlock({ lang, lines, flushTop = false }) {
-    const theme = useTheme();
-    // Lazy init: try sync highlight when shiki is already warm so the very first
-    // paint carries highlighted output. Fall back to raw lines if shiki hasn't
-    // loaded yet; useEffect will refresh the mounted transcript item later.
-    const [highlighted, setHighlighted] = React.useState(() => {
-        const code = lines.join("\n");
-        if (!code)
-            return lines;
-        const sync = highlightCodeSync(code, lang || "text");
-        return sync ? sync.split("\n") : lines;
-    });
-    const upgraded = React.useRef(highlighted !== lines);
-    React.useEffect(() => {
-        if (upgraded.current)
-            return;
-        let cancelled = false;
-        const code = lines.join("\n");
-        if (!code)
-            return;
-        highlightCode(code, lang || "text")
-            .then((ansi) => {
-            if (cancelled)
-                return;
-            upgraded.current = true;
-            setHighlighted(ansi.split("\n"));
-        })
-            .catch(() => { });
-        return () => {
-            cancelled = true;
-        };
-    }, [lang, lines]);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: flushTop ? 0 : 1, marginBottom: 1, children: [lang && _jsx(Text, { color: theme.muted, children: lang }), _jsx(Box, { flexDirection: "column", children: highlighted.map((line, i) => (_jsx(Text, { children: line || " " }, i))) })] }));
-}
-function TableBlock({ headers, rows, maxWidth, flushTop = false, }) {
-    const theme = useTheme();
-    const { columns: termWidth } = useTerminalSize();
-    const colCount = headers.length;
-    // Reserve a buffer so the table fits even when wrapped inside an indented
-    // box (e.g. the timeline gutter contributes marginLeft + "●  " = 5 cells).
-    const budget = Math.max(20, (maxWidth ?? termWidth) - 8);
-    // Box-drawing ─│┌┬┼… are East Asian *Ambiguous*-width: on a terminal that
-    // renders them 2 cells wide, border rows would paint at twice the width the
-    // cell rows were budgeted for (and twice what Ink itself measures), so the
-    // terminal hard-wraps them into scattered fragments. There is no way to hit
-    // odd widths with 2-cell dashes, so on such terminals draw ASCII borders —
-    // the only glyphs whose width every layer agrees on.
-    const g = ambiguousIsWide()
-        ? { h: "-", v: "|", tl: "+", tm: "+", tr: "+", ml: "+", mm: "+", mr: "+", bl: "+", bm: "+", br: "+" }
-        : { h: "─", v: "│", tl: "┌", tm: "┬", tr: "┐", ml: "├", mm: "┼", mr: "┤", bl: "└", bm: "┴", br: "┘" };
-    const maxWidths = headers.map((h, i) => {
-        let max = visualWidth(inlinePlainText(h));
-        for (const row of rows) {
-            const cell = row[i] || "";
-            max = Math.max(max, visualWidth(inlinePlainText(cell)));
-        }
-        return max;
-    });
-    const totalInnerWidth = maxWidths.reduce((a, b) => a + b, 0);
-    const separatorsWidth = colCount * 3 + 1; // " │ " separators + outer edges
-    const totalWidth = totalInnerWidth + separatorsWidth;
-    let widths = [...maxWidths];
-    if (totalWidth > budget) {
-        const available = Math.max(budget - separatorsWidth, colCount * 4);
-        widths = allocateColumnWidths(maxWidths, available);
-    }
-    const top = g.tl + widths.map((w) => g.h.repeat(w + 2)).join(g.tm) + g.tr;
-    const mid = g.ml + widths.map((w) => g.h.repeat(w + 2)).join(g.mm) + g.mr;
-    const bot = g.bl + widths.map((w) => g.h.repeat(w + 2)).join(g.bm) + g.br;
-    // A cell wider than its column wraps onto continuation lines (CJK-aware, so
-    // 、-joined user lists break cleanly); the row grows to its tallest cell.
-    const renderRow = (cells, keyPrefix, isHeader = false) => {
-        const wrapped = cells.map((c, i) => {
-            const width = widths[i] ?? 4;
-            let lines = wrapInlineSegments(parseMarkdownInlineSegments(c, { bold: isHeader }), width);
-            if (lines.length > MAX_TABLE_CELL_LINES) {
-                lines = lines.slice(0, MAX_TABLE_CELL_LINES);
-                const last = lines[MAX_TABLE_CELL_LINES - 1];
-                lines[MAX_TABLE_CELL_LINES - 1] = truncateInlineSegments([...last, { text: " …" }], width);
-            }
-            return lines;
-        });
-        const height = Math.max(1, ...wrapped.map((lines) => lines.length));
-        return (_jsx(Box, { flexDirection: "column", children: Array.from({ length: height }, (_, line) => (_jsxs(Text, { children: [`${g.v} `, wrapped.map((cellLines, i) => (_jsxs(React.Fragment, { children: [renderCellLine(cellLines[line] ?? [], widths[i] ?? 4, `${keyPrefix}-cell-${i}-${line}`, theme.inlineCode), i < colCount - 1 ? ` ${g.v} ` : ` ${g.v}`] }, i)))] }, `${keyPrefix}-line-${line}`))) }, keyPrefix));
-    };
-    return (_jsxs(Box, { flexDirection: "column", marginTop: flushTop ? 0 : 1, marginBottom: 1, children: [_jsx(Text, { children: top }), renderRow(headers, "header", true), _jsx(Text, { children: mid }), rows.map((row, ri) => renderRow(row, `row-${ri}`)), _jsx(Text, { children: bot })] }));
-}
-/** Cap a pathological cell (huge blob of text) at this many wrapped lines. */
-const MAX_TABLE_CELL_LINES = 8;
-/**
- * Distribute `available` inner cells across columns. Columns whose natural
- * width already fits their fair share keep it untouched (numbers and dates
- * never wrap); only the wider columns split the remainder proportionally and
- * wrap their content.
- */
-export function allocateColumnWidths(natural, available) {
-    const count = natural.length;
-    const widths = new Array(count).fill(0);
-    const fixed = new Array(count).fill(false);
-    let remaining = available;
-    let unfixed = count;
-    // Each fixed column frees slack that can fit further columns — iterate to a
-    // fixpoint. Terminates: natural sum exceeds `available` (only caller path),
-    // so at least one column always stays unfixed.
-    let changed = true;
-    while (changed && unfixed > 0) {
-        changed = false;
-        const fair = remaining / unfixed;
-        for (let i = 0; i < count; i++) {
-            if (fixed[i] || natural[i] > fair)
-                continue;
-            fixed[i] = true;
-            widths[i] = natural[i];
-            remaining -= natural[i];
-            unfixed -= 1;
-            changed = true;
-        }
-    }
-    if (unfixed > 0) {
-        const wideTotal = natural.reduce((sum, w, i) => sum + (fixed[i] ? 0 : w), 0);
-        let assigned = 0;
-        let lastWide = -1;
-        for (let i = 0; i < count; i++) {
-            if (fixed[i])
-                continue;
-            widths[i] = Math.max(4, Math.floor((remaining * natural[i]) / wideTotal));
-            assigned += widths[i];
-            lastWide = i;
-        }
-        // Flooring leftovers go to the last wide column instead of being wasted.
-        if (lastWide >= 0 && assigned < remaining)
-            widths[lastWide] += remaining - assigned;
-    }
-    // On a very narrow budget the 4-cell floor can overshoot; shave the widest
-    // columns so the row never exceeds `available` and hard-wraps.
-    let excess = widths.reduce((a, b) => a + b, 0) - available;
-    while (excess > 0) {
-        let widest = -1;
-        for (let i = 0; i < count; i++) {
-            if (widths[i] > 4 && (widest === -1 || widths[i] > widths[widest]))
-                widest = i;
-        }
-        if (widest === -1)
-            break;
-        widths[widest] -= 1;
-        excess -= 1;
-    }
-    return widths;
-}
-function renderCellLine(segments, width, keyPrefix, codeColor) {
-    const padding = " ".repeat(Math.max(0, width - inlineSegmentsWidth(segments)));
-    return [
-        ...renderSegmentNodes(segments, keyPrefix, codeColor),
-        _jsx(Text, { children: padding }, `${keyPrefix}-pad`),
-    ];
-}
-function truncateInlineSegments(segments, width) {
-    if (inlineSegmentsWidth(segments) <= width)
-        return segments;
-    // The ellipsis is itself ambiguous-width (2 cells on an ambiguous-wide
-    // terminal) — reserve its real width or every truncated cell overflows.
-    const ellipsisWidth = graphemeWidth("…");
-    if (width <= ellipsisWidth)
-        return [{ text: "…" }];
-    const target = width - ellipsisWidth;
-    const output = [];
-    let used = 0;
-    for (const segment of segments) {
-        let text = "";
-        for (const grapheme of splitGraphemes(segment.text)) {
-            const gWidth = graphemeWidth(grapheme);
-            if (used + gWidth > target) {
-                if (text)
-                    appendInlineSegment(output, text, segment);
-                appendInlineSegment(output, "…", {});
-                return output;
-            }
-            text += grapheme;
-            used += gWidth;
-        }
-        appendInlineSegment(output, text, segment);
-    }
-    appendInlineSegment(output, "…", {});
-    return output;
-}
-/**
- * CJK-aware line wrap over styled inline segments.
- *
- * Ink wraps a <Text> via wrap-ansi with `hard: true`, which treats only ASCII
- * spaces as break opportunities. Chinese joins items with ideographic
- * punctuation like "、" and no ASCII space, so a long run such as
- * `A、B、ProviderSendTurnInput` is seen as ONE unbreakable word and gets chopped
- * mid-token at the column edge (e.g. `ProviderSendTurnInpu` + `t`), and the
- * overflow spills past the box into the terminal's own hard wrap. We instead
- * break at ASCII spaces AND after CJK punctuation (、,。!?;:)等 — keeping ASCII
- * identifiers whole — and hard-split only a lone token wider than the line.
- */
-export function wrapInlineSegments(segments, maxWidth) {
-    if (maxWidth <= 0)
-        return [segments];
-    const cells = [];
-    for (const segment of segments) {
-        const style = { bold: segment.bold, italic: segment.italic, code: segment.code };
-        for (const grapheme of splitGraphemes(segment.text)) {
-            cells.push({ grapheme, width: graphemeWidth(grapheme), style });
-        }
-    }
-    // CJK punctuation that acts as break opportunity AFTER it (like English comma/period).
-    const isCJKPunctuation = (g) => /^[、,。!?;:,!?;:]$/.test(g);
-    const chunks = [];
-    const chunkWidth = (run) => run.reduce((sum, cell) => sum + cell.width, 0);
-    let i = 0;
-    while (i < cells.length) {
-        const cell = cells[i];
-        if (cell.grapheme === " ") {
-            const run = [];
-            while (i < cells.length && cells[i].grapheme === " ")
-                run.push(cells[i++]);
-            chunks.push({ cells: run, width: chunkWidth(run), breakAfter: true });
-        }
-        else if (cell.width >= 2) {
-            chunks.push({ cells: [cell], width: cell.width, breakAfter: isCJKPunctuation(cell.grapheme) });
-            i++;
-        }
-        else {
-            const run = [];
-            while (i < cells.length && cells[i].grapheme !== " " && cells[i].width < 2)
-                run.push(cells[i++]);
-            chunks.push({ cells: run, width: chunkWidth(run), breakAfter: false });
-        }
-    }
-    // CJK line-break rules (禁則処理 / kinsoku): a closing bracket or a trailing
-    // punctuation mark must never begin a wrapped line (避头), and an opening
-    // bracket must never end one (避尾). Otherwise a line that fills up right
-    // before "）。" pushes that lone punctuation onto the next row — the jarring
-    // orphaned "）。" at the left margin. Glue each such mark to the chunk it must
-    // stay with, so the pair wraps as one unit (and may move down together).
-    const noStartGlyph = (g) => /^[、，。．！？；：）)〕】｝」』》〉…―ー]$/.test(g);
-    const noEndGlyph = (g) => /^[（(〔【｛「『《〈]$/.test(g);
-    const soleGlyph = (c) => (c.cells.length === 1 ? c.cells[0].grapheme : "");
-    const isSpaceChunk = (c) => c.cells[0]?.grapheme === " ";
-    const glued = [];
-    for (const chunk of chunks) {
-        const g = soleGlyph(chunk);
-        const prev = glued[glued.length - 1];
-        if (g && noStartGlyph(g) && prev && !isSpaceChunk(prev)) {
-            prev.cells.push(...chunk.cells);
-            prev.width += chunk.width;
-            prev.breakAfter = chunk.breakAfter; // inherit the mark's own break behavior
-        }
-        else {
-            glued.push({ cells: [...chunk.cells], width: chunk.width, breakAfter: chunk.breakAfter });
-        }
-    }
-    for (let k = glued.length - 2; k >= 0; k--) {
-        const g = soleGlyph(glued[k]);
-        if (g && noEndGlyph(g) && !isSpaceChunk(glued[k + 1])) {
-            const next = glued[k + 1];
-            next.cells.unshift(...glued[k].cells);
-            next.width += glued[k].width;
-            glued.splice(k, 1);
-        }
-    }
-    const lines = [];
-    let line = [];
-    let lineWidth = 0;
-    const flush = () => { lines.push(line); line = []; lineWidth = 0; };
-    for (let j = 0; j < glued.length; j++) {
-        const chunk = glued[j];
-        const isSpace = chunk.cells[0]?.grapheme === " ";
-        if (isSpace) {
-            if (lineWidth === 0)
-                continue;
-            if (lineWidth + chunk.width <= maxWidth) {
-                line.push(...chunk.cells);
-                lineWidth += chunk.width;
-            }
-            else {
-                flush();
-            }
-            continue;
-        }
-        if (lineWidth + chunk.width <= maxWidth) {
-            line.push(...chunk.cells);
-            lineWidth += chunk.width;
-            if (chunk.breakAfter && j < glued.length - 1) {
-                const nextChunk = glued[j + 1];
-                const nextIsSpace = nextChunk.cells[0]?.grapheme === " ";
-                if (!nextIsSpace && lineWidth + nextChunk.width > maxWidth)
-                    flush();
-            }
-            continue;
-        }
-        if (lineWidth > 0)
-            flush();
-        if (chunk.width <= maxWidth) {
-            line.push(...chunk.cells);
-            lineWidth = chunk.width;
-            continue;
-        }
-        for (const cell of chunk.cells) {
-            if (lineWidth + cell.width > maxWidth && lineWidth > 0)
-                flush();
-            line.push(cell);
-            lineWidth += cell.width;
-        }
-    }
-    if (line.length > 0 || lines.length === 0)
-        lines.push(line);
-    return lines.map((lineCells) => {
-        const out = [];
-        for (const cell of lineCells)
-            appendInlineSegment(out, cell.grapheme, cell.style);
-        return out;
-    });
-}
-function inlineSegmentsWidth(segments) {
-    return segments.reduce((sum, segment) => sum + visualWidth(segment.text), 0);
-}
-function HeadingBlock({ level, text, flushTop = false }) {
-    const theme = useTheme();
-    const props = { bold: true };
-    if (level === 1) {
-        props.underline = true;
-        props.color = theme.accent;
-    }
-    else if (level === 2) {
-        props.color = theme.accent;
-    }
-    else if (level === 3) {
-        props.color = theme.warning;
-    }
-    return (_jsx(Box, { marginTop: flushTop ? 0 : 1, marginBottom: 1, children: _jsx(Text, { ...props, children: text }) }));
-}
-/**
- * Streaming-aware wrapper around `MarkdownContent`.
- *
- * On every render, splits the incoming `content` into a stable prefix
- * (everything before the in-flight block) and an unstable suffix (the block
- * currently being typed). The two halves are rendered as two separate
- * `MarkdownContent` instances; the stable one uses the same `content` prop
- * across deltas, so its internal `useMemo([content])` short-circuits and
- * does NOT re-parse on each token — which is the whole point. Only the
- * shorter unstable suffix re-parses per delta.
- *
- * The boundary advances monotonically (the prefix only grows). A defensive
- * reset handles the rare case where `content` is replaced wholesale (e.g.,
- * the user re-enters a turn).
- */
-export function StreamingMarkdown({ content, maxWidth, flushTop = false, }) {
-    const stablePrefixRef = React.useRef("");
-    if (!content.startsWith(stablePrefixRef.current)) {
-        stablePrefixRef.current = "";
-    }
-    const boundary = stablePrefixRef.current.length;
-    const tail = content.substring(boundary);
-    const advance = findLastBlockStart(tail);
-    if (advance > 0) {
-        stablePrefixRef.current = content.substring(0, boundary + advance);
-    }
-    const stablePrefix = stablePrefixRef.current;
-    const unstableSuffix = content.substring(stablePrefix.length);
-    return (_jsxs(Box, { flexDirection: "column", children: [stablePrefix && _jsx(MarkdownContent, { content: stablePrefix, maxWidth: maxWidth, flushTop: flushTop }), unstableSuffix && _jsx(MarkdownContent, { content: unstableSuffix, maxWidth: maxWidth, flushTop: flushTop && !stablePrefix })] }));
-}
-// A markdown list item: optional indent, a bullet (-, *, +) or ordered marker
-// (1. / 2)), then whitespace, then the item text. The captured prefix is
-// rendered in its own fixed column so wrapped continuation lines hang-indent
-// under the item text instead of collapsing back to the left margin.
-const LIST_ITEM_RE = /^(\s*)([-*+]|\d{1,9}[.)])(\s+)(\S.*)$/;
-export function splitListItem(line) {
-    const m = LIST_ITEM_RE.exec(line);
-    if (!m)
-        return null;
-    const prefix = m[1] + m[2] + m[3];
-    return { prefix, content: m[4], indent: visualWidth(prefix) };
-}
-export function MarkdownContent({ content, maxWidth, flushTop = false, }) {
-    const blocks = React.useMemo(() => parseMarkdownBlocks(content), [content]);
-    return (_jsx(Box, { flexDirection: "column", children: blocks.map((block, i) => {
-            const blockFlushTop = flushTop && i === 0;
-            if (block.type === "code") {
-                return _jsx(CodeBlock, { lang: block.lang, lines: block.lines, flushTop: blockFlushTop }, i);
-            }
-            if (block.type === "table") {
-                return (_jsx(TableBlock, { headers: block.headers, rows: block.rows, maxWidth: maxWidth, flushTop: blockFlushTop }, i));
-            }
-            if (block.type === "heading") {
-                return _jsx(HeadingBlock, { level: block.level, text: block.text, flushTop: blockFlushTop }, i);
-            }
-            return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: block.lines.map((line, li) => {
-                    const item = splitListItem(line);
-                    if (item) {
-                        // Marker in a non-shrinking column; the item text flows in a
-                        // flex column to its right so every wrapped row aligns under it.
-                        const contentWidth = maxWidth !== undefined ? Math.max(4, maxWidth - item.indent) : undefined;
-                        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: item.prefix }) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(InlineText, { text: item.content, maxWidth: contentWidth }) })] }, li));
-                    }
-                    return _jsx(InlineText, { text: line, maxWidth: maxWidth }, li);
-                }) }, i));
-        }) }));
-}