@falkenslab/agent-kit 0.10.1

package/dist/tui/ink/fullscreen.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Switches `stream` to the full screen and returns the function that restores it. The
+ * restore runs once, whichever comes first: the caller, or the process exiting (an
+ * uncaught error, `process.exit()`), since a terminal left in the alternate screen with
+ * mouse reporting on is unusable until reset.
+ */
+export declare function enterFullscreen(stream: NodeJS.WriteStream): () => void;
+export interface MouseEvent {
+    kind: "press" | "drag" | "release" | "right" | "wheel-up" | "wheel-down" | "other";
+    /** 0-based column and row of the cell. */
+    x: number;
+    y: number;
+}
+/** The left-button presses, drags and releases, right-button presses and wheel steps in `input`, in order. */
+export declare function mouseEvents(input: string): MouseEvent[];
+/** True when `input` is only mouse reports (clicks, wheel), never text to type. */
+export declare function isMouseReport(input: string): boolean;
+/** Wheel movement in `input`: negative scrolls up, positive down, 0 if none. */
+export declare function wheelSteps(input: string): number;
+export interface WrappedRows {
+    rows: string[];
+    /** Whether each row continues the line of the row before it (it was wrapped there). */
+    continued: boolean[];
+}
+/** A history line as the row cache needs it (see sessionModel.ts's HistoryItem). */
+export interface RowSource {
+    text: string;
+    kind?: string;
+    expanded?: string[];
+}
+/**
+ * The human's line as a full-width gray bar, bold, as in the Claude Code CLI: wrapped to
+ * `width` and each row padded in columns, so the bar is even whatever the text holds.
+ */
+export declare function userBarRows(text: string, width: number): string[];
+/**
+ * The history's rows, wrapped to `width`, with a cache that only wraps the lines added
+ * since the last call: the history only grows, and re-wrapping every line on every frame
+ * (up to 30 a second while a reply streams) would get slow in a long session. A different
+ * width, a change of `expand` (Ctrl+O), or a history that didn't just grow, wraps
+ * everything again. Tool groups show their unfolded lines when `expand` is on, and the
+ * human's lines are drawn as bars.
+ */
+export declare function createRowCache(): (lines: readonly RowSource[], width: number, expand?: boolean) => WrappedRows;
+/** A cell of the history: a row index and a 0-based column. */
+export interface Cell {
+    row: number;
+    col: number;
+}
+/** A selection from where the drag started to where it is now, in either order. */
+export interface Selection {
+    anchor: Cell;
+    focus: Cell;
+}
+/** The selection's first and last cells, in reading order. */
+export declare function orderedCells({ anchor, focus }: Selection): [Cell, Cell];
+/** Columns [from, to) of `row` inside the selection, or null if the row is outside it. */
+export declare function selectedColumns(selection: Selection, row: number, rowWidth: number): [number, number] | null;
+/** `row` with the selected columns drawn in inverse video. */
+export declare function highlightRow(row: string, selection: Selection | null, index: number): string;
+/**
+ * The selected text, plain: rows joined with line breaks, except where a row only continues
+ * a wrapped line; trailing spaces of each line dropped.
+ */
+export declare function selectedText(wrapped: WrappedRows, selection: Selection): string;
+/** OSC 52: sets the system clipboard from the terminal (Windows Terminal supports it). */
+export declare function clipboardSequence(text: string): string;
+/**
+ * Where the history view sits: the index of the last row shown, or null to follow the
+ * bottom. Anchoring to a row (not to a distance from the bottom) keeps the view still
+ * while new output arrives below it.
+ */
+export type ScrollAnchor = number | null;
+/** The rows [start, end) shown in `height` rows. */
+export declare function visibleRows(total: number, height: number, anchor: ScrollAnchor): [number, number];
+/** Moves the view by `delta` rows (negative is up), never above the first page; back to following the bottom once it gets there. */
+export declare function scrollBy(anchor: ScrollAnchor, delta: number, total: number, height: number): ScrollAnchor;
+/** Rows below the view (0 when following the bottom). */
+export declare function rowsBelow(anchor: ScrollAnchor, total: number): number;

package/dist/tui/ink/fullscreen.js

@@ -0,0 +1,175 @@
+import sliceAnsi from "slice-ansi";
+import stringWidth from "string-width";
+import wrapAnsi from "wrap-ansi";
+import { stripAnsi } from "./lineBuffer.js";
+import * as ui from "../ui.js";
+// Alternate screen plus mouse reporting in SGR form: button events with drags (?1002h), so
+// the wheel scrolls and dragging selects text (see the feature ink-selection).
+const ENTER = "\x1b[?1049h\x1b[?1000h\x1b[?1002h\x1b[?1006h";
+// Back to the normal screen, which brings back what was there before; then clear it and
+// put the cursor at the top, keeping the scrollback (like `cls` / `clear`).
+const LEAVE = "\x1b[?1002l\x1b[?1000l\x1b[?1006l\x1b[?1049l\x1b[2J\x1b[H";
+/**
+ * Switches `stream` to the full screen and returns the function that restores it. The
+ * restore runs once, whichever comes first: the caller, or the process exiting (an
+ * uncaught error, `process.exit()`), since a terminal left in the alternate screen with
+ * mouse reporting on is unusable until reset.
+ */
+export function enterFullscreen(stream) {
+    stream.write(ENTER);
+    let restored = false;
+    const restore = () => {
+        if (restored)
+            return;
+        restored = true;
+        process.off("exit", restore);
+        stream.write(LEAVE);
+    };
+    process.on("exit", restore);
+    return restore;
+}
+// An SGR mouse report as Ink hands it to useInput: "[<button;x;yM" (press, or drag) or
+// "...m" (release), with or without the leading ESC; x and y are 1-based cells. Wheel up is
+// button 64, wheel down 65; the left button is 0 (32 is added while it drags), the right one 2.
+// eslint-disable-next-line no-control-regex -- \x1b is the ESC byte the report may start with
+const MOUSE_REPORT = /\x1b?\[<(\d+);(\d+);(\d+)([Mm])/g;
+/** The left-button presses, drags and releases, right-button presses and wheel steps in `input`, in order. */
+export function mouseEvents(input) {
+    return [...input.matchAll(MOUSE_REPORT)].map((match) => {
+        const button = Number(match[1]);
+        const x = Number(match[2]) - 1;
+        const y = Number(match[3]) - 1;
+        const kind = button === 64 ? "wheel-up"
+            : button === 65 ? "wheel-down"
+                : button === 0 && match[4] === "m" ? "release"
+                    : button === 0 ? "press"
+                        : button === 32 ? "drag"
+                            : button === 2 && match[4] === "M" ? "right"
+                                : "other";
+        return { kind, x, y };
+    });
+}
+/** True when `input` is only mouse reports (clicks, wheel), never text to type. */
+export function isMouseReport(input) {
+    return input.length > 0 && input.replace(MOUSE_REPORT, "") === "";
+}
+/** Wheel movement in `input`: negative scrolls up, positive down, 0 if none. */
+export function wheelSteps(input) {
+    let steps = 0;
+    for (const match of input.matchAll(MOUSE_REPORT)) {
+        if (match[1] === "64")
+            steps--;
+        else if (match[1] === "65")
+            steps++;
+    }
+    return steps;
+}
+/**
+ * The human's line as a full-width gray bar, bold, as in the Claude Code CLI: wrapped to
+ * `width` and each row padded in columns, so the bar is even whatever the text holds.
+ */
+export function userBarRows(text, width) {
+    return wrapAnsi(text, Math.max(1, width - 1), { hard: true, trim: false })
+        .split("\n")
+        .map((row) => ui.userBar(ui.bold(` ${row}${" ".repeat(Math.max(0, width - 1 - stringWidth(stripAnsi(row))))}`)));
+}
+/**
+ * The history's rows, wrapped to `width`, with a cache that only wraps the lines added
+ * since the last call: the history only grows, and re-wrapping every line on every frame
+ * (up to 30 a second while a reply streams) would get slow in a long session. A different
+ * width, a change of `expand` (Ctrl+O), or a history that didn't just grow, wraps
+ * everything again. Tool groups show their unfolded lines when `expand` is on, and the
+ * human's lines are drawn as bars.
+ */
+export function createRowCache() {
+    let cachedWidth = -1;
+    let cachedExpand = false;
+    let cachedLines = [];
+    let result = { rows: [], continued: [] };
+    return (lines, width, expand = false) => {
+        const grew = width === cachedWidth &&
+            expand === cachedExpand &&
+            lines.length >= cachedLines.length &&
+            lines[cachedLines.length - 1] === cachedLines.at(-1);
+        const fresh = grew ? lines.slice(cachedLines.length) : lines;
+        const rows = [];
+        const continued = [];
+        for (const line of fresh) {
+            const texts = expand && line.expanded ? line.expanded : [line.text];
+            for (const text of texts) {
+                const wrapped = line.kind === "user" ? userBarRows(text, width) : wrapAnsi(text, width, { hard: true, trim: false }).split("\n");
+                wrapped.forEach((row, i) => {
+                    rows.push(row);
+                    continued.push(i > 0);
+                });
+            }
+        }
+        result = grew ? { rows: result.rows.concat(rows), continued: result.continued.concat(continued) } : { rows, continued };
+        cachedWidth = width;
+        cachedExpand = expand;
+        cachedLines = lines;
+        return result;
+    };
+}
+/** The selection's first and last cells, in reading order. */
+export function orderedCells({ anchor, focus }) {
+    const anchorFirst = anchor.row < focus.row || (anchor.row === focus.row && anchor.col <= focus.col);
+    return anchorFirst ? [anchor, focus] : [focus, anchor];
+}
+/** Columns [from, to) of `row` inside the selection, or null if the row is outside it. */
+export function selectedColumns(selection, row, rowWidth) {
+    const [first, last] = orderedCells(selection);
+    if (row < first.row || row > last.row)
+        return null;
+    const from = row === first.row ? first.col : 0;
+    const to = row === last.row ? last.col + 1 : rowWidth;
+    return from < to ? [from, Math.min(to, Math.max(from, rowWidth))] : null;
+}
+/** `row` with the selected columns drawn in inverse video. */
+export function highlightRow(row, selection, index) {
+    if (!selection)
+        return row;
+    const columns = selectedColumns(selection, index, stringWidth(stripAnsi(row)));
+    if (!columns)
+        return row;
+    const [from, to] = columns;
+    return `${sliceAnsi(row, 0, from)}\x1b[7m${stripAnsi(sliceAnsi(row, from, to))}\x1b[27m${sliceAnsi(row, to)}`;
+}
+/**
+ * The selected text, plain: rows joined with line breaks, except where a row only continues
+ * a wrapped line; trailing spaces of each line dropped.
+ */
+export function selectedText(wrapped, selection) {
+    const [first, last] = orderedCells(selection);
+    let text = "";
+    for (let row = first.row; row <= last.row && row < wrapped.rows.length; row++) {
+        const plain = stripAnsi(wrapped.rows[row]);
+        const columns = selectedColumns(selection, row, stringWidth(plain));
+        const piece = columns ? sliceAnsi(plain, columns[0], columns[1]) : "";
+        if (row > first.row && !wrapped.continued[row])
+            text = `${text.trimEnd()}\n`;
+        text += piece;
+    }
+    return text.trimEnd();
+}
+/** OSC 52: sets the system clipboard from the terminal (Windows Terminal supports it). */
+export function clipboardSequence(text) {
+    return `\x1b]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`;
+}
+/** The rows [start, end) shown in `height` rows. */
+export function visibleRows(total, height, anchor) {
+    const end = anchor === null ? total : Math.min(total, anchor + 1);
+    return [Math.max(0, end - height), end];
+}
+/** Moves the view by `delta` rows (negative is up), never above the first page; back to following the bottom once it gets there. */
+export function scrollBy(anchor, delta, total, height) {
+    if (total <= height)
+        return null;
+    const current = anchor ?? total - 1;
+    const next = Math.min(total - 1, Math.max(height - 1, current + delta));
+    return next >= total - 1 ? null : next;
+}
+/** Rows below the view (0 when following the bottom). */
+export function rowsBelow(anchor, total) {
+    return anchor === null ? 0 : Math.max(0, total - 1 - anchor);
+}

package/dist/tui/ink/header.d.ts

@@ -0,0 +1,17 @@
+export interface HeaderInfo {
+    title: string;
+    /** Shown under the title as "name value" pairs, e.g. the workspace or the model. */
+    fields?: Record<string, string>;
+    /**
+     * A small logo drawn left of the title, one string per row, colored as the consumer
+     * likes. One-column characters only (ASCII, box and block characters such as ▄ ▀ █),
+     * never emoji: their width is measured differently by the kit and by the terminal, which
+     * would shift the title (see the feature `ink-claude-style`).
+     */
+    art?: string[];
+}
+/**
+ * The header as screen lines: the art on the left, padded to its widest row in columns,
+ * and the title and fields beside it, vertically centered on the art.
+ */
+export declare function headerLines(header: HeaderInfo): string[];

package/dist/tui/ink/header.js

@@ -0,0 +1,24 @@
+import stringWidth from "string-width";
+import { stripAnsi } from "./lineBuffer.js";
+import * as ui from "../ui.js";
+const GAP = "  ";
+/**
+ * The header as screen lines: the art on the left, padded to its widest row in columns,
+ * and the title and fields beside it, vertically centered on the art.
+ */
+export function headerLines(header) {
+    const fields = Object.entries(header.fields ?? {}).map(([name, value]) => `${ui.dim(name)} ${value}`);
+    const text = [ui.heading(header.title), ...(fields.length > 0 ? [fields.join("   ")] : [])];
+    const art = header.art ?? [];
+    if (art.length === 0)
+        return text;
+    const artWidth = Math.max(...art.map((row) => stringWidth(stripAnsi(row))));
+    const height = Math.max(art.length, text.length);
+    const textTop = Math.floor((height - text.length) / 2);
+    return Array.from({ length: height }, (_, row) => {
+        const left = art[row] ?? "";
+        const padding = " ".repeat(artWidth - stringWidth(stripAnsi(left)));
+        const right = text[row - textTop] ?? "";
+        return right ? `${left}${padding}${GAP}${right}` : left;
+    });
+}

package/dist/tui/ink/inkInteraction.d.ts

@@ -0,0 +1,22 @@
+import type { ApprovalPrompt, InteractionPort } from "../../core/interaction.js";
+export type CheckpointKind = "decision" | "manual-intervention";
+export interface Checkpoint {
+    id: number;
+    kind: CheckpointKind;
+    prompt: ApprovalPrompt;
+    /** Settles the checkpoint with the raw answer ("y", "n", "q" for a decision). */
+    answer(value: string): void;
+}
+export interface InkInteraction {
+    port: InteractionPort;
+    subscribe(listener: () => void): () => void;
+    /** The checkpoint on screen, or null. */
+    getSnapshot(): Checkpoint | null;
+}
+/**
+ * An `InteractionPort` for the Ink views: each checkpoint waits in a queue (the step gate
+ * can fire for several tool calls at once) until the panel answers it, or until the
+ * response file does and the signal drops it. Once settled it is written to the history
+ * through `note` — like the terminal port, it never reaches the session log.
+ */
+export declare function createInkInteraction(note: (text: string) => void): InkInteraction;

package/dist/tui/ink/inkInteraction.js

@@ -0,0 +1,64 @@
+import * as ui from "../ui.js";
+const OUTCOMES = {
+    y: ui.success("✔ Approved"),
+    n: ui.warn("✘ Rejected"),
+    q: ui.error("■ Stopped"),
+};
+/**
+ * An `InteractionPort` for the Ink views: each checkpoint waits in a queue (the step gate
+ * can fire for several tool calls at once) until the panel answers it, or until the
+ * response file does and the signal drops it. Once settled it is written to the history
+ * through `note` — like the terminal port, it never reaches the session log.
+ */
+export function createInkInteraction(note) {
+    const listeners = new Set();
+    let queue = [];
+    let nextId = 0;
+    function emit() {
+        for (const listener of listeners)
+            listener();
+    }
+    function remove(checkpoint) {
+        if (!queue.includes(checkpoint))
+            return false;
+        queue = queue.filter((c) => c !== checkpoint);
+        emit();
+        return true;
+    }
+    function record(prompt, outcome) {
+        note([ui.heading(`=== ${prompt.title} ===`), ...prompt.lines, outcome].join("\n"));
+    }
+    function ask(kind, prompt, signal) {
+        return new Promise((resolve) => {
+            const checkpoint = {
+                id: nextId++,
+                kind,
+                prompt,
+                answer(value) {
+                    if (!remove(checkpoint))
+                        return;
+                    record(prompt, kind === "decision" ? (OUTCOMES[value] ?? value) : ui.success("✔ Done"));
+                    resolve(value);
+                },
+            };
+            signal.addEventListener("abort", () => {
+                if (remove(checkpoint))
+                    record(prompt, ui.dim("(answered through the response file)"));
+            }, { once: true });
+            queue = [...queue, checkpoint];
+            emit();
+        });
+    }
+    return {
+        port: {
+            askDecision: (prompt, signal) => ask("decision", prompt, signal),
+            askManualIntervention: (prompt, signal) => ask("manual-intervention", prompt, signal),
+            notify: (message) => note(message),
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        getSnapshot: () => queue[0] ?? null,
+    };
+}

package/dist/tui/ink/lineBuffer.d.ts

@@ -0,0 +1,28 @@
+export declare function stripAnsi(text: string): string;
+export interface LineBuffer {
+    /** Appends `text`; returns the lines it completed, each self-contained in its colors. */
+    push(text: string): string[];
+    /** The line still being written (e.g. a reply mid-stream), with its colors reopened. */
+    readonly partial: string;
+    /**
+     * Cuts the line in progress into rows of at most `width` columns, at word boundaries,
+     * and returns every full row, leaving only the last one in progress.
+     */
+    wrap(width: number): string[];
+}
+/**
+ * Splits the console renderer's output into whole lines, for Ink's `<Static>`, plus the
+ * line in progress, for the live area. A streamed reply is colored per delta, and a delta
+ * often spans a newline, so a split line would leave its color open on one side and lost
+ * on the other: each completed line is closed with a reset and the next one reopens
+ * whatever was still active.
+ *
+ * `wrap()` exists because Ink redraws the live area by erasing as many rows as it believes
+ * it drew. A line in progress that reaches the terminal's edge can take one row more than
+ * Ink computed, and every redraw then leaves a stale copy of it behind (seen on Windows: a
+ * streamed reply repeated once per spinner frame; likely the console wrapping as soon as the
+ * last column is written, or drawing some emoji wider). Rows cut short of the edge don't.
+ */
+export declare function createLineBuffer(): LineBuffer;
+/** `text` on one row of at most `width` columns, cut with "…" when it doesn't fit. */
+export declare function fitWidth(text: string, width: number): string;

package/dist/tui/ink/lineBuffer.js

@@ -0,0 +1,87 @@
+import wrapAnsi from "wrap-ansi";
+// eslint-disable-next-line no-control-regex -- \x1b is the ESC byte SGR sequences start with, not an accident
+const SGR = /\x1b\[([0-9;]*)m/g;
+// Which attribute each picocolors code opens, and which attributes each code closes.
+const OPENS = {};
+for (const code of [30, 31, 32, 33, 34, 35, 36, 37, 90, 91, 92, 93, 94, 95, 96, 97])
+    OPENS[code] = "fg";
+for (const code of [40, 41, 42, 43, 44, 45, 46, 47, 100, 101, 102, 103, 104, 105, 106, 107])
+    OPENS[code] = "bg";
+Object.assign(OPENS, { 1: "bold", 2: "dim", 3: "italic", 4: "underline", 7: "inverse", 8: "hidden", 9: "strike" });
+const CLOSES = {
+    39: ["fg"],
+    49: ["bg"],
+    22: ["bold", "dim"],
+    23: ["italic"],
+    24: ["underline"],
+    27: ["inverse"],
+    28: ["hidden"],
+    29: ["strike"],
+};
+/** The SGR codes still open at the end of `text`, as a prefix that reopens them. */
+function openStyles(text) {
+    const active = new Map();
+    for (const match of text.matchAll(SGR)) {
+        for (const code of (match[1] || "0").split(";")) {
+            if (code === "0" || code === "")
+                active.clear();
+            else if (OPENS[code])
+                active.set(OPENS[code], code);
+            else
+                for (const attribute of CLOSES[code] ?? [])
+                    active.delete(attribute);
+        }
+    }
+    return [...active.values()].map((code) => `\x1b[${code}m`).join("");
+}
+export function stripAnsi(text) {
+    return text.replace(SGR, "");
+}
+/**
+ * Splits the console renderer's output into whole lines, for Ink's `<Static>`, plus the
+ * line in progress, for the live area. A streamed reply is colored per delta, and a delta
+ * often spans a newline, so a split line would leave its color open on one side and lost
+ * on the other: each completed line is closed with a reset and the next one reopens
+ * whatever was still active.
+ *
+ * `wrap()` exists because Ink redraws the live area by erasing as many rows as it believes
+ * it drew. A line in progress that reaches the terminal's edge can take one row more than
+ * Ink computed, and every redraw then leaves a stale copy of it behind (seen on Windows: a
+ * streamed reply repeated once per spinner frame; likely the console wrapping as soon as the
+ * last column is written, or drawing some emoji wider). Rows cut short of the edge don't.
+ */
+export function createLineBuffer() {
+    let partial = "";
+    return {
+        push(text) {
+            const parts = (partial + text).split("\n");
+            partial = parts.pop() ?? "";
+            const lines = [];
+            let carry = "";
+            for (const part of parts) {
+                const line = carry + part;
+                carry = openStyles(line);
+                lines.push(carry ? `${line}\x1b[0m` : line);
+            }
+            if (lines.length > 0)
+                partial = carry + partial;
+            return lines;
+        },
+        get partial() {
+            return partial;
+        },
+        wrap(width) {
+            // trim: false keeps the space a row ends on, which the next streamed word needs.
+            const rows = wrapAnsi(partial, width, { hard: true, trim: false }).split("\n");
+            if (rows.length <= 1)
+                return [];
+            partial = rows.pop() ?? "";
+            return rows;
+        },
+    };
+}
+/** `text` on one row of at most `width` columns, cut with "…" when it doesn't fit. */
+export function fitWidth(text, width) {
+    const rows = wrapAnsi(text, Math.max(1, width - 1), { wordWrap: false, trim: false }).split("\n");
+    return rows.length > 1 ? `${rows[0]}…` : rows[0];
+}

package/dist/tui/ink/markdown.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Markdown to terminal lines, in the look of the Claude Code CLI: bold, italic, inline code
+ * in blue, lists, headings, quotes, rules, code blocks and tables, wrapped to `width`
+ * columns. `marked` only tokenizes; the drawing is ours, so it stays within the kit's
+ * alignment rules (one-column glyphs, widths in columns).
+ */
+export declare function renderMarkdown(source: string, width: number): string[];
+/**
+ * Where the finished blocks end in a reply still streaming: after its last blank line
+ * outside a code fence. Everything before it renders for good; the rest is still growing.
+ */
+export declare function finishedLength(source: string): number;

package/dist/tui/ink/markdown.js

@@ -0,0 +1,148 @@
+import { marked } from "marked";
+import stringWidth from "string-width";
+import wrapAnsi from "wrap-ansi";
+import { stripAnsi } from "./lineBuffer.js";
+import * as ui from "../ui.js";
+/**
+ * Markdown to terminal lines, in the look of the Claude Code CLI: bold, italic, inline code
+ * in blue, lists, headings, quotes, rules, code blocks and tables, wrapped to `width`
+ * columns. `marked` only tokenizes; the drawing is ours, so it stays within the kit's
+ * alignment rules (one-column glyphs, widths in columns).
+ */
+export function renderMarkdown(source, width) {
+    const tokens = marked.lexer(source, { gfm: true });
+    return renderBlocks(tokens, Math.max(10, width));
+}
+/** `gap`: a blank line between blocks (not inside a tight list item). */
+function renderBlocks(tokens, width, gap = true) {
+    const lines = [];
+    for (const token of tokens) {
+        const block = renderBlock(token, width);
+        if (block === null)
+            continue;
+        if (gap && lines.length > 0)
+            lines.push("");
+        lines.push(...block);
+    }
+    return lines;
+}
+function wrap(text, width) {
+    return wrapAnsi(text, width, { hard: true, trim: false }).split("\n");
+}
+function renderBlock(token, width) {
+    switch (token.type) {
+        case "space":
+        case "def":
+        case "checkbox": // drawn by renderList() as "[x] " before the item's text
+            return null;
+        case "paragraph":
+        case "text":
+            return wrap(inline(token.tokens ?? [], token.text), width);
+        case "heading": {
+            const heading = token;
+            return wrap(ui.bold(inline(heading.tokens, heading.text)), width);
+        }
+        case "hr":
+            return [ui.dim("─".repeat(Math.min(width, 40)))];
+        case "code":
+            return renderCode(token, width);
+        case "blockquote": {
+            const inner = renderBlocks(token.tokens, width - 2);
+            return inner.map((line) => `${ui.dim("│")} ${line}`);
+        }
+        case "list":
+            return renderList(token, width);
+        case "table":
+            return renderTable(token, width);
+        case "html":
+            return wrap(token.raw.trimEnd(), width);
+        default:
+            return wrap(token.raw.trimEnd(), width);
+    }
+}
+function renderCode(token, width) {
+    return token.text.split("\n").flatMap((line) => wrap(ui.code(line), width - 2).map((row) => `  ${row}`));
+}
+function renderList(list, width) {
+    const start = typeof list.start === "number" ? list.start : 1;
+    const lines = [];
+    list.items.forEach((item, index) => {
+        const marker = list.ordered ? `${start + index}.` : "-";
+        const indent = stringWidth(marker) + 1;
+        const body = renderBlocks(item.tokens, width - indent, list.loose);
+        const box = item.task ? (item.checked ? "[x] " : "[ ] ") : "";
+        body.forEach((line, i) => {
+            lines.push(i === 0 ? `${marker} ${box}${line}` : `${" ".repeat(indent)}${line}`);
+        });
+        if (list.loose && index < list.items.length - 1)
+            lines.push("");
+    });
+    return lines;
+}
+function renderTable(table, width) {
+    const cell = (c) => inline(c.tokens, c.text);
+    const header = table.header.map(cell);
+    const rows = table.rows.map((row) => row.map(cell));
+    const widths = header.map((h, i) => Math.max(stringWidth(stripAnsi(h)), ...rows.map((row) => stringWidth(stripAnsi(row[i] ?? "")))));
+    const pad = (text, i) => text + " ".repeat(Math.max(0, widths[i] - stringWidth(stripAnsi(text))));
+    const line = (cells) => cells.map(pad).join("  ").trimEnd();
+    const out = [ui.bold(line(header)), ui.dim(widths.map((w) => "─".repeat(w)).join("  ")), ...rows.map(line)];
+    // A table wider than the room is cut, not wrapped: wrapping would scramble the columns.
+    return out.map((row) => (stringWidth(stripAnsi(row)) > width ? wrapAnsi(row, width, { hard: true, wordWrap: false }).split("\n")[0] : row));
+}
+/** Inline tokens (bold, italic, code, links...) as styled text. */
+function inline(tokens, fallback) {
+    if (tokens.length === 0)
+        return fallback;
+    return tokens
+        .map((token) => {
+        switch (token.type) {
+            case "strong":
+                return ui.bold(inline(token.tokens, token.raw));
+            case "em":
+                return ui.italic(inline(token.tokens, token.raw));
+            case "del":
+                return ui.strike(inline(token.tokens, token.raw));
+            case "codespan":
+                return ui.code(token.text);
+            case "link": {
+                const link = token;
+                const text = inline(link.tokens, link.text);
+                return stripAnsi(text) === link.href ? ui.code(text) : `${ui.code(text)}${ui.dim(` (${link.href})`)}`;
+            }
+            case "image":
+                return ui.dim(`[${token.text}]`);
+            case "br":
+                return "\n";
+            case "escape":
+                return token.text;
+            case "text":
+                return token.tokens ? inline(token.tokens, token.text) : decodeEntities(token.text);
+            default:
+                return token.raw;
+        }
+    })
+        .join("");
+}
+/** The few HTML entities marked leaves in text tokens. */
+function decodeEntities(text) {
+    return text.replace(/&(amp|lt|gt|quot|#39);/g, (_, name) => ({ amp: "&", lt: "<", gt: ">", quot: '"', "#39": "'" })[name] ?? _);
+}
+/**
+ * Where the finished blocks end in a reply still streaming: after its last blank line
+ * outside a code fence. Everything before it renders for good; the rest is still growing.
+ */
+export function finishedLength(source) {
+    let fenceOpen = false;
+    let cut = 0;
+    let offset = 0;
+    for (const line of source.split("\n")) {
+        const end = offset + line.length + 1;
+        if (/^\s*(```|~~~)/.test(line))
+            fenceOpen = !fenceOpen;
+        else if (!fenceOpen && line.trim() === "" && end <= source.length)
+            cut = end;
+        offset = end;
+    }
+    return cut;
+}