brane 0.1.1 → 0.3.1

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

@@ -0,0 +1,210 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestDb } from "./helpers.js";
+import { appendEvent } from "../db/events.js";
+import { exportNarrativeHtml } from "../export.js";
+import { diagnoseMarkdown } from "../markdown-diagnostics.js";
+import { renderDiagram } from "../diagram/index.js";
+import { DIAGRAM_EDGE_HIGHLIGHT_CSS } from "../shared/diagram-css.js";
+const HOST = "claude-aaaaaaaa";
+const PEER = "goose-bbbbbbbb";
+function insertNarrative(db, id) {
+    db.prepare(`INSERT INTO narratives (id, brane_id, agent_type, role, created_at, status)
+     VALUES (?, 'brane-test', ?, 'worker', 0, 'active')`).run(id, id.split("-")[0]);
+}
+const fence = (body) => "```mermaid\n" + body + "\n```";
+// One renderer, two targets. The export calls the same `renderDiagram` the app
+// reaches through POST /api/diagram, so a downloaded conversation is a snapshot
+// of what the operator saw rather than a lookalike of it. What makes that
+// possible here is that the SVG is static — the export carries no script, and
+// never can.
+describe("the HTML export draws mermaid fences", () => {
+    it("emits an inline SVG where the fence was", async () => {
+        const db = createTestDb();
+        insertNarrative(db, HOST);
+        appendEvent(db, HOST, "narration", {
+            content: "Here is the loop:\n\n" + fence("flowchart TD\n  A[Listen] --> B[Interpret]"),
+        });
+        const html = (await exportNarrativeHtml(db, HOST));
+        assert.match(html, /<div class="diagram"><svg/);
+        assert.ok(html.includes(">Listen<"), "the label is in the document as text");
+        assert.ok(!/language-mermaid/.test(html), "it should no longer be a code block");
+    });
+    it("scrolls a wide diagram inside its bubble instead of spilling out", async () => {
+        const db = createTestDb();
+        insertNarrative(db, HOST);
+        appendEvent(db, HOST, "narration", {
+            content: fence("flowchart LR\n  A --> B --> C --> D --> E --> F --> G --> H"),
+        });
+        const html = (await exportNarrativeHtml(db, HOST));
+        // The SVG carries a fixed width, so without a scroller around it a wide
+        // diagram draws past the bubble's edge — the export shows all of it at
+        // once, where the app clips and scrolls.
+        const rule = /\.content \.diagram\s*\{([^}]*)\}/.exec(html);
+        assert.ok(rule, "the stylesheet has a rule for the diagram wrapper");
+        assert.match(rule[1], /overflow-x:\s*auto/);
+    });
+    it("keeps the export scriptless, which is its whole constraint", async () => {
+        const db = createTestDb();
+        insertNarrative(db, HOST);
+        appendEvent(db, HOST, "narration", {
+            content: fence("flowchart TD\n  A --> B --> C\n  A --> C"),
+        });
+        const html = (await exportNarrativeHtml(db, HOST));
+        // Just the diagram. The document around it legitimately carries links.
+        const start = html.indexOf('<div class="diagram">');
+        const body = html.slice(start, html.indexOf("</svg>", start) + 6);
+        assert.ok(body.includes("<svg"), "found the diagram");
+        assert.ok(!/<script/i.test(body));
+        assert.ok(!/@import/i.test(body));
+        assert.ok(!/\son\w+\s*=/i.test(body), "no inline event handlers");
+        assert.ok(!/https?:\/\//.test(body.replace(/xmlns="[^"]*"/g, "")), "a diagram must reference nothing over the network");
+    });
+    it("picks out an arrow and its label on hover or tap, with CSS alone", async () => {
+        const db = createTestDb();
+        insertNarrative(db, HOST);
+        appendEvent(db, HOST, "narration", {
+            content: fence("flowchart TD\n  A -->|first| B\n  A -->|second| C\n  B --> C"),
+        });
+        const html = (await exportNarrativeHtml(db, HOST));
+        const start = html.indexOf('<div class="diagram">');
+        const svg = html.slice(start, html.indexOf("</svg>", start) + 6);
+        const groups = svg.match(/<g class="brane-diagram-edge-hl"[^>]*>/g) ?? [];
+        // One per edge for its line, and one more per labelled edge for its label,
+        // painted above every line so no later stroke covers an earlier label.
+        assert.equal(groups.length, 5, "a line group per edge, a label group per label");
+        for (const g of groups) {
+            // Hidden by attribute, so a page without the rule shows nothing extra;
+            // focusable, so a tap can hold it open without a script.
+            assert.match(g, /opacity="0"/);
+            assert.match(g, /tabindex="0"/);
+        }
+        assert.ok(groups.some((g) => /aria-label="first"/.test(g)));
+        // Above every edge label, which is what makes it disambiguate; below every
+        // node, so the boxes cover the highlighted line's ends.
+        const first = svg.indexOf('<g class="brane-diagram-edge-hl"');
+        const last = svg.lastIndexOf('<g class="brane-diagram-edge-hl"');
+        assert.ok(first > svg.indexOf(">second</text>"), "the highlight layer is painted after the edge labels");
+        assert.ok(last < svg.indexOf(">A<") && last < svg.indexOf(">C<"), "and before the nodes");
+        assert.ok(html.includes(DIAGRAM_EDGE_HIGHLIGHT_CSS), "the shared rule is in the document verbatim");
+        assert.match(DIAGRAM_EDGE_HIGHLIGHT_CSS, /\.brane-diagram-edge-hl:focus\s*\{\s*opacity:\s*1/);
+    });
+    it("stops a highlighted line short of each arrowhead, and nowhere else", () => {
+        const ends = (d) => {
+            const n = d.match(/-?\d+(?:\.\d+)?/g).map(Number);
+            return { start: [n[0], n[1]], end: [n[n.length - 2], n[n.length - 1]] };
+        };
+        const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+        const paths = (src) => {
+            const svg = renderDiagram(src, { edgeHighlight: true }).svg;
+            const base = /<path d="([^"]+)" fill="none" stroke="var\(--brane-diagram-line/.exec(svg)[1];
+            const hl = /<path d="([^"]+)" fill="none" stroke="var\(--brane-diagram-highlight/.exec(svg)[1];
+            return { base: ends(base), hl: ends(hl), svg };
+        };
+        // A 3px line run under the point blunts it, so it stops one head length
+        // back, and the highlight's head is anchored at its base to make up the
+        // difference: the tip lands where the base line's does.
+        const one = paths("flowchart TD\n  A --> B");
+        assert.ok(Math.abs(dist(one.base.end, one.hl.end) - 10) < 0.01, "pulled back one head length");
+        assert.deepEqual(one.hl.start, one.base.start, "the tail, which has no head, is untouched");
+        assert.match(one.svg, /<marker id="ah-hl-[0-9a-f]+"[^>]*refX="0"/);
+        const both = paths("flowchart TD\n  A <--> B");
+        assert.ok(Math.abs(dist(both.base.start, both.hl.start) - 10) < 0.01, "both heads, both ends");
+        assert.ok(Math.abs(dist(both.base.end, both.hl.end) - 10) < 0.01);
+        // No head, nothing to blunt: the line runs into the box, which covers it.
+        const open = paths("flowchart TD\n  A --- B");
+        assert.deepEqual(open.hl.end, open.base.end);
+        assert.deepEqual(open.hl.start, open.base.start);
+    });
+    it("draws no highlight layer for a caller that did not ask, having no rule to reveal it", () => {
+        const drawn = renderDiagram("flowchart TD\n  A -->|x| B");
+        assert.ok(drawn);
+        assert.ok(!drawn.svg.includes("brane-diagram-edge-hl"));
+        assert.ok(!drawn.svg.includes("tabindex"));
+    });
+    it("falls back to the highlighted code block for a diagram it cannot draw", async () => {
+        const db = createTestDb();
+        insertNarrative(db, HOST);
+        appendEvent(db, HOST, "narration", {
+            content: fence("gantt\n  title A schedule\n  section S\n  task :a1, 2026-01-01, 30d"),
+        });
+        const html = (await exportNarrativeHtml(db, HOST));
+        assert.ok(!/<div class="diagram">/.test(html), "nothing should have been drawn");
+        // The fence loop only substitutes non-null results, so an undrawn diagram
+        // lands exactly as the code block it was before this feature existed.
+        assert.ok(/gantt/.test(html), "the source is still there for the reader");
+    });
+    it("leaves other languages alone", async () => {
+        const db = createTestDb();
+        insertNarrative(db, HOST);
+        appendEvent(db, HOST, "narration", {
+            content: "```js\nconst a = 1;\n```",
+        });
+        const html = (await exportNarrativeHtml(db, HOST));
+        assert.ok(!/<div class="diagram">/.test(html));
+    });
+    it("links a node labelled with a narrative that exists, and only that one", async () => {
+        const db = createTestDb();
+        insertNarrative(db, HOST);
+        insertNarrative(db, PEER);
+        appendEvent(db, HOST, "narration", {
+            content: fence(`flowchart TD\n  A[${PEER}] --> B[codex-cccccccc]`),
+        });
+        const html = (await exportNarrativeHtml(db, HOST));
+        const svg = html.slice(html.indexOf('<div class="diagram">'));
+        // A sibling `<nid>.html`, the same target prose references already use —
+        // *not* `brane://nid/…`, which is the app's in-band scheme and opens in no
+        // browser, so it would have been a link that does nothing in a download.
+        assert.ok(svg.includes(`<a href="${PEER}.html">`), "the real narrative links");
+        assert.ok(!svg.includes("brane://nid/"), "no in-app scheme in a downloaded file");
+        assert.equal((svg.match(/<a href="[a-z]+-[0-9a-z]{8}\.html/g) ?? []).length, 1, "the narrative that does not exist stays plain text");
+    });
+    it("draws several fences in one conversation, each with its own marker ids", async () => {
+        const db = createTestDb();
+        insertNarrative(db, HOST);
+        appendEvent(db, HOST, "narration", { content: fence("flowchart TD\n  A --> B") });
+        appendEvent(db, HOST, "narration", { content: fence("flowchart LR\n  C --> D") });
+        const html = (await exportNarrativeHtml(db, HOST));
+        const ids = [...html.matchAll(/id="ah-([0-9a-f]+)"/g)].map((m) => m[1]);
+        assert.equal(ids.length, 2);
+        assert.notEqual(ids[0], ids[1], "two diagrams on a page must not share a marker");
+    });
+});
+describe("an author is told when their diagram will not draw", () => {
+    it("warns, with the source as the fallback", () => {
+        const out = diagnoseMarkdown("Look:\n\n" + fence("gantt\n  title X") + "\n\nafter");
+        const d = out.find((w) => w.kind === "diagram_unsupported");
+        assert.ok(d, "expected a diagram warning");
+        assert.match(d.message, /gantt/);
+        assert.ok(d.fallback.includes("gantt"), "the fallback is what the reader will see");
+    });
+    it("distinguishes a syntax error from an unsupported type", () => {
+        const bad = diagnoseMarkdown(fence("flowchart TD\n  A --> @@@"));
+        assert.equal(bad[0]?.kind, "diagram_parse_error");
+    });
+    it("points at the line inside the document, not inside the fence", () => {
+        const md = "line one\nline two\n\n" + fence("flowchart TD\n  A --> B\n  click A cb");
+        const d = diagnoseMarkdown(md).find((w) => w.kind === "diagram_unsupported");
+        assert.ok(d);
+        // The fence opens on line 4, so its body starts on line 5 and `click` is
+        // the third body line: line 7.
+        assert.equal(d.line, 7);
+    });
+    it("says nothing at all about a diagram that draws", () => {
+        const out = diagnoseMarkdown(fence("flowchart TD\n  A --> B"));
+        assert.deepEqual(out.filter((w) => w.kind.startsWith("diagram_")), []);
+    });
+    it("says nothing about a fence in another language", () => {
+        const out = diagnoseMarkdown("```js\nnot a diagram\n```");
+        assert.deepEqual(out.filter((w) => w.kind.startsWith("diagram_")), []);
+    });
+    it("leaves an unclosed fence to the warning that already covers it", () => {
+        // `fence_unclosed` already says everything after it became one code block.
+        // A second warning saying the diagram did not draw would be noise about a
+        // consequence of the first.
+        const out = diagnoseMarkdown("```mermaid\nflowchart TD\n A --> B");
+        assert.ok(out.some((w) => w.kind === "fence_unclosed"));
+        assert.deepEqual(out.filter((w) => w.kind.startsWith("diagram_")), []);
+    });
+});
+//# sourceMappingURL=diagram-export.test.js.map

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

@@ -0,0 +1,313 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseDiagram } from "../diagram/parse.js";
+import { layoutDiagram } from "../diagram/layout.js";
+import { renderDiagram, diagnoseDiagram } from "../diagram/index.js";
+import { MARKDOWN_WRAP_WIDTH, parseLabel, wrapRuns } from "../diagram/label.js";
+/** A label line that the test knows is text, not a table. */
+const line = (l) => {
+    assert.ok(Array.isArray(l), "expected a line of runs, got a table");
+    return l;
+};
+import { FONT_SIZE, measureNode, runWidth, textWidth } from "../diagram/metrics.js";
+import { diagnoseMarkdown } from "../markdown-diagnostics.js";
+// Styled text in diagram labels. Mermaid has two label grammars, and before
+// this brane read only `<br/>` from either: an agent on another daemon tried
+// `<b>`, then a markdown string ``"`**Plan**`"``, then a `font-weight`
+// classDef, and drew literal tags, then literal backticks and asterisks, then
+// nothing, with a clean `narrate` receipt each time (claude-cdouqlgt:12–:24).
+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("markdown strings", () => {
+    it("draws **bold** and *italic*, not the asterisks and backticks", () => {
+        const ir = ok('flowchart TD\n A["`**Plan** mixin, *maybe*`"] --> B');
+        assert.deepEqual(ir.nodes[0].lines, ["Plan mixin, maybe"]);
+        assert.deepEqual(ir.nodes[0].runs, [[
+                { text: "Plan", bold: true },
+                { text: " mixin, " },
+                { text: "maybe", italic: true },
+            ]]);
+        assert.deepEqual(ir.literal, []);
+    });
+    it("spans lines, and each source line is a drawn line", () => {
+        const ir = ok([
+            "flowchart TD",
+            '  Plan["`**Plan**',
+            "  inspectable before it runs`\"]",
+            "  Plan --> Intent",
+        ].join("\n"));
+        assert.deepEqual(ir.nodes[0].lines, ["Plan", "inspectable before it runs"]);
+        assert.equal(line(ir.nodes[0].runs[0])[0].bold, true);
+        assert.deepEqual(ir.edges.map((e) => `${e.from}->${e.to}`), ["Plan->Intent"]);
+    });
+    it("parses the fence that started this exactly as it was written", () => {
+        // claude-cdouqlgt:14, abridged: multi-line markdown strings with bold
+        // heads, chained and dotted edges, and a classDef.
+        const ir = ok([
+            "flowchart TD",
+            '  Plan["`**Plan**',
+            '  inspectable before it runs`"]',
+            "",
+            '  Intent["`**IntentPlan**',
+            "  declare(intent)",
+            '  planner picks the operations`"]',
+            '  Effect["`**EffectPlan** mixin',
+            '  ordering, idempotency, rollback`"]',
+            "",
+            "  Plan --> Intent",
+            "  Plan -.-> Effect",
+            "  classDef proposed stroke-dasharray: 5 5",
+            "  class Effect proposed",
+        ].join("\n"));
+        assert.deepEqual(ir.nodes.map((n) => n.id), ["Plan", "Intent", "Effect"]);
+        assert.deepEqual(ir.literal, []);
+        for (const n of ir.nodes) {
+            assert.equal(line(n.runs[0])[0].bold, true, `${n.id} has a bold head`);
+            assert.ok(!n.lines.some((l) => /[`*]/.test(l)), `${n.id} draws no markup characters`);
+        }
+        // Wrapped at mermaid's width: "planner picks the operations" is two lines.
+        assert.deepEqual(ir.nodes[1].lines, ["IntentPlan", "declare(intent)", "planner picks the", "operations"]);
+    });
+    it("refuses an unclosed markdown string, naming the line it opened on", () => {
+        const r = parseDiagram('flowchart TD\n A --> B\n C["`never\n closed\n D --> E');
+        assert.equal(r.ok, false);
+        assert.equal(!r.ok && r.refusal.kind, "parse_error");
+        assert.equal(!r.ok && r.refusal.line, 3);
+    });
+    it("honours inline <b> and <br> inside a markdown string", () => {
+        const { runs } = parseLabel('"`a <b>b</b><br>c`"');
+        assert.deepEqual(runs, [[{ text: "a " }, { text: "b", bold: true }], [{ text: "c" }]]);
+    });
+    it("draws inline code in a monospace run", () => {
+        const { runs, literal } = parseLabel('"`call `watch()` first`"');
+        assert.deepEqual(runs, [[{ text: "call " }, { text: "watch()", code: true }, { text: " first" }]]);
+        assert.deepEqual(literal, []);
+    });
+    it("draws a link as its text, and says it is not followed", () => {
+        const { lines, literal } = parseLabel('"`see [the doc](https://x.test)`"');
+        assert.deepEqual(lines, ["see the doc"]);
+        assert.equal(literal.length, 1);
+    });
+    it("works in edge labels and subgraph titles", () => {
+        const ir = ok([
+            "flowchart LR",
+            '  subgraph S["`**Stage** one`"]',
+            "    A",
+            "  end",
+            '  A -->|"`**yes**`"| B',
+        ].join("\n"));
+        assert.equal(ir.subgraphs[0].title, "Stage one");
+        assert.deepEqual(ir.subgraphs[0].titleRuns, [{ text: "Stage", bold: true }, { text: " one" }]);
+        assert.equal(ir.edges[0].label, "yes");
+        assert.deepEqual(ir.edges[0].labelRuns, [[{ text: "yes", bold: true }]]);
+    });
+});
+describe("plain labels", () => {
+    it("draws <b>, <i>, <code>, <u> and <s> the way mermaid's HTML labels do", () => {
+        const { runs, literal } = parseLabel("<b>B</b> <i>I</i> <code>C</code> <u>U</u> <s>S</s>");
+        assert.deepEqual(runs, [[
+                { text: "B", bold: true }, { text: " " },
+                { text: "I", italic: true }, { text: " " },
+                { text: "C", code: true }, { text: " " },
+                { text: "U", underline: true }, { text: " " },
+                { text: "S", strike: true },
+            ]]);
+        assert.deepEqual(literal, []);
+    });
+    it("keeps nesting straight and lets a stray closer close nothing", () => {
+        assert.deepEqual(parseLabel("<b><b>x</b> y</b> z").runs, [[{ text: "x y", bold: true }, { text: " z" }]]);
+        assert.deepEqual(parseLabel("a</b> b").runs, [[{ text: "a b" }]]);
+    });
+    it("still splits on <br/> and drops blank lines, as before", () => {
+        assert.deepEqual(parseLabel("one<br/>two<br><br/>three").lines, ["one", "two", "three"]);
+    });
+    it("leaves **x** literal, as mermaid does, and says how to style it", () => {
+        const ir = ok("flowchart TD\n A[**Plan** mixin] --> B");
+        assert.deepEqual(ir.nodes[0].lines, ["**Plan** mixin"]);
+        assert.equal(ir.literal.length, 1);
+        assert.match(ir.literal[0].message, /markdown string/);
+        assert.equal(ir.literal[0].line, 2);
+    });
+    it("shows an unknown tag as text, reported once per tag name", () => {
+        const { lines, literal } = parseLabel("<span>q</span>");
+        assert.deepEqual(lines, ["<span>q</span>"]);
+        assert.equal(literal.length, 1);
+    });
+    it("never wraps", () => {
+        const long = "word ".repeat(40).trim();
+        assert.equal(parseLabel(long).lines.length, 1);
+    });
+});
+describe("font-weight and font-style in style and classDef", () => {
+    it("bolds the whole label, and measures it bold", () => {
+        const plain = layoutDiagram(ok("flowchart TD\n A[Weighty label]"));
+        const bold = layoutDiagram(ok("flowchart TD\n A[Weighty label]\n classDef key font-weight:bold\n class A key"));
+        assert.equal(line(bold.nodes[0].runs[0])[0].bold, true);
+        assert.ok(bold.nodes[0].width > plain.nodes[0].width, "a bold label gets a wider box");
+    });
+    it("drops a value the property cannot take", () => {
+        const ir = ok("flowchart TD\n A\n style A font-weight:heavy,font-style:italic");
+        assert.deepEqual(ir.nodes[0].style, { "font-style": "italic" });
+    });
+});
+describe("measurement", () => {
+    it("uses Helvetica-Bold's own widths, not a stretch", () => {
+        const w = (text, bold) => runWidth({ text, bold }, 1000);
+        assert.equal(w("r", false), 333);
+        assert.equal(w("r", true), 389);
+        assert.equal(w("W", true), w("W", false)); // 944 in both faces
+        assert.equal(runWidth({ text: "abc" }, FONT_SIZE), textWidth("abc", FONT_SIZE));
+    });
+    it("gives code a monospace advance", () => {
+        assert.equal(runWidth({ text: "iiii", code: true }, 1000), runWidth({ text: "MMMM", code: true }, 1000));
+    });
+    it("measures a node by its runs", () => {
+        const plain = measureNode([[{ text: "Standing mandate" }]]);
+        const bold = measureNode([[{ text: "Standing mandate", bold: true }]]);
+        assert.ok(bold.width > plain.width);
+        assert.deepEqual(measureNode(["Standing mandate"]), plain);
+    });
+    it("wraps at word boundaries and never breaks a word", () => {
+        const lines = wrapRuns([{ text: "a ".repeat(60) + "x".repeat(80) }], MARKDOWN_WRAP_WIDTH);
+        for (const l of lines.slice(0, -1)) {
+            assert.ok(l.reduce((s, r) => s + runWidth(r, FONT_SIZE), 0) <= MARKDOWN_WRAP_WIDTH);
+        }
+        assert.equal(lines[lines.length - 1][0].text, "x".repeat(80));
+    });
+    it("keeps a run boundary inside a word from becoming a break", () => {
+        const lines = wrapRuns([{ text: "Plan", bold: true }, { text: "s and more" }], 10_000);
+        assert.deepEqual(lines, [[{ text: "Plan", bold: true }, { text: "s and more" }]]);
+    });
+});
+describe("SVG", () => {
+    it("draws a bold run as a bold tspan", () => {
+        const svg = renderDiagram('flowchart TD\n A["`**Plan** mixin`"]').svg;
+        assert.match(svg, /<tspan font-weight="bold">Plan<\/tspan> mixin/);
+        assert.doesNotMatch(svg, /\*\*|`/);
+    });
+    it("draws an unstyled label exactly as it did before runs", () => {
+        const svg = renderDiagram("flowchart TD\n A[Plain]").svg;
+        assert.match(svg, /<tspan x="[\d.]+" dy="0">Plain<\/tspan>/);
+    });
+    it("escapes markup in every grammar", () => {
+        for (const label of ['"`**<script>x</script>**`"', "<b><script>x</script></b>", "<img src=x onerror=y>"]) {
+            const svg = renderDiagram(`flowchart TD\n A[${label}]`).svg;
+            assert.doesNotMatch(svg, /<script|<img/, label);
+        }
+    });
+    it("stacks a multi-line edge label inside one chip", () => {
+        const svg = renderDiagram("flowchart TD\n A -->|one<br/>two| B").svg;
+        assert.match(svg, />one<\/tspan><tspan x="[\d.]+" dy="[\d.]+">two</);
+    });
+});
+describe("narrate warns iff label markup shows as typed", () => {
+    const fence = (body) => "```mermaid\n" + body + "\n```";
+    it("warns on **x** in a plain label, with the source line", () => {
+        const ds = diagnoseMarkdown(fence("flowchart TD\n A[**Plan**] --> B"));
+        assert.deepEqual(ds.map((d) => d.kind), ["diagram_label_literal"]);
+        assert.equal(ds[0].line, 3);
+        assert.equal(ds[0].fallback, "A[**Plan**] --> B");
+    });
+    it("is silent when everything draws", () => {
+        const ds = diagnoseMarkdown(fence('flowchart TD\n A["`**Plan**`"] --> B[<b>Query</b><br/>plan]'));
+        assert.deepEqual(ds, []);
+    });
+    it("does not let a literal note make a diagram a refusal", () => {
+        assert.equal(diagnoseDiagram("flowchart TD\n A[**x**] --> B"), null);
+    });
+});
+describe("label parsing stays linear on hostile input", () => {
+    const time = (src) => {
+        const t = process.hrtime.bigint();
+        parseDiagram(src);
+        return Number(process.hrtime.bigint() - t) / 1e6;
+    };
+    it("an unclosed markdown string followed by many lines", () => {
+        assert.ok(time('flowchart TD\n A["`x\n' + "y\n".repeat(5000)) < 500);
+    });
+    it("a label full of half-tags and asterisks", () => {
+        const label = "<b ".repeat(300) + "**a".repeat(150) + "`b".repeat(150);
+        assert.ok(time(`flowchart TD\n A[${label}]`) < 500);
+    });
+});
+describe("tables in node labels", () => {
+    // Brane-only: mermaid shows "Unsupported markdown: table" here. Allowed by
+    // the dialect rule because the fence is still valid mermaid, and because
+    // the drawing is static SVG made on the daemon, so the HTML export carries
+    // no rendering logic for it (claude-uwaj0umf:33).
+    const TABLE = [
+        "flowchart LR",
+        '  K["`**Plan kinds**',
+        "  | kind | input | standing |",
+        "  |:---|:---:|---:|",
+        "  | QueryPlan | operation | no |",
+        "  | WatchPlan | *intent* | **yes** |",
+        "",
+        '  the spine`"]',
+    ].join("\n");
+    const tableOf = (l) => {
+        assert.ok(!Array.isArray(l), "expected a table");
+        return l;
+    };
+    it("parses a GFM table into a bold header, rows and alignment", () => {
+        const ir = ok(TABLE);
+        const runs = ir.nodes[0].runs;
+        assert.equal(runs.length, 3);
+        const t = tableOf(runs[1]);
+        assert.deepEqual(t.align, ["left", "center", "right"]);
+        assert.deepEqual(t.header, [[{ text: "kind", bold: true }], [{ text: "input", bold: true }], [{ text: "standing", bold: true }]]);
+        assert.deepEqual(t.rows[1], [[{ text: "WatchPlan" }], [{ text: "intent", italic: true }], [{ text: "yes", bold: true }]]);
+        assert.deepEqual(ir.nodes[0].lines, [
+            "Plan kinds", "kind | input | standing", "QueryPlan | operation | no", "WatchPlan | intent | yes", "the spine",
+        ]);
+        assert.deepEqual(ir.literal, []);
+    });
+    it("pads a short row and drops extra cells, as GFM does", () => {
+        const t = tableOf(parseLabel('"`| a | b |\n|---|---|\n| 1 |\n| 1 | 2 | 3 |`"', { tables: true }).runs[0]);
+        assert.deepEqual(t.rows, [[[{ text: "1" }], []], [[{ text: "1" }], [{ text: "2" }]]]);
+    });
+    it("sizes the node to the columns and to every row", () => {
+        const placed = layoutDiagram(ok(TABLE));
+        const node = placed.nodes[0];
+        assert.ok(node.height >= 5 * FONT_SIZE * 1.35, "five line slots: title, header, two rows, trailer");
+        const flat = measureNode(["kind | input | standing"]);
+        assert.ok(node.width > flat.width, "the gaps between columns cost more than ` | `");
+    });
+    it("draws cells at their column's edge, and a rule under the header", () => {
+        const svg = renderDiagram(TABLE).svg;
+        assert.match(svg, /text-anchor="end"><tspan font-weight="bold">standing<\/tspan>/);
+        assert.match(svg, /text-anchor="middle"><tspan font-weight="bold">input<\/tspan>/);
+        assert.match(svg, /text-anchor="start">QueryPlan</);
+        assert.match(svg, /<path d="M[\d.]+,[\d.]+h[\d.]+" stroke="[^"]+" stroke-width="1" opacity="0.6"/);
+    });
+    it("bolds the cells too when the node is bold", () => {
+        const placed = layoutDiagram(ok(TABLE + "\n  style K font-weight:bold"));
+        const t = tableOf(placed.nodes[0].runs[1]);
+        assert.ok(t.rows.flat(2).every((r) => r.bold));
+    });
+    it("shows a table in an edge label as its source, and says so", () => {
+        const ir = ok('flowchart LR\n A -->|"`| a | b |\n|---|---|\n| 1 | 2 |`"| B');
+        assert.equal(ir.edges[0].label, "| a | b | |---|---| | 1 | 2 |");
+        assert.equal(ir.literal.length, 1);
+        assert.match(ir.literal[0].message, /only in node labels/);
+    });
+});
+describe("plain-label details", () => {
+    it("does not warn about ** inside <code>, where it is meant literally", () => {
+        const { runs, literal } = parseLabel("<code>**x**</code>");
+        assert.deepEqual(runs, [[{ text: "**x**", code: true }]]);
+        assert.deepEqual(literal, []);
+    });
+    it("decodes character references, as mermaid's HTML labels do", () => {
+        assert.deepEqual(parseLabel("x &lt; y &amp;&amp; a &#x2192; b &rarr; c").lines, ["x < y && a → b → c"]);
+        assert.deepEqual(parseLabel("&bogus; &#0; &#xD800;").lines, ["&bogus; &#0; &#xD800;"]);
+    });
+    it("never reads a decoded < as a tag", () => {
+        const { runs } = parseLabel("&lt;b&gt;not bold&lt;/b&gt;");
+        assert.deepEqual(runs, [[{ text: "<b>not bold</b>" }]]);
+    });
+});
+//# sourceMappingURL=diagram-labels.test.js.map