@illuminis/comprism 0.1.3 → 0.1.5

package/out/agent/render.js

@@ -22,23 +22,32 @@
  * symbol as well as a color.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gray = exports.yellow = exports.green = exports.red = exports.bold = exports.dim = void 0;
+exports.violet = exports.gray = exports.yellow = exports.green = exports.red = exports.bold = exports.dim = void 0;
+exports.modelName = modelName;
 exports.money = money;
 exports.duration = duration;
 exports.action = action;
+exports.actionName = actionName;
 exports.reusePct = reusePct;
 exports.step = step;
 exports.todos = todos;
+exports.question = question;
 exports.diff = diff;
+exports.stoppedLines = stoppedLines;
+exports.ending = ending;
 exports.outcome = outcome;
+exports.link = link;
+exports.savedFile = savedFile;
 exports.receipt = receipt;
 exports.plain = plain;
 /** Built from a character code rather than written as a literal escape, so this
  *  file contains no control characters and stays safe to grep, diff and paste. */
+const url_1 = require("url");
 const CSI = String.fromCharCode(27) + "[";
-const supportsColour = process.stdout.isTTY && process.env.NO_COLOR === undefined;
+/** Decided when drawn, so plain mode set at start up applies (manual 6.12). */
+const supportsColour = () => process.stdout.isTTY && !process.env.NO_COLOR;
 function paint(code, text) {
-    return supportsColour ? CSI + code + "m" + text + CSI + "0m" : text;
+    return supportsColour() ? CSI + code + "m" + text + CSI + "0m" : text;
 }
 const dim = (t) => paint("2", t);
 exports.dim = dim;
@@ -52,6 +61,34 @@ const yellow = (t) => paint("33", t);
 exports.yellow = yellow;
 const gray = (t) => paint("90", t);
 exports.gray = gray;
+/** The brand's violet, for model names and the receipt's label. */
+const violet = (t) => paint("38;5;141", t);
+exports.violet = violet;
+/** The rail down the left of a job's steps, as the website draws it. */
+const rail = () => (0, exports.dim)("\u2502");
+const TICK = "\u2713";
+const CROSS = "\u2717";
+/** What a person sees, with color and link escapes taken out, so lines can be
+ *  measured and padded. */
+function visible(text) {
+    const esc = String.fromCharCode(27);
+    return text
+        .replace(new RegExp(`${esc}\\][^${String.fromCharCode(7)}${esc}]*(?:${String.fromCharCode(7)}|${esc}\\\\)`, "g"), "")
+        .replace(new RegExp(`${esc}\\[[0-9;]*m`, "g"), "");
+}
+function width() {
+    return Math.max(60, Math.min(process.stdout.columns || 100, 110));
+}
+/** `claude-haiku-4-5` as a person says it, `Claude Haiku 4.5`. Other vendors'
+ *  ids are shown as they arrive: a wrong guess at a name is worse than the id. */
+function modelName(id) {
+    const m = /^claude-([a-z]+)-(\d+)(?:-(\d+))?$/.exec(id);
+    if (!m)
+        return id;
+    const word = m[1] ?? "";
+    const family = word.charAt(0).toUpperCase() + word.slice(1);
+    return `Claude ${family} ${m[2]}${m[3] ? `.${m[3]}` : ""}`;
+}
 /** Money, at the precision a person can act on.
  *
  *  Four decimal places below a cent, because a coding step often costs less
@@ -70,9 +107,16 @@ function duration(ms) {
 /** One action, as it happens. A word as well as a color, so this still reads
  *  when piped to a file. */
 function action(name, target, ok, ms) {
-    const mark = ok ? (0, exports.green)("ok  ") : (0, exports.red)("fail");
+    // A tick or a cross on the rail, as the website draws a job. A failure also
+    // says so in words, so it still reads in a log with no color.
+    const mark = ok ? (0, exports.green)(TICK) : (0, exports.red)(`${CROSS} failed`);
     const tail = ms ? (0, exports.dim)(`  ${duration(ms)}`) : "";
-    return `  ${mark} ${(0, exports.bold)(name)} ${(0, exports.dim)(target)}${tail}`;
+    return `  ${rail()} ${mark} ${(0, exports.bold)(actionName(name))} ${(0, exports.dim)(target)}${tail}`;
+}
+/** A connected tool as people write it, `server.tool` (manual 9.10). */
+function actionName(name) {
+    const m = /^connected__(.+?)__(.+)$/.exec(name);
+    return m ? `${m[1]}.${m[2]}` : name;
 }
 /** The share of a step's context the provider served from its cache, or null
  *  when it reported no counts. Anthropic counts cached tokens OUTSIDE the input
@@ -89,9 +133,16 @@ function reusePct(tokensIn, cacheRead, cacheWrite) {
  *  provider had already seen. The last figure is the one study 005 found
  *  missing from our receipt: without it nobody could tell a warm step from a
  *  cold one, and every step was cold. */
-function step(index, model, usd, ms, reused = null) {
+function step(index, model, usd, ms, reused = null, reason = "") {
     const warm = reused === null ? "" : `  cached ${reused}%`;
-    return (0, exports.dim)(`  step ${index}  ${model || "?"}  ${money(usd)}  ${duration(ms)}${warm}`);
+    // The model that ran and why, in the service's words (manual 4.16).
+    const why = reason ? `  chosen: ${reason}` : "";
+    // The step and why its model was chosen on the left, the model on the right,
+    // as the website draws a job; the cost and timing follow, quieter.
+    const left = `  ${rail()} ${(0, exports.dim)(`step ${index}${why}`)}`;
+    const right = `${(0, exports.violet)(modelName(model || "?"))}${(0, exports.dim)(`  ${money(usd)}  ${duration(ms)}${warm}`)}`;
+    const gap = Math.max(2, width() - visible(left).length - visible(right).length - 2);
+    return `${left}${" ".repeat(gap)}${right}`;
 }
 /** The task list, reprinted whenever it changes.
  *
@@ -99,24 +150,33 @@ function step(index, model, usd, ms, reused = null) {
  *  is worth keeping, and it is often the fastest way to see where a job went off
  *  course. */
 function todos(items) {
+    // Drawn as manual 4.4 shows it: [x] done, [>] in progress, [ ] not yet.
     if (!items.length)
         return "";
     const rows = items.map((t) => {
-        const mark = t.status === "completed" ? (0, exports.green)("done")
-            : t.status === "in_progress" ? (0, exports.yellow)("now ") : (0, exports.dim)("todo");
+        const mark = t.status === "completed" ? (0, exports.green)("[x]")
+            : t.status === "in_progress" ? (0, exports.yellow)("[>]") : (0, exports.dim)("[ ]");
         const text = t.status === "completed" ? (0, exports.dim)(t.content) : t.content;
-        return `    ${mark}  ${text}`;
+        return `  ${mark} ${text}`;
     });
-    return `\n  ${(0, exports.bold)("Plan")}\n${rows.join("\n")}\n`;
+    return `${rows.join("\n")}\n`;
+}
+/** A question from the agent, or the plan question (manual 4.2, 4.3). The
+ *  wording is the service's; this only lays it out. */
+function question(q, options) {
+    const lines = [`  ${(0, exports.bold)("Question:")} ${q}`];
+    options.forEach((o, i) => lines.push(`  ${i + 1}  ${o}`));
+    return `\n${lines.join("\n")}\n`;
 }
 /** A change, before it is made.
  *
  *  Full text for a small edit and a summary for a large one. Pasting four
  *  hundred lines into a terminal is not review, it is a wall somebody presses
  *  through, and an approval people press through protects nobody. */
-function diff(name, input) {
+function diff(name, input, withHead = true) {
     const target = String(input.path ?? input.to ?? "");
-    const head = `\n  ${(0, exports.bold)(name)} ${target}\n`;
+    // Without the heading under an action line that already names the file.
+    const head = withHead ? `\n  ${(0, exports.bold)(name)} ${target}\n` : "";
     const show = (from, to) => {
         const before = from.split("\n"), after = to.split("\n");
         if (before.length + after.length > 60) {
@@ -142,6 +202,12 @@ function diff(name, input) {
         }
         return head + `    ${(0, exports.dim)(`${lines.length} lines, ${bodyText.length.toLocaleString()} characters`)}\n`;
     }
+    if (name === "git_commit") {
+        // What will be committed, shown before it is (manual 5.17).
+        const files = input.paths ?? [];
+        return `\n  ${(0, exports.bold)("git_commit")}\n    files    ${files.join(", ") || (0, exports.dim)("none")}\n`
+            + `    message  ${String(input.message ?? "").split("\n")[0]}\n`;
+    }
     if (name === "run_command" || name === "run_background") {
         return `\n  ${(0, exports.bold)("run")} ${String(input.command ?? "")}\n`;
     }
@@ -154,6 +220,22 @@ function diff(name, input) {
     }
     return head;
 }
+/** What was stopped when a session ended, one line each (manual 5.13). */
+function stoppedLines(stopped) {
+    if (!stopped.length)
+        return "";
+    return (0, exports.dim)(`  stopped the background process${stopped.length === 1 ? "" : "es"} this session started:\n`)
+        + stopped.map((l) => (0, exports.dim)(`    ${l}\n`)).join("");
+}
+/** The first line of a finished job, as the service wrote it (manual 5.15).
+ *  Colored by its first word only; the words are the service's. */
+function ending(line, detail) {
+    const paint = /^Done$/.test(line) ? exports.green : /^Done,/.test(line) ? exports.yellow
+        : /^(Stopped|Incomplete)/.test(line) ? exports.red : (t) => t;
+    // The service may put the same words in both; they are said once.
+    const extra = detail && detail !== line ? (0, exports.dim)(`  ${detail}`) : "";
+    return `\n${paint(line)}${extra}\n`;
+}
 /** How the job ended, in the words a person reads. */
 function outcome(o, detail) {
     const word = {
@@ -163,6 +245,8 @@ function outcome(o, detail) {
         spend_limit: (0, exports.yellow)("Stopped at the spending limit"),
         failed: (0, exports.red)("Could not finish"),
         refused: (0, exports.red)("Refused"),
+        busy: (0, exports.yellow)("Busy"),
+        unknown: (0, exports.yellow)("Outcome unknown"),
     };
     return `\n${word[o] ?? o}${detail ? (0, exports.dim)(`  ${detail}`) : ""}\n`;
 }
@@ -179,6 +263,32 @@ function link(text, url) {
         return `${text} (${url})`;
     return `]8;;${url}${text}]8;;`;
 }
+/**
+ * A file the agent made, as a link that opens it, with where it lives beneath.
+ *
+ * The name alone is not enough: somebody who asked from their home folder for a
+ * diagram cannot tell which folder "saved diagram.png" means. So the full path
+ * is written out underneath in gray, where it can be copied into Finder or a
+ * terminal, and the name above it opens the file on a click.
+ */
+function savedFile(name, fullPath, bytes) {
+    const href = (0, url_1.pathToFileURL)(fullPath).href;
+    return `${(0, exports.green)("  saved  ")}${link(name, href)}${(0, exports.dim)(`  ${bytes} bytes`)}\n`
+        + `${(0, exports.gray)(`         ${fullPath}`)}\n`;
+}
+/** The card's two lines, as the approved look draws them. */
+function cardRows(card) {
+    const rows = [];
+    const head = [card.title ? (0, exports.bold)(card.title) : "", card.badge ? (0, exports.violet)(card.badge) : "",
+        card.vs ? (0, exports.dim)(card.vs) : ""].filter(Boolean).join(" ");
+    if (head)
+        rows.push(head);
+    if (card.amount)
+        rows.push(card.saved ? (0, exports.bold)((0, exports.green)(card.amount)) : (0, exports.dim)(card.amount));
+    if (card.warning)
+        rows.push((0, exports.dim)(card.warning));
+    return rows;
+}
 /**
  * The receipt under a finished job.
  *
@@ -195,9 +305,9 @@ function link(text, url) {
  * it, quieten it, and turn the address in it into something clickable. That is
  * formatting, which belongs to the client, and it is the only part that does.
  */
-function receipt(text, models = [], testsPassed) {
-    const lines = [];
-    for (const line of String(text || "").split("\n")) {
+function receipt(text, models = [], testsPassed, card) {
+    const lines = card ? cardRows(card).map((r) => `  ${r}`) : [];
+    for (const line of card ? [] : String(text || "").split("\n")) {
         if (!line.trim())
             continue;
         // The address our server put in the sentence becomes a real link, and the
@@ -224,32 +334,324 @@ function receipt(text, models = [], testsPassed) {
     if (testsPassed !== undefined) {
         lines.push(testsPassed ? (0, exports.green)("  tests passed") : (0, exports.red)("  tests failed"));
     }
-    return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+    if (!lines.length)
+        return "";
+    // On a screen, the receipt is a highlighted box, as on the website. Piped to
+    // a file or another program it stays plain lines, which is what a log wants.
+    if (card) {
+        // The link the server put in its sentence still goes last.
+        const found = /\[([^\]]+)\]\(([^)]+)\)/.exec(String(text || ""));
+        if (found)
+            lines.push((0, exports.dim)(`  ${link(String(card.details || found[1]), String(found[2]))}`));
+    }
+    return process.stdout.isTTY ? boxed(text, models, testsPassed, card) : `${lines.join("\n")}\n`;
+}
+/** Words wrapped to a width, never breaking a word. */
+function wrap(text, room) {
+    const out = [];
+    let line = "";
+    for (const word of text.split(/\s+/).filter(Boolean)) {
+        if (line && line.length + 1 + word.length > room) {
+            out.push(line);
+            line = word;
+        }
+        else
+            line = line ? `${line} ${word}` : word;
+    }
+    if (line)
+        out.push(line);
+    return out;
+}
+/**
+ * The receipt in a rounded box: `receipt` as its label, the saving in green,
+ * everything else quiet. The server's words are unchanged; each clause it
+ * separated with `|` gets its own line, and its link goes last, clickable.
+ */
+function boxed(text, models, testsPassed, card) {
+    // Room for the border, the padding and the `receipt` label on the first line.
+    const inner = width() - 16;
+    const rows = card ? cardRows(card) : [];
+    const links = [];
+    for (const raw of String(text || "").split("\n")) {
+        if (card) {
+            // The card carries the words; only the sentence's link is kept.
+            raw.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, label, url) => {
+                links.push({ label: String(card.details || label), url: String(url) });
+                return "";
+            });
+            continue;
+        }
+        const withoutLinks = raw.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, label, url) => {
+            links.push({ label: String(label), url: String(url) });
+            return "";
+        });
+        for (const clause of withoutLinks.split("|").map((c) => c.trim()).filter(Boolean)) {
+            const paintIt = /\bsaved\b/i.test(clause) ? exports.green : exports.dim;
+            for (const piece of wrap(clause, inner))
+                rows.push(paintIt(piece));
+        }
+    }
+    const priced = models.filter((m) => m.model);
+    if (priced.length > 1) {
+        const order = [...priced].sort((a, b) => (a.usd ?? 0) - (b.usd ?? 0));
+        const w = Math.max(...order.map((m) => modelName(String(m.model)).length));
+        for (const m of order) {
+            const steps = `${m.steps} step${m.steps === 1 ? "" : "s"}`;
+            const cost = m.usd === null || m.usd === undefined ? "not priced" : money(m.usd);
+            rows.push(`${(0, exports.violet)(modelName(String(m.model)).padEnd(w))}${(0, exports.dim)(`  ${steps.padEnd(9)}  ${cost}`)}`);
+        }
+    }
+    if (testsPassed !== undefined)
+        rows.push(testsPassed ? (0, exports.green)("tests passed") : (0, exports.red)("tests failed"));
+    for (const l of links)
+        rows.push((0, exports.dim)(link(l.label, l.url)));
+    if (rows.length)
+        rows[0] = `${(0, exports.violet)("receipt")} ${rows[0]}`;
+    const widest = Math.max(...rows.map((r) => visible(r).length));
+    const bar = "\u2500".repeat(widest + 2);
+    const body = rows.map((r) => `  ${(0, exports.violet)("\u2502")} ${r}${" ".repeat(widest - visible(r).length)} ${(0, exports.violet)("\u2502")}`);
+    return [`  ${(0, exports.violet)(`\u256d${bar}\u256e`)}`, ...body, `  ${(0, exports.violet)(`\u2570${bar}\u256f`)}`].join("\n") + "\n";
+}
+/** A markdown table's cells, with emphasis and code marks taken off and a
+ *  `<br>` kept as a line break inside the cell. */
+function cells(row) {
+    return row.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim()
+        .replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/`([^`]+)`/g, "$1")
+        .replace(/<br\s*\/?>/gi, "\n"));
+}
+/** Widths that fit the terminal: each column its natural width when they all
+ *  fit, otherwise the narrow ones keep theirs and the wide ones share the rest. */
+function fitWidths(natural, room) {
+    const out = natural.map(() => 0);
+    let left = room;
+    let open = natural.map((_, i) => i).sort((a, b) => natural[a] - natural[b]);
+    while (open.length) {
+        const share = Math.floor(left / open.length);
+        const i = open[0];
+        if (natural[i] <= share) {
+            out[i] = natural[i];
+            left -= natural[i];
+            open = open.slice(1);
+            continue;
+        }
+        for (const j of open)
+            out[j] = Math.max(6, share);
+        break;
+    }
+    return out;
+}
+/** One cell's text as lines no wider than its column. */
+function cellLines(text, w) {
+    const lines = [];
+    for (const part of text.split("\n")) {
+        const words = wrap(part, w);
+        for (const l of words.length ? words : [""]) {
+            // A single word longer than the column is cut, never allowed to push the border.
+            for (let k = 0; k < Math.max(1, l.length); k += w)
+                lines.push(l.slice(k, k + w));
+        }
+    }
+    return lines;
+}
+/**
+ * Markdown tables drawn as terminal tables.
+ *
+ * A model asked for "a summary table" writes pipes and dashes, which a browser
+ * draws and a terminal shows as raw markup. Each block of `|` rows with a
+ * `|---|` line under its header becomes a boxed table, with long cells wrapped
+ * inside their column so the table always fits the window.
+ */
+function tables(text) {
+    const lines = text.split("\n");
+    const out = [];
+    const isRow = (l) => l !== undefined && /^\s*\|.*\|\s*$/.test(l);
+    const isRule = (l) => l !== undefined && /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/.test(l);
+    for (let i = 0; i < lines.length; i++) {
+        if (!(isRow(lines[i]) && isRule(lines[i + 1]))) {
+            out.push(lines[i]);
+            continue;
+        }
+        const head = cells(lines[i]);
+        const body = [];
+        i += 2;
+        while (isRow(lines[i]))
+            body.push(cells(lines[i++]));
+        i--;
+        const cols = head.length;
+        const rows = [head, ...body].map((r) => Array.from({ length: cols }, (_, k) => r[k] ?? ""));
+        const natural = Array.from({ length: cols }, (_, k) => Math.max(3, ...rows.map((r) => Math.max(...r[k].split("\n").map((s) => s.length)))));
+        const w = fitWidths(natural, width() - 4 - (3 * cols + 1));
+        const bar = (l, m, r) => (0, exports.dim)(`  ${l}${w.map((n) => "─".repeat(n + 2)).join(m)}${r}`);
+        const draw = (r, strong) => {
+            const wrapped = r.map((c, k) => cellLines(c, w[k]));
+            const height = Math.max(...wrapped.map((c) => c.length));
+            for (let h = 0; h < height; h++) {
+                out.push(`  ${(0, exports.dim)("│")}${wrapped.map((c, k) => {
+                    const s = (c[h] ?? "").padEnd(w[k]);
+                    return ` ${strong ? (0, exports.bold)(s) : s} `;
+                }).join((0, exports.dim)("│"))}${(0, exports.dim)("│")}`);
+            }
+        };
+        out.push(bar("┌", "┬", "┐"));
+        draw(rows[0], true);
+        out.push(bar("├", "┼", "┤"));
+        rows.slice(1).forEach((r, n) => {
+            draw(r, false);
+            if (n < rows.length - 2)
+                out.push(bar("├", "┼", "┤"));
+        });
+        out.push(bar("└", "┴", "┘"));
+    }
+    return out.join("\n");
+}
+/** The answer's two accents, one pair per terminal background (manual 6.10):
+ *  the brand violet and amber on a dark terminal, the brand purple and deep
+ *  blue on a light one, each above 4.5 to 1 against its background. */
+const onLight = () => process.env.COMPRISM_THEME === "light";
+const headingPaint = (t) => paint(onLight() ? "1;38;2;107;91;167" : "1;38;5;141", t);
+const codePaint = (t) => paint(onLight() ? "38;2;31;77;120" : "38;2;217;119;6", t);
+/** Characters of text per line, the width Glow and Claude Code read at. */
+const READING_WIDTH = 80;
+const same = (t) => t;
+/** A line of markdown as words, each piece carrying its own emphasis, so a
+ *  wrapped line never starts inside a color it cannot see the start of. */
+function words(text) {
+    const linked = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, t, u) => `${t} (${u})`);
+    const parts = [];
+    const re = /(\*\*[^*]+\*\*|__[^_]+__|`[^`]+`|\*[^*\s][^*]*\*)/g;
+    let last = 0;
+    for (let m = re.exec(linked); m; m = re.exec(linked)) {
+        parts.push({ t: linked.slice(last, m.index), p: same });
+        const s = m[0];
+        parts.push(s.startsWith("`") ? { t: s.slice(1, -1), p: codePaint }
+            : s.startsWith("**") || s.startsWith("__") ? { t: s.slice(2, -2), p: exports.bold }
+                : { t: s.slice(1, -1), p: (t) => paint("3", t) });
+        last = m.index + s.length;
+    }
+    parts.push({ t: linked.slice(last), p: same });
+    const out = [];
+    let cur = [];
+    for (const part of parts) {
+        for (const piece of part.t.split(/(\s+)/)) {
+            if (!piece)
+                continue;
+            if (/^\s+$/.test(piece)) {
+                if (cur.length) {
+                    out.push(cur);
+                    cur = [];
+                }
+            }
+            else
+                cur.push({ t: piece, p: part.p });
+        }
+    }
+    if (cur.length)
+        out.push(cur);
+    return out;
+}
+const show = (w) => w.map((x) => x.p(x.t)).join("");
+const size = (w) => w.reduce((n, x) => n + x.t.length, 0);
+/** Words filled into lines no wider than `room`, a word never split, every
+ *  line after the first starting under the first line's text. */
+function fill(text, lead, hang, room) {
+    const lines = [];
+    let line = lead, used = visible(lead).length, empty = true;
+    for (const w of words(text)) {
+        if (!empty && used + 1 + size(w) > room) {
+            lines.push(line);
+            line = hang;
+            used = visible(hang).length;
+            empty = true;
+        }
+        line += (empty ? "" : " ") + show(w);
+        used += (empty ? 0 : 1) + size(w);
+        empty = false;
+    }
+    lines.push(line);
+    return lines;
 }
 /**
- * Plain text, from a model that writes markdown.
+ * An answer, laid out for reading in a terminal (manual 6.17).
  *
- * A terminal has no bold and no bullet glyphs, so `**like this**` arrives on
- * screen as literal asterisks and a heading looks like a typing mistake. The
- * emphasis is real, so it is kept as terminal bold rather than thrown away;
- * everything that only exists to be rendered by a browser is removed.
+ * The approved design (docs/product/design/cli-answer, option B): the whole
+ * answer on one left margin behind a violet rail, so where the question ends
+ * and the answer begins is never in doubt; words wrapped at a reading width
+ * and never split by the window edge; a blank line between every block;
+ * headings in the brand violet; code in its own color; wrapped list items
+ * continuing under their own text. Piped to a file or another program, the
+ * same answer comes out without the rail or the color, as a log wants it.
  */
 function plain(text) {
-    return text
-        // Fenced code keeps its content and loses its fence markers.
-        .replace(/^```[a-zA-Z0-9]*\n?/gm, '')
-        .replace(/^```$/gm, '')
-        // Headings become their own words, emphasized.
-        .replace(/^#{1,6}\s+(.+)$/gm, (_m, t) => (0, exports.bold)(String(t)))
-        // Bold and italic become the terminal's own emphasis.
-        .replace(/\*\*([^*]+)\*\*/g, (_m, t) => (0, exports.bold)(String(t)))
-        .replace(/__([^_]+)__/g, (_m, t) => (0, exports.bold)(String(t)))
-        .replace(/(^|[^*])\*([^*\n]+)\*/g, (_m, pre, t) => pre + String(t))
-        // A bullet is a bullet, not an asterisk.
-        .replace(/^\s*[*-]\s+/gm, '  . ')
-        // Inline code keeps its text; the backticks were never for a terminal.
-        .replace(/`([^`]+)`/g, (_m, t) => String(t))
-        // A link reads as its words, with the address after it.
-        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, t, u) => `${t} (${u})`)
-        .replace(/\n{3,}/g, '\n\n');
+    const screen = supportsColour();
+    const lead = screen ? `  ${paint(onLight() ? "38;2;107;91;167" : "38;5;141", "│")} ` : "  ";
+    const railOnly = screen ? lead.trimEnd() : "";
+    const room = Math.min(width() - 1, visible(lead).length + READING_WIDTH);
+    const src = text.replace(/\r\n/g, "\n").split("\n");
+    const out = [];
+    const gap = () => { if (out.length && out[out.length - 1] !== railOnly)
+        out.push(railOnly); };
+    const isTableRow = (l) => l !== undefined && /^\s*\|.*\|\s*$/.test(l);
+    const startsBlock = (l) => /^\s*([-*+•]\s|\d+[.)]\s|#{1,6}\s|```|>|\|)/.test(l) || /^\s*([-*_])\s*\1\s*\1[\s\-*_]*$/.test(l);
+    for (let i = 0; i < src.length; i++) {
+        const l = src[i];
+        if (!l.trim())
+            continue;
+        if (/^\s*```/.test(l)) {
+            gap();
+            for (i++; i < src.length && !/^\s*```/.test(src[i]); i++)
+                out.push(`${lead}  ${codePaint(src[i])}`);
+            continue;
+        }
+        const h = /^\s*#{1,6}\s+(.+?)\s*#*\s*$/.exec(l);
+        if (h) {
+            gap();
+            out.push(lead + headingPaint(h[1].replace(/\*\*/g, "")));
+            gap();
+            continue;
+        }
+        if (/^\s*([-*_])\s*\1\s*\1[\s\-*_]*$/.test(l)) {
+            gap();
+            continue;
+        }
+        if (isTableRow(l)) {
+            const block = [];
+            while (isTableRow(src[i]))
+                block.push(src[i++]);
+            i--;
+            gap();
+            // The table's own two space indent gives way to the rail, whether or
+            // not a color code comes before it.
+            const indent = new RegExp(`^((?:${String.fromCharCode(27)}\\[[0-9;]*m)*) {2}`);
+            for (const row of tables(block.join("\n")).split("\n"))
+                out.push(lead + row.replace(indent, "$1"));
+            gap();
+            continue;
+        }
+        const bullet = /^(\s*)([-*+•]|\d+[.)])\s+(.*)$/.exec(l);
+        if (bullet) {
+            if (out.length && !/^\s*([-*+•]|\d+[.)])\s/.test(src[i - 1] ?? ""))
+                gap();
+            const depth = Math.floor(bullet[1].replace(/\t/g, "  ").length / 2);
+            const mark = /\d/.test(bullet[2]) ? `${bullet[2].replace(")", ".")} ` : "• ";
+            let body = bullet[3];
+            // A list item that runs onto an indented next line is one item.
+            while (i + 1 < src.length && src[i + 1].trim() && /^\s{2,}\S/.test(src[i + 1]) && !startsBlock(src[i + 1]))
+                body += " " + src[++i].trim();
+            const indent = "  ".repeat(depth);
+            out.push(...fill(body, lead + indent + (0, exports.dim)(mark), lead + indent + " ".repeat(mark.length), room));
+            if (i + 1 < src.length && !/^\s*([-*+•]|\d+[.)])\s/.test(src[i + 1]))
+                gap();
+            continue;
+        }
+        // A paragraph is every line up to the next blank line or block.
+        let para = l.trim().replace(/^>\s?/, "");
+        while (i + 1 < src.length && src[i + 1].trim() && !startsBlock(src[i + 1]))
+            para += " " + src[++i].trim();
+        gap();
+        out.push(...fill(para, lead, lead, room));
+        gap();
+    }
+    while (out.length && out[out.length - 1] === railOnly)
+        out.pop();
+    return out.join("\n");
 }