brane 0.1.1 → 0.3.0

package/dist/test/diagram-parse.test.js

@@ -0,0 +1,191 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseDiagram } from "../diagram/parse.js";
+// The dialect brane renders was measured, not chosen: across every ```mermaid
+// fence in the archive (21 diagrams, 316 lines, home brane plus two absorbed
+// ones) it is flowcharts and nothing else — 131 `-->`, 9 `<-->`, zero `-.->`,
+// `==>`, `---` or `~~~`; `[rect]` 125, `(round)` 9, `[(cyl)]` 5, `{diamond}` 4,
+// `>asym]` 4, `[[sub]]` 1; `subgraph` 10, `&` 13, `<br/>` 15, classDef/class
+// 3+3, style 2. One `stateDiagram-v2` is the only non-flowchart.
+//
+// The fixtures below are written to cover that census rather than lifted from
+// it: the archive diagrams are the operator's own conversations, and a public
+// repository is not the place for them.
+function ok(src) {
+    const r = parseDiagram(src);
+    assert.equal(r.ok, true, `expected a parse, got ${r.ok ? "" : r.refusal.message}`);
+    return r.ok ? r.ir : undefined;
+}
+function refused(src) {
+    const r = parseDiagram(src);
+    assert.equal(r.ok, false, "expected a refusal");
+    return r.ok ? undefined : r.refusal;
+}
+describe("headers", () => {
+    for (const h of ["flowchart TD", "graph TD", "flowchart LR", "flowchart TB", "graph BT", "graph RL"]) {
+        it(`accepts \`${h}\``, () => {
+            assert.equal(ok(`${h}\n A --> B`).nodes.length, 2);
+        });
+    }
+    it("normalises TD to TB, since they are the same direction spelled twice", () => {
+        assert.equal(ok("flowchart TD\n A --> B").direction, "TB");
+        assert.equal(ok("flowchart TB\n A --> B").direction, "TB");
+    });
+    it("names the diagram type it is refusing, so the author knows it was recognised", () => {
+        for (const t of ["gantt", "sequenceDiagram", "stateDiagram-v2", "mindmap", "pie", "erDiagram"]) {
+            const r = refused(`${t}\n whatever`);
+            assert.equal(r.kind, "unsupported");
+            assert.match(r.message, new RegExp(t, "i"));
+        }
+    });
+    it("refuses a fence that is not a diagram at all", () => {
+        assert.equal(refused("hello world").kind, "parse_error");
+    });
+    it("skips comments and blank lines before the header", () => {
+        assert.equal(ok("\n%% a note\n\nflowchart TD\n A --> B").edges.length, 1);
+    });
+});
+describe("edges", () => {
+    it("reads an arrow written without spaces", () => {
+        // Regression: the node-id pattern was `[\w-]*`, and `-` inside a character
+        // class eats the arrow — `A-->B` parsed its id as `A--` and then failed on
+        // the remaining `>B`. Agents write arrows unspaced constantly.
+        const ir = ok("flowchart TD\n A-->B");
+        assert.deepEqual(ir.edges.map((e) => [e.from, e.to]), [["A", "B"]]);
+    });
+    it("still admits a hyphenated id, which is the shape brane cares about most", () => {
+        const ir = ok("flowchart TD\n claude-0qjv4nny --> claude-hhuptny5");
+        assert.deepEqual(ir.edges.map((e) => [e.from, e.to]), [["claude-0qjv4nny", "claude-hhuptny5"]]);
+    });
+    it("distinguishes the four link forms", () => {
+        const ir = ok("flowchart TD\n A --> B\n B <--> C\n C -.-> D\n D ==> E\n E --- F");
+        assert.deepEqual(ir.edges.map((e) => `${e.arrow}/${e.line}`), ["arrow/solid", "biarrow/solid", "arrow/dotted", "arrow/thick", "open/solid"]);
+    });
+    it("carries a `|label|`", () => {
+        const ir = ok("flowchart TD\n A -->|yes| B\n A -->|no| C");
+        assert.deepEqual(ir.edges.map((e) => e.label), ["yes", "no"]);
+    });
+    it("reads the inline-label link forms", () => {
+        const ir = ok("flowchart TD\n A -- yes --> B\n B -. maybe .-> C\n C == no ==> D");
+        assert.deepEqual(ir.edges.map((e) => `${e.line}:${e.label}`), ["solid:yes", "dotted:maybe", "thick:no"]);
+    });
+    it("does not mistake a bare arrow for a labelled one", () => {
+        const ir = ok("flowchart TD\n A --> B\n B -.-> C\n C ==> D");
+        assert.deepEqual(ir.edges.map((e) => e.label), [undefined, undefined, undefined]);
+    });
+    it("keeps a delimiter that a quoted label legitimately contains", () => {
+        // Both of these are in the archive. `P(C|A,B)` is a conditional
+        // probability, where the bar is notation rather than a delimiter; the
+        // lattice node's text really does contain a bracket. Scanning to the first
+        // delimiter truncates each and then fails on the remainder.
+        const edge = ok('flowchart TD\n A -->|"P(C|A,B)"| C');
+        assert.equal(edge.edges[0].label, "P(C|A,B)");
+        const node = ok('flowchart TD\n ARR["Array[…]"] --> B');
+        assert.deepEqual(node.nodes[0].lines, ["Array[…]"]);
+    });
+    it("chains, so `A --> B --> C` is two edges", () => {
+        const ir = ok("flowchart TD\n A --> B --> C");
+        assert.deepEqual(ir.edges.map((e) => [e.from, e.to]), [["A", "B"], ["B", "C"]]);
+    });
+    it("expands `&` on both sides as a cross product, the way mermaid does", () => {
+        const ir = ok("flowchart TD\n A & B --> C & D");
+        assert.deepEqual(ir.edges.map((e) => `${e.from}${e.to}`).sort(), ["AC", "AD", "BC", "BD"]);
+    });
+    it("reads the LIVE loop's own `I --> V & E` fan-out", () => {
+        const ir = ok([
+            "flowchart TD",
+            "    L[Listen] --> I[Interpret]",
+            "    I --> V[Vocalize] & E[Execute]",
+            "    V --> E",
+            "    E --> V",
+            "    V --> L",
+        ].join("\n"));
+        assert.equal(ir.nodes.length, 4);
+        assert.deepEqual(ir.edges.map((e) => `${e.from}->${e.to}`), ["L->I", "I->V", "I->E", "V->E", "E->V", "V->L"]);
+    });
+    it("keeps a self-loop as an edge rather than dropping it", () => {
+        const ir = ok("flowchart TD\n A --> A");
+        assert.deepEqual(ir.edges.map((e) => [e.from, e.to]), [["A", "A"]]);
+    });
+});
+describe("node shapes and labels", () => {
+    it("reads every shape the dialect has", () => {
+        const ir = ok("flowchart TD\n A[r] --> B(rd) --> C([st]) --> D[[sub]] --> E[(cyl)]" +
+            " --> F((ci)) --> G{di} --> H{{hex}} --> I>asym]");
+        assert.deepEqual(ir.nodes.map((n) => n.shape), ["rect", "round", "stadium", "subroutine", "cylinder", "circle", "diamond", "hexagon", "asymmetric"]);
+    });
+    it("prefers the longer opener, so `[[` is a subroutine and not a rect", () => {
+        assert.equal(ok("flowchart TD\n A[[x]] --> B").nodes[0].shape, "subroutine");
+        assert.equal(ok("flowchart TD\n A((x)) --> B").nodes[0].shape, "circle");
+    });
+    it("splits `<br/>` into lines rather than carrying it as markup", () => {
+        const ir = ok("flowchart TD\n A[one<br/>two<br>three] --> B");
+        assert.deepEqual(ir.nodes[0].lines, ["one", "two", "three"]);
+    });
+    it("strips the quotes mermaid allows around a label", () => {
+        assert.deepEqual(ok('flowchart TD\n A["a b"] --> B').nodes[0].lines, ["a b"]);
+    });
+    it("defaults an unlabelled node to its own id", () => {
+        assert.deepEqual(ok("flowchart TD\n A --> B").nodes[0].lines, ["A"]);
+    });
+    it("keeps non-Latin labels intact", () => {
+        // The archive's one state diagram is Greek morphology. Whatever else it
+        // exercises, a label must survive the parse byte for byte.
+        assert.deepEqual(ok("flowchart TD\n A[πραΰς] --> B[πραεῖσι]").nodes[0].lines, ["πραΰς"]);
+    });
+});
+describe("subgraphs, classes and styles", () => {
+    it("collects a subgraph's members", () => {
+        const ir = ok("flowchart TD\n subgraph S[Group]\n  A --> B\n end\n B --> C");
+        assert.equal(ir.subgraphs.length, 1);
+        assert.equal(ir.subgraphs[0].title, "Group");
+        assert.deepEqual(ir.subgraphs[0].nodes, ["A", "B"]);
+    });
+    it("refuses an unbalanced subgraph rather than guessing", () => {
+        assert.equal(refused("flowchart TD\n subgraph S\n A --> B").kind, "parse_error");
+        assert.equal(refused("flowchart TD\n A --> B\n end").kind, "parse_error");
+    });
+    it("applies classDef through `class` and through `:::`", () => {
+        const viaClass = ok("flowchart TD\n A --> B\n classDef hot fill:#f9f\n class A hot");
+        assert.deepEqual(viaClass.nodes[0].classes, ["hot"]);
+        assert.deepEqual(viaClass.classDefs.hot, { fill: "#f9f" });
+        const viaInline = ok("flowchart TD\n A:::hot --> B\n classDef hot fill:#f9f");
+        assert.deepEqual(viaInline.nodes[0].classes, ["hot"]);
+    });
+    it("keeps only known style properties, with values that cannot smuggle markup", () => {
+        const ir = ok("flowchart TD\n A --> B\n style A fill:url(#x),stroke:#0a0,stroke-width:3px,behavior:evil");
+        // `url(` is how an SVG references external content; `behavior` is not a
+        // property we emit. Both are dropped; the two real ones survive.
+        assert.deepEqual(ir.nodes[0].style, { stroke: "#0a0", "stroke-width": "3px" });
+    });
+    it("honours `style X stroke-width:4px`, which the LIVE loop diagram relies on", () => {
+        const ir = ok("flowchart TD\n L[Listen] --> I\n style L stroke-width:4px");
+        assert.deepEqual(ir.nodes[0].style, { "stroke-width": "4px" });
+    });
+    it("refuses the directives it does not implement, by name", () => {
+        for (const d of ["click A callback", "linkStyle 0 stroke:#f00"]) {
+            const r = refused(`flowchart TD\n A --> B\n ${d}`);
+            assert.equal(r.kind, "unsupported");
+            assert.equal(r.line, 3);
+        }
+    });
+    it("ignores a per-subgraph `direction` instead of refusing the diagram", () => {
+        // Not implemented, but harmless to skip: the diagram still draws, which
+        // beats showing source over a one-line layout hint.
+        assert.equal(ok("flowchart TD\n subgraph S\n direction LR\n A --> B\n end").edges.length, 1);
+    });
+    it("drops trailing semicolons, and treats `%%` as a comment only at line start", () => {
+        // Mermaid's own rule. Stripping `%%` anywhere on a line broke any label
+        // containing one — `A[100%% done]` failed to parse at all.
+        const ir = ok("flowchart TD\n %% a whole-line note\n A --> B;\n B --> C;");
+        assert.equal(ir.edges.length, 2);
+        assert.deepEqual(ok("flowchart TD\n A[100%% done] --> B").nodes[0].lines, ["100%% done"]);
+    });
+});
+describe("refusals carry a line number", () => {
+    it("points at the offending line, counting from the fence body", () => {
+        const r = refused("flowchart TD\n A --> B\n A --> @@@");
+        assert.equal(r.line, 3);
+    });
+});
+//# sourceMappingURL=diagram-parse.test.js.map

package/dist/test/diagram-render.test.js

@@ -0,0 +1,175 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import Database from "better-sqlite3";
+import { renderDiagram, diagnoseDiagram, MAX_SOURCE_BYTES } from "../diagram/index.js";
+import { charWidth, textWidth, measureNode } from "../diagram/metrics.js";
+import { nidHrefFor } from "../diagram/links.js";
+const draw = (src) => {
+    const r = renderDiagram(src);
+    assert.ok(r, "expected the diagram to draw");
+    return r.svg;
+};
+describe("the SVG carries nothing executable", () => {
+    it("has no script, in the plainest case", () => {
+        const svg = draw("flowchart TD\n A --> B");
+        assert.ok(!/<script/i.test(svg));
+        assert.ok(!/\son\w+\s*=/i.test(svg), "no inline event handlers");
+    });
+    it("escapes a label that tries to close the text element and open a script", () => {
+        const svg = draw('flowchart TD\n A["</text><script>alert(1)</script>"] --> B');
+        assert.ok(!/<script/i.test(svg), "script tag survived");
+        assert.ok(svg.includes("&lt;script&gt;"), "expected the label escaped, not dropped");
+    });
+    it("escapes quotes and ampersands, which would otherwise break an attribute", () => {
+        const svg = draw('flowchart TD\n A["a & b \' c"] --> B');
+        assert.ok(svg.includes("&amp;"));
+        assert.ok(!/>[^<]*"[^<]*</.test(svg.replace(/<[^>]*>/g, "")) || true);
+    });
+    it("references nothing over the network", () => {
+        // The HTML export contains no script and must open anywhere, including
+        // offline. An `@import` or an external `url(…)` would break that silently.
+        const svg = draw("flowchart TD\n A --> B");
+        assert.ok(!/https?:\/\//.test(svg.replace(/xmlns="[^"]*"/g, "")));
+        assert.ok(!/@import/i.test(svg));
+        const urls = svg.match(/url\([^)]*\)/g) ?? [];
+        for (const u of urls)
+            assert.match(u, /^url\(#ah(-start)?-[0-9a-f]+\)$/, u);
+    });
+    it("has no <style> element, because an inline SVG's styles are document-global", () => {
+        // A `text { font-family: … }` rule inside one diagram would restyle every
+        // other inline SVG on the page, and brane renders several per screen.
+        assert.ok(!/<style/i.test(draw("flowchart TD\n A --> B")));
+    });
+    it("gives each diagram its own marker ids, so two on a page don't collide", () => {
+        const a = draw("flowchart TD\n A --> B");
+        const b = draw("flowchart TD\n C --> D");
+        const idOf = (s) => /id="ah-([0-9a-f]+)"/.exec(s)?.[1];
+        assert.ok(idOf(a));
+        assert.notEqual(idOf(a), idOf(b));
+    });
+    it("is deterministic, so the same fence renders identically every time", () => {
+        assert.equal(draw("flowchart TD\n A --> B"), draw("flowchart TD\n A --> B"));
+    });
+    it("turns `<br/>` into tspans rather than forwarding the markup", () => {
+        const svg = draw("flowchart TD\n A[one<br/>two] --> B");
+        assert.ok(!/<br/i.test(svg), "the br survived into the output");
+        assert.equal((svg.match(/<tspan/g) ?? []).length >= 3, true);
+        assert.ok(svg.includes(">one<") && svg.includes(">two<"));
+    });
+});
+describe("refusing is a normal answer", () => {
+    it("returns null rather than throwing, for every shape of bad input", () => {
+        for (const src of ["", "gantt\n x", "flowchart TD", "not a diagram", "flowchart TD\n @@@"]) {
+            assert.equal(renderDiagram(src), null, JSON.stringify(src));
+        }
+    });
+    it("refuses a source past the byte bound instead of laying it out", () => {
+        const huge = "flowchart TD\n" + "A --> B\n".repeat(MAX_SOURCE_BYTES);
+        assert.equal(renderDiagram(huge), null);
+        assert.equal(diagnoseDiagram(huge)?.kind, "unsupported");
+    });
+    it("refuses a graph with too many nodes, so layout cannot stall the daemon", () => {
+        const wide = "flowchart TD\n" +
+            Array.from({ length: 400 }, (_, i) => `n${i} --> n${i + 1}`).join("\n");
+        assert.equal(diagnoseDiagram(wide)?.kind, "unsupported");
+        assert.equal(renderDiagram(wide), null);
+    });
+    it("says why, with a line, so `narrate` can tell the author", () => {
+        const r = diagnoseDiagram("flowchart TD\n A --> B\n click A cb");
+        assert.equal(r?.kind, "unsupported");
+        assert.equal(r?.line, 3);
+        assert.match(r.message, /click/);
+    });
+    it("reports nothing at all for a diagram that draws", () => {
+        assert.equal(diagnoseDiagram("flowchart TD\n A --> B"), null);
+    });
+});
+describe("text measurement", () => {
+    it("uses real Helvetica advances for ASCII", () => {
+        assert.equal(charWidth(0x20), 278); // space
+        assert.equal(charWidth("i".codePointAt(0)), 222);
+        assert.equal(charWidth("m".codePointAt(0)), 833);
+        assert.equal(charWidth("W".codePointAt(0)), 944);
+    });
+    it("gives narrow and wide letters different widths, which is the whole point", () => {
+        assert.ok(textWidth("iiii", 14) < textWidth("mmmm", 14));
+    });
+    it("measures Greek rather than falling back to a single constant", () => {
+        // The archive's one state diagram is Greek morphology — `πραΰς`,
+        // `πραεῖσι(ν)`. A table keyed on ASCII alone would size those boxes from
+        // the default and clip the text.
+        assert.ok(charWidth("π".codePointAt(0)) > 0);
+        assert.ok(charWidth("ῖ".codePointAt(0)) > 0, "Greek Extended must be covered");
+        assert.ok(textWidth("πραεῖσι", 14) > textWidth("πρα", 14));
+    });
+    it("treats CJK as full width and combining marks as zero", () => {
+        assert.equal(charWidth("字".codePointAt(0)), 1000);
+        assert.equal(charWidth(0x0301), 0);
+    });
+    it("counts an emoji once, not once per surrogate", () => {
+        const one = textWidth("🦠", 14);
+        assert.equal(one, textWidth("🦠", 14));
+        assert.ok(one < textWidth("🦠🦠", 14));
+    });
+    it("sizes a box to fit its longest line", () => {
+        const one = measureNode(["short"]);
+        const two = measureNode(["short", "a much longer line"]);
+        assert.ok(two.width > one.width);
+        assert.ok(two.height > one.height, "two lines are taller than one");
+    });
+    it("never returns a degenerate box for an empty label", () => {
+        const m = measureNode([""]);
+        assert.ok(m.width > 0 && m.height > 0);
+    });
+});
+describe("node labels reach brane's own grammars", () => {
+    function db() {
+        const d = new Database(":memory:");
+        d.exec("CREATE TABLE narratives (id TEXT PRIMARY KEY)");
+        d.prepare("INSERT INTO narratives (id) VALUES (?)").run("claude-0qjv4nny");
+        return d;
+    }
+    it("links a label that is a narrative that exists", () => {
+        assert.equal(nidHrefFor(db())("claude-0qjv4nny"), "brane://nid/claude-0qjv4nny");
+    });
+    it("carries a `:seq` through, so a node can cite a message", () => {
+        assert.equal(nidHrefFor(db())("claude-0qjv4nny:42"), "brane://nid/claude-0qjv4nny/42");
+    });
+    it("declines the addressed form, because a node cites and does not address", () => {
+        // `mentions-scan` walks the rendered markdown, where a fence is inert — so
+        // linking `@nid` here would show the operator a mention that notifies
+        // nobody, breaking the rule that a handle fires iff it is seen as one.
+        assert.equal(nidHrefFor(db())("@claude-0qjv4nny"), null);
+    });
+    it("declines a narrative that does not exist, rather than making a dead link", () => {
+        // The same rule `markdown-nids.ts` applies in prose: an arbitrary string of
+        // the right shape is not a reference.
+        assert.equal(nidHrefFor(db())("claude-deadbeef"), null);
+    });
+    it("declines a label that merely contains a reference", () => {
+        assert.equal(nidHrefFor(db())("see claude-0qjv4nny for details"), null);
+    });
+    it("puts the link in the SVG as a plain anchor", () => {
+        const r = renderDiagram("flowchart TD\n A[claude-0qjv4nny] --> B[plain]", {
+            hrefFor: nidHrefFor(db()),
+        });
+        assert.ok(r);
+        assert.ok(r.svg.includes('<a href="brane://nid/claude-0qjv4nny">'));
+        assert.equal((r.svg.match(/<a /g) ?? []).length, 1, "only the resolving label links");
+    });
+    it("adds no syntax for it, so the same fence still renders on GitHub", () => {
+        // The linked label is ordinary mermaid text. Nothing in the source says
+        // "this is a link" — which is what keeps the fence portable.
+        const src = "flowchart TD\n A[claude-0qjv4nny] --> B";
+        const withDb = renderDiagram(src, { hrefFor: nidHrefFor(db()) });
+        const without = renderDiagram(src);
+        assert.ok(withDb.svg.includes("<a "));
+        assert.ok(!without.svg.includes("<a "));
+        assert.deepEqual(withDb.labels, without.labels);
+    });
+    it("reports node labels as text, so a fence is indexable as more than source", () => {
+        const r = renderDiagram("flowchart TD\n A[Listen] --> B[Interpret]");
+        assert.deepEqual(r.labels, ["Listen", "Interpret"]);
+    });
+});
+//# sourceMappingURL=diagram-render.test.js.map

package/dist/test/diagram-review.test.js

@@ -0,0 +1,288 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseDiagram } from "../diagram/parse.js";
+import { renderDiagram, diagnoseDiagram } from "../diagram/index.js";
+import { layoutDiagram } from "../diagram/layout.js";
+import { measureEdgeLabel } from "../diagram/metrics.js";
+import { diagnoseMarkdown } from "../markdown-diagnostics.js";
+// Regressions from the review of #500 (claude-91m90xgn:5). Each of these was a
+// real defect in the first draft, reproduced by execution before it was fixed.
+// They are gathered here rather than scattered so that the shape of what went
+// wrong stays legible: three of the seven were *silent* — a plausible, wrong
+// diagram, or a wrong warning — which is the failure mode the whole
+// draw-or-fall-back design exists to avoid.
+const ok = (src) => {
+    const r = parseDiagram(src);
+    assert.equal(r.ok, true, `expected a parse, got ${r.ok ? "" : r.refusal.message}`);
+    return r.ok ? r.ir : undefined;
+};
+describe("a hostile line cannot stall the daemon", () => {
+    // The labelled-link patterns were `-{2,}\s+(.+?)\s+-{2,}>`: three overlapping
+    // quantifiers over whitespace, cubic in the run length. `A -- <N spaces> x`
+    // measured 17/30/195/1542 ms at N=250/500/1000/2000 — 8× per doubling. It
+    // reached the daemon through `diagnoseMarkdown`, which runs on *every*
+    // narration containing a mermaid fence, so any agent could have wedged the
+    // daemon by narrating. `MAX_SOURCE_BYTES` was no defence: it bounds n while
+    // the cost is n³.
+    it("parses a long whitespace run in linear time", () => {
+        const timeAt = (n) => {
+            const src = `flowchart TD\n A -- ${" ".repeat(n)}x`;
+            const t = process.hrtime.bigint();
+            parseDiagram(src);
+            return Number(process.hrtime.bigint() - t) / 1e6;
+        };
+        timeAt(200); // warm
+        const small = Math.max(timeAt(250), 0.05);
+        const large = timeAt(1500);
+        // Cubic would be ~216× here. Generous bound: this is a complexity assertion,
+        // not a benchmark, and CI machines are noisy.
+        assert.ok(large < small * 30 + 50, `6× the input took ${large.toFixed(1)}ms against ${small.toFixed(1)}ms — superlinear`);
+    });
+    it("refuses an absurdly long line outright", () => {
+        const r = diagnoseDiagram(`flowchart TD\n A[${"x".repeat(3000)}] --> B`);
+        assert.equal(r?.kind, "unsupported");
+        assert.match(r.message, /line is over/);
+    });
+    it("stays fast on a whole fence of hostile lines", () => {
+        const src = "flowchart TD\n" + `A -- ${" ".repeat(400)}x\n`.repeat(40);
+        const t = process.hrtime.bigint();
+        parseDiagram(src);
+        assert.ok(Number(process.hrtime.bigint() - t) / 1e6 < 500);
+    });
+});
+describe("a link form never silently loses a node", () => {
+    // Both of these drew a plausible, wrong diagram with no warning — the worst
+    // available outcome, since the reader cannot tell and the author is not told.
+    it("chains dotted links instead of spanning them", () => {
+        // Was: one edge A → C labelled `-> B -`, with B gone entirely.
+        const ir = ok("flowchart TD\n A -.-> B -.-> C");
+        assert.equal(ir.nodes.length, 3);
+        assert.deepEqual(ir.edges.map((e) => `${e.from}->${e.to}`), ["A->B", "B->C"]);
+        assert.deepEqual(ir.edges.map((e) => e.label), [undefined, undefined]);
+    });
+    it("reads `---` as an open link, not as a labelled-link opener", () => {
+        // Was: one edge A → C labelled `B`. Three dashes is an open link; the
+        // inline-label opener is exactly two.
+        const ir = ok("flowchart TD\n A --- B --> C");
+        assert.equal(ir.nodes.length, 3);
+        assert.deepEqual(ir.edges.map((e) => `${e.from}->${e.to}`), ["A->B", "B->C"]);
+        assert.deepEqual(ir.edges.map((e) => e.line), ["solid", "solid"]);
+        assert.deepEqual(ir.edges.map((e) => e.arrow), ["open", "arrow"]);
+    });
+    it("still reads a genuine inline label", () => {
+        const ir = ok("flowchart TD\n A -- x --> B -- y --> C");
+        assert.deepEqual(ir.edges.map((e) => e.label), ["x", "y"]);
+    });
+    it("allows `>` inside a dotted label, which the archive needs", () => {
+        // The lattice diagram writes `-. "All<String, true> ⇒ ⊥" .->`. A first
+        // attempt at the fix above excluded `>` from every inline label and broke
+        // it — which is why the dotted form excludes `.` instead, and only forbids
+        // `-`/`>` as the *first* character.
+        const ir = ok('flowchart TD\n STR -. "All<String, true> ⇒ ⊥" .-> BOT');
+        assert.equal(ir.edges[0].label, "All<String, true> ⇒ ⊥");
+        assert.equal(ir.edges[0].line, "dotted");
+    });
+});
+describe("`classDef` is applied, not merely parsed", () => {
+    // Was: parsed into the IR, carried through layout, and never read — so
+    // `classDef hot fill:#f00` produced no `#f00` anywhere, while the same
+    // colour via `style` worked. The original test asserted the IR and stopped
+    // one layer short of the thing that matters.
+    it("paints a class through to the SVG", () => {
+        const svg = renderDiagram("flowchart TD\n A --> B\n classDef hot fill:#f00\n class A hot").svg;
+        assert.ok(svg.includes("#f00"), "the class colour never reached the output");
+    });
+    it("paints the inline `:::` form too", () => {
+        const svg = renderDiagram("flowchart TD\n A:::hot --> B\n classDef hot fill:#0f0").svg;
+        assert.ok(svg.includes("#0f0"));
+    });
+    it("lets an explicit `style` win over a class, as mermaid does", () => {
+        const ir = ok("flowchart TD\n A --> B\n classDef hot fill:#f00\n class A hot\n style A fill:#00f");
+        const placed = layoutDiagram(ir);
+        assert.equal(placed.nodes.find((n) => n.id === "A").style?.fill, "#00f");
+    });
+    it("merges several classes in declaration order", () => {
+        const ir = ok([
+            "flowchart TD", " A --> B",
+            " classDef one fill:#f00,stroke:#111", " classDef two fill:#0f0",
+            " class A one", " class A two",
+        ].join("\n"));
+        const style = layoutDiagram(ir).nodes.find((n) => n.id === "A").style;
+        assert.equal(style.fill, "#0f0", "the later class wins");
+        assert.equal(style.stroke, "#111", "the earlier class still contributes");
+    });
+});
+describe("a diagram that will not draw always says so", () => {
+    // `C --> S` where S is a subgraph is legal mermaid; dagre throws on it, and
+    // the throw was swallowed into a silent fallback. The operator saw source,
+    // the author got no warning, and `strict: true` did not refuse — which is
+    // exactly the invariant the warnings exist to uphold.
+    it("refuses an edge whose endpoint is a subgraph, with a reason", () => {
+        const src = "flowchart TD\n subgraph S[Group]\n  A --> B\n end\n C --> S";
+        const r = diagnoseDiagram(src);
+        assert.equal(r?.kind, "unsupported");
+        assert.match(r.message, /subgraph/);
+        assert.equal(renderDiagram(src), null);
+    });
+    it("warns for everything it refuses, and refuses everything it cannot draw", () => {
+        // The invariant itself, over a spread of inputs: `diagnoseDiagram` and
+        // `renderDiagram` must never disagree about whether a diagram appears.
+        const cases = [
+            "flowchart TD\n A --> B",
+            "flowchart TD\n subgraph S\n A --> B\n end\n C --> S",
+            "gantt\n title X",
+            "flowchart TD\n A --> @@@",
+            "flowchart TD\n A --> B\n click A cb",
+            "flowchart TD\n A --> A",
+            "flowchart LR\n A[x] --> B{y} --> C((z))",
+            "stateDiagram-v2\n [*] --> A",
+        ];
+        for (const src of cases) {
+            const refused = diagnoseDiagram(src) !== null;
+            const drew = renderDiagram(src) !== null;
+            assert.equal(refused, !drew, `disagreement on ${JSON.stringify(src)}`);
+        }
+    });
+});
+describe("the fence finder is the markdown parse, not a pattern", () => {
+    const bad = "gantt\n title X";
+    const warns = (md) => diagnoseMarkdown(md).some((w) => w.kind.startsWith("diagram_"));
+    it("says nothing about a mermaid fence quoted inside a longer fence", () => {
+        // Which is how an agent documents this feature — as the narrations that
+        // produced it do. A regex scanner warned about a diagram that was never
+        // going to be drawn in the first place.
+        assert.equal(warns("````\n```mermaid\n" + bad + "\n```\n````"), false);
+    });
+    it("warns about one inside a blockquote, which does render", () => {
+        assert.equal(warns("> ```mermaid\n> gantt\n>  title X\n> ```"), true);
+    });
+    it("warns about one inside a list item", () => {
+        assert.equal(warns("- item\n\n  ```mermaid\n  gantt\n   title X\n  ```"), true);
+    });
+    it("says nothing about an indented code block that merely looks like one", () => {
+        assert.equal(warns("    ```mermaid\n    " + bad + "\n    ```"), false);
+    });
+    it("does not pay for a parse when there is no mermaid at all", () => {
+        const md = "ordinary prose ".repeat(500);
+        const t = process.hrtime.bigint();
+        diagnoseMarkdown(md);
+        assert.ok(Number(process.hrtime.bigint() - t) / 1e6 < 50);
+    });
+});
+describe("headers and comments follow mermaid, not the first draft", () => {
+    it("accepts a trailing semicolon on the header", () => {
+        // `graph TD;` — a common habit in the absorbed ChatGPT history. Statements
+        // stripped a trailing `;`, but the header was tested against the raw line.
+        assert.equal(ok("graph TD;\n A --> B").edges.length, 1);
+    });
+    it("defaults a bare `flowchart` to TB, as mermaid does", () => {
+        assert.equal(ok("flowchart\n A --> B").direction, "TB");
+    });
+    it("treats `%%` as a comment only at the start of a line", () => {
+        assert.deepEqual(ok("flowchart TD\n A[100%% done] --> B").nodes[0].lines, ["100%% done"]);
+        assert.equal(ok("flowchart TD\n %% note\n A --> B").edges.length, 1);
+    });
+});
+describe("a self-loop stays inside the canvas", () => {
+    // The loop bows above its node, and on a top-rank node that meant negative
+    // coordinates — outside `viewBox="0 0 …"`, so the loop was simply invisible.
+    it("keeps every drawn point within the reported viewBox", () => {
+        for (const src of ["flowchart TD\n A --> A\n A --> B", "flowchart LR\n A --> A\n A --> B"]) {
+            const placed = layoutDiagram(ok(src));
+            for (const e of placed.edges) {
+                for (const p of e.points) {
+                    assert.ok(p.x >= 0 && p.y >= 0, `${src}: point ${p.x},${p.y} is outside the canvas`);
+                    assert.ok(p.x <= placed.width && p.y <= placed.height, `${src}: point ${p.x},${p.y} exceeds ${placed.width}x${placed.height}`);
+                }
+            }
+        }
+    });
+    it("keeps the nodes inside it too, after any shift", () => {
+        const placed = layoutDiagram(ok("flowchart TD\n A --> A\n A --> B"));
+        for (const n of placed.nodes) {
+            assert.ok(n.x - n.width / 2 >= 0 && n.y - n.height / 2 >= 0, `${n.id} at ${n.x},${n.y} hangs off the canvas`);
+        }
+    });
+});
+describe("a subgraph gets a box around its actual members", () => {
+    // Found while checking the theming fix on a real render: a node introduced
+    // by an edge and *then* listed inside a `subgraph` never joined it, because
+    // membership was claimed only when a node was created. The cluster came out
+    // empty, dagre left its geometry undefined, and the renderer drew a title
+    // floating in the corner with no box.
+    it("claims a node listed inside a subgraph after it was already used", () => {
+        const ir = ok("flowchart TD\n V --> E\n subgraph S[out]\n  V\n  E\n end");
+        assert.deepEqual(ir.subgraphs[0].nodes, ["V", "E"]);
+        const c = layoutDiagram(ir).clusters[0];
+        assert.ok(c, "the cluster survived layout");
+        assert.ok(c.width > 0 && c.height > 0, "and has real geometry");
+    });
+    it("still claims a node on first mention inside", () => {
+        const ir = ok("flowchart TD\n A --> B\n subgraph S[Group]\n  C --> D\n end\n B --> C");
+        assert.deepEqual(ir.subgraphs[0].nodes, ["C", "D"]);
+    });
+    it("never emits a cluster without finite geometry", () => {
+        for (const src of [
+            "flowchart TD\n subgraph S[empty]\n end\n A --> B",
+            "flowchart TD\n V --> E\n subgraph S[out]\n  V\n end",
+        ]) {
+            for (const c of layoutDiagram(ok(src)).clusters) {
+                assert.ok([c.x, c.y, c.width, c.height].every(Number.isFinite), src);
+            }
+        }
+    });
+});
+describe("an edge label's chip fits its text", () => {
+    // The chip was sized as `length × 0.55em` while layout reserved space with
+    // `measureEdgeLabel`. The two agreed for ASCII and nowhere else, so a Greek
+    // or CJK label hung out of its own background.
+    it("uses the same measurement layout reserved space with", () => {
+        const wide = renderDiagram("flowchart TD\n A -->|字字字字| B").svg;
+        const narrow = renderDiagram("flowchart TD\n A -->|iiii| B").svg;
+        const chip = (svg) => Number(/<rect x="[-\d.]+" y="[-\d.]+" width="([\d.]+)"[^>]*rx="3"/.exec(svg)?.[1] ?? 0);
+        assert.ok(chip(wide) > chip(narrow), "a full-width label must get a wider chip than a narrow one");
+    });
+});
+describe("a subgraph title wider than its members", () => {
+    // dagre sizes a cluster from its members and never sees the title, which is
+    // centred on the box; a long title hung past x = 0, where the operator could
+    // neither see nor scroll to it (claude-myl5ez9e:24). The members still set
+    // the box's width; the title wraps to it and the box grows upward to hold
+    // the extra lines (claude-myl5ez9e:46).
+    const title = "apollographql/connector-factory (private, public after the gates)";
+    for (const dir of ["TD", "LR"]) {
+        it(`wraps inside its box and stays inside the drawing (${dir})`, () => {
+            const src = `flowchart ${dir}\n subgraph P["${title}"]\n  A[canon] --> B[out]\n end\n B -. copy .-> C[elsewhere]`;
+            const ir = ok(src);
+            const free = layoutDiagram(ok(`flowchart ${dir}\n subgraph P[x]\n  A[canon] --> B[out]\n end\n B -. copy .-> C[elsewhere]`));
+            const placed = layoutDiagram(ir);
+            const c = placed.clusters[0];
+            assert.ok(measureEdgeLabel([c.titleRuns]).width > c.width, "the title is wider than its box, or this tests nothing");
+            assert.equal(c.width, free.clusters[0].width, "the members, not the title, set the box's width");
+            assert.ok(c.titleLines.length > 1, "so it wraps");
+            const text = (l) => l.map((r) => r.text).join("");
+            assert.equal(c.titleLines.map(text).join(" "), title, "every word survives, in order");
+            for (const line of c.titleLines) {
+                // A single word wider than the box can't wrap; it overhangs, and the
+                // bounds keep it in view (the case below).
+                if (/\s/.test(text(line)))
+                    assert.ok(measureEdgeLabel([line]).width <= c.width, `line fits its box: ${text(line)}`);
+            }
+            const extra = (c.titleLines.length - 1) * 12 * 1.35;
+            assert.ok(Math.abs(c.height - (free.clusters[0].height + extra)) < 0.01, "and the box grew a line per extra line");
+            assert.ok(c.y - c.height / 2 >= 0, `box top ${c.y - c.height / 2} is inside the drawing`);
+            const members = placed.nodes.filter((n) => n.id === "A" || n.id === "B");
+            const top = c.y - c.height / 2 + 15 + extra; // the last title baseline
+            for (const n of members)
+                assert.ok(n.y - n.height / 2 > top, `${n.id} sits below the title`);
+        });
+    }
+    it("keeps a word too long to wrap inside the drawing", () => {
+        const placed = layoutDiagram(ok(`flowchart TD\n subgraph P["${"x".repeat(80)}"]\n  A\n end`));
+        const c = placed.clusters[0];
+        const { width } = measureEdgeLabel(c.titleLines);
+        assert.ok(width > c.width, "the word overhangs its box");
+        assert.ok(c.x - width / 2 >= 0 && c.x + width / 2 <= placed.width, "but not the drawing");
+    });
+});
+//# sourceMappingURL=diagram-review.test.js.map