@datalayer/agent-runtimes 1.0.29 → 1.3.10

package/lib/chat/messages/ChatMessages.d.ts

@@ -32,5 +32,5 @@ export interface ChatMessagesProps {
 /**
  * Chat Messages component
  */
-export declare function ChatMessages({ messageRenderer, activityRenderer, showTimestamps, showAvatars, autoScroll, className, extensionRegistry: extensionRegistryProp, }: ChatMessagesProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChatMessages({ messageRenderer, activityRenderer, showTimestamps, showAvatars, autoScroll, className, extensionRegistry: extensionRegistryProp, }: ChatMessagesProps): React.JSX.Element;
 export default ChatMessages;

package/lib/chat/messages/NotebookToolSurfaces.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Notebook tool results, shown in the transcript as surfaces.
+ *
+ * A chat whose agent works a notebook the reader cannot see — the Loop Shell
+ * mounts one hidden; any headless-notebook host is in the same position —
+ * used to leave the tool row as the only trace: "ran cell 3" with nothing to
+ * look at. This renders the trace itself. A cell that was inserted, updated
+ * or run appears under its tool row in two parts, the change first (the
+ * cell's source, read-only) and the outputs after, bound to the live model's
+ * own output area so a run that prints as it goes streams into the
+ * transcript. An `executeCodeInNotebook` shows only its outputs: the code was the
+ * agent's means, the output is the result.
+ *
+ * Part of the chat rather than of any workspace: `ChatBase` turns it on for
+ * a given notebook via `notebookToolSurfacesId`, and the LOOP chat sets that
+ * only while no editor is on screen — with the notebook open beside the
+ * chat, the change is already visible where it happened.
+ *
+ * @module chat/messages/NotebookToolSurfaces
+ */
+import type { JSX } from 'react';
+import type { ICellModel } from '@jupyterlab/cells';
+import type { IOutput } from '@jupyterlab/nbformat';
+import type { RenderToolResult, ToolCallRenderContext } from '../../types/chat';
+/**
+ * The notebook tools whose result is a cell worth showing, by the reference
+ * names the adapter registers them under (with the raw `datalayer_` names
+ * kept as aliases, since both spellings exist in the definitions).
+ */
+export declare const CELL_TOOLS: Set<string>;
+export declare const EXECUTE_TOOLS: Set<string>;
+/**
+ * The tool's result, as the structure it was before serialisation.
+ *
+ * The result the agent gets is a TOON *string* — human-readable, exactly so
+ * the model can read it — and TOON round-trips: `decode` gives the operation
+ * result back. A result that is already an object passes through; one that
+ * decodes to nothing (an error message, free text) yields nothing rather
+ * than a guess.
+ */
+export declare function decodedResult(context: ToolCallRenderContext): Record<string, unknown> | undefined;
+/**
+ * Which cell a completed tool call touched: the argument when the call named
+ * one, the result when the operation chose — an insert with no index appends,
+ * and only the result says where it landed.
+ */
+export declare function touchedCellIndex(context: ToolCallRenderContext): number | undefined;
+/**
+ * The live model of the cell a tool call touched, or nothing.
+ *
+ * The *live* model rather than a serialised snapshot, because the outputs
+ * hang off it as an `IOutputAreaModel` the output area can follow — which is
+ * what makes a long-running cell stream into the transcript instead of
+ * appearing all at once when it finishes.
+ */
+export declare function touchedCellModel(documentId: string, context: ToolCallRenderContext): ICellModel | null;
+/** Best-effort nbformat outputs from an `executeCodeInNotebook` result. */
+export declare function executionOutputs(context: ToolCallRenderContext): IOutput[];
+export declare function NotebookToolSurfaces({ documentId, context, }: {
+    documentId: string;
+    context: ToolCallRenderContext;
+}): JSX.Element;
+/**
+ * The renderer `ChatBase` mounts when a host names a notebook: the default
+ * row composed with this module's surfaces.
+ */
+export declare function notebookToolSurfacesRenderer(documentId: string): RenderToolResult;
+export default NotebookToolSurfaces;

package/lib/chat/messages/NotebookToolSurfaces.js

@@ -0,0 +1,302 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text } from '@primer/react';
+import { Cell, Output, OutputViewer, notebookStore, } from '@datalayer/jupyter-react';
+import { decode } from '@toon-format/toon';
+/**
+ * The notebook tools whose result is a cell worth showing, by the reference
+ * names the adapter registers them under (with the raw `datalayer_` names
+ * kept as aliases, since both spellings exist in the definitions).
+ */
+export const CELL_TOOLS = new Set([
+    'insertCell',
+    'updateCell',
+    'runCell',
+    'datalayer_insertCell',
+    'datalayer_updateCell',
+    'datalayer_runCell',
+]);
+export const EXECUTE_TOOLS = new Set([
+    'executeCodeInNotebook',
+    'datalayer_executeCodeInNotebook',
+    'executeCodeInDocument',
+    'datalayer_executeCodeInDocument',
+]);
+/**
+ * The tool's result, as the structure it was before serialisation.
+ *
+ * The result the agent gets is a TOON *string* — human-readable, exactly so
+ * the model can read it — and TOON round-trips: `decode` gives the operation
+ * result back. A result that is already an object passes through; one that
+ * decodes to nothing (an error message, free text) yields nothing rather
+ * than a guess.
+ */
+export function decodedResult(context) {
+    const result = context.result;
+    if (result && typeof result === 'object') {
+        return result;
+    }
+    if (typeof result === 'string') {
+        try {
+            const decoded = decode(result);
+            if (decoded && typeof decoded === 'object') {
+                return decoded;
+            }
+        }
+        catch {
+            // Not TOON. The default row already shows the raw text.
+        }
+    }
+    return undefined;
+}
+/**
+ * Which cell a completed tool call touched: the argument when the call named
+ * one, the result when the operation chose — an insert with no index appends,
+ * and only the result says where it landed.
+ */
+export function touchedCellIndex(context) {
+    const args = context.args ?? {};
+    if (typeof args.index === 'number') {
+        return args.index;
+    }
+    const decoded = decodedResult(context);
+    if (decoded && typeof decoded.index === 'number') {
+        return decoded.index;
+    }
+    return undefined;
+}
+/**
+ * The live model of the cell a tool call touched, or nothing.
+ *
+ * The *live* model rather than a serialised snapshot, because the outputs
+ * hang off it as an `IOutputAreaModel` the output area can follow — which is
+ * what makes a long-running cell stream into the transcript instead of
+ * appearing all at once when it finishes.
+ */
+export function touchedCellModel(documentId, context) {
+    const index = touchedCellIndex(context);
+    if (index === undefined) {
+        return null;
+    }
+    const model = notebookStore.getState().notebooks.get(documentId)?.model;
+    return model?.cells?.get(index) ?? null;
+}
+/** Best-effort nbformat outputs from an `executeCodeInNotebook` result. */
+export function executionOutputs(context) {
+    const result = (decodedResult(context) ?? {});
+    const outputs = [];
+    for (const entry of result.outputs ?? []) {
+        const content = entry.content;
+        if (content && typeof content === 'object') {
+            const record = content;
+            if ('output_type' in record) {
+                outputs.push(record);
+                continue;
+            }
+            if ('data' in record || 'text' in record || 'ename' in record) {
+                outputs.push({
+                    output_type: entry.type ?? 'display_data',
+                    ...record,
+                });
+                continue;
+            }
+        }
+        // A plain value: shown the way a kernel would print it.
+        outputs.push({
+            output_type: 'stream',
+            name: 'stdout',
+            text: String(content ?? ''),
+        });
+    }
+    return outputs;
+}
+/*
+ * Live models already spoken for by a finished row.
+ *
+ * The adapter exposes only "the last execution's outputs" — `executeCodeInNotebook`
+ * has no cell, so there is nothing better to address one by. Tool calls run
+ * one at a time, so the model an *executing* row reads is its own — unless
+ * it renders in the instant before its handler starts, when the previous
+ * call's model is still standing. Each completed row claims its model here,
+ * and an executing row refuses a claimed one rather than replaying somebody
+ * else's outputs.
+ */
+const claimedModels = new WeakSet();
+/** What the surface's caption says the tool did. */
+const TOOL_VERBS = {
+    insertCell: 'inserted',
+    updateCell: 'updated',
+    runCell: 'ran',
+    executeCodeInNotebook: 'executed',
+    executeCodeInDocument: 'executed',
+};
+export function NotebookToolSurfaces({ documentId, context, }) {
+    const { name, status, defaultUI } = context;
+    const shortName = name.replace(/^datalayer_/, '');
+    /*
+     * What each tool leaves on the transcript.
+     *
+     * The cell tools show the change in two parts, the way the A2UI Jupyter
+     * Output example splits its panels: the cell's *source* first — the change
+     * itself — and its outputs after, drawn from the live model's own output
+     * area so a run that prints as it goes streams into the transcript rather
+     * than appearing all at once. `executeCodeInNotebook` runs in the kernel without
+     * touching any cell — the code was the agent's means, the output is the
+     * result — so it shows only what came back.
+     *
+     * Rendered from `executing` onwards, not just on completion: with the
+     * index already named in the arguments (update, run) the cell is on
+     * screen while it works, which is where the streaming is worth watching.
+     */
+    /* This row's live execution outputs, held once found — see the claim
+       registry above for how a row avoids capturing its predecessor's. */
+    const liveExecution = useRef({ id: null, model: null });
+    /*
+     * The claim is a race this row loses on its first render: the executor
+     * creates `lastExecuteOutputs` only once the kernel call actually starts,
+     * which is *after* the transcript has drawn the row as `executing` — and a
+     * long silent run gives React no reason to render again, so the model was
+     * only ever claimed at completion and the whole stream painted at once.
+     * While executing and unclaimed, probe on a short timer; the state bump
+     * re-renders the row and the claim below picks the model up. Once bound,
+     * the output area follows the model on its own.
+     */
+    const [, setClaimTick] = useState(0);
+    useEffect(() => {
+        if (!EXECUTE_TOOLS.has(name) || status !== 'executing') {
+            return undefined;
+        }
+        if (liveExecution.current.id === context.toolCallId &&
+            liveExecution.current.model) {
+            return undefined;
+        }
+        let cancelled = false;
+        let timer;
+        const probe = () => {
+            if (cancelled) {
+                return;
+            }
+            const candidate = notebookStore.getState().notebooks.get(documentId)?.adapter
+                ?.lastExecuteOutputs ?? null;
+            if (candidate && !claimedModels.has(candidate)) {
+                setClaimTick(tick => tick + 1);
+                return;
+            }
+            timer = window.setTimeout(probe, 250);
+        };
+        probe();
+        return () => {
+            cancelled = true;
+            if (timer !== undefined) {
+                window.clearTimeout(timer);
+            }
+        };
+    }, [name, status, context.toolCallId, documentId]);
+    let cellModel = null;
+    let outputs = null;
+    let liveOutputs = null;
+    let index;
+    /*
+     * `error` included deliberately: an interrupted or failed run still *ran*,
+     * and whatever it printed before the stop is the state worth seeing. The
+     * surface used to vanish the moment a reader pressed stop — the one moment
+     * they were looking straight at it.
+     */
+    if (status === 'executing' || status === 'complete' || status === 'error') {
+        if (CELL_TOOLS.has(name)) {
+            index = touchedCellIndex(context);
+            cellModel = touchedCellModel(documentId, context);
+        }
+        else if (EXECUTE_TOOLS.has(name)) {
+            if (liveExecution.current.id !== context.toolCallId) {
+                const candidate = notebookStore.getState().notebooks.get(documentId)?.adapter
+                    ?.lastExecuteOutputs ?? null;
+                if (candidate && !claimedModels.has(candidate)) {
+                    liveExecution.current = { id: context.toolCallId, model: candidate };
+                }
+            }
+            liveOutputs =
+                liveExecution.current.id === context.toolCallId
+                    ? liveExecution.current.model
+                    : null;
+            // A finished row — completed or stopped — owns its model for good.
+            if (liveOutputs && status !== 'executing') {
+                claimedModels.add(liveOutputs);
+            }
+            if (!liveOutputs && status === 'complete') {
+                // No live model to show — an older build of the adapter, or the row
+                // arrived after another call replaced it. The serialised outputs are
+                // still the truth, just not a stream.
+                const produced = executionOutputs(context);
+                outputs = produced.length > 0 ? produced : null;
+            }
+        }
+    }
+    const cellOutputsModel = cellModel?.type === 'code'
+        ? cellModel.outputs
+        : undefined;
+    // Compose, never replace: the tool row stays, and every other tool keeps
+    // its default rendering untouched.
+    return (_jsxs(_Fragment, { children: [defaultUI, liveOutputs || outputs ? (
+            /* An execution's outputs, and nothing else — see above. */
+            _jsxs(Box, { sx: {
+                    mt: 1,
+                    // The full column, not the content's own width: a surface sized
+                    // to its longest line reads as a fragment.
+                    width: '100%',
+                    border: '1px solid',
+                    borderColor: 'border.default',
+                    borderRadius: 2,
+                    overflow: 'hidden',
+                    bg: 'canvas.default',
+                }, children: [_jsx(Box, { sx: {
+                            px: 2,
+                            py: 1,
+                            bg: 'canvas.subtle',
+                            borderBottom: '1px solid',
+                            borderColor: 'border.muted',
+                        }, children: _jsxs(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: ["Output \u00B7", ' ', status === 'executing'
+                                    ? 'executing…'
+                                    : status === 'error'
+                                        ? 'stopped'
+                                        : 'executed'] }) }), _jsx(Box, { sx: { p: 2 }, children: liveOutputs ? (
+                        /* The adapter's live mirror of the run: the area follows the
+                           model, so each line lands here the moment the kernel prints
+                           it — mounted from the first render of `executing`, before
+                           anything has arrived, or there would be nothing to watch. */
+                        _jsx(Output, { id: `${context.toolCallId}-execute-outputs`, model: liveOutputs, showControl: false, showEditor: false, autoRun: false })) : (_jsx(OutputViewer, { cell: { cell_type: 'code', outputs, metadata: {} } })) })] })) : null, cellModel ? (
+            /*
+              Drawn as a surface, the way the A2UI example presents an execution:
+              a captioned card, the change first, the outputs after.
+            */
+            _jsxs(Box, { sx: {
+                    mt: 1,
+                    // The full column, not the content's own width: a surface sized
+                    // to its longest line reads as a fragment.
+                    width: '100%',
+                    border: '1px solid',
+                    borderColor: 'border.default',
+                    borderRadius: 2,
+                    overflow: 'hidden',
+                    bg: 'canvas.default',
+                }, children: [_jsx(Box, { sx: {
+                            px: 2,
+                            py: 1,
+                            bg: 'canvas.subtle',
+                            borderBottom: '1px solid',
+                            borderColor: 'border.muted',
+                        }, children: _jsxs(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: [index !== undefined ? `Cell ${index}` : 'Cell', ' · ', TOOL_VERBS[shortName] ?? shortName] }) }), _jsx(Cell, { readOnly: true, type: cellModel.type ?? 'code', source: cellModel.sharedModel.getSource(), outputs: [] }), cellOutputsModel &&
+                        (status === 'executing' || cellOutputsModel.length > 0) ? (_jsx(Box, { sx: {
+                            borderTop: '1px solid',
+                            borderColor: 'border.muted',
+                            p: 2,
+                        }, children: _jsx(Output, { id: `${context.toolCallId}-outputs`, model: cellOutputsModel, showControl: false, showEditor: false, autoRun: false }) })) : null] })) : null] }));
+}
+/**
+ * The renderer `ChatBase` mounts when a host names a notebook: the default
+ * row composed with this module's surfaces.
+ */
+export function notebookToolSurfacesRenderer(documentId) {
+    return context => (_jsx(NotebookToolSurfaces, { documentId: documentId, context: context }));
+}
+export default NotebookToolSurfaces;

package/lib/chat/messages/TurnFooter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The line under a turn: what it cost, and what to do with it.
+ *
+ * One quiet row at the end of each exchange, in the idiom the usage band
+ * under the prompt already speaks — `324 / 128.0K ctx · turn 0▲ 0▼`. While
+ * the turn streams, the numbers tick: the window as it stands, the tokens
+ * spent since the turn began. Once the turn is over they freeze into that
+ * turn's record, and two actions appear beside them — copy the turn,
+ * remove it from the transcript.
+ *
+ * Deliberately barely there: faint ink that firms up under the pointer, and
+ * actions that only surface on hover or keyboard focus. A transcript is for
+ * reading; the accounting keeps to the margin.
+ *
+ * @module chat/messages/TurnFooter
+ */
+import type { JSX } from 'react';
+import type { ContextSnapshotData } from '../../types/context';
+export interface TurnFooterProps {
+    /**
+     * The live snapshot the agent reports. The footer reads it only while its
+     * own turn is the one the snapshot describes — streaming, or the most
+     * recent one finished — and keeps the last figures it saw once a newer
+     * turn takes the snapshot over.
+     */
+    usage?: ContextSnapshotData;
+    /** Whether this footer's turn is the one currently streaming. */
+    live: boolean;
+    /**
+     * Whether this is the most recently finished turn — the one the
+     * snapshot's `turnUsage` still describes.
+     */
+    latest: boolean;
+    /** The transcript's horizontal padding, so the row sits on the grid. */
+    padding: number;
+    /** Copy the turn's messages. The footer shows the moment of success. */
+    onCopy: () => void | Promise<void>;
+    /** Take the turn's messages out of the transcript. */
+    onRemove: () => void;
+}
+export declare function TurnFooter({ usage, live, latest, padding, onCopy, onRemove, }: TurnFooterProps): JSX.Element | null;
+export default TurnFooter;

package/lib/chat/messages/TurnFooter.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { IconButton, Text } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { CheckIcon, CopyIcon, TrashIcon } from '@primer/octicons-react';
+import { formatTokenCount } from '../../utils';
+export function TurnFooter({ usage, live, latest, padding, onCopy, onRemove, }) {
+    const [copied, setCopied] = useState(false);
+    const copiedTimer = useRef(null);
+    useEffect(() => () => {
+        if (copiedTimer.current !== null) {
+            window.clearTimeout(copiedTimer.current);
+        }
+    }, []);
+    const current = usage
+        ? {
+            contextTokens: usage.totalTokens,
+            contextWindow: usage.contextWindow,
+            inputTokens: usage.turnUsage?.inputTokens ?? 0,
+            outputTokens: usage.turnUsage?.outputTokens ?? 0,
+        }
+        : null;
+    /*
+     * The freeze. While the snapshot is about this turn (live, or the latest
+     * finished one) remember what it says; the render after a newer turn
+     * takes over, what was remembered becomes this turn's permanent record.
+     * No dependency array: the guard makes the effect idempotent, and the
+     * figures worth remembering can change on any render.
+     */
+    const lastSeen = useRef(null);
+    const [frozen, setFrozen] = useState(null);
+    useEffect(() => {
+        if ((live || latest) && current) {
+            lastSeen.current = current;
+        }
+        else if (!live && !latest && !frozen && lastSeen.current) {
+            setFrozen(lastSeen.current);
+        }
+    });
+    const record = live || latest ? current : frozen;
+    if (!record && live) {
+        // Streaming with nothing reported yet: nothing worth a row.
+        return null;
+    }
+    const handleCopy = async () => {
+        await onCopy();
+        setCopied(true);
+        if (copiedTimer.current !== null) {
+            window.clearTimeout(copiedTimer.current);
+        }
+        copiedTimer.current = window.setTimeout(() => setCopied(false), 1500);
+    };
+    return (_jsxs(Box, { "data-turn-footer": "", sx: {
+            display: 'flex',
+            alignItems: 'center',
+            gap: 1,
+            px: padding,
+            // Tucked against the turn it accounts for, not opening a new band.
+            mt: -1,
+            pb: 1,
+            minHeight: 24,
+            // Barely there until wanted.
+            opacity: 0.55,
+            transition: 'opacity 0.15s ease',
+            '&:hover, &:focus-within': { opacity: 1 },
+            '& [data-turn-actions]': {
+                opacity: 0,
+                transition: 'opacity 0.15s ease',
+            },
+            '&:hover [data-turn-actions], &:focus-within [data-turn-actions]': {
+                opacity: 1,
+            },
+        }, children: [record && (_jsxs(Text, { sx: { fontSize: 0, color: 'fg.muted', flexShrink: 0 }, children: [_jsx(Text, { as: "span", sx: { fontWeight: 'semibold', color: 'fg.default', fontSize: 0 }, children: formatTokenCount(record.contextTokens) }), ' / ', formatTokenCount(record.contextWindow), ' ctx · turn ', formatTokenCount(record.inputTokens), _jsx(Text, { as: "span", sx: { color: 'success.fg', fontSize: 0 }, children: '▲' }), ' ', formatTokenCount(record.outputTokens), _jsx(Text, { as: "span", sx: { color: 'attention.fg', fontSize: 0 }, children: '▼' })] })), !live && (_jsxs(Box, { "data-turn-actions": "", sx: { display: 'flex', alignItems: 'center' }, children: [_jsx(IconButton, { "data-turn-copy": "", icon: copied ? CheckIcon : CopyIcon, "aria-label": "Copy this turn", size: "small", variant: "invisible", onClick: () => void handleCopy() }), _jsx(IconButton, { "data-turn-remove": "", icon: TrashIcon, "aria-label": "Remove this turn", size: "small", variant: "invisible", onClick: onRemove })] }))] }));
+}
+export default TurnFooter;

package/lib/chat/messages/assistantMarkdown.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What an assistant's markdown needs before a renderer sees it.
+ *
+ * Shared by every surface that renders a reply — the transcript and the page
+ * layout's turn panel — so a table that renders in one renders in the other.
+ *
+ * @module chat/messages/assistantMarkdown
+ */
+/**
+ * Expand a single-line markdown table (rows joined with `||`) into one row
+ * per line so a markdown renderer can produce a real HTML table. Idempotent:
+ * any pre-existing `|\n|` boundaries are unaffected.
+ */
+export declare function expandCompactMarkdownTableBody(body: string): string;
+/**
+ * Pre-process assistant text for Streamdown:
+ *  - Unwrap ```markdown / ```md fenced blocks so tables render as HTML
+ *    instead of as a code block.
+ *  - Inside any fenced block (or top-level body), expand compact one-line
+ *    markdown tables.
+ */
+export declare function normalizeAssistantMarkdown(text: string): string;

package/lib/chat/messages/assistantMarkdown.js

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * What an assistant's markdown needs before a renderer sees it.
+ *
+ * Shared by every surface that renders a reply — the transcript and the page
+ * layout's turn panel — so a table that renders in one renders in the other.
+ *
+ * @module chat/messages/assistantMarkdown
+ */
+/**
+ * Expand a single-line markdown table (rows joined with `||`) into one row
+ * per line so a markdown renderer can produce a real HTML table. Idempotent:
+ * any pre-existing `|\n|` boundaries are unaffected.
+ */
+export function expandCompactMarkdownTableBody(body) {
+    if (!body)
+        return body;
+    if (!/\|\s*[-:| ]{3,}\|/.test(body))
+        return body;
+    if (!body.includes('||'))
+        return body;
+    return body.replace(/\|\|/g, '|\n|');
+}
+/**
+ * Pre-process assistant text for Streamdown:
+ *  - Unwrap ```markdown / ```md fenced blocks so tables render as HTML
+ *    instead of as a code block.
+ *  - Inside any fenced block (or top-level body), expand compact one-line
+ *    markdown tables.
+ */
+export function normalizeAssistantMarkdown(text) {
+    if (!text)
+        return text;
+    // Unwrap explicit ```markdown / ```md fences and expand compact tables.
+    let out = text.replace(/```(markdown|md)\s*\n([\s\S]*?)```/gi, (_match, _lang, body) => {
+        const expanded = expandCompactMarkdownTableBody(body.trim());
+        return `\n\n${expanded}\n\n`;
+    });
+    // Also expand compact tables inside other fenced blocks that happen to
+    // carry a markdown table (e.g. bare ``` fences).
+    out = out.replace(/```([a-zA-Z0-9_+-]*)\n([\s\S]*?)```/g, (match, lang, body) => {
+        const expanded = expandCompactMarkdownTableBody(body);
+        if (expanded === body)
+            return match;
+        // If we expanded an unlabeled fence containing a real markdown table,
+        // unwrap it so it renders as a table.
+        if (!lang || /^(text|plain)$/i.test(lang)) {
+            return `\n\n${expanded.trim()}\n\n`;
+        }
+        return `\`\`\`${lang}\n${expanded}\`\`\``;
+    });
+    return out;
+}