aontu 0.54.0 → 0.55.0

package/dist/view.js

@@ -1,6 +1,7 @@
 "use strict";
 /* Copyright (c) 2026 Richard Rodger, MIT License */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewDefaultProfile = viewDefaultProfile;
 exports.view = view;
 exports.viewTree = viewTree;
 exports.viewSet = viewSet;
@@ -41,7 +42,7 @@ exports.viewSet = viewSet;
 // emitted order, not of the model) -- and leave the verdict `rendered`. Every
 // other code makes it `lossy`, which `--strict` refuses: a figure that
 // quietly omits things is the failure this capability exists to avoid.
-const path_1 = require("path");
+const node_path_1 = require("node:path");
 const aontu_1 = require("./aontu");
 const vet_1 = require("./vet");
 const graph_1 = require("./graph");
@@ -49,10 +50,27 @@ const keyorder_1 = require("./keyorder");
 const provenance_1 = require("./provenance");
 const query_1 = require("./query");
 const subsume_1 = require("./subsume");
+// The text profile's mechanism: the eight named colours, `bold` and
+// `dim`, and nothing else. `label` is unstyled -- an entity's own name
+// is the figure's content, not a mark about it.
+const SGR = {
+    label: '', muted: '2', rule: '2', direct: '1', closure: '36',
+    unmirrored: '33', upward: '31', repeat: '2', bar: '36', hole: '2',
+};
+const PLAIN = (_role, text) => text;
+const ANSI = (role, text) => '' === SGR[role] || '' === text
+    ? text : `\x1b[${SGR[role]}m${text}\x1b[0m`;
+const painter = (style) => 'ansi' === style ? ANSI : PLAIN;
+// The style a figure gets when the caller named none. An SVG carries
+// its stylesheet, which is what makes it standalone and what every
+// pinned golden holds; everything else carries no mechanism, since a
+// library cannot see whether its output is a terminal.
+const styleOf = (style, as) => style ?? ('svg' === as ? 'css' : 'none');
 // Each kind's profiles, the first being its default. There is no
 // global default, because there is no sensible text form of a
 // node-link drawing and no sensible Mermaid form of a matrix.
 const PROFILES = {
+    doc: ['text', 'svg'],
     tree: ['text', 'svg'],
     matrix: ['text', 'svg'],
     graph: ['mermaid', 'dot', 'er'],
@@ -62,6 +80,12 @@ const PROFILES = {
     ladder: ['mermaid', 'dot'],
     poset: ['mermaid', 'dot'],
 };
+// The profile a kind draws into when none is asked for. The CLI needs
+// it to resolve `--style auto` BEFORE the library runs, since the
+// mechanism is the profile's.
+function viewDefaultProfile(kind) {
+    return PROFILES[kind]?.[0];
+}
 // Loss codes that describe the drawing rather than a gap in it.
 const INFORMATIONAL = ['edges_deduped', 'inverse_suppressed', 'crossings'];
 const DEFAULT_MAX_ROWS = 60;
@@ -323,11 +347,16 @@ const SVG_STYLE = '<style>' +
 const svgEsc = (s) => escape(s, SVG_ESC);
 // The document: a viewBox the size of the figure, the style, and the
 // parts, one per line, so the bytes read as a figure and diff as one.
-function svgDoc(w, h, about, parts) {
+function svgDoc(w, h, about, parts, style) {
+    // The CLASSES are structure and are always written -- a rect that
+    // does not say whether it is a direct cell or a closure cell is not
+    // a figure. What `--style none` drops is the STYLESHEET, for a host
+    // page that has already bound the variables and would otherwise
+    // carry one copy of these rules per embedded figure.
     return [
         `<svg xmlns="http://www.w3.org/2000/svg" class="av" viewBox="0 0 ${w} ${h}" ` +
             `width="${w}" height="${h}" role="img" aria-label="${svgEsc(about)}">`,
-        SVG_STYLE,
+        ...('css' === style ? [SVG_STYLE] : []),
         ...parts,
         '</svg>',
     ].join('\n');
@@ -394,7 +423,8 @@ function collapse(triples, relation) {
     // One winner per pair, so (from, to) is unique and orders the set.
     return out.sort((x, y) => (0, keyorder_1.cmpCodePoint)(x.from, y.from) || (0, keyorder_1.cmpCodePoint)(x.to, y.to));
 }
-function drawTree(all, relation, roots, max, as) {
+function drawTree(all, relation, roots, max, as, style) {
+    const paint = painter(style);
     // With a relation named, the tree is OVER THAT RELATION. A node-link
     // diagram can label each edge and so draw every relation at once; a
     // tree cannot without becoming unreadable, and walking two relations
@@ -479,7 +509,8 @@ function drawTree(all, relation, roots, max, as) {
             const grown = 0 < kids.get(edge.to).length;
             const text = label(edge.to) + (many ? ' (' + edge.label + ')' : '');
             const mark = loop ? ' (cycle)' : (seen && grown ? ' (*)' : '');
-            out.push(frame.prefix + (last ? '└── ' : '├── ') + text + mark);
+            out.push(paint('rule', frame.prefix + (last ? '└── ' : '├── '))
+                + text + paint('repeat', mark));
             rows.push({ depth: stack.length, text, mark, parent: frame.row });
             if (loop || seen) {
                 continue;
@@ -511,13 +542,17 @@ function drawTree(all, relation, roots, max, as) {
             }
         }
     }
-    return { text: 'svg' === as ? treeSvg(rows, nodes.length) : out.join('\n') };
+    return {
+        text: 'svg' === as
+            ? treeSvg(rows, `Dependency tree: ${nodes.length} nodes`, style)
+            : out.join('\n'),
+    };
 }
 // The tree as SVG: one line per row, each node indented one unit per
 // depth, joined to its parent by a path that drops from the parent's
 // row and turns in to the child. The marks are muted text after the
 // label.
-function treeSvg(rows, count) {
+function treeSvg(rows, about, style) {
     const U = 24;
     const parts = [];
     let width = 0;
@@ -537,7 +572,138 @@ function treeSvg(rows, count) {
                 `</tspan><tspan class="av-m">${svgEsc(r.mark)}</tspan></text>`);
         width = Math.max(width, x + (r.text.length + r.mark.length) * CH);
     });
-    return svgDoc(width + PAD, rows.length * LH + PAD, `Dependency tree: ${count} nodes`, parts);
+    return svgDoc(width + PAD, rows.length * LH + PAD, about, parts, style);
+}
+// ---------------------------------------------------------------------
+// The document tree
+// THE SHAPE OF THE MODEL ITSELF, which no other kind draws. Every
+// other figure here reads a REPORT -- the edge set, the provenance
+// record, the subsumption order -- and so can only draw a document
+// that has links, contributions or peers. A reader meeting a model for
+// the first time wants the plainer thing first: what is in it, and how
+// it is arranged.
+//
+// This is `get --keys --types` as a picture, and it reads the same
+// walk: map keys in code-point order, list indices in order, and a
+// leaf's KIND rather than its value -- the canon of a scalar's type,
+// not the scalar. Values are what the document is for; the shape is
+// what a reader needs before any of them mean anything.
+//
+// DEPTH IS A BOUND, NOT AN ELISION MARK. Below it the subtree is not
+// drawn and the row says how many keys were not drawn, because a tree
+// that stops without saying so is the one thing a structural drawing
+// must not be.
+const DEFAULT_DOC_DEPTH = 3;
+// A node's own children, as the anchor walk sees them: map keys sorted
+// by code point, list indices in order, and nothing for a leaf.
+function docKids(v) {
+    const node = throughDoc(v);
+    if (true === node?.isMap) {
+        // AN ALIAS DECLARATION IS NOT PART OF THE DOCUMENT
+        // (docs/reference-language.md, "Aliases"): it does not generate
+        // and it does not appear in canon. It IS a key of the root map in
+        // the value tree, which `get --keys` reports and this does not --
+        // a figure of the document's shape that showed `%Cents` beside
+        // `customers` would be drawing the declaration as data
+        // (use-cases/BUGS.md 74).
+        return Object.keys(node.peg)
+            .filter((k) => !k.startsWith('%')).sort(keyorder_1.cmpCodePoint);
+    }
+    if (true === node?.isList) {
+        return Object.keys(node.peg).filter((k) => /^[0-9]+$/.test(k));
+    }
+    return [];
+}
+// A preference wraps its value without being a level of its own, and
+// `anchorAt` already steps through a sizing residue; this is the same
+// unwrapping, for the shape walk.
+function throughDoc(v) {
+    // Every caller reaches this with a Val the anchor walk handed over,
+    // so the node is never absent and the optional chain that would say
+    // otherwise is an arm no test can take.
+    const node = (0, vet_1.throughResidue)(v);
+    return true === node.isPref ? throughDoc(node.peg) : node;
+}
+// What a leaf IS, in one short word: its canon, which for a constraint
+// is the constraint and for a scalar its value. Long canons are cut,
+// since the figure is the shape and not the data.
+function docLeaf(v) {
+    // A CONTAINER WITH NOTHING IN IT IS NOT A LEAF, and calling it one
+    // by writing nothing after the key would make it read as a value the
+    // figure declined to describe. Its canon says what it is -- `{}`,
+    // `[]`, or a template a spread wrote and no member filled.
+    //
+    // `canon` is a string on every Val, so there is no other-type arm to
+    // take; the cut is the only decision here.
+    const canon = throughDoc(v).canon;
+    return 32 < canon.length ? canon.slice(0, 29) + '...' : canon;
+}
+function drawDoc(root, o, max, loss) {
+    const paint = painter(o.style);
+    const at = o.at ?? '$';
+    const anchor = (0, vet_1.anchorAt)(root, at);
+    if (null == anchor) {
+        return {
+            // The same code and the same sentence `get` answers with: the
+            // question is identical, so a caller that already handles one
+            // handles the other.
+            errors: [finding('no_path', 'reference', at, `The path ${at} names nothing in this document.`)],
+        };
+    }
+    const depth = o.depth ?? DEFAULT_DOC_DEPTH;
+    const out = [];
+    const rows = [];
+    let elided = 0;
+    out.push(at);
+    rows.push({ depth: 0, text: at, mark: '', parent: 0 });
+    const stack = [
+        { node: anchor, kids: docKids(anchor), at: 0, prefix: '', row: 0 },
+    ];
+    while (0 < stack.length) {
+        const frame = stack[stack.length - 1];
+        if (frame.at >= frame.kids.length) {
+            stack.pop();
+            continue;
+        }
+        const key = frame.kids[frame.at++];
+        const last = frame.at === frame.kids.length;
+        const child = throughDoc(throughDoc(frame.node).peg[key]);
+        const kids = docKids(child);
+        const under = stack.length < depth;
+        // A container the depth bound stops at says how many keys are not
+        // drawn; a leaf says what it is.
+        // A leaf says what it is and a stopped container says how many
+        // keys it holds; both are written after the key with one space,
+        // and neither is ever empty (a canon has at least one character).
+        const mark = 0 === kids.length ? ' ' + docLeaf(child)
+            : under ? '' : ` (${kids.length})`;
+        if (0 < kids.length && !under) {
+            elided += kids.length;
+        }
+        out.push(paint('rule', frame.prefix + (last ? '└── ' : '├── ')) + key +
+            paint('muted', mark));
+        rows.push({ depth: stack.length, text: key, mark, parent: frame.row });
+        if (max < rows.length) {
+            return {
+                errors: [rowsFinding(rows.length, max, '--at or --depth')],
+            };
+        }
+        if (0 < kids.length && under) {
+            stack.push({
+                node: child, kids, at: 0,
+                prefix: frame.prefix + (last ? '    ' : '│   '),
+                row: rows.length - 1,
+            });
+        }
+    }
+    if (0 < elided) {
+        loss.push({ code: 'depth_elided', count: elided });
+    }
+    return {
+        text: 'svg' === o.as
+            ? treeSvg(rows, `Document tree at ${at}: ${rows.length - 1} keys to depth ${depth}`, o.style)
+            : out.join('\n'),
+    };
 }
 // ---------------------------------------------------------------------
 // The matrix (Ghoniem et al. 2004; Sangal et al. 2005)
@@ -597,6 +763,7 @@ function pickRelation(relation, keys) {
     return { relation: keys[0] ?? '' };
 }
 function drawMatrix(triples, decls, o, max, loss) {
+    const paint = painter(o.style);
     const picked = pickRelation(o.relation, keysOf(triples));
     if (undefined !== picked.error) {
         return { errors: [picked.error] };
@@ -634,7 +801,7 @@ function drawMatrix(triples, decls, o, max, loss) {
     // column stays one character wide.
     for (let d = 0; d < iw; d++) {
         lines.push(' '.repeat(w + 1 + iw + 1) +
-            idx.map((s) => lpad(s, iw)[d]).join(' '));
+            paint('muted', idx.map((s) => lpad(s, iw)[d]).join(' ')));
     }
     let above = 0;
     const grid = [];
@@ -652,14 +819,15 @@ function drawMatrix(triples, decls, o, max, loss) {
                     : o.closure && reach.get(r).has(c) ? '+' : '.';
         });
         grid.push(cells);
-        lines.push(pad(label(r), w) + ' ' + lpad(idx[ri], iw) + ' ' + cells.join(' '));
+        lines.push(pad(label(r), w) + ' ' + paint('muted', lpad(idx[ri], iw)) + ' ' +
+            cells.map((g) => paint(CELL_ROLE[g], g)).join(' '));
     });
     const footer = `# above-diagonal direct cells: ${above}`;
-    lines.push(footer);
+    lines.push(paint('muted', footer));
     if ('svg' === o.as) {
         return {
             text: matrixSvg(order.map(label), idx, grid, footer, `Dependency matrix${over(relation)}: ${order.length} rows, ` +
-                `${above} direct cells above the diagonal`),
+                `${above} direct cells above the diagonal`, o.style),
         };
     }
     return { text: lines.join('\n') };
@@ -670,7 +838,16 @@ const CELL_CLASS = {
     X: 'av-direct', '!': 'av-unmirrored', '+': 'av-closure',
     '.': 'av-cell', '\\': 'av-cell',
 };
-function matrixSvg(labels, idx, grid, footer, about) {
+// The same five states as ROLES, for the text profile. One table per
+// mechanism rather than one shared one, because the two vocabularies
+// are not in step: SVG needs a class for the empty cell (it draws a
+// rect there) and the text profile has nothing to say about a `.`
+// beyond that it is not a mark.
+const CELL_ROLE = {
+    X: 'direct', '!': 'unmirrored', '+': 'closure',
+    '.': 'muted', '\\': 'rule',
+};
+function matrixSvg(labels, idx, grid, footer, about, style) {
     const S = 20;
     const w = widest(labels);
     const iw = widest(idx);
@@ -695,7 +872,7 @@ function matrixSvg(labels, idx, grid, footer, about) {
     const n = labels.length;
     parts.push(svgText(4, y0 + n * S + 16, 'av-m', footer));
     const width = Math.max(gutter + n * S, 4 + footer.length * CH) + PAD;
-    return svgDoc(width, y0 + n * S + LH + PAD, about, parts);
+    return svgDoc(width, y0 + n * S + LH + PAD, about, parts, style);
 }
 // A node's field, as label text: the value of a scalar leaf at
 // `path.field`, taken as its canon for anything but a string. A value
@@ -1001,19 +1178,32 @@ function drawLayer(triples, root, o, max, loss) {
                 ? `${upward} upward edges, none drawn`
                 : `${upward} upward edges`;
         return {
-            text: layerSvg(bands, shown, footer, `Architecture layers${over(relation)}: ${bands.length} bands, ${drew}`),
+            text: layerSvg(bands, shown, footer, `Architecture layers${over(relation)}: ${bands.length} bands, ${drew}`, o.style),
         };
     }
     if ('text' === o.as) {
+        const paint = painter(o.style);
         const w = widest(bands.map((b) => b.name));
-        const rows = bands.map((b) => pad(b.name, w) + '  ' + b.nodes.map((n) => n.label).join('  '));
-        const inner = widest(rows);
-        const rule = '+' + '-'.repeat(inner + 2) + '+';
+        const rows = bands.map((b) => paint('muted', pad(b.name, w)) + '  ' +
+            b.nodes.map((n) => n.label).join('  '));
+        const inner = widest(bands.map((b) => pad(b.name, w) + '  ' + b.nodes.map((n) => n.label).join('  ')));
+        const rule = paint('rule', '+' + '-'.repeat(inner + 2) + '+');
         out.push(rule);
-        for (const row of rows) {
-            out.push('| ' + pad(row, inner) + ' |', rule);
-        }
-        out.push(...footer);
+        rows.forEach((row, i) => {
+            // The row was padded from its UNPAINTED width, which the band
+            // name's escapes do not change; `pad` would count them, so the
+            // padding is computed here and appended.
+            const bare = pad(bands[i].name, w) + '  ' +
+                bands[i].nodes.map((n) => n.label).join('  ');
+            out.push(paint('rule', '|') + ' ' + row +
+                ' '.repeat(inner - bare.length) + ' ' + paint('rule', '|'), rule);
+        });
+        // The first footer line counts; the rest name one edge each, and
+        // an upward edge is the violation the bands cannot show.
+        out.push(paint('muted', footer[0]));
+        footer.slice(1).forEach((f, i) => {
+            out.push(paint('upward' === shown[i].way ? 'upward' : 'muted', f));
+        });
     }
     else {
         const esc = (s) => escape(s, MERMAID_ESC);
@@ -1041,7 +1231,7 @@ function drawLayer(triples, root, o, max, loss) {
 // dipped below the boxes, since two modules of one band sit on the
 // same line and a straight edge between them would cross whatever
 // stands between.
-function layerSvg(bands, shown, footer, about) {
+function layerSvg(bands, shown, footer, about, style) {
     const BH = 44;
     const gutter = widest(bands.map((b) => b.name)) * CH + 16;
     const box = new Map();
@@ -1104,7 +1294,7 @@ function layerSvg(bands, shown, footer, about) {
     footer.forEach((f, i) => {
         parts.push(svgText(4, y1 + i * LH + 14, 'av-m', f));
     });
-    return svgDoc(width, y1 + footer.length * LH + PAD, about, parts);
+    return svgDoc(width, y1 + footer.length * LH + PAD, about, parts, style);
 }
 // Elements grouped by their exact membership signature; columns by
 // degree descending, then cardinality descending, then signature (the
@@ -1129,45 +1319,53 @@ function columnsOf(names, members, elements, shown) {
     return [...groups.values()].sort((a, b) => degree(b) - degree(a) || b.items.length - a.items.length
         || (0, keyorder_1.cmpCodePoint)(sigText(a), sigText(b)));
 }
-function renderPanel(p) {
+function renderPanel(p, style) {
+    const paint = painter(style);
     const w = widest(p.names);
-    const out = [p.header, ''];
+    const out = [paint('muted', p.header), ''];
     const most = p.sizes.reduce((m, n) => Math.max(m, n), 0);
     p.names.forEach((n, i) => {
+        // The bar is padded to `most` from its own length, so the pad is
+        // written outside the painted run rather than counted inside it.
+        const bar = '#'.repeat(p.sizes[i]);
         out.push(pad(n, w) + '  ' +
-            (p.bars ? pad('#'.repeat(p.sizes[i]), most) + '  ' : '') +
-            String(p.sizes[i]));
+            (p.bars ? paint('bar', bar) + ' '.repeat(most - bar.length) + '  ' : '') +
+            paint('muted', String(p.sizes[i])));
     });
     out.push('');
     p.names.forEach((n, i) => {
-        out.push(pad(n, w) + ' | ' +
-            p.cols.map((c) => c.sig[i] ? '*' : '.').join(' '));
+        out.push(pad(n, w) + ' ' + paint('rule', '|') + ' ' +
+            p.cols.map((c) => c.sig[i] ? paint('direct', '*') : paint('hole', '.'))
+                .join(' '));
     });
-    out.push(pad('', w) + ' +' + '-'.repeat(2 * p.cols.length));
+    out.push(pad('', w) + ' ' + paint('rule', '+' + '-'.repeat(2 * p.cols.length)));
     if (p.bars) {
         const tallest = p.cols.reduce((m, c) => Math.max(m, c.items.length), 0);
-        // The bars, tallest column first; a line ends at its last bar.
+        // The bars, tallest column first; a line ends at its last bar. The
+        // trailing blanks are trimmed BEFORE painting, so an escape can
+        // never be what the trim leaves behind.
         for (let h = tallest; 0 < h; h--) {
-            out.push((pad('', w) + ' |' +
-                p.cols.map((c) => h <= c.items.length ? ' #' : '  ').join(''))
-                .replace(/ +$/, ''));
+            const cells = p.cols.map((c) => h <= c.items.length ? ' #' : '  ')
+                .join('').replace(/ +$/, '');
+            out.push(pad('', w) + ' ' + paint('rule', '|') +
+                cells.replace(/#/g, () => paint('bar', '#')));
         }
     }
     out.push(pad('', w) + '   ' +
-        p.cols.map((c) => String(c.items.length)).join(' '));
+        paint('muted', p.cols.map((c) => String(c.items.length)).join(' ')));
     out.push('');
     p.cols.forEach((c, i) => {
         const shown = 4 < c.items.length && !p.bars
             ? c.items.slice(0, 3).join(' ') + ' ...' : c.items.join(' ');
-        out.push(`  col ${i + 1}${p.bars ? '' : ` (${c.items.length})`}: ${shown}` +
-            (c.sig.some((b) => b) ? '' : p.none));
+        out.push(paint('muted', `  col ${i + 1}${p.bars ? '' : ` (${c.items.length})`}:`) +
+            ` ${shown}` + (c.sig.some((b) => b) ? '' : paint('muted', p.none)));
     });
     return out.join('\n');
 }
 // The panel as SVG: the set sizes as bars, the intersections as a dot
 // matrix (a filled dot where the set lies in the column), the column
 // cardinalities as bars under it, and the columns' elements as text.
-function panelSvg(p, about) {
+function panelSvg(p, about, style) {
     const w = widest(p.names);
     const most = p.sizes.reduce((m, n) => Math.max(m, n), 0);
     const parts = [svgText(4, 14, 'av-m', p.header)];
@@ -1208,7 +1406,7 @@ function panelSvg(p, about) {
         parts.push(svgText(4, yI + i * LH + 14, 'av-t', l));
     });
     const width = Math.max(gx + p.cols.length * 20, gx + (p.bars ? most * 10 + 8 : 0) + 3 * CH, 4 + widest(lines) * CH, 4 + p.header.length * CH) + PAD;
-    return svgDoc(width, yI + lines.length * LH + PAD, about, parts);
+    return svgDoc(width, yI + lines.length * LH + PAD, about, parts, style);
 }
 // Elide the columns beyond `--max-cols`, counted. Zero means no limit,
 // in both ports.
@@ -1307,18 +1505,18 @@ function drawSets(gen, o, max, loss) {
     return {
         text: 'svg' === o.as
             ? panelSvg(panel, `Set panel over ${o.sets}: ${names.length} sets, ` +
-                `${elements.size} elements, ${cols.length} intersections`)
-            : renderPanel(panel),
+                `${elements.size} elements, ${cols.length} intersections`, o.style)
+            : renderPanel(panel, o.style),
     };
 }
 // The file a contribution names, as the panel shows it: relative to
 // the entry document's directory, the entry itself by its own name.
 function docName(file, entry) {
     if ('' === file || file === entry) {
-        return undefined === entry ? '-' : (0, path_1.basename)(entry);
+        return undefined === entry ? '-' : (0, node_path_1.basename)(entry);
     }
-    return (0, path_1.isAbsolute)(file) && undefined !== entry
-        ? (0, path_1.relative)((0, path_1.dirname)((0, path_1.resolve)(entry)), file) : file;
+    return (0, node_path_1.isAbsolute)(file) && undefined !== entry
+        ? (0, node_path_1.relative)((0, node_path_1.dirname)((0, node_path_1.resolve)(entry)), file) : file;
 }
 function drawLayers(prov, root, entry, o, max, loss) {
     // Every path something met at AND THE DOCUMENT HAS A VALUE AT,
@@ -1365,7 +1563,7 @@ function drawLayers(prov, root, entry, o, max, loss) {
     }
     cols = elide(cols, o.maxCols, loss);
     const panel = {
-        header: `# layers  file=${undefined === entry ? '-' : (0, path_1.basename)(entry)}` +
+        header: `# layers  file=${undefined === entry ? '-' : (0, node_path_1.basename)(entry)}` +
             `  documents=${names.length}  paths=${paths.length}`,
         names,
         sizes: names.map((n) => members.get(n).size),
@@ -1376,8 +1574,8 @@ function drawLayers(prov, root, entry, o, max, loss) {
     return {
         text: 'svg' === o.as
             ? panelSvg(panel, `Document layers: ${names.length} documents, ` +
-                `${paths.length} paths, ${cols.length} intersections`)
-            : renderPanel(panel),
+                `${paths.length} paths, ${cols.length} intersections`, o.style)
+            : renderPanel(panel, o.style),
     };
 }
 // ---------------------------------------------------------------------
@@ -1406,7 +1604,7 @@ function drawLadder(src, options, as, max) {
     if (max < rungs.length) {
         return { errors: [rowsFinding(rungs.length, max, 'a narrower --at')] };
     }
-    const where = (c) => `${(0, path_1.basename)(c.site.file)}:${c.site.row}:${c.site.col}`;
+    const where = (c) => `${(0, node_path_1.basename)(c.site.file)}:${c.site.row}:${c.site.col}`;
     const out = [];
     if ('mermaid' === as) {
         const esc = (s) => escape(s, MERMAID_ESC);
@@ -1655,6 +1853,24 @@ function view(src, opts, hooks) {
             errors: [finding('view_profile_unknown', 'reference', '$', `The ${kind} figure does not render as ${as}.`, `profiles: ${profiles.join(', ')}`)],
         });
     }
+    // ONE MECHANISM PER PROFILE (VIEWS.0.md, "7. Styling"). `ansi` is
+    // the text profile's and `css` the SVG's; asking for one on a
+    // profile that has no way to carry it is a usage error rather than a
+    // silent no-op, so a script that asks for colour and gets none is
+    // told why. `none` is always available -- it is the absence of a
+    // mechanism.
+    const style = styleOf(options.style, as);
+    const carrier = { ansi: 'text', css: 'svg' };
+    if (undefined !== carrier[style] && carrier[style] !== as) {
+        return done({
+            errors: [finding('view_style_profile', 'reference', '$', `The ${as} profile cannot carry --style ${style}.`, `${style} is the ${carrier[style]} profile's mechanism`)],
+        });
+    }
+    if (undefined === carrier[style] && 'none' !== style) {
+        return done({
+            errors: [finding('view_style_unknown', 'reference', '$', `${style} is not a style.`, 'styles: auto, none, ansi, css')],
+        });
+    }
     // Zero means the default, in both ports.
     const max = options.maxRows || DEFAULT_MAX_ROWS;
     if ('poset' === kind) {
@@ -1662,7 +1878,7 @@ function view(src, opts, hooks) {
             .map((d, i) => ({
             src: d.src, path: d.path,
             label: d.name ?? (undefined === d.path
-                ? `doc${i + 1}` : (0, path_1.basename)(d.path).replace(/\.aon$/, '')),
+                ? `doc${i + 1}` : (0, node_path_1.basename)(d.path).replace(/\.aon$/, '')),
         }));
         return done(drawPoset(docs, options, as, max, loss, compare));
     }
@@ -1685,8 +1901,12 @@ function view(src, opts, hooks) {
 // that a document generating `undefined` is still a value the panel
 // has rather than one it must recompute.
 function drawLoaded(root, ctx, gen, prov, kind, as, options, max, loss) {
+    const style = styleOf(options.style, as);
+    if ('doc' === kind) {
+        return drawDoc(root, { ...options, as, style }, max, loss);
+    }
     if ('layers' === kind) {
-        return drawLayers(prov, root, options.path, { ...options, as }, max, loss);
+        return drawLayers(prov, root, options.path, { ...options, as, style }, max, loss);
     }
     if ('sets' === kind) {
         if (undefined === options.sets || undefined === options.member) {
@@ -1710,7 +1930,7 @@ function drawLoaded(root, ctx, gen, prov, kind, as, options, max, loss) {
         }
         return drawSets(value, {
             sets: options.sets, member: options.member, universe: options.universe,
-            minDegree: options.minDegree, maxCols: options.maxCols, as,
+            minDegree: options.minDegree, maxCols: options.maxCols, as, style,
         }, max, loss);
     }
     const triples = triplesOf((0, graph_1.graphOf)(root), options.at, loss);
@@ -1721,7 +1941,7 @@ function drawLoaded(root, ctx, gen, prov, kind, as, options, max, loss) {
     if ('matrix' === kind) {
         return drawMatrix(triples, decls, {
             relation, order: options.order ?? 'canon', closure: true === options.closure,
-            as,
+            as, style,
         }, max, loss);
     }
     if ('graph' === kind) {
@@ -1733,10 +1953,10 @@ function drawLoaded(root, ctx, gen, prov, kind, as, options, max, loss) {
     if ('layer' === kind) {
         return drawLayer(triples, root, {
             relation, groupBy: options.groupBy, layers: options.layers ?? [],
-            edges: options.edges, as,
+            edges: options.edges, as, style,
         }, max, loss);
     }
-    return drawTree(collapse(triples, relation), relation, options.roots ?? [], max, as);
+    return drawTree(collapse(triples, relation), relation, options.roots ?? [], max, as, style);
 }
 // The tree view of one document: `view` with the kind fixed.
 function viewTree(src, opts) {
@@ -1766,7 +1986,7 @@ const DECL_ENUM = {
     order: ['canon', 'partition'],
     edges: ['upward', 'all', 'none'],
 };
-const DECL_COUNT = ['maxRows', 'maxCols', 'minDegree', 'minSize'];
+const DECL_COUNT = ['maxRows', 'maxCols', 'minDegree', 'minSize', 'depth'];
 const DECL_FLAG = ['closure'];
 const DECL_LIST = ['roots', 'relations', 'layers'];
 const DECL_KEYS = [...DECL_TEXT, ...DECL_COUNT, ...DECL_FLAG, ...DECL_LIST]