@zenera/cli 1.1.18 → 1.1.20

package/dist/tui/wrap.js

@@ -82,13 +82,21 @@ export function wrap(text, width) {
 // ---------------------------------------------------------------------------
 /** The three footer rows, its margin, the prompt, and a row in hand. */
 export const CHROME_ROWS = 7;
-/** How much of the reasoning stream is worth showing. It is a progress bar. */
-export const THINKING_ROWS = 6;
+/**
+ * How much of the reasoning stream is worth showing.
+ *
+ * One row. A reasoning summary is not a document to be read while it arrives —
+ * it is the model saying what it is about to do, and the sentence that says so
+ * is the heading it writes for itself. Six rows of it pushed the answer and the
+ * work down the screen to make room for a paragraph nobody finishes reading,
+ * and the whole chain is in the trajectory either way.
+ */
+export const THINKING_ROWS = 1;
 /** How much of the frame the work in flight may take. A branch is a box now,
- *  not a row, so a fan-out of two costs fourteen of these. */
-export const ACTIVITY_ROWS = 16;
-/** The rule that opens a reasoning block and the one that closes it. */
-export const THINKING_CHROME = 2;
+ *  not a row, so a fan-out of two costs twenty-two of these. */
+export const ACTIVITY_ROWS = 24;
+/** The width of the elapsed-time column every call row is drawn behind. */
+export const TIME_COL = 5;
 /**
  * How many rows each repainting block may draw in a terminal `rows` tall.
  *
@@ -96,27 +104,28 @@ export const THINKING_CHROME = 2;
  * arrives matters more than the machinery producing it. Reasoning yields to it
  * in turn, because it is a progress indicator and the answer is the point.
  *
- * `thinking` is how many rows of reasoning are wanted, counting text only: none
- * when there is no reasoning, fewer than `THINKING_ROWS` once the stream has
- * settled and its tail is history rather than progress. The two rules are
- * charged on top, so a block too cramped to be worth boxing is not drawn at all
- * rather than drawn as a border with a line in it.
+ * `thinking` is how many rows of reasoning are wanted — one while the model is
+ * reasoning, none otherwise — and it never takes the answer's last row.
  */
 export function budgetOf(rows, activity, thinking) {
     const total = Math.max(2, rows - CHROME_ROWS);
     const shown = Math.min(Math.max(0, activity), ACTIVITY_ROWS, Math.max(0, total - 2));
     const rest = total - shown;
-    const room = rest - 1 - THINKING_CHROME;
-    const tail = room >= 1 ? Math.min(Math.max(0, thinking), THINKING_ROWS, room) : 0;
-    return {
-        activity: shown,
-        thinking: tail,
-        live: rest - tail - (tail ? THINKING_CHROME : 0),
-        total,
-    };
+    const tail = Math.min(Math.max(0, thinking), THINKING_ROWS, Math.max(0, rest - 1));
+    return { activity: shown, thinking: tail, live: rest - tail, total };
 }
-/** The rows a branch box may spend on its own calls and its reasoning. */
-export const BRANCH_ROWS = 5;
+/** The rows a branch box may spend on its own calls, prose and reasoning. */
+export const BRANCH_ROWS = 9;
+/**
+ * The fewest a box is worth drawing at.
+ *
+ * One row per branch fit more of them on screen and said nothing about any of
+ * them: a box holding a single call is a label, and the reason it is a box at
+ * all is that what a branch just did and said is why it is doing this. Below
+ * six rows there is no *what it just did* — so a fork too wide to give every
+ * branch six is cut to the ones that fit and counted, which is `fitActivity`.
+ */
+export const BRANCH_MIN = 6;
 /** Rows a branch box spends on chrome: the title rule and the closing one. */
 export const BOX_CHROME = 2;
 /**
@@ -124,26 +133,51 @@ export const BOX_CHROME = 2;
  * activity region has to divide between them.
  *
  * Every branch gets the same number, because they are the same kind of thing
- * and a fan-out is read across, not down. A wide fork spends its rows on being
- * complete rather than on being detailed: eight branches showing one call each
- * is a picture of the fork, eight rows of one branch is not.
+ * and a fan-out is read across, not down.
  */
 export function branchRows(count, allowance) {
     if (count <= 0) {
         return 0;
     }
     const each = Math.floor(Math.max(0, allowance) / count) - BOX_CHROME;
-    return Math.max(1, Math.min(BRANCH_ROWS, each));
+    return Math.max(BRANCH_MIN, Math.min(BRANCH_ROWS, each));
 }
 /**
- * How wide the answer is drawn. A line of prose spanning a 200-column terminal
- * is measurably harder to read than one that stops, which is why every demo in
+ * How wide *prose* is drawn. A line spanning a 200-column terminal is
+ * measurably harder to read than one that stops, which is why every demo in
  * `examples/sdk/` puts its answer in a box of bounded width — the terminal is the
  * page, not the paragraph.
+ *
+ * `boxWidth` is what a whole answer is drawn at; this is the floor it starts from.
  */
 export function answerWidth(columns) {
     return Math.max(24, Math.min(columns - 4, 96));
 }
+/**
+ * How wide the box holding `text` has to be.
+ *
+ * Prose stops at the comfort width, but a fence and a table cannot be
+ * reflowed — fold a table row and the columns stop lining up, which is the one
+ * thing the table was for — so the box grows to hold the widest of them, as far
+ * as the terminal allows and no further.
+ */
+export function boxWidth(text, columns) {
+    let rigid = 0;
+    for (const block of blocksOf(text)) {
+        // A fence is drawn behind a `│ ` gutter; a table row is not.
+        const lines = block.kind === 'code'
+            ? (block.lines ?? []).map((l) => l.length + 6)
+            : block.kind === 'table'
+                ? textOf(block)
+                    .split('\n')
+                    .map((l) => l.length + 4)
+                : [];
+        for (const width of lines) {
+            rigid = Math.max(rigid, width);
+        }
+    }
+    return Math.max(answerWidth(columns), Math.min(Math.max(24, columns - 4), rigid));
+}
 // ---------------------------------------------------------------------------
 // Reading a payload
 // ---------------------------------------------------------------------------
@@ -176,32 +210,644 @@ function unquote(raw) {
     const body = raw.length > 1 && raw.endsWith('"') ? raw.slice(1, -1) : raw.slice(1);
     return body.replace(/\\[nrt]/g, ' ').replace(/\\(["\\/])/g, '$1');
 }
+/** Every field of a preview, first mention winning. */
+export function fieldsOf(preview) {
+    const out = new Map();
+    for (const m of preview.matchAll(FIELD)) {
+        const key = m[1];
+        if (!out.has(key)) {
+            out.set(key, unquote(m[2]));
+        }
+    }
+    return out;
+}
+/** The text between `"key":[` and the first `]`, or nothing if there is no such array. */
+function arrayBody(preview, key) {
+    const at = preview.indexOf(`"${key}"`);
+    if (at < 0) {
+        return undefined;
+    }
+    const open = preview.indexOf('[', at);
+    if (open < 0) {
+        return undefined;
+    }
+    const close = preview.indexOf(']', open);
+    return preview.slice(open + 1, close < 0 ? undefined : close);
+}
+/**
+ * An array argument, as the two things worth knowing about it: what is in it,
+ * when its items say their own names, and how many there are either way.
+ */
+function itemsOf(preview, key) {
+    const body = arrayBody(preview, key);
+    if (body === undefined || !body.trim()) {
+        return { names: [], total: 0 };
+    }
+    if (/^\s*\{/.test(body)) {
+        const names = [...body.matchAll(/"name"\s*:\s*"([^"]*)"/g)].map((m) => m[1]);
+        return { names, total: Math.max(names.length, (body.match(/\{/g) ?? []).length) };
+    }
+    const names = [...body.matchAll(/"([^"]*)"/g)].map((m) => m[1]).filter(Boolean);
+    return { names, total: names.length };
+}
+/** A few things are worth naming; more than a few are worth counting. */
+function named(items, unit) {
+    if (!items.total) {
+        return '';
+    }
+    if (items.names.length && items.names.length <= 2) {
+        return items.names.join(', ');
+    }
+    return `${items.total} ${items.total === 1 ? unit : `${unit}s`}`;
+}
+const CALLS = {
+    read_file: { verb: 'read', of: ['path'] },
+    list_dir: { verb: 'list', of: ['path'] },
+    find_files: { verb: 'find', of: ['pattern'] },
+    write_file: { verb: 'write', of: ['path'] },
+    apply_patch: { verb: 'patch' },
+    move_file: { verb: 'move', pair: ['from', 'to'] },
+    delete_file: { verb: 'delete', of: ['path'] },
+    run_command: { verb: 'run', of: ['command'] },
+    run_command_background: { verb: 'start', of: ['command'] },
+    read_command_output: { verb: 'output', of: ['job_id'] },
+    stop_command: { verb: 'stop', of: ['job_id'] },
+    memory_search: { verb: 'recall', of: ['query'] },
+    memory_load: { verb: 'read memory', count: ['ids', 'node'] },
+    memory_commit: { verb: 'remember', count: ['nodes', 'node'] },
+    memory_forget: { verb: 'forget', count: ['ids', 'node'] },
+    skill_search: { verb: 'find skill', of: ['query'] },
+    skill_load: { verb: 'load skill', count: ['names', 'skill'] },
+    fork: { verb: 'fork', count: ['branches', 'branch'] },
+    final_output: { verb: 'answer' },
+    search_api: { verb: 'search api', of: ['query'] },
+    list_api: { verb: 'list api', of: ['name', 'kind'] },
+    grep_api: { verb: 'grep api', of: ['pattern'] },
+    trace_api: { verb: 'trace api', of: ['pattern'] },
+};
+/** The handoff tools are minted per agent, so they are matched by prefix. */
+const TRANSFER = 'transfer_to_';
+/** A patch names its own files, and that is the only part of it worth a row. */
+const PATCHED = /\*\*\* (?:Add|Update|Delete) File:\s*(.*?)(?:\\[nr]|"|$)/g;
+export function describeCall(name, preview) {
+    if (name.startsWith(TRANSFER)) {
+        return { verb: 'hand off to', subject: name.slice(TRANSFER.length) };
+    }
+    const shape = CALLS[name];
+    if (!shape) {
+        return { verb: name, subject: readable(preview) };
+    }
+    if (name === 'apply_patch') {
+        const files = [...preview.matchAll(PATCHED)].map((m) => m[1].trim());
+        return { verb: shape.verb, subject: named({ names: files, total: files.length }, 'file') };
+    }
+    if (shape.pair) {
+        const fields = fieldsOf(preview);
+        const [from, to] = shape.pair;
+        return { verb: shape.verb, subject: `${fields.get(from) ?? ''} → ${fields.get(to) ?? ''}` };
+    }
+    if (shape.count) {
+        const [key, unit] = shape.count;
+        return { verb: shape.verb, subject: named(itemsOf(preview, key), unit) };
+    }
+    const fields = fieldsOf(preview);
+    for (const key of shape.of ?? []) {
+        const value = fields.get(key);
+        if (value) {
+            return { verb: shape.verb, subject: value };
+        }
+    }
+    return { verb: shape.verb, subject: '' };
+}
+/**
+ * What a finished call has to say for itself, in the few words a row has left.
+ *
+ * A `[]` suffix means "count it": the interesting thing about a listing is how
+ * much came back, and printing the first two of forty entries says less than
+ * the number does.
+ */
+const RESULTS = {
+    read_file: ['lines'],
+    list_dir: ['entries[]'],
+    find_files: ['matches[]'],
+    write_file: ['bytes'],
+    apply_patch: ['files[]'],
+    move_file: ['to'],
+    delete_file: ['path'],
+    run_command: ['exit_code'],
+    run_command_background: ['job_id'],
+};
+export function summarise(name, preview) {
+    const fields = fieldsOf(preview);
+    // An error is the whole of what happened, and it is what the next turn
+    // will be about. Nothing else on the row competes with it.
+    const failed = fields.get('error');
+    if (failed) {
+        return failed;
+    }
+    const parts = [];
+    for (const key of RESULTS[name] ?? []) {
+        if (key.endsWith('[]')) {
+            const of = key.slice(0, -2);
+            const { total } = itemsOf(preview, of);
+            if (total) {
+                parts.push(`${total} ${of}`);
+            }
+            continue;
+        }
+        const value = fields.get(key);
+        if (value !== undefined && value !== '') {
+            parts.push(`${key.replace(/_/g, ' ')} ${value}`);
+        }
+    }
+    return parts.length ? parts.join(' · ') : readable(preview);
+}
+// ---------------------------------------------------------------------------
+// The gist of a reasoning stream
+// ---------------------------------------------------------------------------
+/** How much of a stream is looked at for a heading. Its end is where it got to. */
+const GIST_TAIL = 4000;
+/** A reasoning summary writes its own headings, in bold. */
+const BOLD = /\*\*([^*\n]{2,}?)\*\*/g;
+/**
+ * One line saying where the model has got to.
+ *
+ * Reasoning summaries arrive as markdown and are structured by their own bold
+ * headings — Gemini emits one every few sentences, and they are the shortest
+ * true account of the step. The last one is where the model is now. Failing
+ * that the raw text is clipped, which is a fragment, but a moving fragment is
+ * still proof that something is happening.
+ */
+export function gistOf(text, width) {
+    const tail = text.slice(-GIST_TAIL);
+    const heads = [...tail.matchAll(BOLD)];
+    const last = heads.at(-1)?.[1];
+    return clip(last ?? tail, width);
+}
+// ---------------------------------------------------------------------------
+// Inline
+// ---------------------------------------------------------------------------
+/** What a backslash may turn back into ordinary text. */
+const ESCAPABLE = /[\\`*_~[\]()#+\-.!>|]/;
+/** Emphasis has to hug its own text, or `2 * 3 * 4` reads as arithmetic in italics. */
+const spacey = (ch) => ch === undefined || /\s/.test(ch);
+/** An underscore between word characters is part of the word: `snake_case_name`. */
+const wordy = (ch) => ch !== undefined && /[\p{L}\p{N}]/u.test(ch);
+/** Far past anything a model writes, and the thing that stops a pathological nest. */
+const NESTING = 4;
+/**
+ * The inline markup of one block, resolved.
+ *
+ * Order is the correctness argument. Code is settled first and never entered
+ * again, which is why this is a scanner and not a chain of replaces: in
+ * "use `[a](b)` syntax" the brackets are prose, and no regex over the whole
+ * string can know that. Everything else recurses on the text between its own
+ * markers, so `**bold with `code` in it**` keeps both.
+ */
+export function inlineOf(text, style = {}, depth = 0) {
+    const out = [];
+    let buffer = '';
+    const keep = () => {
+        if (buffer) {
+            out.push({ text: buffer, ...style });
+            buffer = '';
+        }
+    };
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === '\\' && ESCAPABLE.test(text[i + 1] ?? '')) {
+            buffer += text[i + 1];
+            i += 2;
+            continue;
+        }
+        if (ch === '`') {
+            const span = codeAt(text, i);
+            if (span) {
+                keep();
+                out.push({ text: span.text, ...style, code: true });
+                i = span.end;
+                continue;
+            }
+        }
+        if (depth < NESTING && (ch === '[' || (ch === '!' && text[i + 1] === '['))) {
+            const link = linkAt(text, i);
+            if (link) {
+                keep();
+                const inner = { ...style, ...(link.href ? { href: link.href } : {}) };
+                out.push(...inlineOf(link.label, inner, depth + 1));
+                i = link.end;
+                continue;
+            }
+        }
+        if (depth < NESTING && (ch === '*' || ch === '_' || ch === '~')) {
+            const marks = ch === '~' ? 2 : Math.min(runOf(text, i, ch), 2);
+            const close = marks === 2 || ch !== '~' ? closingAt(text, i, ch, marks) : undefined;
+            if (close !== undefined) {
+                keep();
+                // Strikethrough has no weight of its own here, so it resolves
+                // to its text: the markers were never meant to be read.
+                const added = ch === '~' ? {} : marks === 2 ? { bold: true } : { italic: true };
+                out.push(...inlineOf(text.slice(i + marks, close), { ...style, ...added }, depth + 1));
+                i = close + marks;
+                continue;
+            }
+        }
+        buffer += ch;
+        i += 1;
+    }
+    keep();
+    return out;
+}
+/** How many of `ch` run on from `at`. */
+function runOf(text, at, ch) {
+    let n = 0;
+    while (text[at + n] === ch) {
+        n += 1;
+    }
+    return n;
+}
+/**
+ * The code span opening at `at`, or nothing when its backticks never close.
+ *
+ * A run of n backticks closes on a run of exactly n, which is what lets a code
+ * span contain a backtick. One space either side of the content is padding for
+ * that case rather than text, so it comes off.
+ */
+function codeAt(text, at) {
+    const run = runOf(text, at, '`');
+    const fence = '`'.repeat(run);
+    let from = at + run;
+    for (;;) {
+        const found = text.indexOf(fence, from);
+        if (found < 0) {
+            return undefined;
+        }
+        if (text[found + run] === '`') {
+            from = found + runOf(text, found, '`');
+            continue;
+        }
+        const body = text.slice(at + run, found);
+        const padded = body.length > 2 && body.startsWith(' ') && body.endsWith(' ');
+        return { text: padded ? body.slice(1, -1) : body, end: found + run };
+    }
+}
 /**
- * Splits an answer on ``` fences. Prose is left exactly as it was — the common
- * answer has no fence in it and comes back in one piece — but a fenced block is
- * the one thing a terminal must not reflow: its indentation is its meaning, and
- * wrapping it as prose destroys it.
+ * Where the emphasis opened at `at` closes, or nothing.
+ *
+ * Two of CommonMark's flanking rules earn their keep and the rest do not: a
+ * marker that opens is followed by something other than a space, one that
+ * closes is preceded by something other than a space. Without them `a * b * c`
+ * is italic and every second multiplication in an answer goes missing.
+ */
+function closingAt(text, at, ch, marks) {
+    if (spacey(text[at + marks]) || (ch === '_' && wordy(text[at - 1]))) {
+        return undefined;
+    }
+    const mark = ch.repeat(marks);
+    let from = at + marks + 1;
+    while (from < text.length) {
+        const found = text.indexOf(mark, from);
+        if (found < 0) {
+            return undefined;
+        }
+        if (!spacey(text[found - 1]) && !(ch === '_' && wordy(text[found + marks]))) {
+            return found;
+        }
+        from = found + 1;
+    }
+    return undefined;
+}
+/** `[label](href)` or `![alt](href)` at `at`, or nothing when it is only a bracket. */
+function linkAt(text, at) {
+    const open = text[at] === '!' ? at + 1 : at;
+    let depth = 0;
+    let close = -1;
+    for (let i = open; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '\\') {
+            i += 1;
+        }
+        else if (ch === '[') {
+            depth += 1;
+        }
+        else if (ch === ']') {
+            depth -= 1;
+            if (depth === 0) {
+                close = i;
+                break;
+            }
+        }
+    }
+    if (close < 0 || text[close + 1] !== '(') {
+        return undefined;
+    }
+    const end = text.indexOf(')', close + 2);
+    if (end < 0) {
+        return undefined;
+    }
+    // `[label](url "title")` — the title is for a tooltip nothing here has.
+    const target = text
+        .slice(close + 2, end)
+        .trim()
+        .split(/\s+/)[0] ?? '';
+    return {
+        label: text.slice(open + 1, close),
+        href: target.replace(/^<|>$/g, ''),
+        end: end + 1,
+    };
+}
+// ---------------------------------------------------------------------------
+// Blocks
+// ---------------------------------------------------------------------------
+const FENCE = /^(\s*)(```+|~~~+)\s*(\S*)/;
+const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+const RULE = /^ {0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const QUOTE = /^ {0,3}>\s?(.*)$/;
+const ITEM = /^(\s*)(?:([-*+])|(\d{1,9})[.)])\s+(.*)$/;
+/** A markdown table row. Both pipes, so a sentence with one in it is still prose. */
+const TABLE_ROW = /^\s*\|.*\|\s*$/;
+/** A cell of the rule row under a header: dashes, and where the column is set. */
+const RULE_CELL = /^:?-+:?$/;
+/** What a bullet is drawn as, by how deep it is nested. */
+const BULLETS = ['\u2022', '\u25e6', '\u25aa'];
+/** Splits a row on the pipes that divide it, dropping the two that bound it. */
+function cellsOf(row) {
+    const out = [];
+    let cell = '';
+    for (let i = 0; i < row.length; i += 1) {
+        const ch = row[i];
+        // An escaped pipe is text, and stays escaped for the inline scan.
+        if (ch === '\\' && row[i + 1] === '|') {
+            cell += '\\|';
+            i += 1;
+        }
+        else if (ch === '|') {
+            out.push(cell);
+            cell = '';
+        }
+        else {
+            cell += ch;
+        }
+    }
+    out.push(cell);
+    return out.slice(1, -1).map((c) => c.trim());
+}
+/**
+ * The rows a table was written as, read into a grid.
+ *
+ * The rule row is not kept: what it said about alignment is kept instead, and
+ * `gridOf` draws a rule of the width the columns turn out to be. A table
+ * without one is still a table — models write them — it just has no header.
  */
-export function segmentsOf(text) {
+function gatherTable(rows) {
+    const grid = rows.map(cellsOf);
+    const rule = grid[1];
+    const ruled = rule !== undefined && rule.length > 0 && rule.every((c) => RULE_CELL.test(c));
+    const body = ruled ? [grid[0], ...grid.slice(2)] : grid;
+    const columns = Math.max(0, ...body.map((row) => row.length));
+    return {
+        kind: 'table',
+        cells: body.map((row) => Array.from({ length: columns }, (_, i) => inlineOf(row[i] ?? ''))),
+        ...(ruled
+            ? {
+                align: Array.from({ length: columns }, (_, i) => (rule[i] ?? '').endsWith(':')
+                    ? rule[i].startsWith(':')
+                        ? 'center'
+                        : 'right'
+                    : 'left'),
+            }
+            : {}),
+    };
+}
+/** Takes back up to `by` columns of indent, and no more than the line has. */
+function dedent(line, by) {
+    let n = 0;
+    while (n < by && (line[n] === ' ' || line[n] === '\t')) {
+        n += 1;
+    }
+    return line.slice(n);
+}
+/**
+ * An answer, as the blocks it is made of.
+ *
+ * Read top down, one line at a time, because that is the order the text
+ * arrives in and a stream must be readable before it is finished. The two
+ * verbatim kinds win over everything: a pipe inside a fence is whatever the
+ * code says it is, and a `#` inside one is a comment, not a heading.
+ */
+export function blocksOf(text) {
     const out = [];
-    let current = { code: false, lines: [] };
-    const flush = () => {
-        if (current.lines.length) {
-            out.push(current);
+    let prose;
+    let fence;
+    let table;
+    const closeProse = () => {
+        if (prose) {
+            out.push({
+                kind: prose.kind,
+                ...(prose.level === undefined ? {} : { level: prose.level }),
+                ...(prose.marker === undefined ? {} : { marker: prose.marker }),
+                spans: inlineOf(prose.lines.join('\n').trim()),
+            });
+            prose = undefined;
+        }
+    };
+    const closeTable = () => {
+        if (table) {
+            out.push(gatherTable(table));
+            table = undefined;
+        }
+    };
+    const closeFence = () => {
+        if (fence) {
+            out.push({
+                kind: 'code',
+                ...(fence.title ? { title: fence.title } : {}),
+                lines: fence.lines,
+            });
+            fence = undefined;
         }
     };
+    const settle = () => {
+        closeProse();
+        closeTable();
+    };
     for (const raw of text.split('\n')) {
-        const fence = /^\s*```+\s*(\S*)/.exec(raw);
-        if (!fence) {
-            current.lines.push(raw);
+        if (fence) {
+            if (raw.trimStart().startsWith(fence.marker)) {
+                closeFence();
+            }
+            else {
+                fence.lines.push(dedent(raw, fence.indent));
+            }
+            continue;
+        }
+        const opening = FENCE.exec(raw);
+        if (opening) {
+            settle();
+            fence = {
+                marker: opening[2].slice(0, 3),
+                indent: opening[1].length,
+                ...(opening[3] ? { title: opening[3] } : {}),
+                lines: [],
+            };
+            continue;
+        }
+        // A blank line ends whatever was being gathered and is not itself a block.
+        if (!raw.trim()) {
+            settle();
             continue;
         }
-        flush();
-        current = current.code
-            ? { code: false, lines: [] }
-            : { code: true, title: fence[1] || undefined, lines: [] };
+        if (TABLE_ROW.test(raw)) {
+            closeProse();
+            (table ??= []).push(raw.trim());
+            continue;
+        }
+        closeTable();
+        const heading = HEADING.exec(raw);
+        if (heading) {
+            closeProse();
+            out.push({
+                kind: 'heading',
+                level: heading[1].length,
+                spans: inlineOf(heading[2]),
+            });
+            continue;
+        }
+        // Before the item check, so `* * *` is a rule and not a list of one star.
+        if (RULE.test(raw)) {
+            closeProse();
+            out.push({ kind: 'rule' });
+            continue;
+        }
+        const quote = QUOTE.exec(raw);
+        if (quote) {
+            if (prose?.kind !== 'quote') {
+                closeProse();
+                prose = { kind: 'quote', lines: [] };
+            }
+            prose.lines.push(quote[1]);
+            continue;
+        }
+        const item = ITEM.exec(raw);
+        if (item) {
+            closeProse();
+            const level = Math.min(BULLETS.length - 1, Math.floor(item[1].length / 2));
+            const number = item[3];
+            prose = {
+                kind: 'item',
+                level,
+                marker: number ? `${number}.` : BULLETS[level],
+                lines: [item[4]],
+            };
+            continue;
+        }
+        // A line under an item belongs to it; a line under nothing starts a paragraph.
+        if (prose) {
+            prose.lines.push(raw.trim());
+        }
+        else {
+            prose = { kind: 'paragraph', lines: [raw] };
+        }
     }
-    flush();
+    settle();
+    closeFence();
     return out;
 }
+// ---------------------------------------------------------------------------
+// Back to text
+// ---------------------------------------------------------------------------
+/** What a run of spans measures, which is the text and never the styling. */
+const lengthOf = (spans) => spans.reduce((n, s) => n + s.text.length, 0);
+/** A cell in its column, set where the rule row asked for it. */
+function padOf(spans, width, align) {
+    const slack = Math.max(0, width - lengthOf(spans));
+    const lead = align === 'right' ? slack : align === 'center' ? Math.floor(slack / 2) : 0;
+    return [
+        ...(lead > 0 ? [{ text: ' '.repeat(lead) }] : []),
+        ...spans,
+        ...(slack > lead ? [{ text: ' '.repeat(slack - lead) }] : []),
+    ];
+}
+/**
+ * A table as its rows, each one a single run of spans.
+ *
+ * Columns are laid out here and nowhere else, so the drawn table and the plain
+ * one are the same table: a cell's width is the length of its text, which is
+ * what a `Span` measures whatever styling rides beside it. Nothing a model
+ * writes in a cell can move the cell after it.
+ */
+export function gridOf(block) {
+    const cells = block.cells ?? [];
+    const count = Math.max(0, ...cells.map((row) => row.length));
+    if (count === 0) {
+        return [];
+    }
+    const widths = Array.from({ length: count }, (_, i) => Math.max(3, ...cells.map((row) => lengthOf(row[i] ?? []))));
+    const rows = cells.map((row) => {
+        const out = [];
+        widths.forEach((width, i) => {
+            out.push({ text: i === 0 ? '| ' : ' | ' });
+            out.push(...padOf(row[i] ?? [], width, block.align?.[i] ?? 'left'));
+        });
+        out.push({ text: ' |' });
+        return out;
+    });
+    if (block.align && rows.length > 0) {
+        rows.splice(1, 0, [{ text: `|${widths.map((w) => '-'.repeat(w + 2)).join('|')}|` }]);
+    }
+    return rows;
+}
+/**
+ * A block as the row or rows it reads as, with its markers resolved rather
+ * than shown, and nothing styled.
+ *
+ * This is what a sink that cannot style gets — the pre-answer stream, and the
+ * plain box `zen meta` draws — so that the text does not visibly change shape
+ * at the moment it settles.
+ */
+export function textOf(block, width = 0) {
+    if (block.kind === 'code') {
+        // The same chrome the settled answer draws, so a fence that is still
+        // arriving is already the shape it will end up as.
+        return [
+            `\u250c\u2500${block.title ? ` ${block.title}` : ''}`,
+            ...(block.lines ?? []).map((l) => `\u2502 ${l}`),
+            '\u2514\u2500',
+        ].join('\n');
+    }
+    if (block.lines) {
+        return block.lines.join('\n');
+    }
+    if (block.kind === 'table') {
+        return gridOf(block)
+            .map((row) => row.map((s) => s.text).join(''))
+            .join('\n');
+    }
+    if (block.kind === 'rule') {
+        return '\u2500'.repeat(Math.max(3, width));
+    }
+    const body = (block.spans ?? []).map((s) => s.text).join('');
+    if (block.kind === 'item') {
+        return `${'  '.repeat(block.level ?? 0)}${block.marker ?? BULLETS[0]} ${body}`;
+    }
+    if (block.kind === 'quote') {
+        return `\u2502 ${body}`;
+    }
+    return body;
+}
+/** A whole answer with its markup resolved instead of shown. Still plain text. */
+export function unmarked(text, width = 0) {
+    const rows = [];
+    let previous;
+    for (const block of blocksOf(text)) {
+        // Items of one list are one thing; a blank row between them is two lists.
+        if (previous && !(block.kind === 'item' && previous.kind === 'item')) {
+            rows.push('');
+        }
+        rows.push(textOf(block, width));
+        previous = block;
+    }
+    return rows.join('\n');
+}
 //# sourceMappingURL=wrap.js.map