tinker-agent 1.0.65 → 1.2.0

package/node_modules/markdansi/dist/stream.d.ts

@@ -0,0 +1,39 @@
+export type MarkdownStreamerSpacing = "preserve" | "single" | "tight";
+export type MarkdownStreamer = {
+    /**
+     * Push an appended Markdown delta (chunk) into the streamer.
+     * Returns ANSI text to write to the terminal (append-only).
+     */
+    push: (delta: string) => string;
+    /**
+     * Flush remaining buffered content and finish the stream.
+     * Optionally accepts one last delta.
+     */
+    finish: (finalDelta?: string) => string;
+    /**
+     * Reset internal state (buffer, fence/table detection, spacing).
+     */
+    reset: () => void;
+};
+export type MarkdownStreamerOptions = {
+    /**
+     * Function used to render a Markdown fragment (block or line) to ANSI.
+     * Must be pure (no cursor control) and must not rely on prior terminal state.
+     */
+    render: (markdown: string) => string;
+    /**
+     * Hybrid streaming: emit complete lines immediately, but buffer multi-line
+     * constructs (fenced code blocks + tables) until they are complete.
+     *
+     * This is designed for terminal scrollback safety: no in-place redraw, no cursor moves.
+     */
+    mode?: "hybrid";
+    /**
+     * Controls how blank lines are emitted.
+     * - preserve: emit blank lines exactly as received
+     * - single: collapse consecutive blank lines to a single blank line
+     * - tight: drop blank lines entirely (dense output)
+     */
+    spacing?: MarkdownStreamerSpacing;
+};
+export declare function createMarkdownStreamer(options: MarkdownStreamerOptions): MarkdownStreamer;

package/node_modules/markdansi/dist/stream.js

@@ -0,0 +1,192 @@
+function normalizeNewlines(input) {
+    return input.replace(/\r\n?/g, "\n");
+}
+function isFenceStart(line) {
+    const trimmed = line.trimStart();
+    const match = trimmed.match(/^(```+|~~~+)/);
+    if (!match?.[1])
+        return null;
+    const token = match[1];
+    const char = token[0] === "~" ? "~" : "`";
+    return { char, len: token.length };
+}
+function isFenceEnd(line, fence) {
+    const trimmed = line.trimStart();
+    const token = fence.char.repeat(fence.len);
+    return trimmed.startsWith(token);
+}
+function looksLikeTableHeader(line) {
+    if (!line.includes("|"))
+        return false;
+    return /[^\s|]/.test(line);
+}
+function isTableSeparator(line) {
+    // Examples:
+    // | --- | --- |
+    // |:--- | ---:|
+    // --- | ---
+    const trimmed = line.trim();
+    if (!trimmed.includes("-"))
+        return false;
+    return /^\|?(?:\s*:?-+:?\s*\|)+\s*:?-+:?\s*\|?$/.test(trimmed);
+}
+function looksLikeTableRow(line) {
+    if (!line.includes("|"))
+        return false;
+    return /[^\s|]/.test(line);
+}
+function normalizeRenderedFragment(rendered) {
+    // Markdansi intentionally prefixes some blocks (e.g. headings) with a newline when rendering
+    // whole documents. For streaming fragments, strip leading newlines to avoid double spacing.
+    const trimmedStart = rendered.replace(/^\n+/, "");
+    // For fragment streaming, normalize to a single trailing newline so spacing is controlled
+    // by the streamer (blank-line collapsing) rather than renderer block heuristics.
+    const trimmedEnd = trimmedStart.replace(/\n+$/, "");
+    return `${trimmedEnd}\n`;
+}
+export function createMarkdownStreamer(options) {
+    const render = options.render;
+    const spacing = options.spacing ?? "single";
+    let buffer = "";
+    let blankStreak = 0;
+    let started = false;
+    let heldTableHeader = null;
+    let inTable = false;
+    let tableBuffer = "";
+    let fence = null;
+    let fenceBuffer = "";
+    const emitBlankLine = () => {
+        if (!started)
+            return "";
+        if (spacing === "tight")
+            return "";
+        if (spacing === "single" && blankStreak >= 1)
+            return "";
+        blankStreak += 1;
+        return "\n";
+    };
+    const emitRendered = (markdown) => {
+        if (!markdown)
+            return "";
+        blankStreak = 0;
+        started = true;
+        return normalizeRenderedFragment(render(markdown));
+    };
+    const flushHeldHeader = () => {
+        if (!heldTableHeader)
+            return "";
+        const md = heldTableHeader;
+        heldTableHeader = null;
+        return emitRendered(md);
+    };
+    const flushTable = () => {
+        if (!inTable)
+            return "";
+        inTable = false;
+        const md = tableBuffer;
+        tableBuffer = "";
+        return emitRendered(md);
+    };
+    const flushFence = () => {
+        if (!fence)
+            return "";
+        fence = null;
+        const md = fenceBuffer;
+        fenceBuffer = "";
+        return emitRendered(md);
+    };
+    const processLine = (line) => {
+        // Fence mode: buffer everything until the closing fence.
+        if (fence) {
+            fenceBuffer += `${line}\n`;
+            if (isFenceEnd(line, fence)) {
+                return flushFence();
+            }
+            return "";
+        }
+        // Table mode: buffer table rows; flush when it ends.
+        if (inTable) {
+            if (line.trim().length === 0) {
+                return flushTable() + emitBlankLine();
+            }
+            if (!looksLikeTableRow(line)) {
+                return flushTable() + processLine(line);
+            }
+            tableBuffer += `${line}\n`;
+            return "";
+        }
+        // Blank line: flush any held header and emit spacing.
+        if (line.trim().length === 0) {
+            return flushHeldHeader() + emitBlankLine();
+        }
+        // Fence start: flush held header and enter fence mode.
+        const fenceStart = isFenceStart(line);
+        if (fenceStart) {
+            const out = flushHeldHeader();
+            fence = fenceStart;
+            fenceBuffer = `${line}\n`;
+            // Some fences are single-line in streams (rare). Handle close immediately.
+            if (isFenceEnd(line, fenceStart) && line.trimStart().match(/^(```+|~~~+)\s*$/)) {
+                return out + flushFence();
+            }
+            return out;
+        }
+        // If we held a possible table header, check if this line starts a table.
+        if (heldTableHeader) {
+            if (isTableSeparator(line) && looksLikeTableHeader(heldTableHeader)) {
+                inTable = true;
+                tableBuffer = `${heldTableHeader}\n${line}\n`;
+                heldTableHeader = null;
+                return "";
+            }
+            const out = flushHeldHeader();
+            return out + processLine(line);
+        }
+        // Potential table header: delay emission until we see the next line.
+        if (looksLikeTableHeader(line)) {
+            heldTableHeader = line;
+            return "";
+        }
+        // Normal line: render immediately.
+        return emitRendered(line);
+    };
+    const push = (delta) => {
+        if (!delta)
+            return "";
+        buffer += normalizeNewlines(delta);
+        let out = "";
+        while (true) {
+            const idx = buffer.indexOf("\n");
+            if (idx < 0)
+                break;
+            const line = buffer.slice(0, idx);
+            buffer = buffer.slice(idx + 1);
+            out += processLine(line);
+        }
+        return out;
+    };
+    const finish = (finalDelta) => {
+        let out = "";
+        if (finalDelta)
+            out += push(finalDelta);
+        if (buffer.length > 0) {
+            out += processLine(buffer);
+            buffer = "";
+        }
+        out += flushHeldHeader();
+        out += flushFence();
+        out += flushTable();
+        return out;
+    };
+    const reset = () => {
+        buffer = "";
+        blankStreak = 0;
+        started = false;
+        heldTableHeader = null;
+        inTable = false;
+        tableBuffer = "";
+        fence = null;
+        fenceBuffer = "";
+    };
+    return { push, finish, reset };
+}

package/node_modules/markdansi/dist/theme.d.ts

@@ -0,0 +1,18 @@
+import type { StyleIntent, Theme } from "./types.js";
+export interface Themes {
+    default: Theme;
+    dim: Theme;
+    bright: Theme;
+    solarized: Theme;
+    monochrome: Theme;
+    contrast: Theme;
+    [key: string]: Theme;
+}
+export declare const themes: Themes;
+export type Styler = (text: string, style?: StyleIntent) => string;
+/**
+ * Create a Chalk-based styling helper that applies StyleIntent safely.
+ */
+export declare function createStyler({ color }: {
+    color: boolean;
+}): Styler;

package/node_modules/markdansi/dist/theme.js

@@ -0,0 +1,105 @@
+import { Chalk } from "chalk";
+const base = {
+    heading: { color: "yellow", bold: true },
+    strong: { bold: true },
+    emph: { italic: true },
+    inlineCode: { color: "cyan" },
+    blockCode: { color: "green" },
+    link: { color: "blue", underline: true },
+    quote: { dim: true },
+    hr: { dim: true },
+    listMarker: { color: "cyan" },
+    tableHeader: { bold: true, color: "yellow" },
+    tableCell: {},
+};
+const dim = {
+    ...base,
+    heading: { color: "white", bold: true, dim: true },
+    link: { color: "blue", underline: true, dim: true },
+};
+const bright = {
+    ...base,
+    heading: { color: "magenta", bold: true },
+    link: { color: "cyan", underline: true },
+    inlineCode: { color: "green" },
+    blockCode: { color: "green" },
+};
+const solarized = {
+    heading: { color: "yellow", bold: true },
+    strong: { bold: true },
+    emph: { italic: true },
+    inlineCode: { color: "cyan" },
+    blockCode: { color: "#2aa198" },
+    link: { color: "blue", underline: true },
+    quote: { color: "white", dim: true },
+    hr: { color: "white", dim: true },
+    listMarker: { color: "cyan" },
+    tableHeader: { color: "yellow", bold: true },
+};
+const monochrome = {
+    heading: { bold: true },
+    strong: { bold: true },
+    emph: { italic: true },
+    inlineCode: { dim: true },
+    blockCode: { dim: true },
+    link: { underline: true },
+    quote: { dim: true },
+    hr: { dim: true },
+    listMarker: { dim: true },
+    tableHeader: { bold: true },
+};
+const contrast = {
+    heading: { color: "magenta", bold: true },
+    strong: { color: "white", bold: true },
+    emph: { color: "white", italic: true },
+    inlineCode: { color: "cyan", bold: true },
+    blockCode: { color: "green", bold: true },
+    link: { color: "blue", underline: true },
+    quote: { color: "white", dim: true },
+    hr: { color: "white", dim: true },
+    listMarker: { color: "yellow", bold: true },
+    tableHeader: { color: "yellow", bold: true },
+    tableCell: { color: "white" },
+};
+export const themes = {
+    default: Object.freeze(base),
+    dim: Object.freeze(dim),
+    bright: Object.freeze(bright),
+    solarized: Object.freeze(solarized),
+    monochrome: Object.freeze(monochrome),
+    contrast: Object.freeze(contrast),
+};
+/**
+ * Create a Chalk-based styling helper that applies StyleIntent safely.
+ */
+export function createStyler({ color }) {
+    const level = color ? 3 : 0;
+    const chalk = new Chalk({ level });
+    const apply = (text, style = {}) => {
+        if (!color)
+            return text;
+        let fn = chalk;
+        if (style.color) {
+            const indexed = fn;
+            if (indexed[style.color])
+                fn = indexed[style.color];
+        }
+        if (style.bgColor) {
+            const indexed = fn;
+            if (indexed[style.bgColor])
+                fn = indexed[style.bgColor];
+        }
+        if (style.bold)
+            fn = fn.bold;
+        if (style.italic)
+            fn = fn.italic;
+        if (style.underline)
+            fn = fn.underline;
+        if (style.dim)
+            fn = fn.dim;
+        if (style.strike)
+            fn = fn.strikethrough;
+        return fn(text);
+    };
+    return apply;
+}

package/node_modules/markdansi/dist/types.d.ts

@@ -0,0 +1,58 @@
+export type ColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | `#${string}` | `${number}`;
+export type StyleIntent = {
+    color?: ColorName;
+    bgColor?: ColorName;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+    strike?: boolean;
+};
+export type Theme = {
+    heading?: StyleIntent;
+    strong?: StyleIntent;
+    emph?: StyleIntent;
+    inlineCode?: StyleIntent;
+    blockCode?: StyleIntent;
+    code?: StyleIntent;
+    link?: StyleIntent;
+    quote?: StyleIntent;
+    hr?: StyleIntent;
+    listMarker?: StyleIntent;
+    tableHeader?: StyleIntent;
+    tableCell?: StyleIntent;
+};
+export type ThemeName = "default" | "dim" | "bright";
+export type Highlighter = (code: string, lang?: string) => string;
+export interface RenderOptions {
+    wrap?: boolean;
+    width?: number;
+    hyperlinks?: boolean;
+    color?: boolean;
+    theme?: ThemeName | Theme;
+    /**
+     * Spaces per nesting level for lists (default 2).
+     */
+    listIndent?: number;
+    /**
+     * Prefix used for blockquotes (default "│ ").
+     */
+    quotePrefix?: string;
+    /** Table border style: unicode (default), ascii, or none. */
+    tableBorder?: "unicode" | "ascii" | "none";
+    /** Spaces around cell content (default 1). */
+    tablePadding?: number;
+    /** If true, reduces separator rows (default false). */
+    tableDense?: boolean;
+    /** If true, truncates cell content to fit column width (default true). */
+    tableTruncate?: boolean;
+    /** Ellipsis text for truncation (default "…"). */
+    tableEllipsis?: string;
+    /** Draw a box around fenced code blocks (default true). */
+    codeBox?: boolean;
+    /** Show line-number gutter for code blocks (default false). */
+    codeGutter?: boolean;
+    /** Wrap code lines to width; otherwise overflow (default true). */
+    codeWrap?: boolean;
+    highlighter?: Highlighter;
+}

package/node_modules/markdansi/dist/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/markdansi/dist/wrap.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Visible width of a string, ignoring ANSI escape codes.
+ */
+export declare function visibleWidth(text: string): number;
+/**
+ * Wrap a single paragraph string into lines respecting visible width.
+ * Breaks only on spaces. Words longer than width overflow.
+ */
+export declare function wrapText(text: string, width: number, wrap: boolean): string[];
+export declare function wrapWithPrefix(text: string, width: number, wrap: boolean, prefix?: string): string[];

package/node_modules/markdansi/dist/wrap.js

@@ -0,0 +1,73 @@
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+/**
+ * Visible width of a string, ignoring ANSI escape codes.
+ */
+export function visibleWidth(text) {
+    return stringWidth(stripAnsi(text));
+}
+/**
+ * Wrap a single paragraph string into lines respecting visible width.
+ * Breaks only on spaces. Words longer than width overflow.
+ */
+export function wrapText(text, width, wrap) {
+    if (!wrap || width <= 0)
+        return [text];
+    const words = text.split(/(\s+)/).filter((w) => w.length > 0);
+    const lines = [];
+    let current = "";
+    let currentWidth = 0;
+    const trimEndSpaces = (s) => s.replace(/\s+$/, "");
+    const orphanPhraseTail = (s) => {
+        const trimmed = trimEndSpaces(s);
+        const phrase = trimmed.match(/\b(with|in|on|of|to|for)\s+(a|an|the)$/i);
+        if (phrase) {
+            const preposition = phrase[1];
+            const article = phrase[2];
+            if (preposition && article)
+                return `${preposition} ${article}`;
+        }
+        const single = trimmed.match(/\b(a|an|the|to|of|with|and|or|in|on|for)$/i);
+        return single?.[1] ?? null;
+    };
+    for (const word of words) {
+        const w = visibleWidth(word);
+        if (current !== "" && currentWidth + w > width && !/^\s+$/.test(word)) {
+            const nextWord = word.replace(/^\s+/, "");
+            const currentNoTrail = trimEndSpaces(current);
+            const tail = orphanPhraseTail(currentNoTrail);
+            if (tail && currentNoTrail.length > tail.length) {
+                const base = trimEndSpaces(currentNoTrail.slice(0, currentNoTrail.length - tail.length));
+                if (base !== "") {
+                    lines.push(base);
+                    current = `${tail} ${nextWord}`;
+                    currentWidth = visibleWidth(current);
+                    continue;
+                }
+            }
+            lines.push(currentNoTrail);
+            current = nextWord;
+            currentWidth = visibleWidth(current);
+            continue;
+        }
+        current += word;
+        currentWidth = visibleWidth(current);
+    }
+    if (current !== "")
+        lines.push(trimEndSpaces(current));
+    if (lines.length === 0)
+        lines.push("");
+    return lines;
+}
+export function wrapWithPrefix(text, width, wrap, prefix = "") {
+    if (!wrap)
+        return text.split("\n").map((line) => prefix + line);
+    const out = [];
+    const w = Math.max(1, width - visibleWidth(prefix));
+    for (const line of text.split("\n")) {
+        const parts = wrapText(line, w, wrap);
+        for (const p of parts)
+            out.push(prefix + p);
+    }
+    return out;
+}

package/node_modules/markdansi/docs/spec.md

@@ -0,0 +1,110 @@
+# Markdansi v0.1.2 – Design Spec
+
+Goal: Tiny, dependency‑light Markdown → ANSI renderer & CLI for Node ≥22, using pnpm. Output is terminal ANSI only (no HTML). Focus on readable defaults, sensible wrapping, and minimal runtime deps.
+
+## Core Dependencies (runtime)
+
+- `marked`: GFM parsing (tables, task lists, strikethrough, autolink literals).
+- `decode-named-character-reference`: decode Markdown character references in text and URLs.
+- `chalk`: small, ESM‑only color/style helper.
+- `string-width`: correct visible width (emoji / wide chars).
+- `strip-ansi`: strip codes for width/wrapping.
+- `supports-hyperlinks`: detect OSC‑8 hyperlink support.
+
+Dev: `vitest`, TypeScript (NodeNext).
+
+## Surface Area
+
+### Library (ESM default, CJS export provided)
+
+`render(markdown: string, options?: RenderOptions): string`
+
+`createRenderer(options?: RenderOptions): (md: string) => string`
+
+`type RenderOptions = {`
+`  wrap?: boolean;            // default: true; if false => no hard wraps anywhere`
+`  width?: number;            // used only when wrap===true; default: TTY cols or 80`
+`  hyperlinks?: boolean;      // default: auto via supports-hyperlinks`
+`  color?: boolean;           // default: true if TTY; if false => no ANSI/OSC at all`
+`  theme?: ThemeName | Theme; // built-ins: default, dim, bright, solarized, monochrome, contrast`
+`  listIndent?: number;       // spaces per nesting level; default 2`
+`  quotePrefix?: string;      // blockquote line prefix; default "│ "`
+`  tableBorder?: "unicode" | "ascii" | "none"; // default unicode box drawing`
+`  tablePadding?: number;     // spaces inside cells (L/R); default 1`
+`  tableDense?: boolean;      // reduce separator rows; default false`
+`  tableTruncate?: boolean;   // truncate cells to fit col widths; default true`
+`  tableEllipsis?: string;    // truncation marker; default "…"`
+`  codeBox?: boolean;         // draw a box around fenced code; default true`
+`  codeGutter?: boolean;      // left gutter with line numbers; default false`
+`  codeWrap?: boolean;        // wrap code to width; default true`
+`  highlighter?: (code: string, lang?: string) => string; // hook, must not add newlines`
+`}``
+
+`type Theme = { heading, strong, emph, inlineCode, blockCode, code?, link, quote, hr, listMarker, tableHeader, tableCell, tableBorder, tableSeparator }`
+Each theme entry holds simple SGR intents (bold/italic/fg color names). `inlineCode` / `blockCode` are used if present; otherwise `code` acts as a fallback for both. Theme exposes defaults for table borders/separators; caller can override per render via options above.
+
+`strip(markdown: string): string` — convenience: render with `color=false`, `hyperlinks=false`.
+
+### CLI
+
+`markdansi [FILE] [--in FILE] [--out FILE] [--width N] [--no-wrap] [--no-color] [--no-links] [--theme default|dim|bright]`
+
+- Input: positional `FILE`, `--in FILE`, or stdin when neither is given.
+- Output: stdout if no `--out`.
+- Wrap: on by default; `--no-wrap` disables; width auto from TTY when not provided.
+- Links: OSC‑8 hyperlinks enabled when terminal supports; `--no-links` disables.
+
+## Feature Scope (v1)
+
+- Blocks: paragraphs, headings (1–6), blockquotes, fenced/indented code blocks, HR, tables, unordered/ordered lists, task lists.
+- Inline: strong, emphasis, code spans, autolinks/links, strikethrough (GFM `~~`), backslash escapes.
+- Code blocks: monospace box (unicode or ascii; `codeBox=false` disables). Optional gutter with 1‑based line numbers when `codeGutter=true`. If `lang` present, show faint header label. Highlighter hook may recolor text but must not add/remove newlines. Code blocks wrap to the available width by default (hard-wrap long tokens); set `codeWrap=false` to allow overflow.
+- Tables: box-drawing (unicode default, ascii or none). Respect GFM alignment per column, pad cells by `tablePadding`, optional dense borders. Can truncate cell text (`tableTruncate=true`, `tableEllipsis` marker) to keep width. Width balancing shrinks columns while possible; if still too wide, cells overflow.
+- Wrapping: word-wrap on spaces; uses `string-width` on stripped text. Preserve hard breaks; words longer than width may overflow. Code blocks wrap by default; turn off with `codeWrap=false`.
+- Hyperlinks: OSC‑8 when supported and allowed; fallback to underlined text plus URL in parentheses.
+- Error handling: never throw on malformed emphasis; leave literals untouched if unmatched.
+
+## Rendering Pipeline
+
+1. **Parse** via Marked's GFM lexer → lightweight internal AST.
+2. **Build light IR** (nodes: paragraph, heading, list, listItem, taskItem, table, tableRow, tableCell, code, inline text/emph/strong/del/code/link).
+3. **Render** to ANSI:
+   - Style map from theme to SGR codes.
+   - Wrap paragraphs/table cells using `string-width` + `strip-ansi`; wrap only breaks on spaces.
+   - OSC‑8 links when `hyperlinks` true; otherwise underline + optional URL suffix.
+   - Track active SGR for wrapping splits to re-open styles on new lines.
+
+## Themes (initial)
+
+- `default`: bold headings, blue links, cyan inline code, green block code, yellow table headers, subtle quotes/hr.
+- `dim`: muted colors for low-contrast terminals.
+- `bright`: higher contrast variant.
+- `solarized`: yellow headings, cyan inline, teal block code, blue links, yellow headers.
+- `monochrome`: bold/italic cues only, dim code, underlined links.
+- `contrast`: magenta headings, cyan inline, green block code, yellow headers, bright markers.
+
+## Testing (vitest)
+
+- Unit: inline formatting (emph/strong/code/strike), links/hyperlinks on/off, wrap/no-wrap behavior, table alignment and wrapping, task lists, strikethrough.
+- Snapshot-ish string comparisons for representative documents (with colors off to avoid brittle codes).
+
+## Non-Goals (v1)
+
+- Images, footnotes, math, HTML passthrough, syntax highlighting bundle.
+
+## Notes
+
+- Highlighting: built-in is “label-only”; extensibility via `highlighter` hook. No extra deps added for highlighting.
+- ESM-first; provide CJS export entry for compatibility.
+
+## Behaviors & edge-case rules
+
+- Wrap/width precedence: `wrap=false` disables all hard wrapping; `width` is ignored in that mode. When `wrap=true`, width is `options.width ?? ttyColumns ?? 80`.
+- Color flag: `color=false` removes all ANSI/OSC output (no bold/italic/underline, no hyperlinks); output is plain text.
+- Hyperlinks fallback: inline links render as `label (url)` when OSC‑8 disabled; autolinks render as the URL only. URLs count toward width.
+- Highlighter hook: receives raw code and optional lang; may return ANSI-colored text but must not add or remove newlines. Markdansi owns indentation/padding; code blocks never hard-wrap.
+- Tables width algorithm: compute desired column widths from content (cap at e.g. 40). While total exceeds width, decrement widest columns until it fits; if even minimums won’t fit, allow overflow. Respect GFM alignment per column. Cells with newlines keep those breaks. Optional truncation shortens cells before layout with `tableEllipsis`.
+- Lists: honor GFM tight vs loose lists (tight => no blank line between items; loose => blank line). Nesting indent = 2 spaces per level; bullets use `-`; ordered lists use input numbering.
+- Blockquotes: prefix each wrapped line with `│ ` (configurable via `quotePrefix`); quote content wraps accounting for the prefix width.
+- List indent is configurable via `listIndent` (default 2 spaces per level).
+- Reference-style definitions with indented title continuations are merged into a single paragraph (instead of becoming indented code blocks), preventing stray boxed output in copied logs.