@openvulcan/dsh-vulcancode 0.0.0-stage → 0.4.3

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/answer-model.js

@@ -0,0 +1,698 @@
+/**
+ * Parsed `ui-*` answer component fences. Parsing is pure and total: a fence that does not match its
+ * documented syntax returns null, so the caller leaves dsh's ordinary code block in place. The syntax
+ * authority is `assets/prompts/answer-mode-interactive.md`.
+ *
+ * Ported from VulcanCode `apps/vulcan-code-web/src/components/conversation/answer-components/answer-component-model.ts`.
+ * `ui-code` (needs the host's answer-time file capture) and `ui-gallery` (needs local image access) are
+ * not offered in dsh, so their fences parse as null and stay ordinary code.
+ */
+import { ANSWER_CHART_MAX_SERIES, ANSWER_COMPONENT_MAX_ROWS } from './limits.js';
+/** Fence languages this plugin renders; any other `ui-*` fence stays ordinary code. */
+export const SUPPORTED_ANSWER_LANGUAGES = new Set([
+    'ui-kv', 'ui-metrics', 'ui-findings', 'ui-compare', 'ui-checklist', 'ui-steps', 'ui-timeline', 'ui-cards',
+    'ui-files', 'ui-tree', 'ui-chart', 'ui-flow', 'ui-sequence', 'ui-er', 'ui-math', 'ui-decision',
+    'ui-callout', 'ui-details', 'ui-tabs', 'ui-columns',
+]);
+const TONES = new Set(['ok', 'warn', 'no']);
+const STATUSES = new Set(['ok', 'warn', 'no', 'todo']);
+const SEVERITIES = new Set(['high', 'medium', 'low', 'info', 'ok']);
+const STEP_STATUSES = new Set(['done', 'now', 'todo']);
+const CALLOUT_TONES = new Set(['info', 'success', 'warning', 'danger']);
+/** Row tone words models reuse as callout tones. */
+const CALLOUT_TONE_ALIASES = new Map([['ok', 'success'], ['warn', 'warning'], ['no', 'danger']]);
+const CHART_KINDS = new Set(['bar', 'hbar', 'stack', 'line', 'area', 'pie', 'donut']);
+/** Finite decimal number syntax shared by metrics and charts. */
+const NUMBER = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/iu;
+/**
+ * Parse one fence; `language` is `ui-<name>`, `meta` the rest of the info string, `body` the text.
+ * Returns null for unknown or unsupported names and for invalid syntax.
+ */
+export function parseAnswerComponent(language, meta, body) {
+    const args = meta.trim();
+    if (!body.trim())
+        return null;
+    switch (language) {
+        case 'ui-kv':
+            // A row that is not a pair, even after the lenient split, may carry a third cell: models give facts a
+            // note column. Reading the pair first keeps a value such as `curl x|sh` whole.
+            return titled(args, () => mapLines(body, (line) => rowCells(line, 2, 2) ?? rowCells(line, 2, 3), ([label = '', value = '', note]) => (note === undefined ? { label, value } : { label, value, note }), (rows) => ({ kind: 'kv', rows })));
+        case 'ui-metrics':
+            return titled(args, () => mapLines(body, metricCells, metric, (rows) => ({ kind: 'metrics', rows })));
+        case 'ui-findings':
+            return titled(args, () => findings(body));
+        case 'ui-compare':
+            return titled(args, () => compare(body));
+        case 'ui-checklist':
+            return titled(args, () => checklist(body));
+        case 'ui-steps':
+            return titled(args, () => mapRows(body, 2, 3, ([status = '', title = '', text]) => (STEP_STATUSES.has(status) ? { status: status, title, text } : null), (steps) => ({ kind: 'steps', steps })));
+        case 'ui-timeline':
+            return titled(args, () => mapRows(body, 2, 3, ([time = '', title = '', text]) => ({ time, title, text }), (rows) => ({ kind: 'timeline', rows })));
+        case 'ui-cards':
+            return titled(args, () => mapRows(body, 2, 3, ([title = '', text = '', tag]) => ({ title, text, tag: tag === undefined ? undefined : toned(tag) }), (cards) => ({ kind: 'cards', cards })));
+        case 'ui-files':
+            return titled(args, () => files(body));
+        case 'ui-tree':
+            return titled(args, () => tree(body));
+        case 'ui-chart':
+            return chart(args, body);
+        case 'ui-flow':
+            return args === '' || args === 'LR' ? flow(args === 'LR', body) : null;
+        case 'ui-sequence':
+            return args === '' || args === 'num' ? sequence(args === 'num', body) : null;
+        case 'ui-er':
+            return args === '' || args === 'LR' || args === 'TB' ? er(args !== 'TB', body) : null;
+        case 'ui-math':
+            return math(args, body);
+        case 'ui-decision':
+            return args === '' || args === 'multi' ? decision(args === 'multi', body) : null;
+        case 'ui-callout':
+            return callout(args, body);
+        case 'ui-details':
+            return args ? { kind: 'details', title: args, body } : null;
+        case 'ui-tabs':
+        case 'ui-columns':
+            return titled(args, () => sections(language === 'ui-tabs' ? 'tabs' : 'columns', body));
+        default:
+            return null;
+    }
+}
+/** Run `parse` for a row component; text written after the name becomes its heading. */
+function titled(args, parse) {
+    const component = parse();
+    return component && args ? { ...component, heading: args } : component;
+}
+/**
+ * `severity | finding | location` rows. Models sometimes add a fourth note cell as in `ui-checklist`; it is read
+ * only after the documented split, including the lenient one, has failed, so `fetch|iex` stays in the finding.
+ * Models also mark a resolved or healthy item with the severity `ok`.
+ */
+function findings(body) {
+    const cells = (line) => rowCells(line, 2, 3) ?? rowCells(line, 4, 4);
+    return mapLines(body, cells, ([severity = '', text = '', location, note]) => (SEVERITIES.has(severity) ? { severity: severity, text, location, note } : null), (rows) => ({ kind: 'findings', rows }));
+}
+/**
+ * `ui-callout <tone> [title]`. Models sometimes omit the tone or write a row tone word: a row tone word maps to
+ * its callout tone, and without any tone word the callout is `info` with the whole text after the name as title.
+ */
+function callout(args, body) {
+    const [word = '', ...rest] = args.split(/\s+/u).filter(Boolean);
+    const tone = CALLOUT_TONES.has(word) ? word : CALLOUT_TONE_ALIASES.get(word);
+    const title = (tone === undefined ? args : rest.join(' ')) || undefined;
+    return { kind: 'callout', tone: tone ?? 'info', title, body };
+}
+/**
+ * Split one row into trimmed cells; outer pipes are optional and `\|` is a literal pipe. `lenient` also
+ * keeps pipes inside balanced backtick code and pipes touching text on both sides (`fetch|iex`) as literal.
+ */
+export function answerCells(line, lenient = false) {
+    let text = line.trim();
+    if (text.startsWith('|'))
+        text = text.slice(1);
+    if (text.endsWith('|') && !text.endsWith('\\|'))
+        text = text.slice(0, -1);
+    const codeAware = lenient && (text.match(/`/gu)?.length ?? 0) % 2 === 0;
+    const cells = [];
+    let cell = '';
+    let inCode = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (char === '\\' && text[index + 1] === '|') {
+            cell += '|';
+            index += 1;
+        }
+        else if (char === '`') {
+            if (codeAware)
+                inCode = !inCode;
+            cell += char;
+        }
+        else if (char === '|' && !(inCode || (lenient && /\S/u.test(text[index - 1] ?? ' ') && /\S/u.test(text[index + 1] ?? ' ')))) {
+            cells.push(cell.trim());
+            cell = '';
+        }
+        else {
+            cell += char;
+        }
+    }
+    cells.push(cell.trim());
+    return cells;
+}
+/** Nonblank lines, skipping a Markdown table delimiter row. */
+function dataLines(body) {
+    return body.split(/\r?\n/u).filter((line) => line.trim() && !(line.includes('-') && /^[\s|:-]+$/u.test(line)));
+}
+/**
+ * Cells of a row with `min..=max` nonempty cells, or null. A row with too many cells is split again
+ * leniently, since models write unescaped pipes inside commands such as `fetch|iex`.
+ */
+function rowCells(line, min, max) {
+    const valid = (cells) => cells.length >= min && cells.length <= max && cells.every(Boolean);
+    const cells = answerCells(line);
+    if (valid(cells))
+        return cells;
+    if (cells.length <= max)
+        return null;
+    const lenient = answerCells(line, true);
+    return valid(lenient) ? lenient : null;
+}
+/** Parse rows of `min..=max` nonempty cells (trailing cells optional) and wrap them; null when invalid. */
+function mapRows(body, min, max, row, wrap) {
+    return mapLines(body, (line) => rowCells(line, min, max), row, wrap);
+}
+/** Parse rows whose cells come from `cells` and wrap them; null when a row is invalid or the row count is out of range. */
+function mapLines(body, cells, row, wrap) {
+    const lines = dataLines(body);
+    if (lines.length === 0 || lines.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const rows = [];
+    for (const line of lines) {
+        const split = cells(line);
+        const parsed = split === null ? null : row(split);
+        if (parsed === null)
+            return null;
+        rows.push(parsed);
+    }
+    return wrap(rows);
+}
+/** Split a leading tone word from a cell. */
+function toned(cell) {
+    const [word = '', ...rest] = cell.split(' ');
+    return TONES.has(word) ? { tone: word, text: rest.join(' ').trim() } : { text: cell };
+}
+/** A finite number, or null. */
+function number(text) {
+    return NUMBER.test(text) ? Number(text) : null;
+}
+/**
+ * `label | value [| maximum [| unit]] [| tone]`; a maximum requires a nonnegative numeric value, and a
+ * value above it is an overrun whose tone defaults to `no`. Models also write `label | value | unit`: a lone
+ * third cell that is not an unsigned number (a change such as `+477` included) is read as the unit, without a
+ * meter, and the value may then be text such as `127 → 604`. Models also leave the maximum and unit
+ * cells empty to keep the columns aligned (`label | value | | | tone`, `label | value | | MB`); an empty cell in
+ * those two positions means the value is absent, while an empty label, value or any other cell is malformed.
+ */
+function metric(input) {
+    const cells = [...input];
+    if (!cells[0] || !cells[1])
+        return null;
+    const last = cells[cells.length - 1] ?? '';
+    const tone = cells.length > 2 && TONES.has(last) ? cells.pop() : undefined;
+    if (cells.slice(4).some((cell) => !cell))
+        return null;
+    const [label = '', value = ''] = cells;
+    const maximum = cells[2] || undefined;
+    const unit = cells[3] || undefined;
+    if (maximum === undefined)
+        return { label, value, unit, tone };
+    // A signed third cell such as `+477` is a change, never a maximum, so it reads as the unit too.
+    const max = /^[+-]/u.test(maximum) ? null : number(maximum);
+    if (max === null && unit === undefined)
+        return { label, value, unit: maximum, tone };
+    const numeric = number(value);
+    if (numeric === null || max === null || max <= 0 || numeric < 0)
+        return null;
+    const over = numeric > max;
+    return { label, value, numeric, maximum: max, over, unit, tone: tone ?? (over ? 'no' : undefined) };
+}
+/**
+ * Cells of one metric row, 2..=5 of them, keeping empty cells for `metric` to judge; a row with too many cells
+ * is split again leniently, as `rowCells` does.
+ */
+function metricCells(line) {
+    const fits = (cells) => cells.length >= 2 && cells.length <= 5;
+    const cells = answerCells(line);
+    if (fits(cells))
+        return cells;
+    if (cells.length <= 5)
+        return null;
+    const lenient = answerCells(line, true);
+    return fits(lenient) ? lenient : null;
+}
+/** Decision matrix: a header of criterion and at least two options, then one row per criterion. */
+function compare(body) {
+    const [headerLine, ...lines] = dataLines(body);
+    if (!headerLine || lines.length === 0 || lines.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const header = rowCells(headerLine, 3, Number.MAX_SAFE_INTEGER);
+    if (header === null)
+        return null;
+    const rows = [];
+    for (const line of lines) {
+        const cells = rowCells(line, header.length, header.length);
+        if (cells === null)
+            return null;
+        rows.push({ criterion: cells[0] ?? '', cells: cells.slice(1).map(toned) });
+    }
+    return { kind: 'compare', header, rows };
+}
+/**
+ * `path | +added -removed | note` rows; both later cells are optional, totals are summed. Models also write one
+ * side only (`+145`), a change label in place of the counts (`path | new | note`), or leave the counts cell empty
+ * to keep the columns aligned (`path | | note`); all are accepted.
+ */
+function files(body) {
+    let added = 0;
+    let removed = 0;
+    return mapLines(body, fileCells, ([path = '', second, third]) => {
+        const delta = second === undefined ? null : lineDelta(second);
+        if (delta === null && third !== undefined)
+            return { path, status: second, note: third };
+        if (delta === null)
+            return { path, note: second };
+        added += delta.added ?? 0;
+        removed += delta.removed ?? 0;
+        return { path, ...delta, note: third };
+    }, (rows) => ({ kind: 'files', files: rows, added, removed }));
+}
+/**
+ * Cells of one `ui-files` row: 1..=3 nonempty cells, or `path | | note` with an empty counts cell, read as
+ * `path | note`. Any other empty cell still makes the row malformed.
+ */
+function fileCells(line) {
+    const plain = rowCells(line, 1, 3);
+    if (plain !== null)
+        return plain;
+    const [path, counts, note, ...rest] = answerCells(line);
+    return rest.length === 0 && path && counts === '' && note ? [path, note] : null;
+}
+/** Line counts of `+added -removed`, `+added` or `-removed` (`−` also marks removals); null for other text. */
+function lineDelta(cell) {
+    const match = /^(?:\+(\d+)(?:\s+[-−](\d+))?|[-−](\d+))$/u.exec(cell);
+    if (match === null)
+        return null;
+    const removed = match[2] ?? match[3];
+    return {
+        ...(match[1] === undefined ? {} : { added: Number(match[1]) }),
+        ...(removed === undefined ? {} : { removed: Number(removed) }),
+    };
+}
+/**
+ * `status | item | note` rows. Models sometimes add a fourth location cell as in `ui-findings`; it is accepted
+ * only when it is path-shaped, so a genuinely extra column of prose still invalidates the component.
+ */
+function checklist(body) {
+    const cells = (line) => {
+        const plain = rowCells(line, 2, 3);
+        if (plain !== null)
+            return plain;
+        const located = rowCells(line, 4, 4);
+        return located !== null && answerLocationPath(located[3] ?? '') !== null ? located : null;
+    };
+    return mapLines(body, cells, ([status = '', item = '', note, location]) => (STATUSES.has(status) ? { status: status, item, note, location } : null), (items) => ({ kind: 'checklist', items }));
+}
+/**
+ * The file path of a path-shaped location such as `src/a.rs:42`, or null for prose: only a token without
+ * spaces or full-width punctuation and with a separator or an extension is a file. The `:line` or
+ * `:line:column` suffix is stripped.
+ */
+export function answerLocationPath(location) {
+    const path = location.trim().replace(/:\d+(?::\d+)?$/u, '');
+    if (!/^[^\s\u3000-\u303f\uff00-\uffef]+$/u.test(path) || !/[\\/]|\.[\p{L}\p{N}]+$/u.test(path))
+        return null;
+    return path;
+}
+/** Split a leading plan marker (`+ `, `- `, `~ `) from a line; a leading `\` keeps the text literal. */
+function change(line) {
+    if (line.startsWith('\\'))
+        return { text: line.slice(1) };
+    const marker = /^([+~-]) /u.exec(line);
+    if (!marker)
+        return { text: line };
+    const mark = marker[1] === '+' ? 'add' : marker[1] === '-' ? 'del' : 'chg';
+    return { mark, text: line.slice(2).trimStart() };
+}
+/** Indentation tree with optional `label | note`; tabs count as four columns. */
+function tree(body) {
+    const lines = body.split(/\r?\n/u).filter((line) => line.trim());
+    if (lines.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const roots = [];
+    const stack = [];
+    for (const line of lines) {
+        const indent = [...(/^\s*/u.exec(line)?.[0] ?? '')].reduce((width, ch) => width + (ch === '\t' ? 4 : 1), 0);
+        const { mark, text } = change(line.trim());
+        const split = text.indexOf('|');
+        const label = (split < 0 ? text : text.slice(0, split)).trim();
+        const note = split < 0 ? undefined : text.slice(split + 1).trim() || undefined;
+        const node = { label, note, mark, children: [] };
+        while (stack.length > 0 && (stack[stack.length - 1]?.indent ?? -1) >= indent)
+            stack.pop();
+        const parent = stack[stack.length - 1];
+        (parent ? parent.node.children : roots).push(node);
+        stack.push({ indent, node });
+    }
+    return { kind: 'tree', nodes: roots };
+}
+/** `### Title` lines split the body into titled Markdown sections; two or more nonempty sections. */
+function sections(kind, body) {
+    const result = [];
+    let current = null;
+    for (const line of body.split(/\r?\n/u)) {
+        if (line.startsWith('### ')) {
+            if (current)
+                result.push({ title: current.title, body: current.lines.join('\n').trim() });
+            current = { title: line.slice(4).trim(), lines: [] };
+        }
+        else if (current) {
+            current.lines.push(line);
+        }
+        else if (line.trim()) {
+            return null;
+        }
+    }
+    if (current)
+        result.push({ title: current.title, body: current.lines.join('\n').trim() });
+    if (result.length < 2 || result.length > ANSWER_COMPONENT_MAX_ROWS || result.some((section) => !section.body))
+        return null;
+    return { kind, sections: result };
+}
+/** `ui-chart <kind> [title]`: header row of category and series names, then one number per series. */
+function chart(args, body) {
+    const [kind = '', ...title] = args.split(/\s+/u).filter(Boolean);
+    if (!CHART_KINDS.has(kind))
+        return null;
+    const [headerLine, ...lines] = dataLines(body);
+    if (!headerLine || lines.length === 0 || lines.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const header = rowCells(headerLine, 2, ANSWER_CHART_MAX_SERIES + 1);
+    const circular = kind === 'pie' || kind === 'donut';
+    if (header === null || (circular && header.length !== 2))
+        return null;
+    const rows = [];
+    for (const line of lines) {
+        const cells = rowCells(line, header.length, header.length);
+        if (cells === null)
+            return null;
+        const values = cells.slice(1).map((cell) => number(cell.replace(/%$/u, '').trim()));
+        if (values.some((value) => value === null))
+            return null;
+        rows.push({ category: cells[0] ?? '', values: values });
+    }
+    if ((circular || kind === 'stack') && rows.some((row) => row.values.some((value) => value < 0)))
+        return null;
+    if (circular && rows.reduce((sum, row) => sum + (row.values[0] ?? 0), 0) <= 0)
+        return null;
+    return {
+        kind: 'chart',
+        chart: { kind: kind, title: title.join(' ') || undefined, categoryLabel: header[0] ?? '', series: header.slice(1), rows },
+    };
+}
+/** Split at the first ASCII or full-width colon, or a `|`, into a trimmed head and an optional tail. */
+function labelled(text) {
+    const index = text.search(/[:：|]/u);
+    return index < 0 ? { head: text.trim() } : { head: text.slice(0, index).trim(), tail: text.slice(index + 1).trim() };
+}
+/** Flow node outline and label from one node spec: `[(Store)]`, `{Decision}`, `(Start)`, `[Box]` or plain. */
+function flowNode(spec) {
+    const text = spec.trim();
+    const outlines = [['[(', ')]', 'store'], ['{', '}', 'decision'], ['(', ')', 'terminal'], ['[', ']', 'box']];
+    for (const [open, close, shape] of outlines) {
+        if (text.length >= open.length + close.length && text.startsWith(open) && text.endsWith(close)) {
+            const label = text.slice(open.length, text.length - close.length).trim();
+            return label ? { label, shape } : null;
+        }
+    }
+    return text ? { label: text, shape: 'box' } : null;
+}
+/** Mermaid node outlines, longer openings first, with the closest `ui-flow` outline. */
+const MERMAID_OUTLINES = [
+    ['([', '])', 'terminal'], ['[[', ']]', 'box'], ['((', '))', 'terminal'], ['{{', '}}', 'box'], ['[/', '/]', 'box'],
+    ['[\\', '\\]', 'box'], ['[(', ')]', 'store'], ['[', ']', 'box'], ['(', ')', 'terminal'], ['{', '}', 'decision'],
+];
+/**
+ * A Mermaid-style node `ID[text]`: an identifier followed directly by an outline with nonempty text.
+ * `paren` marks the plain `(` outline, which also reads as a call such as `f(x)`.
+ */
+function mermaidNode(spec) {
+    const match = /^([A-Za-z_][\w-]*)([[({].*)$/u.exec(spec);
+    if (!match)
+        return null;
+    const id = match[1] ?? '';
+    const outline = match[2] ?? '';
+    for (const [open, close, shape] of MERMAID_OUTLINES) {
+        if (outline.length >= open.length + close.length && outline.startsWith(open) && outline.endsWith(close)) {
+            const label = outline.slice(open.length, outline.length - close.length).trim();
+            return label ? { id, label, shape, paren: open === '(' } : null;
+        }
+    }
+    return null;
+}
+/**
+ * `ui-flow [LR]`: one chain per line; nodes keep their first outline unless a later one is explicit. A
+ * Mermaid ID such as `B` in `B{OK?}` names the node `OK?` throughout the fence. A plain `(` outline counts
+ * only when its ID also stands alone, so `f(x)` stays text.
+ */
+function flow(horizontal, body) {
+    const lines = dataLines(body);
+    if (lines.length === 0 || lines.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const parsedLines = lines.map((line) => {
+        const { mark, text } = change(line.trim());
+        const parts = [];
+        const dashed = [];
+        let rest = text;
+        for (let index = rest.indexOf('->'); index >= 0; index = rest.indexOf('->')) {
+            const dash = index > 0 && rest[index - 1] === '-';
+            parts.push(rest.slice(0, dash ? index - 1 : index));
+            dashed.push(dash);
+            rest = rest.slice(index + 2);
+        }
+        if (parts.length === 0)
+            return { mark, groups: [[text.trim()]], dashed, label: undefined, lone: true };
+        const { head, tail } = labelled(rest);
+        parts.push(head);
+        return { mark, groups: parts.map((part) => part.split('&').map((spec) => spec.trim())), dashed, label: tail, lone: false };
+    });
+    const specs = parsedLines.flatMap((line) => line.groups.flat());
+    const standalone = new Set(specs);
+    const aliases = new Map();
+    for (const spec of specs) {
+        const mermaid = mermaidNode(spec);
+        if (mermaid && (!mermaid.paren || standalone.has(mermaid.id)))
+            aliases.set(mermaid.id, mermaid.label);
+    }
+    const nodes = [];
+    const ids = new Map();
+    const chains = [];
+    const changed = new Set();
+    const node = (spec) => {
+        const mermaid = mermaidNode(spec);
+        const alias = aliases.get(spec);
+        const parsed = mermaid && aliases.has(mermaid.id) ? mermaid
+            : alias !== undefined ? { label: alias, shape: 'box' }
+                : flowNode(spec);
+        if (parsed === null)
+            return null;
+        let id = ids.get(parsed.label);
+        if (id === undefined) {
+            id = nodes.push({ label: parsed.label, shape: 'box' }) - 1;
+            ids.set(parsed.label, id);
+        }
+        const entry = nodes[id];
+        if (entry && parsed.shape !== 'box')
+            entry.shape = parsed.shape;
+        return id;
+    };
+    for (const { mark, groups: specGroups, dashed, label, lone } of parsedLines) {
+        if (lone) {
+            const id = node(specGroups[0]?.[0] ?? '');
+            if (id === null)
+                return null;
+            if (mark === 'chg')
+                changed.add(id);
+            chains.push({ groups: [[id]], dashed: [], mark });
+            continue;
+        }
+        const groups = [];
+        for (const part of specGroups) {
+            const group = part.map(node);
+            if (group.some((id) => id === null))
+                return null;
+            groups.push(group);
+        }
+        chains.push({ groups, dashed, label: label || undefined, mark });
+    }
+    // Nodes drawn only on added (or only on removed) chains carry that marker; `~ Node` lines mark changes.
+    const linked = new Set();
+    nodes.forEach((entry, id) => {
+        const marks = new Set(chains.filter((chain) => chain.groups.length > 1 && chain.groups.some((group) => group.includes(id))).map((chain) => chain.mark));
+        if (marks.size > 0)
+            linked.add(id);
+        const [only] = [...marks];
+        if (marks.size === 1 && (only === 'add' || only === 'del'))
+            entry.mark = only;
+        if (changed.has(id))
+            entry.mark = 'chg';
+    });
+    // A lone node line only declares or marks a node that already appears on a chain.
+    const shown = chains.filter((chain) => chain.groups.length > 1 || !linked.has(chain.groups[0]?.[0] ?? -1));
+    return { kind: 'flow', horizontal, nodes, chains: shown };
+}
+/** `ui-sequence [num]`: messages, notes and phases; actors appear in first-use order. */
+function sequence(numbered, body) {
+    const lines = dataLines(body);
+    if (lines.length === 0 || lines.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const actors = [];
+    const actor = (name) => {
+        const trimmed = name.trim();
+        if (!trimmed)
+            return null;
+        const known = actors.indexOf(trimmed);
+        return known >= 0 ? known : actors.push(trimmed) - 1;
+    };
+    const steps = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (line.length >= 4 && line.startsWith('==') && line.endsWith('==')) {
+            steps.push({ kind: 'phase', text: line.slice(2, -2).trim() });
+            continue;
+        }
+        if (line.startsWith('note ')) {
+            const { head, tail } = labelled(line.slice(5));
+            const indexes = head.split(/[,，]/u).map(actor);
+            if (tail === undefined || indexes.some((index) => index === null))
+                return null;
+            const span = indexes;
+            steps.push({ kind: 'note', first: Math.min(...span), last: Math.max(...span), text: tail });
+            continue;
+        }
+        const { mark, text } = change(line);
+        const index = text.indexOf('->');
+        if (index < 0)
+            return null;
+        const dashed = index > 0 && text[index - 1] === '-';
+        const from = actor(text.slice(0, dashed ? index - 1 : index));
+        const { head, tail } = labelled(text.slice(index + 2));
+        const to = actor(head);
+        if (from === null || to === null)
+            return null;
+        steps.push({ kind: 'message', from, to, dashed, text: tail ?? '', mark });
+    }
+    return actors.length > 0 ? { kind: 'sequence', numbered, actors, steps } : null;
+}
+const ER_KEYS = new Set(['PK', 'FK', 'UK']);
+/** Split a trailing `| note` from a line into a trimmed head and an optional nonempty note. */
+function noted(text) {
+    const split = text.indexOf('|');
+    if (split < 0)
+        return { head: text.trim() };
+    return { head: text.slice(0, split).trim(), note: text.slice(split + 1).trim() || undefined };
+}
+/**
+ * `ui-er [LR|TB]`: unindented lines name tables, indented lines are `name [type] [PK|FK|UK] [-> Table]`
+ * fields; every reference must name a table of the same diagram.
+ */
+function er(horizontal, body) {
+    const lines = body.split(/\r?\n/u).filter((line) => line.trim());
+    if (lines.length === 0 || lines.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const tables = [];
+    const references = [];
+    for (const line of lines) {
+        const { mark, text } = change(line.trim());
+        const { head, note } = noted(text);
+        if (!head)
+            return null;
+        if (!/^\s/u.test(line)) {
+            tables.push({ name: head, note, mark, fields: [] });
+            continue;
+        }
+        const table = tables[tables.length - 1];
+        if (!table)
+            return null;
+        const arrow = head.indexOf('->');
+        const target = arrow < 0 ? undefined : head.slice(arrow + 2).trim();
+        if (target === '')
+            return null;
+        const [name, ...rest] = (arrow < 0 ? head : head.slice(0, arrow)).trim().split(/\s+/u).filter(Boolean);
+        if (!name)
+            return null;
+        const keys = rest.filter((token) => ER_KEYS.has(token));
+        if (target !== undefined && !keys.includes('FK'))
+            keys.push('FK');
+        const type = rest.filter((token) => !ER_KEYS.has(token)).join(' ') || undefined;
+        const field = { name, type, keys, note, mark };
+        table.fields.push(field);
+        if (target !== undefined)
+            references.push({ field, target });
+    }
+    const names = tables.map((table) => table.name);
+    if (new Set(names).size !== names.length)
+        return null;
+    for (const reference of references) {
+        const index = names.indexOf(reference.target);
+        if (index < 0)
+            return null;
+        reference.field.target = index;
+    }
+    return { kind: 'er', horizontal, tables };
+}
+/**
+ * `ui-math [title]`: formula lines, then after a blank line optional `symbol | meaning` legend rows. Each
+ * formula line is one displayed equation unless the formula uses a `\begin` environment.
+ */
+function math(args, body) {
+    const lines = body.split(/\r?\n/u);
+    while (lines.length > 0 && !lines[0]?.trim())
+        lines.shift();
+    while (lines.length > 0 && !lines[lines.length - 1]?.trim())
+        lines.pop();
+    // Models also separate groups of equations with blank lines, so only the group after the last blank line can
+    // be the legend: it is one when every row is `symbol | meaning`, further formulas when none is, and a mix is
+    // invalid. Every earlier group is formulas.
+    let blank = lines.length - 1;
+    while (blank >= 0 && lines[blank]?.trim())
+        blank -= 1;
+    const after = blank < 0 ? [] : dataLines(lines.slice(blank + 1).join('\n'));
+    const legendRows = after.map((line) => rowCells(line, 2, 2));
+    const isLegend = legendRows.every((cells) => cells !== null);
+    if (!isLegend && legendRows.some((cells) => cells !== null))
+        return null;
+    const formula = (blank < 0 ? lines : lines.slice(0, blank)).map((line) => line.trim()).filter(Boolean)
+        .concat(isLegend ? [] : after.map((line) => line.trim()));
+    const legend = isLegend ? legendRows : [];
+    if (formula.length === 0 || formula.length + legend.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const symbols = legend.map(([symbol = '', meaning = '']) => ({ symbol, meaning }));
+    const equations = formula.some((line) => line.includes('\\begin')) ? [formula.join('\n')] : formula;
+    return { kind: 'math', title: args || undefined, equations, symbols };
+}
+/**
+ * One decision option line: `* text` (recommended) or `- text`. Models also write the recommendation as `*text`
+ * without the space; a line wrapped in or opening with emphasis (`*Q?*`, `**Q?**`) stays text. `-` still needs
+ * its space so labels such as `-3` are not read as options.
+ */
+function decisionOption(line) {
+    if (line.startsWith('* ') || line.startsWith('- '))
+        return { recommended: line.startsWith('*'), text: line.slice(2) };
+    if (line.startsWith('*') && !line.startsWith('**') && !line.endsWith('*'))
+        return { recommended: true, text: line.slice(1) };
+    return null;
+}
+/**
+ * `ui-decision [multi]`: the question line, then option lines `* label | note` (the recommended option)
+ * or `- label | note`. Labels are unique; a single choice recommends at most one option. A body whose first
+ * line is already an option has no question; the reply summary then names it by its options.
+ */
+function decision(multiple, body) {
+    const rows = body.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+    const [first = ''] = rows;
+    const question = decisionOption(first) === null ? first : '';
+    const lines = question ? rows.slice(1) : rows;
+    if (lines.length < 2 || lines.length > ANSWER_COMPONENT_MAX_ROWS)
+        return null;
+    const options = [];
+    for (const line of lines) {
+        const option = decisionOption(line);
+        const cells = option === null ? null : rowCells(option.text, 1, 2);
+        const label = cells?.[0];
+        if (option === null || cells === null || label === undefined || options.some((item) => item.label === label))
+            return null;
+        options.push({ label, note: cells[1], recommended: option.recommended });
+    }
+    if (!multiple && options.filter((option) => option.recommended).length > 1)
+        return null;
+    return { kind: 'decision', multiple, question, options };
+}