brane 0.1.1 → 0.3.0

package/dist/test/markdown-math.test.js

@@ -0,0 +1,256 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { micromark } from "micromark";
+import { math } from "micromark-extension-math";
+import { MATH_BLOCK_CSS, prepareMathMarkdown, isMathContent, renderMathHtml } from "../shared/markdown-math.js";
+import { mathHtmlExtension, katexStyleFor } from "../math.js";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
+// Rendering LaTeX is the easy half. The hard half is deciding which dollars are
+// delimiters — narratives are full of prices, shell variables and awk fields —
+// and making the app and the HTML export agree about it, since they render the
+// same markdown through the same functions and any disagreement shows up as an
+// export that no longer matches what the operator saw.
+function render(md) {
+    return micromark(prepareMathMarkdown(md), {
+        extensions: [math()],
+        htmlExtensions: [mathHtmlExtension()],
+    });
+}
+/** "display" | "inline" | "none" — how a source's math came out. */
+function mode(md) {
+    const html = render(md);
+    if (!html.includes("katex"))
+        return "none";
+    return html.includes("math-display") ? "display" : "inline";
+}
+describe("dollar-sign guard", () => {
+    it("renders real inline math", () => {
+        for (const md of ["$B = Tc^2$", "$\\Lambda$", "$g_{\\mu\\nu}$", "$R$", "$\\sqrt{-g}$"]) {
+            assert.equal(mode(md), "inline", md);
+        }
+    });
+    it("leaves currency alone — including the range that Pandoc's digit rule catches", () => {
+        // `$10k–$500k` is the motivating case: a naive parser reads "10k–" as math.
+        for (const md of ["Between $10k and $500k.", "It costs $5 and $10 more.", "$3/M in, $15/M out"]) {
+            assert.equal(mode(md), "none", md);
+        }
+    });
+    it("leaves shell and awk alone even outside a code span", () => {
+        for (const md of ["${curcontext%:*:*}:organelle-command-$state", "awk '{print $1, $9}' and $2"]) {
+            assert.equal(mode(md), "none", md);
+        }
+    });
+    it("ends a code span at its paragraph, so a stray backtick run guards nothing past it", () => {
+        const html = render("mentions ```lua in prose.\n\nDinner was $5 and $10.\n");
+        assert.doesNotMatch(html, /class="math/);
+        assert.match(html, /\$5 and \$10/);
+    });
+    it("keeps the real math in a line that also has prices", () => {
+        // Escaping only the *opening* delimiter is what makes this work: the closer
+        // of a rejected run gets its own hearing as the next candidate's opener.
+        const html = render("$5 and $10 and $x$ here");
+        assert.equal((html.match(/class="katex"/g) ?? []).length, 1);
+        assert.ok(html.includes("$5 and $10 and"), "the prices survive as prose");
+    });
+    it("never escapes inside code, where a backslash would be literal", () => {
+        for (const md of ["Use `$HOME` and `$PATH` here.", "```sh\necho $HOME $PATH\n```", "    echo $HOME"]) {
+            assert.ok(!prepareMathMarkdown(md).includes("\\$"), md);
+            assert.equal(mode(md), "none", md);
+        }
+    });
+    it("respects a dollar the author already escaped", () => {
+        assert.equal(prepareMathMarkdown("Costs \\$5 and \\$10."), "Costs \\$5 and \\$10.");
+    });
+    it("scores the individual rules", () => {
+        assert.equal(isMathContent("x + y", ""), true);
+        assert.equal(isMathContent("", ""), false, "empty");
+        assert.equal(isMathContent(" x", ""), false, "leading space");
+        assert.equal(isMathContent("x ", ""), false, "trailing space");
+        assert.equal(isMathContent("10k–", "5"), false, "digit after the closer");
+        assert.equal(isMathContent("{nid}", ""), false, "shell expansion");
+        assert.equal(isMathContent('line[1] \\"', ""), false, "raw double quote");
+    });
+});
+describe("display math", () => {
+    it("promotes a one-line $$…$$ paragraph to a display block", () => {
+        // The form agents actually write. micromark-extension-math only knows `$$`
+        // as a fence, so without the promotion this renders inline.
+        assert.equal(mode("$$B = m\\ddot U$$"), "display");
+        assert.equal(mode("Swap it:\n\n$$B = m\\ddot U = m = T.$$\n\nDone."), "display");
+    });
+    it("still accepts the fenced form", () => {
+        assert.equal(mode("$$\nB = Tc^2\n$$"), "display");
+    });
+    it("leaves $$…$$ inline when it shares its line with prose", () => {
+        assert.equal(mode("the value $$x$$ inline"), "inline");
+    });
+});
+describe("TeX delimiters", () => {
+    // `\(…\)` and `\[…\]` are the OpenAI house style, and they dominate any
+    // absorbed archive — 1576 and 351 occurrences against 578 single-dollar runs
+    // in the corpus this was built against. Markdown would eat both halves as
+    // escaped brackets and leave the LaTeX sitting in the prose.
+    it("renders \\(…\\) as inline math", () => {
+        assert.equal(mode("The claim \\(B = Tc^2\\) holds."), "inline");
+    });
+    it("renders \\[…\\] alone on a line as display math", () => {
+        assert.equal(mode("Swap it:\n\n\\[B = m\\ddot U\\]\n\nDone."), "display");
+        assert.equal(mode("\\[\n\\dot\\sigma = -A(t)\\sigma\n\\]"), "display");
+    });
+    it("keeps \\[…\\] inline when it shares its line with prose", () => {
+        assert.equal(mode("the value \\[x^2\\] inline"), "inline");
+    });
+    it("leaves TeX delimiters inside code alone", () => {
+        assert.equal(mode("Write `\\(x\\)` for inline."), "none");
+        assert.equal(mode("```\n\\(x\\)\n```"), "none");
+    });
+    it("ignores an unmatched opener", () => {
+        assert.equal(mode("An open \\( with no close."), "none");
+    });
+    it("renders a ```math fence as display math, but leaves ```latex as source", () => {
+        // GitHub's convention: ```math is an equation, ```latex is a listing.
+        assert.equal(mode("```math\nB = m\\ddot U\n```"), "display");
+        assert.equal(mode("```latex\n\\frac{a}{b}\n```"), "none");
+    });
+    it("normalizes to the dollar forms, so one syntax reaches both renderers", () => {
+        assert.equal(prepareMathMarkdown("The claim \\(B = Tc^2\\) holds."), "The claim $B = Tc^2$ holds.");
+        assert.equal(prepareMathMarkdown("\\[B = m\\ddot U\\]"), "$$\nB = m\\ddot U\n$$");
+    });
+});
+describe("math nested inside other blocks", () => {
+    // Every one of these came from a real absorbed conversation, and every one of
+    // them lost equations before it was fixed. The failure mode is always the
+    // same: a rewrite that is correct in isolation and blind to the block it sits
+    // in. They are worth pinning because none of them errors — the equation just
+    // stops being there.
+    it("keeps a blockquoted display equation", () => {
+        // `$$` swallows the rest of its line as an info string, so emitting the
+        // fence without the `> ` fed the equation into it and micromark dropped it.
+        const md = "> \\[\n> \\mathbb{E}\\,T = O(n)\n> \\]";
+        assert.equal(mode(md), "display");
+        assert.ok(render(md).includes("O(n)"), "the equation survives");
+    });
+    it("keeps a display equation indented inside a list item", () => {
+        // Opening the fence at the item's indent and closing it at column 0 ends
+        // the list and leaves the fence hanging.
+        const md = "3. **Form**: written as:\n\n   \\[ i\\hbar \\partial_t \\Psi = \\hat{H}\\Psi \\]\n\n   Here.";
+        const html = render(md);
+        assert.ok(html.includes("math-display"), "renders as display");
+        assert.ok(html.includes("hbar"), "the equation survives");
+    });
+    it("renders math in a deeply indented list item", () => {
+        // Four spaces of list indent are indent, not an indented code block.
+        assert.equal(mode("   - outer\n     - inner \\( A \\to A\\alpha \\) here"), "inline");
+    });
+    it("tolerates the padding spaces TeX delimiters usually carry", () => {
+        // `\( i \)` is idiomatic; `$ i $` is what the dollar guard throws out.
+        assert.equal(prepareMathMarkdown("Here, \\( i \\) is the unit."), "Here, $i$ is the unit.");
+    });
+    it("leaves a whole indented code block alone, not just its first line", () => {
+        // Only the first line of an indented block follows a blank one, so a
+        // per-line test lets every later line back in — which is how ASCII art
+        // drawn in dollar signs got backslashes inserted through it.
+        const md = "Art:\n\n    ooo$$$$ooo\n    oo$$$$$$oo\n    o$$ $$ $$o\n";
+        assert.equal(prepareMathMarkdown(md), md);
+    });
+});
+describe("renderMathHtml", () => {
+    it("emits MathML alongside the visible layout, for screen readers", () => {
+        const html = renderMathHtml("x^2", false);
+        assert.ok(html.includes("katex-mathml"));
+        assert.ok(html.includes("<math"));
+    });
+    it("falls back to the literal source rather than KaTeX's error markup", () => {
+        const html = renderMathHtml("\\bogusmacro{", false);
+        assert.ok(!html.includes("katex"), "no half-rendered error node");
+        assert.equal(html, "$\\bogusmacro{$");
+    });
+    it("escapes the fallback, since it lands in an HTML document", () => {
+        // `<script>` on its own is perfectly good LaTeX — two relations around a
+        // word — so reaching the fallback needs input KaTeX also can't parse.
+        assert.equal(renderMathHtml("<script>\\nosuchmacro", false), "$&lt;script&gt;\\nosuchmacro$");
+    });
+    it("reads a markdown-escaped asterisk as an asterisk", () => {
+        // `\*` isn't TeX; it's a model escaping `*` so markdown won't read emphasis,
+        // then leaving the escape inside the math. Half the unparseable equations in
+        // the absorbed archive are this.
+        const html = renderMathHtml("t^\\*", false);
+        assert.ok(html.includes("katex"), "renders rather than falling back");
+    });
+    it("escapes markup on the success path too, which is KaTeX's job", () => {
+        const html = renderMathHtml("<script>", false);
+        assert.ok(html.includes("katex"), "this one really does render");
+        assert.ok(!html.includes("<script>"), "no raw tag reaches the document");
+    });
+});
+describe("katexStyleFor", () => {
+    it("returns null for a document with no math, so it costs nothing", () => {
+        assert.equal(katexStyleFor("<p>no math here</p>"), null);
+    });
+    it("inlines every font it keeps, and reaches for no network", () => {
+        const style = katexStyleFor(render("$$\\frac{d^2U}{dt^2} = \\sqrt{-g}$$"));
+        assert.ok(style, "math document gets a stylesheet");
+        assert.equal((style.match(/url\((?!data:)/g) ?? []).length, 0, "no url() survives that isn't a data: URI");
+        assert.ok(style.includes("data:font/woff2;base64,"));
+    });
+    it("carries only the families the document reaches for", () => {
+        const style = katexStyleFor(render("$x$"));
+        const faces = (style.match(/@font-face/g) ?? []).length;
+        assert.ok(faces > 0, "at least the base family");
+        assert.ok(faces < 20, `subset, not all twenty faces (got ${faces})`);
+        // Fraktur is only reachable via \mathfrak, which this document never uses.
+        assert.ok(!style.includes("KaTeX_Fraktur-Regular.woff2"));
+    });
+});
+/** What a display block does when the equation is wider than the bubble.
+ *
+ *  KaTeX won't wrap display math and TeX has no line-breaking for it, so the
+ *  only honest answer is a scroller. Getting one is less obvious than setting
+ *  `overflow-x`, and the failure mode when it's wrong is the dangerous kind:
+ *  the equation is trimmed at both ends and still looks whole.
+ */
+describe("MATH_BLOCK_CSS — wide equations scroll rather than truncate", () => {
+    const katexCss = readFileSync(join(dirname(createRequire(import.meta.url).resolve("katex/package.json")), "dist", "katex.min.css"), "utf8");
+    it("sizes the inner block to its content, which is what gives it somewhere to scroll", () => {
+        // Without this the block is exactly the container's width and its content
+        // overflows *centered* — spilling both ways, with the left spill outside
+        // scrollWidth and therefore unreachable.
+        assert.match(MATH_BLOCK_CSS, /\.math-display\s*>\s*\.katex-display\s*>\s*\.katex\s*\{[^}]*min-width:\s*max-content/);
+    });
+    it("outranks the KaTeX rule it is correcting", () => {
+        // Three classes to KaTeX's two, so it wins on specificity no matter which
+        // stylesheet the document loads last — the app appends ours, the export
+        // emits KaTeX's after it.
+        assert.match(katexCss, /\.katex-display>\.katex\{[^}]*white-space:nowrap/, "the rule being corrected still exists");
+        const ours = (MATH_BLOCK_CSS.match(/\.math-display\s*>\s*\.katex-display\s*>\s*\.katex/) ?? [])[0];
+        assert.ok(ours, "our override is present");
+        assert.equal((ours.match(/\./g) ?? []).length, 3);
+    });
+    it("fades the equation itself, rather than washing anything over it", () => {
+        // A mask makes the block's own paint transparent, so a faded edge shows
+        // the bubble it sits on — which is why nothing here needs to be told what
+        // color that bubble is.
+        const block = MATH_BLOCK_CSS.match(/\.math-display\s*\{[^}]*\}/)[0];
+        assert.match(block, /mask-image:\s*linear-gradient/);
+        assert.ok(!/--math-bg/.test(MATH_BLOCK_CSS), "no background color to be told about");
+    });
+    it("fades an edge only while there is something past it", () => {
+        // The fade widths ride a scroll timeline over the block itself, which is
+        // how a stylesheet gets to know something it would otherwise have to
+        // measure: no scrollable overflow means an inactive timeline, so the
+        // registered initial widths stand and neither edge fades. The ranges put
+        // one animation at each end of the travel, so the far edge is crisp once
+        // you have actually reached it.
+        const block = MATH_BLOCK_CSS.match(/\.math-display\s*\{[^}]*\}/)[0];
+        assert.match(block, /animation-timeline:\s*scroll\(self x\), scroll\(self x\)/);
+        assert.match(block, /animation-range:\s*0 32px, calc\(100% - 32px\) 100%/);
+        for (const prop of ["--math-fade-start", "--math-fade-end"]) {
+            assert.match(MATH_BLOCK_CSS, new RegExp(`@property ${prop} \\{[^}]*initial-value: 0px`), `${prop} rests at no fade`);
+        }
+        // The end-side animation runs backwards — full fade until you arrive.
+        assert.match(MATH_BLOCK_CSS, /@keyframes brane-math-fade-end \{ from \{ --math-fade-end: 28px; \} to \{ --math-fade-end: 0px; \} \}/);
+    });
+});
+//# sourceMappingURL=markdown-math.test.js.map

package/dist/test/markdown-nids.test.js

@@ -0,0 +1,146 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmAutolinkLiteral } from "micromark-extension-gfm-autolink-literal";
+import { gfmAutolinkLiteralFromMarkdown } from "mdast-util-gfm-autolink-literal";
+import { narrativeIdLinks } from "../shared/markdown-nids.js";
+// These exercise the live app's markdown pipeline (expo/components/Markdown.tsx)
+// through the same two extensions it installs: GFM autolink literals, then the
+// narrative-id tree transform. The transform is the part worth pinning — it
+// replaced a regex over raw markdown source, and the whole reason for the swap
+// is that the parser, not a pattern, decides what counts as prose.
+const KNOWN = new Set(["claude-4c7289d1", "goose-aa11bb22"]);
+/** Parses the way the app does and returns the resulting mdast tree. */
+function render(md, knownIds = KNOWN) {
+    return fromMarkdown(md, {
+        extensions: [gfmAutolinkLiteral()],
+        mdastExtensions: [gfmAutolinkLiteralFromMarkdown(), narrativeIdLinks(knownIds)],
+    });
+}
+/** Flattens a tree to `[type, url|value]` pairs for the leaves that carry text,
+ *  so assertions read as "what the reader ends up seeing". */
+function leaves(node, out = []) {
+    if (node.type === "link") {
+        out.push(["link", node.url]);
+        return out;
+    }
+    if (node.type === "inlineCode" || node.type === "code" || node.type === "text") {
+        out.push([node.type, node.value]);
+        return out;
+    }
+    for (const child of node.children ?? [])
+        leaves(child, out);
+    return out;
+}
+function urls(md, knownIds) {
+    return leaves(render(md, knownIds)).filter(([t]) => t === "link").map(([, u]) => u);
+}
+describe("autolink literals", () => {
+    it("links bare http(s) URLs", () => {
+        assert.deepEqual(urls("see https://example.com/a?b=1 now"), ["https://example.com/a?b=1"]);
+    });
+    it("links www. literals with an implied scheme", () => {
+        assert.deepEqual(urls("see www.example.com now"), ["http://www.example.com"]);
+    });
+    it("links bare email addresses via mailto:", () => {
+        assert.deepEqual(urls("mail ben@example.com now"), ["mailto:ben@example.com"]);
+    });
+    it("leaves trailing sentence punctuation outside the link", () => {
+        const l = leaves(render("read https://example.com/docs."));
+        assert.deepEqual(l, [
+            ["text", "read "],
+            ["link", "https://example.com/docs"],
+            ["text", "."],
+        ]);
+    });
+    it("balances trailing parens", () => {
+        // GFM keeps a closing paren only when it balances one inside the URL.
+        assert.deepEqual(urls("(see https://en.wikipedia.org/wiki/Foo_(bar))"), [
+            "https://en.wikipedia.org/wiki/Foo_(bar)",
+        ]);
+    });
+    it("does not touch URLs inside code spans or fenced blocks", () => {
+        assert.deepEqual(urls("`https://example.com`"), []);
+        assert.deepEqual(urls("```\nhttps://example.com\n```"), []);
+    });
+    it("leaves an explicit markdown link's href alone", () => {
+        assert.deepEqual(urls("[docs](https://example.com/x)"), ["https://example.com/x"]);
+    });
+});
+describe("narrative id linkification", () => {
+    it("links a bare id and an id:seq reference", () => {
+        assert.deepEqual(urls("see claude-4c7289d1 and claude-4c7289d1:42"), [
+            "brane://nid/claude-4c7289d1",
+            "brane://nid/claude-4c7289d1/42",
+        ]);
+    });
+    it("keeps the surrounding prose intact around a reference", () => {
+        assert.deepEqual(leaves(render("before claude-4c7289d1:7 after")), [
+            ["text", "before "],
+            ["link", "brane://nid/claude-4c7289d1/7"],
+            ["text", " after"],
+        ]);
+    });
+    it("links only ids that actually exist", () => {
+        assert.deepEqual(urls("claude-deadbeef is not a narrative"), []);
+        assert.deepEqual(urls("claude-4c7289d1", new Set()), []);
+    });
+    it("promotes a code span that is exactly one reference", () => {
+        assert.deepEqual(urls("`claude-4c7289d1:42`"), ["brane://nid/claude-4c7289d1/42"]);
+    });
+    it("leaves a code span that merely contains a reference as code", () => {
+        assert.deepEqual(leaves(render("`brane list claude-4c7289d1`")), [
+            ["inlineCode", "brane list claude-4c7289d1"],
+        ]);
+    });
+    it("does not touch references inside fenced code", () => {
+        assert.deepEqual(urls("```\nclaude-4c7289d1\n```"), []);
+    });
+    it("does not rewrite the label or href of an existing link", () => {
+        const l = leaves(render("[claude-4c7289d1](https://example.com/x)"));
+        assert.deepEqual(l, [["link", "https://example.com/x"]]);
+    });
+    it("links references inside emphasis, headings and list items", () => {
+        assert.deepEqual(urls("*claude-4c7289d1*"), ["brane://nid/claude-4c7289d1"]);
+        assert.deepEqual(urls("# claude-4c7289d1"), ["brane://nid/claude-4c7289d1"]);
+        assert.deepEqual(urls("- claude-4c7289d1"), ["brane://nid/claude-4c7289d1"]);
+    });
+    it("links several references in one text run", () => {
+        assert.deepEqual(urls("claude-4c7289d1 then goose-aa11bb22:3"), [
+            "brane://nid/claude-4c7289d1",
+            "brane://nid/goose-aa11bb22/3",
+        ]);
+    });
+    it("skips unknown ids without disturbing known ones beside them", () => {
+        assert.deepEqual(leaves(render("claude-deadbeef vs claude-4c7289d1 ok")), [
+            ["text", "claude-deadbeef vs "],
+            ["link", "brane://nid/claude-4c7289d1"],
+            ["text", " ok"],
+        ]);
+    });
+    it("leaves a URL whose path contains a narrative id intact", () => {
+        // The regression that motivated moving off a source-level regex: the old
+        // linkifier rewrote the id *inside* the URL, producing nested link syntax.
+        assert.deepEqual(urls("https://brane.organelle.dev/claude-4c7289d1"), [
+            "https://brane.organelle.dev/claude-4c7289d1",
+        ]);
+    });
+    it("gives every synthesized node a key, so React can list them", () => {
+        // Nodes the parser produced are keyed by the renderer's own extension,
+        // which runs before this one; nodes this transform *creates* have to bring
+        // their own. So the paragraph's rewritten children are what's under test.
+        const paragraph = render("before claude-4c7289d1:7 after").children[0];
+        const keys = [];
+        const collect = (n) => {
+            keys.push(n.key);
+            for (const c of n.children ?? [])
+                collect(c);
+        };
+        for (const child of paragraph.children)
+            collect(child);
+        assert.equal(keys.length, 4); // text, link, link's label, text
+        assert.ok(keys.every((k) => typeof k === "string" && k.length > 0), `missing keys: ${keys}`);
+        assert.equal(new Set(keys).size, keys.length, `duplicate keys: ${keys}`);
+    });
+});
+//# sourceMappingURL=markdown-nids.test.js.map

package/dist/test/markdown-protocols.test.js

@@ -0,0 +1,139 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmAutolinkLiteral } from "micromark-extension-gfm-autolink-literal";
+import { gfmAutolinkLiteralFromMarkdown } from "mdast-util-gfm-autolink-literal";
+import { narrativeIdLinks } from "../shared/markdown-nids.js";
+import { protocolLinks } from "../shared/markdown-protocols.js";
+// `/ramify` in a message should open the protocol. The hard part isn't linking
+// it — it's *not* linking the slashes that fill ordinary agent chatter: paths,
+// dates, `and/or`. These pin both halves.
+const KNOWN = new Set(["ramify", "memory", "LIVE_loop", "reviewer.draft"]);
+function render(md, known = KNOWN) {
+    return fromMarkdown(md, {
+        extensions: [gfmAutolinkLiteral()],
+        mdastExtensions: [gfmAutolinkLiteralFromMarkdown(), protocolLinks(known)],
+    });
+}
+function leaves(node, out = []) {
+    if (node.type === "link") {
+        out.push(["link", node.url]);
+        return out;
+    }
+    if (node.type === "inlineCode" || node.type === "code" || node.type === "text") {
+        out.push([node.type, node.value]);
+        return out;
+    }
+    for (const child of node.children ?? [])
+        leaves(child, out);
+    return out;
+}
+function urls(md, known) {
+    return leaves(render(md, known)).filter(([t]) => t === "link").map(([, u]) => u);
+}
+describe("protocol command linkification", () => {
+    it("links a bare command", () => {
+        assert.deepEqual(urls("run /ramify now"), ["brane://protocol/ramify"]);
+    });
+    it("links names with underscores and dots", () => {
+        assert.deepEqual(urls("/LIVE_loop and /reviewer.draft"), [
+            "brane://protocol/LIVE_loop",
+            "brane://protocol/reviewer.draft",
+        ]);
+    });
+    it("links only protocols that actually exist", () => {
+        assert.deepEqual(urls("/nonesuch is not a protocol"), []);
+        assert.deepEqual(urls("/ramify", new Set()), []);
+    });
+    it("keeps the surrounding prose intact", () => {
+        assert.deepEqual(leaves(render("try /memory please")), [
+            ["text", "try "],
+            ["link", "brane://protocol/memory"],
+            ["text", " please"],
+        ]);
+    });
+    it("leaves the command's arguments as prose", () => {
+        assert.deepEqual(leaves(render("/ramify fix the auth module")), [
+            ["link", "brane://protocol/ramify"],
+            ["text", " fix the auth module"],
+        ]);
+    });
+    it("drops trailing sentence punctuation from the link", () => {
+        assert.deepEqual(leaves(render("as described in /memory.")), [
+            ["text", "as described in "],
+            ["link", "brane://protocol/memory"],
+            ["text", "."],
+        ]);
+        assert.deepEqual(leaves(render("either /ramify, or not")), [
+            ["text", "either "],
+            ["link", "brane://protocol/ramify"],
+            ["text", ", or not"],
+        ]);
+    });
+    it("ignores a path segment that happens to name a protocol", () => {
+        assert.deepEqual(urls("see src/memory/index.ts"), []);
+        assert.deepEqual(urls("~/memory holds the db"), []);
+        assert.deepEqual(urls("./memory"), []);
+        assert.deepEqual(urls("/memory/index.ts"), []);
+    });
+    it("ignores a slash used as a conjunction", () => {
+        assert.deepEqual(urls("read and/or write"), []);
+    });
+    it("promotes a code span that is exactly one command", () => {
+        assert.deepEqual(urls("`/ramify`"), ["brane://protocol/ramify"]);
+    });
+    it("leaves a code span that merely contains a command as code", () => {
+        assert.deepEqual(leaves(render("`/ramify fix auth`")), [
+            ["inlineCode", "/ramify fix auth"],
+        ]);
+    });
+    it("does not touch commands inside fenced code or existing links", () => {
+        assert.deepEqual(urls("```\n/ramify\n```"), []);
+        assert.deepEqual(urls("[/ramify](https://example.com/x)"), ["https://example.com/x"]);
+    });
+    it("leaves a URL whose path names a protocol intact", () => {
+        assert.deepEqual(urls("https://brane.organelle.dev/memory"), [
+            "https://brane.organelle.dev/memory",
+        ]);
+    });
+    it("links several commands in one run", () => {
+        assert.deepEqual(urls("/ramify then /memory"), [
+            "brane://protocol/ramify",
+            "brane://protocol/memory",
+        ]);
+    });
+    it("links commands inside emphasis, headings and list items", () => {
+        assert.deepEqual(urls("*/ramify*"), ["brane://protocol/ramify"]);
+        assert.deepEqual(urls("# /ramify"), ["brane://protocol/ramify"]);
+        assert.deepEqual(urls("- /ramify"), ["brane://protocol/ramify"]);
+    });
+    it("coexists with narrative-id linkification", () => {
+        const tree = fromMarkdown("claude-4c7289d1 ran /ramify", {
+            extensions: [gfmAutolinkLiteral()],
+            mdastExtensions: [
+                gfmAutolinkLiteralFromMarkdown(),
+                narrativeIdLinks(new Set(["claude-4c7289d1"])),
+                protocolLinks(KNOWN),
+            ],
+        });
+        assert.deepEqual(leaves(tree).filter(([t]) => t === "link").map(([, u]) => u), [
+            "brane://nid/claude-4c7289d1",
+            "brane://protocol/ramify",
+        ]);
+    });
+    it("gives every synthesized node a key, so React can list them", () => {
+        const paragraph = render("run /ramify now").children[0];
+        const keys = [];
+        const collect = (n) => {
+            keys.push(n.key);
+            for (const c of n.children ?? [])
+                collect(c);
+        };
+        for (const child of paragraph.children)
+            collect(child);
+        assert.equal(keys.length, 4); // text, link, link's label, text
+        assert.ok(keys.every((k) => typeof k === "string" && k.length > 0), `missing keys: ${keys}`);
+        assert.equal(new Set(keys).size, keys.length, `duplicate keys: ${keys}`);
+    });
+});
+//# sourceMappingURL=markdown-protocols.test.js.map

package/dist/test/mcp-bridge-cancel.test.js

@@ -0,0 +1,98 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { WebSocketServer } from "ws";
+// The bridge when the agent's harness gives up on a call: Esc, or a killed
+// background task, arrives as MCP `notifications/cancelled`. The bridge used
+// to answer it "Method not found" — an error with no id, which Claude Code
+// logs as a connection error — and never told the daemon, so a cancelled
+// listen stayed parked and its narrative kept glowing as awaiting direction.
+// Driven for real, as in mcp-bridge-reconnect.test.ts: a child runs the
+// bridge, this test plays daemon on a WebSocket and agent on stdio.
+const BRIDGE = pathToFileURL(join(dirname(fileURLToPath(import.meta.url)), "..", "mcp", "server.js")).href;
+function childEnv(port) {
+    const env = { ...process.env, PORT: String(port), HOME: mkdtempSync(join(tmpdir(), "brane-bridge-")) };
+    for (const k of Object.keys(env)) {
+        if (k.startsWith("BRANE_") || k === "CLAUDE_CODE_SESSION_ID" || k === "NODE_TEST_CONTEXT")
+            delete env[k];
+    }
+    return env;
+}
+describe("the MCP bridge when a call is cancelled", () => {
+    it("tells the daemon, answers nothing, and drops a late result", async () => {
+        const received = [];
+        const sockets = [];
+        const server = createServer();
+        const wss = new WebSocketServer({ noServer: true });
+        server.on("upgrade", (req, sock, head) => {
+            wss.handleUpgrade(req, sock, head, (ws) => {
+                sockets.push(ws);
+                ws.send(JSON.stringify({ type: "welcome", brane_id: "b", narrative_id: "external-test0002", bind_secret: "s" }));
+                ws.on("message", (d) => {
+                    const msg = JSON.parse(d.toString());
+                    received.push(msg);
+                    // listen parks: no answer until the test sends one by hand.
+                    if (msg.type === "tool_call" && msg.tool !== "listen") {
+                        ws.send(JSON.stringify({ type: "tool_result", id: msg.id, result: { ok: msg.tool } }));
+                    }
+                });
+            });
+        });
+        await new Promise((r) => server.listen(0, "127.0.0.1", () => r()));
+        const port = server.address().port;
+        const child = spawn(process.execPath, ["--input-type=module", "-e",
+            `const { startMcpBridge } = await import(${JSON.stringify(BRIDGE)});
+         startMcpBridge(async () => "ws://127.0.0.1:" + process.env.PORT + "/ws/mcp?token=t");`], { env: childEnv(port), stdio: ["pipe", "pipe", "pipe"] });
+        const lines = [];
+        let buf = "";
+        child.stdout.on("data", (d) => {
+            buf += d.toString();
+            let i;
+            while ((i = buf.indexOf("\n")) >= 0) {
+                const line = buf.slice(0, i);
+                buf = buf.slice(i + 1);
+                if (line.trim())
+                    lines.push(JSON.parse(line));
+            }
+        });
+        const send = (m) => child.stdin.write(JSON.stringify({ jsonrpc: "2.0", ...m }) + "\n");
+        const until = async (pred, ms) => {
+            const end = Date.now() + ms;
+            while (!pred()) {
+                if (Date.now() > end)
+                    throw new Error("timed out waiting");
+                await new Promise((r) => setTimeout(r, 25));
+            }
+        };
+        try {
+            await until(() => sockets.length === 1, 3000);
+            send({ id: 7, method: "tools/call", params: { name: "listen", arguments: { after: 3 } } });
+            await until(() => received.some((m) => m.type === "tool_call"), 3000);
+            const listenCall = received.find((m) => m.type === "tool_call");
+            send({ method: "notifications/cancelled", params: { requestId: 7, reason: "user-cancel" } });
+            await until(() => received.some((m) => m.type === "tool_cancel"), 3000);
+            assert.deepEqual(received.find((m) => m.type === "tool_cancel"), { type: "tool_cancel", id: listenCall.id });
+            // The daemon answers anyway (it raced the cancel), and a notification
+            // the bridge has never heard of arrives: neither may produce output.
+            sockets[0].send(JSON.stringify({ type: "tool_result", id: listenCall.id, result: { late: true } }));
+            send({ method: "notifications/somethingNew" });
+            // A later call's answer is the fence: everything before it has landed.
+            send({ id: 8, method: "tools/call", params: { name: "whoami", arguments: {} } });
+            await until(() => lines.some((l) => l.id === 8), 3000);
+            assert.deepEqual(lines.map((l) => l.id), [8], "only the live call is ever answered");
+        }
+        finally {
+            child.kill();
+            for (const s of sockets)
+                s.terminate();
+            wss.close();
+            server.close();
+        }
+    });
+});
+//# sourceMappingURL=mcp-bridge-cancel.test.js.map