@alisio/alisio-code 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/tui/state.js

@@ -229,6 +229,16 @@ export const COMMANDS = [
         aliases: ["prefs"],
     },
     { name: "copy", description: "Copy the last assistant response to the clipboard" },
+    {
+        name: "agents",
+        description: "List and switch the active agent (applies from the next prompt)",
+        argumentHint: "[<verb>]",
+    },
+    {
+        name: "effort",
+        description: "Set the reasoning effort level for the active model",
+        argumentHint: "[level]",
+    },
     {
         name: "ask",
         description: "Ask the agent to turn your question into a multiple-choice ask_user_question",
@@ -250,6 +260,68 @@ export function parseCommand(input) {
         return undefined;
     return { name: match[1], args: (match[2] ?? "").trim() };
 }
+/**
+ * The effective reasoning effort to send for a model: the persisted level when the model
+ * supports it, otherwise the model's default level (silent fallback), and nothing when the
+ * model advertises no effort levels at all.
+ */
+export function effectiveEffort(persisted, capability) {
+    if (!capability?.supportedLevels?.length)
+        return undefined;
+    if (persisted && capability.supportedLevels.includes(persisted))
+        return persisted;
+    return capability.defaultLevel;
+}
+/** Validates a `/effort <level>` argument against the active model; returns an error or nothing. */
+export function validateEffortLevel(level, capability) {
+    if (!capability?.supportedLevels?.length)
+        return "This model does not advertise reasoning effort levels, so no effort is sent to it.";
+    if (!capability.supportedLevels.includes(level))
+        return `Unsupported effort level "${level}". Supported levels: ${capability.supportedLevels.join(", ")}.`;
+    return undefined;
+}
+export function effortPickerItems(capability, active) {
+    const items = capability.supportedLevels.map((level) => ({
+        value: level,
+        label: [
+            level,
+            level === active ? "(current)" : undefined,
+            level === capability.defaultLevel ? "(default)" : undefined,
+        ]
+            .filter(Boolean)
+            .join(" · "),
+        ...(level === capability.defaultLevel ? { description: "The model's own default" } : {}),
+    }));
+    return [
+        ...items,
+        {
+            value: "!clear",
+            label: "Auto · provider default",
+            description: "Clear the saved effort; the provider uses its own default",
+        },
+    ];
+}
+/**
+ * The ordered identity parts for the status line below the editor:
+ * `agent: <name> · <model> · <provider> · <effort>`, with the effort part omitted when the
+ * active model advertises no supported levels (`effort === undefined`). Colors are applied by
+ * the renderer per role; this module stays terminal-free and testable.
+ */
+export function identityParts(input) {
+    const parts = [
+        { text: `agent: ${input.agent}`, priority: 10, role: "agent" },
+        { text: input.model || "not connected", priority: 9, role: "model" },
+    ];
+    if (input.provider)
+        parts.push({ text: input.provider, priority: 8, role: "provider" });
+    if (input.effort)
+        parts.push({ text: input.effort, priority: 7, role: "effort" });
+    return parts;
+}
+/** Drops the lowest-priority identity parts until the line fits `width`; truncates the survivor. */
+export function fitIdentityParts(input, width) {
+    return fitSegments(identityParts(input), width, " · ");
+}
 export const SKILL_COMPLETION_DESCRIPTION_LIMIT = 80;
 /** Status hint prefixes (no color): shadowed < disabled < locked states shown by /skills. */
 const skillStatus = (skill) => !skill.effective
@@ -436,19 +508,40 @@ export function addItem(state, item) {
 const withModel = (stats, model) => typeof model === "string" && model && !stats.models.includes(model)
     ? { ...stats, models: [...stats.models, model] }
     : stats;
-function appendAssistant(state, field, delta) {
+/**
+ * Streaming assistant items stamp the thinking interval: the first reasoning delta records
+ * `reasoningStartedAt` and every later one refreshes `reasoningDoneAt`, so a completed thought
+ * section can show a `Thought · 2.9s` duration. The stamp stops once text arrives (the model
+ * moved on to the answer), so the duration measures the visible reasoning span, never the turn.
+ */
+const withReasoningStamp = (item, field, at) => {
+    if (field !== "reasoning" || item.text)
+        return item;
+    return { ...item, reasoningStartedAt: item.reasoningStartedAt ?? at, reasoningDoneAt: at };
+};
+function appendAssistant(state, field, delta, at = Date.now()) {
     const last = state.items.at(-1);
     if (last?.kind === "assistant" && !last.done)
         return {
             ...state,
-            items: [...state.items.slice(0, -1), { ...last, [field]: last[field] + delta }],
+            items: [
+                ...state.items.slice(0, -1),
+                withReasoningStamp({ ...last, [field]: last[field] + delta }, field, at),
+            ],
         };
-    return addItem(state, {
+    return addItem(state, withReasoningStamp({
         kind: "assistant",
         text: field === "text" ? delta : "",
         reasoning: field === "reasoning" ? delta : "",
         done: false,
-    });
+    }, field, at));
+}
+/** Approximated thinking interval of a completed reasoning section, when the events carried timestamps. */
+export function reasoningDurationMs(item) {
+    const { reasoningStartedAt, reasoningDoneAt } = item;
+    if (reasoningStartedAt === undefined || reasoningDoneAt === undefined)
+        return undefined;
+    return Math.max(0, reasoningDoneAt - reasoningStartedAt);
 }
 function updateTool(state, id, update) {
     const index = state.items.findLastIndex((i) => i.kind === "tool" && i.id === id);
@@ -471,9 +564,9 @@ export function reduceEvent(state, event) {
                 stats: withModel({ ...state.stats, runs: state.stats.runs + 1 }, d.model),
             };
         case "text_delta":
-            return appendAssistant(state, "text", String(d.delta ?? ""));
+            return appendAssistant(state, "text", String(d.delta ?? ""), at);
         case "reasoning_delta":
-            return appendAssistant(state, "reasoning", String(d.delta ?? ""));
+            return appendAssistant(state, "reasoning", String(d.delta ?? ""), at);
         case "turn_completed": {
             const usage = d.usage;
             const last = state.items.at(-1);
@@ -495,15 +588,18 @@ export function reduceEvent(state, event) {
                 },
             };
         }
-        case "tool_started":
+        case "tool_started": {
+            const name = String(d.name ?? "tool");
             return addItem(state, {
                 kind: "tool",
                 id: String(d.id ?? ""),
-                name: String(d.name ?? "tool"),
+                name,
                 args: typeof d.arguments === "string" ? d.arguments : "",
                 summary: summarizeToolArgs(String(d.name ?? ""), typeof d.arguments === "string" ? d.arguments : ""),
                 status: "running",
+                toolKind: toolKindOf(name, typeof d.effect === "string" ? d.effect : undefined),
             });
+        }
         case "approval_requested":
             return updateTool(state, d.id, { status: "approval" });
         case "approval_resolved":
@@ -515,6 +611,9 @@ export function reduceEvent(state, event) {
                 status: d.isError ? "error" : "ok",
                 ...(typeof d.durationMs === "number" ? { durationMs: d.durationMs } : {}),
                 ...(typeof d.preview === "string" ? { preview: d.preview } : {}),
+                ...exitCodePart(d.preview),
+                ...(isUiBlock(d.ui) ? { ui: d.ui } : {}),
+                ...(isImagePart(d.image) ? { image: d.image } : {}),
             });
             return {
                 ...next,
@@ -624,6 +723,391 @@ export function lastAssistantText(items) {
     }
     return undefined;
 }
+/**
+ * True when a printable key should copy the last assistant response instead of typing: bound to
+ * `c`/`y` (and uppercase) on an EMPTY editor line, while no autocomplete is showing and no turn
+ * is running — the same "empty input" convention Enter and Ctrl+D already use. A non-empty input
+ * never triggers, so typing `c` or `y` mid-message is unaffected.
+ */
+export function editorCopyKey(data, input) {
+    return ((data === "c" || data === "C" || data === "y" || data === "Y") &&
+        input.text === "" &&
+        !input.autocomplete &&
+        !input.busy);
+}
+/** True when an unknown event value is a `Node` of a tree UI block. */
+export function isTreeNode(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    if (typeof record.label !== "string")
+        return false;
+    if (record.meta !== undefined && typeof record.meta !== "string")
+        return false;
+    if (record.children !== undefined && !Array.isArray(record.children))
+        return false;
+    return record.children === undefined || record.children.every(isTreeNode);
+}
+/** True when an unknown event value is an Alisio `UiBlock` (validated defensively). */
+export function isUiBlock(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const block = value;
+    switch (block.kind) {
+        case "table":
+            return (Array.isArray(block.columns) &&
+                block.columns.every((c) => typeof c === "string") &&
+                Array.isArray(block.rows) &&
+                block.rows.every((r) => Array.isArray(r) && r.every((c) => typeof c === "string")) &&
+                (block.caption === undefined || typeof block.caption === "string"));
+        case "key-value":
+            return (Array.isArray(block.entries) &&
+                block.entries.every((e) => Array.isArray(e) &&
+                    e.length === 2 &&
+                    typeof e[0] === "string" &&
+                    typeof e[1] === "string") &&
+                (block.caption === undefined || typeof block.caption === "string"));
+        case "tree":
+            return Array.isArray(block.nodes) && block.nodes.every(isTreeNode);
+        case "code":
+            return (typeof block.code === "string" &&
+                (block.lang === undefined || typeof block.lang === "string") &&
+                (block.caption === undefined || typeof block.caption === "string"));
+        case "markdown":
+            return typeof block.text === "string";
+        default:
+            return false;
+    }
+}
+/** True when an unknown event value is a `{type:"image"}`-style part (mime + base64 data). */
+export function isImagePart(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.mimeType === "string" && typeof record.data === "string";
+}
+/** Rich (ui/image) parts of a persisted tool result, if any. */
+export function richPartsOf(result) {
+    if (!result)
+        return {};
+    const ui = result.content.find((part) => part.type === "ui");
+    const image = result.content.find((part) => part.type === "image");
+    return {
+        ...(ui?.type === "ui" ? { ui: ui.block } : {}),
+        ...(image?.type === "image" ? { image: { mimeType: image.mimeType, data: image.data } } : {}),
+    };
+}
+// ============================================================================
+// Tool presentation model — the pure extension point for transcript display.
+// Everything the TUI renders beyond a plain `TranscriptItem` is a
+// `TranscriptEntry`, and anything collapsible declares a `FoldCandidate` here,
+// so the renderer, the keybinding and (optionally) mouse clicks stay consistent
+// without importing pi-tui. Future block kinds hook in by extending these
+// shapes, never by special-casing components.
+// ============================================================================
+/** Words keyed by their canonical upper-case spelling that stay acronyms when humanized. */
+const ACRONYM_WORDS = new Set([
+    "MCP",
+    "HTTP",
+    "HTTPS",
+    "URL",
+    "API",
+    "CLI",
+    "JSON",
+    "CSV",
+    "XML",
+    "HTML",
+    "SQL",
+    "SQLITE",
+    "DNS",
+    "SSH",
+    "IP",
+    "ID",
+    "DB",
+    "UI",
+    "OS",
+    "IDE",
+    "TUI",
+    "PNG",
+    "SVG",
+    "PDF",
+    "YAML",
+    "TOML",
+    "2FA",
+    "V2",
+]);
+/**
+ * `read_file` → `Read File`, `search_text` → `Search Text`, `mcp_devforge_time_diff` →
+ * `MCP · Devforge Time Diff`. Splits on `_`/`-`/`.`/spaces, keeps known acronyms (MCP, HTTP…)
+ * and bare numeric suffixes (`read_file_2` → `Read File 2`). The machine name stays available
+ * dimmed in grouped detail rows and in the `/tools` and `/stats` reports.
+ */
+export function humanizeToolName(name) {
+    const trimmed = name.trim();
+    let rest = trimmed;
+    let prefix = "";
+    const mcp = /^mcp_/i.exec(rest);
+    if (mcp) {
+        prefix = "MCP · ";
+        rest = rest.slice(mcp[0].length);
+    }
+    const words = rest
+        .split(/[_\-. /]+/)
+        .filter(Boolean)
+        .map((word) => {
+        const upper = word.toUpperCase();
+        if (ACRONYM_WORDS.has(upper))
+            return upper;
+        if (/^\d+$/.test(upper))
+            return upper;
+        return `${word[0]?.toUpperCase() ?? ""}${word.slice(1).toLowerCase()}`;
+    });
+    return words.length ? `${prefix}${words.join(" ")}` : trimmed;
+}
+/** Verb and count noun used by grouped batch rows per tool kind. */
+export const TOOL_KIND_VERB = {
+    read: "Explored",
+    write: "Edited",
+    process: "Ran",
+    mcp: "Queried",
+    internal: "Ran",
+    other: "Called",
+};
+export const TOOL_KIND_WORD = {
+    read: "reads",
+    write: "files",
+    process: "commands",
+    mcp: "calls",
+    internal: "tasks",
+    other: "calls",
+};
+/**
+ * Capability kind of a tool call. Live events carry the registry `effect` (exact); replayed
+ * history falls back to conservative name heuristics. `mcp_*` is always the mcp kind.
+ */
+export function toolKindOf(name, effect) {
+    if (name.startsWith("mcp_"))
+        return "mcp";
+    switch (effect) {
+        case "read":
+        case "write":
+        case "process":
+        case "internal":
+            return effect;
+        default:
+            break;
+    }
+    if (/^(read|search|list|git|context|ask|web|fetch)_/.test(name))
+        return "read";
+    if (/^(write|edit|append|delete|rename|move|mkdir|patch)_/.test(name))
+        return "write";
+    if (/^(run|shell|execute)/.test(name))
+        return "process";
+    if (name === "task" || name.startsWith("task_"))
+        return "internal";
+    return "other";
+}
+/** Terminal-preview caps for collapsed rows (same values the renderer always used). */
+export const OUTPUT_PREVIEW_LINES_OK = 3;
+export const OUTPUT_PREVIEW_LINES_ERROR = 6;
+export const previewLinesFor = (status) => status === "error" ? OUTPUT_PREVIEW_LINES_ERROR : OUTPUT_PREVIEW_LINES_OK;
+/** Preview rows as the renderer shows them: blank lines dropped, tabs kept for the caller to expand. */
+export const previewRows = (preview) => preview.split("\n").filter((line) => line.trim());
+/** True when the preview exceeds the collapsed cap (the row becomes a collapsible "output"). */
+export function previewTruncated(preview, status) {
+    return !!preview && previewRows(preview).length > previewLinesFor(status);
+}
+/**
+ * Exit code derived safely from a text preview. `run_process`/`shell`/`search_text` return
+ * `{stdout, stderr, exitCode, truncated}` JSON; read-effect tools may carry an appended
+ * `\n<instructions>…` block, retried on the JSON prefix. Any other shape yields nothing.
+ */
+export function exitCodeOf(preview) {
+    if (!preview)
+        return undefined;
+    const codeOf = (text) => {
+        try {
+            const value = JSON.parse(text);
+            const code = value && typeof value === "object" && !Array.isArray(value)
+                ? value.exitCode
+                : undefined;
+            return typeof code === "number" ? code : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const direct = codeOf(preview);
+    if (direct !== undefined)
+        return direct;
+    const cut = preview.indexOf("\n<instructions>");
+    if (cut > 0)
+        return codeOf(preview.slice(0, cut));
+    return undefined;
+}
+const exitCodePart = (preview) => {
+    if (typeof preview !== "string")
+        return {};
+    const code = exitCodeOf(preview);
+    return code === undefined ? {} : { exitCode: code };
+};
+export function toolItemView(item) {
+    return {
+        id: item.id,
+        name: item.name,
+        humanName: humanizeToolName(item.name),
+        kind: item.toolKind ?? toolKindOf(item.name),
+        summary: item.summary,
+        status: item.status,
+        ...(item.durationMs !== undefined ? { durationMs: item.durationMs } : {}),
+        ...(item.preview !== undefined ? { preview: item.preview } : {}),
+        ...(item.ui ? { ui: item.ui } : {}),
+        ...(item.image ? { image: item.image } : {}),
+        ...(item.exitCode !== undefined ? { exitCode: item.exitCode } : {}),
+    };
+}
+/**
+ * Consecutive tool calls of the same kind whose statuses are ALL terminal (ok/error) merge into
+ * one `group` entry; running/approval calls always stay singleton so their spinner and live state
+ * stay visible. A kind change splits the run (`read` never merges with `shell`). Order is
+ * preserved; every entry carries its index within `items` (fold keys for assistant items need
+ * it). One linear pass — called on state changes only, never per frame.
+ */
+export function groupToolEntries(items) {
+    const out = [];
+    let run = [];
+    let runKind;
+    const flush = () => {
+        if (!run.length)
+            return;
+        const views = run.map((r) => toolItemView(r.item));
+        const first = views[0];
+        const groupable = views.length > 1 &&
+            first !== undefined &&
+            views.every((v) => v.kind === runKind) &&
+            views.every((v) => v.status === "ok" || v.status === "error");
+        if (groupable) {
+            const sameName = views.every((v) => v.name === first.name);
+            out.push({
+                entry: {
+                    kind: "group",
+                    group: {
+                        id: first.id,
+                        members: views,
+                        kind: first.kind,
+                        status: views.some((v) => v.status === "error") ? "error" : "ok",
+                        totalMs: views.reduce((sum, v) => sum + (v.durationMs ?? 0), 0),
+                        label: sameName ? first.humanName : TOOL_KIND_VERB[first.kind],
+                        word: TOOL_KIND_WORD[first.kind],
+                    },
+                },
+                at: run[0]?.at ?? 0,
+            });
+        }
+        else {
+            for (const r of run)
+                out.push({ entry: r.item, at: r.at });
+        }
+        run = [];
+        runKind = undefined;
+    };
+    items.forEach((item, at) => {
+        if (item.kind === "tool") {
+            const kind = item.toolKind ?? toolKindOf(item.name);
+            if (runKind === undefined) {
+                runKind = kind;
+                run.push({ item, at });
+            }
+            else if (runKind === kind) {
+                run.push({ item, at });
+            }
+            else {
+                flush();
+                runKind = kind;
+                run.push({ item, at });
+            }
+        }
+        else {
+            flush();
+            out.push({ entry: item, at });
+        }
+    });
+    flush();
+    return out;
+}
+/** Content identity of a group (fold/diff purposes): member ids, statuses and durations. */
+export function groupIdentity(group) {
+    return `${group.id}|${group.members.length}|${group.members
+        .map((m) => `${m.id}:${m.status}:${m.durationMs ?? ""}`)
+        .join(",")}`;
+}
+/** Cap for the reasoning text when expanded; longer sections show a truncation note. */
+export const REASONING_EXPAND_MAX_LINES = 40;
+/**
+ * The fold contract of one transcript entry: nothing (not collapsible), or a candidate with its
+ * default state. `at` is the entry's index within the ORIGINAL items array (assistant fold keys
+ * are stable because transcript items are append-only).
+ */
+export function foldCandidateOf(entry, at) {
+    if (entry.kind === "assistant") {
+        const reasoning = entry.reasoning.trim();
+        if (!reasoning || !(entry.done || entry.text))
+            return undefined;
+        return { key: `a:${at}`, kind: "reasoning", defaultExpanded: false };
+    }
+    if (entry.kind === "group")
+        return { key: `g:${entry.group.id}`, kind: "group", defaultExpanded: false };
+    if (entry.kind === "tool") {
+        if (entry.status === "running" || entry.status === "approval")
+            return undefined;
+        // Rich blocks keep their native rendering (tables/trees/images are already bounded);
+        // only plain text output folds when it exceeds the collapsed cap.
+        if (entry.ui || entry.image)
+            return undefined;
+        if (previewTruncated(entry.preview, entry.status))
+            return { key: `t:${entry.id}`, kind: "output", defaultExpanded: false };
+        return undefined;
+    }
+    return undefined;
+}
+/** Stable key of a transcript entry (used by the component sync to reuse row instances). */
+export function entryKeyOf(entry, at) {
+    switch (entry.kind) {
+        case "assistant":
+            return `a:${at}`;
+        case "group":
+            return `g:${entry.group.id}`;
+        case "tool":
+            return `t:${entry.id}`;
+        case "user":
+            return `u:${at}`;
+        case "notice":
+            return `n:${at}`;
+        case "info":
+            return `i:${at}`;
+        case "error":
+            return `e:${at}`;
+    }
+}
+/** Every fold candidate of the transcript in display order; the keybinding targets the last one. */
+export function foldCandidates(items) {
+    const candidates = [];
+    for (const { entry, at } of groupToolEntries(items)) {
+        const candidate = foldCandidateOf(entry, at);
+        if (candidate)
+            candidates.push(candidate);
+    }
+    return candidates;
+}
+/**
+ * True when a printable key should toggle the nearest collapsible transcript row instead of
+ * typing: bound to `x`/`X` on an EMPTY editor line (no autocomplete), the same "empty input"
+ * convention Enter, Ctrl+D and `c`/`y` already use. Unlike copy, it also works while a turn runs
+ * (the nearest candidate may still exist mid-stream). A non-empty input never triggers.
+ */
+export function foldToggleKey(data, input) {
+    return (data === "x" || data === "X") && input.text === "" && !input.autocomplete;
+}
 /** Rebuilds transcript items from persisted history (used by /resume). */
 export function itemsFromHistory(messages) {
     const items = [];
@@ -639,6 +1123,11 @@ export function itemsFromHistory(messages) {
                 items.push({ kind: "assistant", text: m.text, reasoning: "", done: true });
             for (const c of m.calls) {
                 const r = results.get(c.id);
+                const preview = r?.result.content
+                    .filter((p) => p.type === "text")
+                    .map((x) => x.text)
+                    .join("\n")
+                    .slice(0, 2_000);
                 items.push({
                     kind: "tool",
                     id: c.id,
@@ -646,10 +1135,10 @@ export function itemsFromHistory(messages) {
                     args: c.arguments,
                     summary: summarizeToolArgs(c.name, c.arguments),
                     status: r?.result.isError ? "error" : "ok",
-                    preview: r?.result.content
-                        .map((x) => x.text)
-                        .join("\n")
-                        .slice(0, 2_000),
+                    preview,
+                    toolKind: toolKindOf(c.name),
+                    ...exitCodePart(preview),
+                    ...richPartsOf(r?.result),
                 });
             }
         }

package/dist/tui/theme.d.ts

@@ -1,4 +1,4 @@
-import type { EditorTheme, ImageTheme, MarkdownTheme, SelectListTheme } from "@earendil-works/pi-tui";
+import type { DefaultTextStyle, EditorTheme, ImageTheme, MarkdownTheme, SelectListTheme } from "@earendil-works/pi-tui";
 import type { Level } from "./state.ts";
 export declare const style: {
     bold: (text: string) => string;
@@ -17,6 +17,47 @@ export declare const style: {
     userBg: (text: string) => string;
 };
 export declare const levelColor: (level: Level) => (text: string) => string;
+/**
+ * Dependency-free, line-based syntax highlighting for code blocks in responses.
+ *
+ * The tokenizer is deliberately approximate: it walks each line once and colors keywords, strings,
+ * comments, numbers, function calls and property keys for the common response languages. It never
+ * tries to be a real parser, never throws on malformed input, and strips ANSI/control characters
+ * from the source first (a model response must never be able to inject terminal control codes).
+ */
+export type TokenStyle = "keyword" | "string" | "comment" | "number" | "function" | "property" | "plain";
+export interface CodeToken {
+    text: string;
+    style: TokenStyle;
+}
+/** Strips ANSI escapes, OSC sequences and control characters; normalizes tabs. */
+export declare function sanitizeCode(code: string): string;
+export interface ScanState {
+    /** Closing delimiter of a block comment started on a previous line. */
+    inComment?: string;
+    /** Delimiter of a multi-line string started on a previous line. */
+    inString?: string;
+}
+/** Tokenizes code into styled segments, maintaining multi-line string/comment state. */
+export declare function tokenizeCode(code: string, lang?: string): CodeToken[][];
+/**
+ * Per-line highlighting for markdown code blocks (pi-tui `MarkdownTheme.highlightCode`).
+ * Returns one styled (or plain, under NO_COLOR) line per source line; never emits ANSI for
+ * bytes that came from the input.
+ */
+export declare function highlightCode(code: string, lang?: string): string[];
+/**
+ * Normalizes table separator rows so models' sloppy ASCII art still renders as aligned tables:
+ * em/en/box dashes become plain `-` runs (marked's table tokenizer only accepts `-`), while
+ * alignment colons are preserved. Anything that is not an obvious separator row, including
+ * fenced or indented code, is left untouched. A bare `---` (horizontal rule / setext) has no
+ * `|` and is never touched.
+ */
+export declare function normalizeTableSeparators(markdown: string): string;
+/** Pre-parse hook for the Markdown component: normalizes table separators before marked parses. */
+export declare const markdownTransform: (markdown: string, _availableWidth: number) => string;
+/** Subtle base tone for response body text; inline styles override it. */
+export declare const markdownDefaultTextStyle: DefaultTextStyle;
 export declare const markdownTheme: MarkdownTheme;
 export declare const selectListTheme: SelectListTheme;
 export declare const editorTheme: EditorTheme;