@bubblebrain-ai/bubble 0.0.12 → 0.0.13

package/dist/tui/trace-groups.d.ts

@@ -0,0 +1,27 @@
+import type { DisplayToolCall } from "./display-history.js";
+export type TraceGroupKind = "list" | "read" | "search" | "execute" | "edit" | "write" | "subagent" | "other";
+export interface TraceGroup {
+    kind: TraceGroupKind;
+    title: string;
+    raw: DisplayToolCall[];
+    count?: number;
+    noun?: string;
+    command?: string;
+    items: string[];
+    previewLines: string[];
+    errorLines: string[];
+    omitted: number;
+    pending: boolean;
+    hasError: boolean;
+    errorCount: number;
+    startedAt?: number;
+}
+export interface TraceGroupOptions {
+    maxItems?: number;
+    maxPreviewLines?: number;
+    homeDir?: string;
+}
+export declare function buildTraceGroups(toolCalls: DisplayToolCall[], options?: TraceGroupOptions): TraceGroup[];
+export declare function formatTracePath(value: unknown, homeDir?: string): string;
+export declare function formatElapsed(startedAt: number | undefined, now?: number): string | null;
+export declare function traceGroupLabel(group: TraceGroup): string;

package/dist/tui/trace-groups.js

@@ -0,0 +1,412 @@
+import os from "node:os";
+import { getEditDiffDetails } from "./edit-diff.js";
+import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+const DEFAULT_MAX_ITEMS = 6;
+const DEFAULT_MAX_PREVIEW_LINES = 8;
+export function buildTraceGroups(toolCalls, options = {}) {
+    const maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+    const maxPreviewLines = options.maxPreviewLines ?? DEFAULT_MAX_PREVIEW_LINES;
+    const homeDir = options.homeDir ?? os.homedir();
+    const groups = [];
+    let bucket = [];
+    let bucketClassifier = null;
+    const flush = () => {
+        if (bucket.length === 0 || !bucketClassifier)
+            return;
+        groups.push(buildTraceGroup(bucketClassifier, bucket, {
+            maxItems,
+            maxPreviewLines,
+            homeDir,
+        }));
+        bucket = [];
+        bucketClassifier = null;
+    };
+    for (const toolCall of toolCalls) {
+        const classifier = classifyTool(toolCall);
+        if (!classifier.groupable) {
+            flush();
+            groups.push(buildTraceGroup(classifier, [toolCall], {
+                maxItems,
+                maxPreviewLines,
+                homeDir,
+            }));
+            continue;
+        }
+        if (bucketClassifier?.bucketKey === classifier.bucketKey) {
+            bucket.push(toolCall);
+        }
+        else {
+            flush();
+            bucket = [toolCall];
+            bucketClassifier = classifier;
+        }
+    }
+    flush();
+    return groups;
+}
+export function formatTracePath(value, homeDir = os.homedir()) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return "";
+    if (text === homeDir)
+        return "~";
+    if (text.startsWith(homeDir + "/"))
+        return "~" + text.slice(homeDir.length);
+    return text;
+}
+export function formatElapsed(startedAt, now = Date.now()) {
+    if (!startedAt)
+        return null;
+    const seconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return `${minutes}m${remainder.toString().padStart(2, "0")}s`;
+}
+export function traceGroupLabel(group) {
+    if (group.command)
+        return `${group.title} ${group.command}`;
+    if (group.count !== undefined && group.noun)
+        return `${group.title} ${group.count} ${group.noun}`;
+    return group.title;
+}
+function classifyTool(toolCall) {
+    if (toolCall.metadata?.kind === "subagent") {
+        return { kind: "subagent", title: "Subagents", bucketKey: `subagent:${toolCall.id}`, groupable: false };
+    }
+    switch (toolCall.name) {
+        case "glob": {
+            const pattern = String(toolCall.args.pattern ?? "");
+            const title = isDirectoryLikeGlob(pattern) ? "List Directory" : "Find Files";
+            return {
+                kind: "list",
+                title,
+                bucketKey: `list:${title}`,
+                groupable: true,
+            };
+        }
+        case "read":
+            return { kind: "read", title: "Read", bucketKey: "read", groupable: true };
+        case "grep":
+            return { kind: "search", title: "Search", bucketKey: "search", groupable: true };
+        case "bash":
+            return { kind: "execute", title: "Execute", bucketKey: `execute:${toolCall.id}`, groupable: false };
+        case "edit":
+            return { kind: "edit", title: "Edit", bucketKey: `edit:${toolCall.id}`, groupable: false };
+        case "write":
+            return { kind: "write", title: "Write", bucketKey: "write", groupable: true };
+        default:
+            return {
+                kind: "other",
+                title: displayToolName(toolCall.name),
+                bucketKey: `${toolCall.name}:${toolCall.id}`,
+                groupable: false,
+            };
+    }
+}
+function buildTraceGroup(classifier, raw, options) {
+    const pending = raw.some((tool) => isToolPending(tool));
+    const startedAt = raw
+        .filter((tool) => isToolPending(tool))
+        .map((tool) => tool.startedAt)
+        .filter((value) => typeof value === "number")
+        .sort((a, b) => a - b)[0];
+    const hasError = raw.some((tool) => !!tool.isError);
+    const errorCount = raw.filter((tool) => !!tool.isError).length;
+    switch (classifier.kind) {
+        case "list":
+            return buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "read":
+            return buildPathGroup(classifier, raw, options, pending, startedAt, hasError, errorCount, "files");
+        case "search":
+            return buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "execute":
+            return buildExecuteGroup(classifier, raw[0], options, pending, startedAt, hasError, errorCount);
+        case "edit":
+        case "write":
+            return buildMutationGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+        case "subagent":
+            return buildSubagentGroup(classifier, raw[0], options, pending, startedAt);
+        default:
+            return buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount);
+    }
+}
+function buildListGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const resultItems = raw.flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)));
+    const fallbackItems = raw
+        .map((tool) => String(tool.args.pattern ?? tool.args.path ?? "").trim())
+        .filter(Boolean)
+        .map((item) => formatTracePath(item, options.homeDir));
+    const sourceItems = resultItems.length > 0 ? resultItems : fallbackItems;
+    const { shown, omitted } = take(sourceItems, options.maxItems);
+    const count = resultItems.length > 0 ? resultItems.length : sourceItems.length || raw.length;
+    const noun = resultItems.length > 0 ? plural(count, "file", "files") : plural(count, "search", "searches");
+    return {
+        kind: "list",
+        title: classifier.title,
+        raw,
+        count,
+        noun,
+        items: shown,
+        previewLines: [],
+        errorLines: collectErrorLines(raw, options),
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildPathGroup(classifier, raw, options, pending, startedAt, hasError, errorCount, nounBase) {
+    const items = unique(raw
+        .map((tool) => formatTracePath(tool.args.path ?? tool.args.file ?? "", options.homeDir))
+        .filter(Boolean));
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = items.length || raw.length;
+    return {
+        kind: classifier.kind,
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, nounBase.slice(0, -1), nounBase),
+        items: shown,
+        previewLines: [],
+        errorLines: collectErrorLines(raw, options),
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildSearchGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const items = raw.map((tool) => {
+        const pattern = String(tool.args.pattern ?? tool.args.query ?? "").trim();
+        const scope = String(tool.args.path ?? tool.args.glob ?? tool.args.include ?? "").trim();
+        const patternText = pattern ? `"${pattern}"` : "(pattern)";
+        return scope ? `${patternText} in ${formatTracePath(scope, options.homeDir)}` : patternText;
+    });
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = raw.length;
+    return {
+        kind: "search",
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, "search", "searches"),
+        items: shown,
+        previewLines: [],
+        errorLines: collectErrorLines(raw, options),
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildExecuteGroup(classifier, tool, options, pending, startedAt, hasError, errorCount) {
+    const lines = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(lines, options.maxPreviewLines);
+    return {
+        kind: "execute",
+        title: classifier.title,
+        raw: [tool],
+        command: normalizeCommand(tool.args.command ?? tool.args.cmd ?? commandFromRawArguments(tool.rawArguments)),
+        items: [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildMutationGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const items = raw
+        .map((tool) => {
+        const path = formatTracePath(tool.args.path ?? "", options.homeDir);
+        const details = tool.name === "edit" ? getEditDiffDetails(tool) : null;
+        const suffix = details ? ` ${formatCompactEditStats(details.added, details.removed)}` : "";
+        return path ? `${path}${suffix}` : "";
+    })
+        .filter(Boolean);
+    const { shown, omitted } = take(items, options.maxItems);
+    const count = items.length || raw.length;
+    const errorPreview = hasError
+        ? raw
+            .filter((tool) => tool.isError)
+            .flatMap((tool) => resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir)))
+            .slice(0, options.maxPreviewLines)
+        : [];
+    return {
+        kind: classifier.kind,
+        title: classifier.title,
+        raw,
+        count,
+        noun: plural(count, "file", "files"),
+        items: shown,
+        previewLines: errorPreview,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function buildSubagentGroup(classifier, tool, options, pending, startedAt) {
+    const subagents = subagentsFromMetadata(tool);
+    const rows = subagents.length > 0
+        ? subagents.map(formatSubagentRow)
+        : resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(rows, options.maxPreviewLines);
+    const errorCount = subagents.filter(isFailedSubagent).length + (tool.isError ? 1 : 0);
+    return {
+        kind: "subagent",
+        title: classifier.title,
+        raw: [tool],
+        count: subagents.length || 1,
+        noun: plural(subagents.length || 1, "agent", "agents"),
+        items: [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending: pending || subagents.some((subagent) => ["queued", "running"].includes(subagent.status ?? "running")),
+        hasError: !!tool.isError || errorCount > 0,
+        errorCount,
+        startedAt,
+    };
+}
+function buildOtherGroup(classifier, raw, options, pending, startedAt, hasError, errorCount) {
+    const tool = raw[0];
+    const header = toolHeader(tool, options.homeDir);
+    const preview = resultLines(tool.result).map((line) => formatTracePath(line, options.homeDir));
+    const { shown, omitted } = take(preview, options.maxPreviewLines);
+    return {
+        kind: "other",
+        title: classifier.title,
+        raw,
+        count: header ? undefined : raw.length,
+        noun: header ? undefined : plural(raw.length, "call", "calls"),
+        items: header ? [header] : [],
+        previewLines: shown,
+        errorLines: [],
+        omitted,
+        pending,
+        hasError,
+        errorCount,
+        startedAt,
+    };
+}
+function subagentsFromMetadata(tool) {
+    const raw = tool.metadata?.subagents;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((item) => typeof item === "object" && item !== null);
+}
+function formatSubagentRow(subagent) {
+    const label = subagent.nickname || subagent.agentName || subagent.subAgentId || "subagent";
+    const role = [subagent.agentName, subagent.category ? `/${subagent.category}` : ""].join("") || "default";
+    const route = formatSubagentRoute(subagent.route);
+    const descriptor = route ? `${role} @ ${route}` : role;
+    const status = subagent.status || "running";
+    const note = subagent.error
+        || subagent.toolNotes?.filter(Boolean).at(-1)
+        || subagent.summary
+        || subagent.task
+        || "";
+    return [label, `(${descriptor})`, status, note].filter(Boolean).join(" ");
+}
+function isFailedSubagent(subagent) {
+    return subagent.status === "failed" || subagent.status === "blocked" || subagent.status === "cancelled";
+}
+function isToolPending(tool) {
+    return tool.result === undefined;
+}
+function isDirectoryLikeGlob(pattern) {
+    const normalized = pattern.trim();
+    return normalized === "" || normalized === "*" || normalized === "**" || normalized === "**/*";
+}
+function resultLines(result) {
+    if (result === undefined)
+        return [];
+    return result
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .filter((line) => line.trim() !== "");
+}
+function take(items, max) {
+    const shown = items.slice(0, max);
+    return { shown, omitted: Math.max(0, items.length - shown.length) };
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function collectErrorLines(raw, options) {
+    return raw
+        .filter((tool) => tool.isError)
+        .flatMap((tool) => resultLines(tool.result).map((line) => formatTraceLine(line, options.homeDir)))
+        .slice(0, options.maxPreviewLines);
+}
+function formatTraceLine(value, homeDir) {
+    const text = String(value ?? "").trimEnd();
+    if (!homeDir)
+        return text;
+    return text.split(homeDir + "/").join("~/").split(homeDir).join("~");
+}
+function plural(count, singular, pluralValue) {
+    return count === 1 ? singular : pluralValue;
+}
+function normalizeCommand(value) {
+    const command = String(value ?? "").replace(/\s+/g, " ").trim();
+    return command;
+}
+function commandFromRawArguments(rawArguments) {
+    if (!rawArguments)
+        return "";
+    try {
+        const parsed = JSON.parse(rawArguments);
+        if (parsed && typeof parsed === "object") {
+            const command = parsed.command ?? parsed.cmd;
+            return typeof command === "string" ? command : "";
+        }
+    }
+    catch {
+        const match = rawArguments.match(/"(?:command|cmd)"\s*:\s*"((?:\\.|[^"\\])*)/);
+        if (match?.[1]) {
+            try {
+                return JSON.parse(`"${match[1]}"`);
+            }
+            catch {
+                return match[1];
+            }
+        }
+    }
+    return "";
+}
+function displayToolName(name) {
+    if (!name)
+        return "Tool";
+    return name.charAt(0).toUpperCase() + name.slice(1).replace(/_/g, " ");
+}
+function toolHeader(tool, homeDir) {
+    const args = tool.args || {};
+    for (const key of ["path", "command", "pattern", "query", "url"]) {
+        const value = args[key];
+        if (value !== undefined && value !== null && String(value).trim() !== "") {
+            return formatTracePath(value, homeDir);
+        }
+    }
+    return undefined;
+}
+function formatCompactEditStats(added, removed) {
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added}`);
+    if (removed > 0)
+        parts.push(`-${removed}`);
+    return parts.length > 0 ? `(${parts.join(" ")})` : "";
+}

package/dist/tui/wordmark.d.ts

@@ -0,0 +1,15 @@
+export type BubbleWordmarkTone = "brand" | "ink" | "stone" | "soft" | "caption";
+export interface BubbleWordmarkSegment {
+    text: string;
+    tone: BubbleWordmarkTone;
+}
+export interface BubbleWordmarkLine {
+    text?: string;
+    tone?: BubbleWordmarkTone;
+    segments?: BubbleWordmarkSegment[];
+}
+export declare const BUBBLE_WORDMARK: BubbleWordmarkLine[];
+export declare const BUBBLE_COMPACT_WORDMARK: BubbleWordmarkLine[];
+export declare function bubbleWordmarkLineText(line: BubbleWordmarkLine): string;
+export declare function bubbleWordmarkMaxWidth(lines?: BubbleWordmarkLine[]): number;
+export declare function bubbleWordmarkForWidth(width: number): BubbleWordmarkLine[];

package/dist/tui/wordmark.js

@@ -0,0 +1,179 @@
+const LEAD_B = {
+    tone: "brand",
+    lines: [
+        "│   ",
+        "│   ",
+        "├─╮ ",
+        "│ │ ",
+        "│ │ ",
+        "╰─╯ ",
+        "    ",
+    ],
+};
+const LOWER_B = {
+    tone: "ink",
+    lines: [
+        "│   ",
+        "│   ",
+        "├─╮ ",
+        "│ │ ",
+        "│ │ ",
+        "╰─╯ ",
+        "    ",
+    ],
+};
+const GLYPHS = {
+    u: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "╷ ╷ ",
+            "│ │ ",
+            "│ │ ",
+            "╰─╯ ",
+            "    ",
+        ],
+    },
+    l: {
+        tone: "ink",
+        lines: [
+            "│  ",
+            "│  ",
+            "│  ",
+            "│  ",
+            "│  ",
+            "╰─ ",
+            "   ",
+        ],
+    },
+    e: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "╭─╮ ",
+            "├─┤ ",
+            "│   ",
+            "╰─╯ ",
+            "    ",
+        ],
+    },
+    beta: {
+        tone: "brand",
+        lines: [
+            "╭─╮ ",
+            "│ │ ",
+            "├─╯ ",
+            "├─╮ ",
+            "│ │ ",
+            "├─╯ ",
+            "│   ",
+        ],
+    },
+    r: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "╭─╮ ",
+            "│   ",
+            "│   ",
+            "│   ",
+            "    ",
+        ],
+    },
+    a: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "╭─╮ ",
+            "│ │ ",
+            "├─┤ ",
+            "│ │ ",
+            "    ",
+        ],
+    },
+    i: {
+        tone: "ink",
+        lines: [
+            "• ",
+            "  ",
+            "│ ",
+            "│ ",
+            "│ ",
+            "╰ ",
+            "  ",
+        ],
+    },
+    n: {
+        tone: "ink",
+        lines: [
+            "    ",
+            "    ",
+            "╭─╮ ",
+            "│ │ ",
+            "│ │ ",
+            "│ │ ",
+            "    ",
+        ],
+    },
+    space: {
+        tone: "caption",
+        lines: [
+            "  ",
+            "  ",
+            "  ",
+            "  ",
+            "  ",
+            "  ",
+            "  ",
+        ],
+    },
+};
+export const BUBBLE_WORDMARK = buildWordmark([
+    LEAD_B,
+    GLYPHS.u,
+    LOWER_B,
+    LOWER_B,
+    GLYPHS.l,
+    GLYPHS.e,
+    GLYPHS.space,
+    GLYPHS.beta,
+    GLYPHS.r,
+    GLYPHS.a,
+    GLYPHS.i,
+    GLYPHS.n,
+]);
+export const BUBBLE_COMPACT_WORDMARK = [
+    {
+        segments: [
+            { text: "b", tone: "brand" },
+            { text: "ubble ", tone: "ink" },
+            { text: "β", tone: "brand" },
+            { text: "rain", tone: "ink" },
+        ],
+    },
+];
+function buildWordmark(glyphs) {
+    const rows = Math.max(...glyphs.map((glyph) => glyph.lines.length));
+    const widths = glyphs.map((glyph) => Math.max(...glyph.lines.map((line) => line.length)));
+    return Array.from({ length: rows }, (_, rowIndex) => ({
+        segments: glyphs.map((glyph, glyphIndex) => ({
+            text: (glyph.lines[rowIndex] ?? "").padEnd(widths[glyphIndex] ?? 0, " "),
+            tone: glyph.tone,
+        })),
+    }));
+}
+export function bubbleWordmarkLineText(line) {
+    if (line.segments)
+        return line.segments.map((segment) => segment.text).join("");
+    return line.text ?? "";
+}
+export function bubbleWordmarkMaxWidth(lines = BUBBLE_WORDMARK) {
+    return Math.max(...lines.map((line) => bubbleWordmarkLineText(line).length));
+}
+export function bubbleWordmarkForWidth(width) {
+    return width < bubbleWordmarkMaxWidth() + 4 ? BUBBLE_COMPACT_WORDMARK : BUBBLE_WORDMARK;
+}

package/dist/tui-ink/app.js

@@ -180,9 +180,40 @@ function withMessageKey(message) {
     const prefix = message.role === "user" ? "user" : message.role === "error" ? "err" : "asst";
     return { ...message, key: nextDisplayMessageKey(prefix) };
 }
-const STREAMING_STATIC_FLUSH_MIN_CHARS = 5000;
-const STREAMING_STATIC_FLUSH_TARGET_CHARS = 3600;
-const STREAMING_STATIC_FLUSH_MIN_TAIL = 700;
+// Keep the live (non-Static) region small so non-GPU terminals (xterm.js DOM
+// renderer, ssh into a basic terminal, tmux without GPU) don't flicker when
+// Ink re-reconciles the streaming block on every token. Flushing earlier and
+// in smaller chunks shifts most of the answer into terminal scrollback, where
+// it's a one-time write that doesn't get re-rendered.
+const STREAMING_STATIC_FLUSH_MIN_CHARS = 600;
+const STREAMING_STATIC_FLUSH_TARGET_CHARS = 400;
+const STREAMING_STATIC_FLUSH_MIN_TAIL = 120;
+/**
+ * True iff `prefix` ends inside an open ```/~~~ fenced code block. Splitting
+ * the streaming buffer at such a point would let the flushed half render
+ * without its closing fence — `MarkdownContent` would then treat the body as
+ * plain prose and the trailing half would render as an isolated code block
+ * with no opener. Fence delimiters of different families don't close each
+ * other (a `~~~` inside a ``` block is just text). We use a permissive
+ * "line starts with three or more of the same char" rule, ignoring the info
+ * string — that's enough to spot when we're mid-block.
+ */
+function endsInsideUnclosedCodeFence(prefix) {
+    let openMarker = null;
+    for (const rawLine of prefix.split("\n")) {
+        const line = rawLine.replace(/^ {0,3}/, "");
+        if (openMarker === null) {
+            if (line.startsWith("```"))
+                openMarker = "`";
+            else if (line.startsWith("~~~"))
+                openMarker = "~";
+        }
+        else if (line.startsWith(openMarker.repeat(3))) {
+            openMarker = null;
+        }
+    }
+    return openMarker !== null;
+}
 function findStreamingStaticFlushIndex(content) {
     if (content.length < STREAMING_STATIC_FLUSH_MIN_CHARS)
         return -1;
@@ -192,12 +223,20 @@ function findStreamingStaticFlushIndex(content) {
     const search = content.slice(0, upper);
     const paragraphBreak = search.lastIndexOf("\n\n");
     if (paragraphBreak >= STREAMING_STATIC_FLUSH_TARGET_CHARS / 2) {
-        return paragraphBreak + 2;
+        const splitIndex = paragraphBreak + 2;
+        if (!endsInsideUnclosedCodeFence(content.slice(0, splitIndex))) {
+            return splitIndex;
+        }
     }
     const lineBreak = search.lastIndexOf("\n");
     if (lineBreak >= STREAMING_STATIC_FLUSH_TARGET_CHARS / 2) {
-        return lineBreak + 1;
+        const splitIndex = lineBreak + 1;
+        if (!endsInsideUnclosedCodeFence(content.slice(0, splitIndex))) {
+            return splitIndex;
+        }
     }
+    // Inside an open code fence: hold off flushing until the closing fence
+    // arrives. The live region grows a bit, but Markdown rendering stays correct.
     return -1;
 }
 function cloneDisplayPart(part) {