@bubblebrain-ai/bubble 0.0.11 → 0.0.13

package/dist/tui-opentui/input-box.js

@@ -0,0 +1,471 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+/** @jsxImportSource @opentui/react */
+/**
+ * Composer input for the OpenTUI TUI. Manages a multi-line editable buffer,
+ * cursor, history, file mention autocomplete, slash-command autocomplete,
+ * and text + image paste. Simpler than the Ink version because OpenTUI
+ * handles paste and selection at the native layer.
+ */
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { useKeyboard, usePaste } from "@opentui/react";
+import { decodePasteBytes } from "@opentui/core";
+import { registry as slashRegistry } from "../slash-commands/index.js";
+import { useTheme } from "./theme.js";
+import { filterFileSuggestions, findAtContext, listProjectFiles } from "./file-mentions.js";
+import { ingestImagePath, isImageFilePath, isScreenshotTempPath, splitPastedPaths, } from "./image-paste.js";
+import { appendHistoryEntry, loadHistorySync, stepHistory, } from "./input-history.js";
+const PROMPT = " > ";
+const LONG_PASTE_CHAR_THRESHOLD = 1000;
+const LONG_PASTE_LINE_THRESHOLD = 20;
+const MAX_VISIBLE_SUGGESTIONS = 8;
+export function shouldCollapsePastedContent(text) {
+    if (text.length >= LONG_PASTE_CHAR_THRESHOLD)
+        return true;
+    const lines = text.split("\n").length;
+    return lines >= LONG_PASTE_LINE_THRESHOLD;
+}
+export function createPastedContentMarker(content) {
+    const lineCount = content.split("\n").length;
+    const wordCount = content.trim().split(/\s+/).length;
+    return `[Pasted ${lineCount} lines · ${wordCount} words]`;
+}
+export function isCtrlCInput(input, key) {
+    return input === "\x03" || (key.ctrl === true && input.toLowerCase() === "c");
+}
+export function InputBox({ onSubmit, onPasteNotice, disabled = false, cursorResetEpoch, draftText, draftEpoch, onDraftApplied, skillRegistry, terminalColumns, cwd, }) {
+    const theme = useTheme();
+    const [buffer, setBuffer] = useState("");
+    const [cursor, setCursor] = useState(0);
+    const [images, setImages] = useState([]);
+    const [pastedRefs, setPastedRefs] = useState(new Map());
+    const [history] = useState(() => loadHistorySync());
+    const [historyIndex, setHistoryIndex] = useState(null);
+    const [suggestions, setSuggestions] = useState([]);
+    const [suggestionIndex, setSuggestionIndex] = useState(0);
+    const [suggestionKind, setSuggestionKind] = useState(null);
+    // Refs mirror the latest values so handlers passed into useKeyboard / usePaste
+    // read fresh state even if those hooks bind the callback once and never
+    // re-subscribe on state change. Updated synchronously on every render so
+    // the next event sees what just landed in the previous setState.
+    const bufferRef = useRef(buffer);
+    const cursorRef = useRef(cursor);
+    const imagesRef = useRef(images);
+    const pastedRefsRef = useRef(pastedRefs);
+    const suggestionsRef = useRef(suggestions);
+    const suggestionIndexRef = useRef(suggestionIndex);
+    const suggestionKindRef = useRef(suggestionKind);
+    const historyIndexRef = useRef(historyIndex);
+    bufferRef.current = buffer;
+    cursorRef.current = cursor;
+    imagesRef.current = images;
+    pastedRefsRef.current = pastedRefs;
+    suggestionsRef.current = suggestions;
+    suggestionIndexRef.current = suggestionIndex;
+    suggestionKindRef.current = suggestionKind;
+    historyIndexRef.current = historyIndex;
+    // Reset cursor / buffer on epoch bump from app (used after /clear, etc).
+    useEffect(() => {
+        if (cursorResetEpoch === undefined)
+            return;
+        setBuffer("");
+        setCursor(0);
+        setImages([]);
+        setPastedRefs(new Map());
+        setSuggestions([]);
+        setSuggestionKind(null);
+        setHistoryIndex(null);
+    }, [cursorResetEpoch]);
+    // Accept draft text fill from outside (e.g. skill picker → composer).
+    useEffect(() => {
+        if (draftText === undefined || draftEpoch === undefined)
+            return;
+        setBuffer(draftText);
+        setCursor(draftText.length);
+        onDraftApplied?.();
+    }, [draftText, draftEpoch, onDraftApplied]);
+    const updateSuggestions = useCallback(async (text, cursorPos) => {
+        const atCtx = findAtContext(text, cursorPos);
+        if (atCtx) {
+            const allFiles = await listProjectFiles(cwd);
+            const files = filterFileSuggestions(allFiles, atCtx.query);
+            if (files.length > 0) {
+                setSuggestions(files.slice(0, MAX_VISIBLE_SUGGESTIONS).map((f) => ({
+                    label: f.path,
+                    insert: `@${f.path}`,
+                })));
+                setSuggestionIndex(0);
+                setSuggestionKind("file");
+                return;
+            }
+        }
+        // Slash command suggestion if the buffer starts with /
+        const slashMatch = /^\s*\/(\S*)$/.exec(text.slice(0, cursorPos));
+        if (slashMatch) {
+            const query = slashMatch[1] ?? "";
+            const commands = slashRegistry.list?.() ?? [];
+            const filtered = commands
+                .filter((c) => !query || c.name.toLowerCase().includes(query.toLowerCase()))
+                .slice(0, MAX_VISIBLE_SUGGESTIONS)
+                .map((c) => ({
+                label: `/${c.name}`,
+                detail: c.description,
+                insert: `/${c.name}`,
+            }));
+            if (filtered.length > 0) {
+                setSuggestions(filtered);
+                setSuggestionIndex(0);
+                setSuggestionKind("slash");
+                return;
+            }
+        }
+        setSuggestions([]);
+        setSuggestionKind(null);
+    }, [cwd]);
+    // All handlers read from refs so they stay correct under hooks that bind
+    // the callback once. Writes still go through setState so React re-renders.
+    const insertAtCursor = useCallback((text) => {
+        const b = bufferRef.current;
+        const c = cursorRef.current;
+        const next = b.slice(0, c) + text + b.slice(c);
+        const nextCursor = c + text.length;
+        setBuffer(next);
+        setCursor(nextCursor);
+        void updateSuggestions(next, nextCursor);
+    }, [updateSuggestions]);
+    const acceptSuggestion = useCallback(() => {
+        const b = bufferRef.current;
+        const c = cursorRef.current;
+        const sugs = suggestionsRef.current;
+        const idx = suggestionIndexRef.current;
+        const kind = suggestionKindRef.current;
+        const s = sugs[idx];
+        if (!s)
+            return;
+        if (kind === "file") {
+            const atCtx = findAtContext(b, c);
+            if (!atCtx)
+                return;
+            const next = b.slice(0, atCtx.start) + s.insert + b.slice(atCtx.end);
+            const nextCursor = atCtx.start + s.insert.length;
+            setBuffer(next);
+            setCursor(nextCursor);
+        }
+        else if (kind === "slash") {
+            const slashMatch = /^(\s*)\/(\S*)$/.exec(b);
+            if (slashMatch) {
+                const lead = slashMatch[1] ?? "";
+                const next = `${lead}${s.insert} `;
+                setBuffer(next);
+                setCursor(next.length);
+            }
+        }
+        setSuggestions([]);
+        setSuggestionKind(null);
+    }, []);
+    const submit = useCallback(() => {
+        const b = bufferRef.current;
+        const imgs = imagesRef.current;
+        const refs = pastedRefsRef.current;
+        if (!b.trim() && imgs.length === 0)
+            return;
+        let expanded = b;
+        for (const [marker, content] of refs) {
+            expanded = expanded.split(marker).join(content);
+        }
+        const payload = {
+            text: expanded,
+            displayText: expanded !== b ? b : undefined,
+            images: imgs,
+        };
+        if (expanded.trim())
+            appendHistoryEntry(expanded);
+        onSubmit(payload);
+        setBuffer("");
+        setCursor(0);
+        setImages([]);
+        setPastedRefs(new Map());
+        setSuggestions([]);
+        setSuggestionKind(null);
+        setHistoryIndex(null);
+    }, [onSubmit]);
+    usePaste((event) => {
+        if (disabled)
+            return;
+        const text = decodePasteBytes(event.bytes);
+        // Detect image file paths from drag-and-drop or screenshot tools.
+        const paths = splitPastedPaths(text);
+        const imagePaths = paths.filter((p) => isImageFilePath(p) || isScreenshotTempPath(p));
+        if (imagePaths.length > 0) {
+            void Promise.all(imagePaths.map((p) => ingestImagePath(p))).then((results) => {
+                const attachments = [];
+                for (const r of results) {
+                    if (r.attachment)
+                        attachments.push(r.attachment);
+                }
+                if (attachments.length > 0) {
+                    setImages((prev) => [...prev, ...attachments]);
+                    onPasteNotice?.(`Attached ${attachments.length} image${attachments.length === 1 ? "" : "s"}`);
+                }
+            });
+            return;
+        }
+        // Plain text: collapse if long, otherwise insert at cursor.
+        if (shouldCollapsePastedContent(text)) {
+            const marker = createPastedContentMarker(text);
+            setPastedRefs((prev) => {
+                const next = new Map(prev);
+                next.set(marker, text);
+                return next;
+            });
+            insertAtCursor(marker);
+        }
+        else {
+            insertAtCursor(text);
+        }
+    });
+    useKeyboard((key) => {
+        if (disabled)
+            return;
+        if (key.eventType === "release")
+            return;
+        // Pull latest state from refs at the top of each event — useKeyboard may
+        // bind this handler once for the component's lifetime, so closure reads
+        // of `buffer`/`cursor`/etc. would otherwise be stuck on initial values.
+        const b = bufferRef.current;
+        const c = cursorRef.current;
+        const sugs = suggestionsRef.current;
+        const hIndex = historyIndexRef.current;
+        // Suggestion navigation
+        if (sugs.length > 0) {
+            if (key.name === "up") {
+                setSuggestionIndex((i) => (i - 1 + sugs.length) % sugs.length);
+                return;
+            }
+            if (key.name === "down") {
+                setSuggestionIndex((i) => (i + 1) % sugs.length);
+                return;
+            }
+            if (key.name === "tab" || key.name === "return") {
+                acceptSuggestion();
+                return;
+            }
+            if (key.name === "escape") {
+                setSuggestions([]);
+                setSuggestionKind(null);
+                return;
+            }
+        }
+        if (key.name === "return") {
+            if (key.shift) {
+                insertAtCursor("\n");
+                return;
+            }
+            submit();
+            return;
+        }
+        if (key.name === "backspace") {
+            if (c === 0)
+                return;
+            const next = b.slice(0, c - 1) + b.slice(c);
+            const nextCursor = c - 1;
+            setBuffer(next);
+            setCursor(nextCursor);
+            void updateSuggestions(next, nextCursor);
+            return;
+        }
+        if (key.name === "delete") {
+            if (c === b.length)
+                return;
+            const next = b.slice(0, c) + b.slice(c + 1);
+            setBuffer(next);
+            void updateSuggestions(next, c);
+            return;
+        }
+        if (key.name === "left") {
+            if (key.option || key.ctrl) {
+                setCursor(previousWordBoundary(b, c));
+            }
+            else {
+                setCursor(Math.max(0, c - 1));
+            }
+            return;
+        }
+        if (key.name === "right") {
+            if (key.option || key.ctrl) {
+                setCursor(nextWordBoundary(b, c));
+            }
+            else {
+                setCursor(Math.min(b.length, c + 1));
+            }
+            return;
+        }
+        if (key.name === "up") {
+            if (hIndex !== null || b === "") {
+                const next = stepHistory({ history, index: hIndex, draft: "" }, "up", b);
+                if (next.changed) {
+                    setBuffer(next.text);
+                    setCursor(next.text.length);
+                    setHistoryIndex(next.index);
+                }
+                return;
+            }
+            const lineStart = b.lastIndexOf("\n", c - 1);
+            if (lineStart === -1)
+                return;
+            const col = c - lineStart - 1;
+            const prevLineEnd = lineStart;
+            const prevLineStart = b.lastIndexOf("\n", prevLineEnd - 1) + 1;
+            setCursor(Math.min(prevLineEnd, prevLineStart + col));
+            return;
+        }
+        if (key.name === "down") {
+            if (hIndex !== null) {
+                const next = stepHistory({ history, index: hIndex, draft: "" }, "down", b);
+                setBuffer(next.text);
+                setCursor(next.text.length);
+                setHistoryIndex(next.index);
+                return;
+            }
+            const lineEnd = b.indexOf("\n", c);
+            if (lineEnd === -1)
+                return;
+            const lineStart = b.lastIndexOf("\n", c - 1) + 1;
+            const col = c - lineStart;
+            const nextLineStart = lineEnd + 1;
+            const nextLineEnd = b.indexOf("\n", nextLineStart);
+            const limit = nextLineEnd === -1 ? b.length : nextLineEnd;
+            setCursor(Math.min(limit, nextLineStart + col));
+            return;
+        }
+        if (key.name === "home" || (key.ctrl && key.name === "a")) {
+            const lineStart = b.lastIndexOf("\n", c - 1) + 1;
+            setCursor(lineStart);
+            return;
+        }
+        if (key.name === "end" || (key.ctrl && key.name === "e")) {
+            const lineEnd = b.indexOf("\n", c);
+            setCursor(lineEnd === -1 ? b.length : lineEnd);
+            return;
+        }
+        if (key.ctrl && key.name === "u") {
+            const lineStart = b.lastIndexOf("\n", c - 1) + 1;
+            const next = b.slice(0, lineStart) + b.slice(c);
+            setBuffer(next);
+            setCursor(lineStart);
+            void updateSuggestions(next, lineStart);
+            return;
+        }
+        if (key.ctrl && key.name === "k") {
+            const lineEnd = b.indexOf("\n", c);
+            const end = lineEnd === -1 ? b.length : lineEnd;
+            const next = b.slice(0, c) + b.slice(end);
+            setBuffer(next);
+            void updateSuggestions(next, c);
+            return;
+        }
+        // Character input — accept anything that's a printable string for key.name
+        // and not a control combo. Multi-codepoint names (CJK input methods send
+        // a fully-composed character; some terminals send 2+ codepoints for one
+        // grapheme) are still treated as a single insert.
+        if (key.name && !key.ctrl && isPrintableKeyName(key.name)) {
+            insertAtCursor(key.name);
+        }
+    });
+    const lines = buffer.split("\n");
+    const placeholderActive = buffer === "" && images.length === 0;
+    const railColor = disabled ? theme.inputBorderDisabled : theme.accent;
+    const surfaceBg = disabled ? theme.shade : theme.surface;
+    // Cursor position in visual lines.
+    const cursorRow = (() => {
+        const before = buffer.slice(0, cursor);
+        return before.split("\n").length - 1;
+    })();
+    const cursorCol = (() => {
+        const lastNl = buffer.lastIndexOf("\n", cursor - 1);
+        return cursor - lastNl - 1;
+    })();
+    return (_jsxs("box", { style: { flexDirection: "column", flexShrink: 0 }, children: [suggestions.length > 0 && (_jsx("box", { style: { flexDirection: "column", marginBottom: 0, paddingLeft: 3 }, children: suggestions.map((s, i) => (_jsx("text", { fg: i === suggestionIndex ? theme.accent : theme.textMuted, attributes: i === suggestionIndex ? 1 : 0, content: `${i === suggestionIndex ? "▸ " : "  "}${s.label}${s.detail ? "  " + s.detail : ""}` }, `sug-${i}`))) })), images.length > 0 && (_jsx("box", { style: { paddingLeft: 3, marginBottom: 0 }, children: _jsx("text", { fg: theme.accent, content: `${images.length} image${images.length === 1 ? "" : "s"} attached` }) })), React.createElement("box", {
+                style: {
+                    flexShrink: 0,
+                    backgroundColor: surfaceBg,
+                    flexDirection: "column",
+                    paddingTop: 1,
+                    paddingBottom: 1,
+                    paddingLeft: 2,
+                    paddingRight: 2,
+                },
+                border: ["left"],
+                borderColor: railColor,
+                customBorderChars: {
+                    topLeft: "",
+                    topRight: "",
+                    bottomLeft: "╹",
+                    bottomRight: "",
+                    horizontal: " ",
+                    vertical: "┃",
+                    topT: "",
+                    bottomT: "",
+                    cross: "",
+                    leftT: "",
+                    rightT: "",
+                },
+            }, placeholderActive ? (_jsx("text", { fg: theme.inputPlaceholder, content: disabled ? "Agent is responding…" : 'Ask anything... "Fix a TODO in the codebase"' }, "placeholder")) : (lines.map((line, idx) => {
+                const isCursorLine = idx === cursorRow;
+                if (!isCursorLine) {
+                    return (_jsx("text", { fg: theme.inputText, content: line || " " }, `l-${idx}`));
+                }
+                const before = line.slice(0, cursorCol);
+                const at = line.slice(cursorCol, cursorCol + 1) || " ";
+                const after = line.slice(cursorCol + 1);
+                return (_jsxs("box", { style: { flexDirection: "row" }, children: [_jsx("text", { fg: theme.inputText, content: before }), _jsx("text", { fg: theme.inputBg, bg: theme.accent, content: at }), _jsx("text", { fg: theme.inputText, content: after })] }, `l-${idx}`));
+            })))] }));
+}
+/**
+ * True if `name` is a graphical character we should insert as-is (covers both
+ * single ASCII codepoints and composed CJK characters delivered by an IME).
+ * Filters out OpenTUI's named keys like "tab", "return", "f1", "pageup".
+ */
+function isPrintableKeyName(name) {
+    if (name.length === 0)
+        return false;
+    // Common named keys OpenTUI passes through as `key.name`. If a single
+    // ASCII letter ends up here, length === 1 and it's not in this list, so it
+    // gets inserted normally.
+    const NAMED = new Set([
+        "tab", "return", "enter", "escape", "backspace", "delete", "space",
+        "up", "down", "left", "right",
+        "home", "end", "pageup", "pagedown", "insert",
+        "capslock", "numlock", "scrolllock", "printscreen", "pause",
+    ]);
+    if (NAMED.has(name))
+        return false;
+    if (/^f\d{1,2}$/.test(name))
+        return false; // f1..f24
+    // Reject obvious control bytes if any sneak through.
+    if (name.length === 1) {
+        const cp = name.codePointAt(0);
+        if (cp < 0x20 || cp === 0x7f)
+            return false;
+    }
+    return true;
+}
+function previousWordBoundary(text, cursor) {
+    if (cursor === 0)
+        return 0;
+    let i = cursor - 1;
+    while (i > 0 && /\s/.test(text[i]))
+        i--;
+    while (i > 0 && !/\s/.test(text[i - 1]))
+        i--;
+    return i;
+}
+function nextWordBoundary(text, cursor) {
+    if (cursor === text.length)
+        return text.length;
+    let i = cursor;
+    while (i < text.length && /\s/.test(text[i]))
+        i++;
+    while (i < text.length && !/\s/.test(text[i]))
+        i++;
+    return i;
+}

package/dist/tui-opentui/input-history.d.ts

@@ -0,0 +1,16 @@
+export declare function defaultHistoryFilePath(): string;
+export declare function loadHistorySync(filePath?: string): string[];
+export declare function appendHistoryEntry(entry: string, filePath?: string): void;
+export interface HistoryNavState {
+    history: string[];
+    index: number | null;
+    draft: string;
+}
+export interface HistoryNavResult {
+    text: string;
+    index: number | null;
+    draft: string;
+    changed: boolean;
+}
+export declare function stepHistory(state: HistoryNavState, direction: "up" | "down", currentText: string): HistoryNavResult;
+export declare function pushHistoryEntry(history: string[], entry: string): string[];

package/dist/tui-opentui/input-history.js

@@ -0,0 +1,79 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+const MAX_HISTORY_ENTRIES = 1000;
+export function defaultHistoryFilePath() {
+    return join(getBubbleHome(), "input-history.jsonl");
+}
+// JSONL on disk: each line is a JSON-encoded string. JSON encoding handles
+// embedded newlines and quotes so multi-line composer entries round-trip safely.
+export function loadHistorySync(filePath = defaultHistoryFilePath()) {
+    try {
+        if (!existsSync(filePath))
+            return [];
+        const raw = readFileSync(filePath, "utf8");
+        const out = [];
+        for (const line of raw.split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (typeof parsed === "string" && parsed.length > 0)
+                    out.push(parsed);
+            }
+            catch {
+                // Malformed line - skip rather than fail the whole load.
+            }
+        }
+        return out.length > MAX_HISTORY_ENTRIES ? out.slice(-MAX_HISTORY_ENTRIES) : out;
+    }
+    catch {
+        return [];
+    }
+}
+export function appendHistoryEntry(entry, filePath = defaultHistoryFilePath()) {
+    if (!entry || entry.trim().length === 0)
+        return;
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        appendFileSync(filePath, JSON.stringify(entry) + "\n", "utf8");
+    }
+    catch {
+        // Persistence is best-effort; never crash the composer over disk IO.
+    }
+}
+// Pure transition for up/down navigation. `index === null` means the user is
+// editing a fresh draft; otherwise it points at history[index]. When stepping
+// from the draft into history we snapshot the current text so down past the
+// newest entry can restore it.
+export function stepHistory(state, direction, currentText) {
+    const { history, index, draft } = state;
+    const noChange = { text: currentText, index, draft, changed: false };
+    if (direction === "up") {
+        if (history.length === 0)
+            return noChange;
+        if (index === null) {
+            const newIdx = history.length - 1;
+            return { text: history[newIdx], index: newIdx, draft: currentText, changed: true };
+        }
+        if (index > 0) {
+            return { text: history[index - 1], index: index - 1, draft, changed: true };
+        }
+        return noChange;
+    }
+    if (index === null)
+        return noChange;
+    if (index < history.length - 1) {
+        return { text: history[index + 1], index: index + 1, draft, changed: true };
+    }
+    return { text: draft, index: null, draft: "", changed: true };
+}
+// Push to in-memory history with last-entry dedupe so repeated identical
+// submissions don't spam the stack.
+export function pushHistoryEntry(history, entry) {
+    if (!entry || entry.trim().length === 0)
+        return history;
+    if (history.length > 0 && history[history.length - 1] === entry)
+        return history;
+    return [...history, entry];
+}

package/dist/tui-opentui/markdown.d.ts

@@ -0,0 +1,66 @@
+/** @jsxImportSource @opentui/react */
+/**
+ * Markdown rendering for the OpenTUI-based TUI.
+ *
+ * The previous Ink implementation hand-parsed markdown into block primitives
+ * because Ink had no native markdown support. OpenTUI ships
+ * `MarkdownRenderable` as a built-in (tree-sitter backed), so most of the
+ * 600+ lines of parsing logic collapse to a single intrinsic element.
+ *
+ * Public exports are kept compatible with the old Ink module so consumers
+ * (message-list, plan-confirm) don't need import changes.
+ */
+import React from "react";
+export type MarkdownBlock = {
+    type: "paragraph";
+    lines: string[];
+} | {
+    type: "heading";
+    level: number;
+    text: string;
+} | {
+    type: "code";
+    lang: string;
+    lines: string[];
+} | {
+    type: "table";
+    headers: string[];
+    rows: string[][];
+};
+export interface MarkdownInlineSegment {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    code?: boolean;
+}
+/**
+ * Detect the byte offset where the last complete block ends. Used by the
+ * streaming renderer to keep already-finalized blocks stable while the
+ * trailing block is still being typed.
+ */
+export declare function findLastBlockStart(text: string): number;
+/** Stub kept for test compatibility — OpenTUI parses internally. */
+export declare function parseMarkdownBlocks(text: string): MarkdownBlock[];
+/** Stub kept for test compatibility. */
+export declare function parseMarkdownInlineSegments(text: string, style?: {
+    bold?: boolean;
+    italic?: boolean;
+    code?: boolean;
+}): MarkdownInlineSegment[];
+interface MarkdownProps {
+    content: string;
+    terminalColumns?: number;
+}
+/**
+ * Render a complete (non-streaming) markdown blob. OpenTUI's MarkdownRenderable
+ * handles parse + style + code highlighting via tree-sitter internally.
+ */
+export declare function MarkdownContent({ content, terminalColumns }: MarkdownProps): React.ReactNode;
+/**
+ * Streaming variant. With OpenTUI's double-buffered renderer there's no
+ * tearing penalty for re-parsing on every token — the renderer composes the
+ * full frame natively before swapping. So we just delegate to the same
+ * primitive and let it handle partial input.
+ */
+export declare function StreamingMarkdown({ content, terminalColumns }: MarkdownProps): React.ReactNode;
+export {};