brane 0.1.1 → 0.3.0

package/dist/test/mentions-listen.test.js

@@ -0,0 +1,265 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestDb } from "./helpers.js";
+import { announceEvent, createMentionRecorder, startMcpListen, wakeListenWaiters, } from "../daemon/server.js";
+import { appendEvent } from "../db/events.js";
+import { recordMentions } from "../db/mentions.js";
+// The regression guard for the failure that would make this feature worse than
+// not having it.
+//
+// A mention has to resolve a parked `listen` — otherwise the daemon's wake
+// finds no *events*, parks again, and the mention waits out the full hold (up
+// to 3400s for claude). But the moment mentions can resolve a listen, they can
+// also resolve *every* listen: if the resolve doesn't settle durable state in
+// the same synchronous block as the send, the agent's next listen returns
+// instantly, forever, at inference speed, with no operator in the loop.
+//
+// So: exactly once. That is what these pin.
+const SELF = "claude-aaaaaaaa";
+const OTHER = "claude-bbbbbbbb";
+const BRANE = "brane-home";
+/** A bridge client whose socket records what it was sent. */
+function fakeClient() {
+    const sent = [];
+    const ws = {
+        readyState: 1, // WebSocket.OPEN
+        send: (raw) => {
+            const msg = JSON.parse(raw);
+            if (msg.type === "tool_result")
+                sent.push({ callId: msg.id, result: msg.result });
+        },
+    };
+    return {
+        client: {
+            ws: ws,
+            narrativeId: SELF,
+            agentType: "claude",
+            pendingListens: new Map(),
+        },
+        sent,
+    };
+}
+function db() {
+    const d = createTestDb();
+    const ins = d.prepare("INSERT INTO narratives (id, brane_id, created_at, status) VALUES (?, ?, 0, 'active')");
+    ins.run(SELF, BRANE);
+    ins.run(OTHER, BRANE);
+    return d;
+}
+/** OTHER mentions SELF, exactly as the daemon's recorder would. */
+function mentionSelf(d, content = `ping @${SELF}`) {
+    const event = appendEvent(d, OTHER, "narration", { content, source: OTHER });
+    recordMentions(d, {
+        mentionedNids: [SELF],
+        srcNarrative: OTHER,
+        srcSeq: event.seq,
+        author: OTHER,
+        time: event.time,
+    });
+    return event.seq;
+}
+function listen(d, c, callId, args = {}) {
+    startMcpListen(c, d, callId, { after: { self: 0 }, ...args }, new Map(), () => { }, BRANE);
+}
+describe("a mention resolves a listen exactly once", () => {
+    it("resolves the first listen and blocks the next", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        mentionSelf(d);
+        listen(d, client, "1");
+        assert.equal(sent.length, 1, "a pending mention must resolve a parked listen");
+        assert.equal(sent[0].result.mentions.length, 1);
+        assert.equal(sent[0].result.mentions[0].src, OTHER);
+        listen(d, client, "2");
+        assert.equal(sent.length, 1, "SPIN LOOP: the same mention resolved a second listen");
+        assert.equal(client.pendingListens.size, 1, "the second listen should be parked");
+    });
+    it("keeps blocking across many listens while the mention stays unread", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        mentionSelf(d);
+        listen(d, client, "1");
+        for (let i = 2; i <= 10; i++)
+            listen(d, client, `${i}`);
+        assert.equal(sent.length, 1);
+    });
+    it("resolves again for a *new* mention, even with the first still unread", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        mentionSelf(d);
+        listen(d, client, "1");
+        assert.equal(sent.length, 1);
+        mentionSelf(d, `again @${SELF}`);
+        listen(d, client, "2");
+        assert.equal(sent.length, 2, "a fresh mention must wake the agent");
+        assert.equal(sent[1].result.mentions.length, 2, "the unread one is still owed");
+    });
+    it("settles in the same call that sends, so a crash after cannot double-deliver", () => {
+        // `markSent` runs inside `mentionReceipt`, which is spread into the very
+        // object handed to `sendToolResult`. Nothing between them can throw and
+        // leave the mention both sent and pending.
+        const d = db();
+        const { client, sent } = fakeClient();
+        mentionSelf(d);
+        listen(d, client, "1");
+        const unsent = d
+            .prepare("SELECT COUNT(*) c FROM mentions WHERE mentioned_nid = ? AND sent_at IS NULL")
+            .get(SELF);
+        assert.equal(unsent.c, 0);
+        assert.equal(sent.length, 1);
+    });
+});
+describe("the receipt", () => {
+    it("is absent entirely when nothing is in play", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        appendEvent(d, SELF, "human_signal", { content: "hello", source: "web" });
+        listen(d, client, "1");
+        assert.equal(sent.length, 1);
+        assert.equal("mentions" in sent[0].result, false, "an ordinary listen must be unchanged");
+        assert.equal("mentions_pending" in sent[0].result, false);
+    });
+    it("does not resolve a listen on its own when only ordinary events arrive", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        listen(d, client, "1");
+        assert.equal(sent.length, 0, "nothing to return: must park");
+        assert.equal(client.pendingListens.size, 1);
+    });
+    it("carries pointers, never the prose", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        const seq = mentionSelf(d, `a long and private message @${SELF} with secrets`);
+        listen(d, client, "1");
+        const row = sent[0].result.mentions[0];
+        assert.deepEqual(Object.keys(row).sort(), ["author", "id", "seq", "src", "time"]);
+        assert.equal(row.seq, seq);
+        assert.equal(JSON.stringify(row).includes("secrets"), false);
+    });
+});
+describe("reading the source settles it", () => {
+    it("annotates the delivered event and stops owing the mention", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        const seq = mentionSelf(d);
+        // The agent goes and reads OTHER, which is what interpreting a mention
+        // means — and the cursor it already passes is the evidence.
+        listen(d, client, "1", { after: { self: 0, [OTHER]: 0 } });
+        const events = sent[0].result.events[OTHER];
+        assert.equal(events.length, 1);
+        assert.deepEqual(events[0].mentions, [SELF], "the event says what it addresses");
+        // Settled by the read: a later listen owes nothing.
+        listen(d, client, "2", { after: { self: 0 } });
+        assert.equal(sent.length, 1, "nothing left to wake for");
+    });
+    it("does not settle a mention the read never showed", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        const first = mentionSelf(d);
+        mentionSelf(d, `later @${SELF}`);
+        // `before` truncates: this read returns the first event only.
+        listen(d, client, "1", { after: { self: 0, [OTHER]: 0 }, before: { [OTHER]: first + 1 } });
+        assert.equal(sent[0].result.events[OTHER].length, 1);
+        // The receipt acks before it reports, so the mention delivered in this
+        // very batch is already settled and only the untouched one is listed.
+        assert.equal(sent[0].result.mentions.length, 1);
+        assert.notEqual(sent[0].result.mentions[0].seq, first);
+        const owed = d
+            .prepare("SELECT COUNT(*) c FROM mentions WHERE mentioned_nid = ? AND seen_at IS NULL")
+            .get(SELF);
+        assert.equal(owed.c, 1, "the event that was never returned is still owed");
+    });
+});
+describe("the escape hatches", () => {
+    it('"dismiss" settles an irrelevant mention so it stops reappearing', () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        mentionSelf(d);
+        listen(d, client, "1", { mentions: "dismiss" });
+        assert.equal(sent.length, 1);
+        listen(d, client, "2");
+        assert.equal(sent.length, 1, "dismissed: must not wake or be re-reported");
+    });
+    it('"all" replays settled mentions without un-settling them', () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        mentionSelf(d);
+        listen(d, client, "1", { after: { self: 0, [OTHER]: 0 } }); // read + settle
+        listen(d, client, "2", { mentions: "all" });
+        assert.equal(sent.length, 2);
+        assert.equal(sent[1].result.mentions.length, 1, "recovery shows what was settled");
+        listen(d, client, "3");
+        assert.equal(sent.length, 2, "and a recovery read must not resurrect it");
+    });
+});
+describe("announceEvent records before it wakes", () => {
+    // The ordering bug this pins, observed live at claude-9o0vgfvb:14–:17.
+    //
+    // Every test above records the mention *before* any listen is parked, so
+    // none of them can see it: the failure needs a waiter that is already
+    // parked when the event lands. `notifyListenWaiters` resolves that waiter
+    // synchronously, and the receipt it builds acks by read — so if the wake
+    // runs before the insert, the ack updates zero rows, the mention lands
+    // unseen, and the agent's cursor has already moved past the only event
+    // that could ever settle it.
+    //
+    // Driving the real `announceEvent` and the real `createMentionRecorder` is
+    // the point: a test that re-implemented the order would pass no matter what
+    // `server.ts` did.
+    const harness = () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        const waiters = new Map();
+        // Stands in for the daemon's transport only. The order under test lives
+        // entirely inside `announceEvent`.
+        const notify = (nid) => wakeListenWaiters(waiters, nid);
+        const record = createMentionRecorder(d, notify);
+        const say = (content) => {
+            const event = appendEvent(d, OTHER, "narration", { content, source: OTHER });
+            announceEvent(OTHER, event, OTHER, notify, record);
+            return event.seq;
+        };
+        const unseen = () => d
+            .prepare("SELECT COUNT(*) c FROM mentions WHERE mentioned_nid = ? AND seen_at IS NULL")
+            .get(SELF).c;
+        return { d, client, sent, waiters, say, unseen };
+    };
+    it("settles a mention delivered to a listen that was already parked", () => {
+        const { d, client, sent, waiters, say, unseen } = harness();
+        // SELF is watching OTHER — the twin's cursor, and the case that breaks.
+        startMcpListen(client, d, "1", { after: { self: 0, [OTHER]: 0 } }, waiters, () => { }, BRANE);
+        assert.equal(sent.length, 0, "nothing to return yet: must park");
+        const seq = say(`ping @${SELF}`);
+        assert.equal(sent.length, 1, "the parked listen must be woken by the event");
+        const events = sent[0].result.events[OTHER];
+        assert.equal(events.length, 1);
+        assert.equal(events[0].seq, seq);
+        assert.deepEqual(events[0].mentions, [SELF], "the row existed when the receipt was built");
+        assert.equal(unseen(), 0, "reading the event that carried it must settle it");
+    });
+    it("does not re-report a mention the parked listen already read", () => {
+        // The user-visible symptom: it came back in every later receipt, and only
+        // a deliberate backward read cleared it.
+        const { d, client, sent, waiters, say } = harness();
+        startMcpListen(client, d, "1", { after: { self: 0, [OTHER]: 0 } }, waiters, () => { }, BRANE);
+        const seq = say(`ping @${SELF}`);
+        assert.equal(sent.length, 1);
+        // A forward cursor past that seq — exactly what an agent passes next.
+        startMcpListen(client, d, "2", { after: { self: 0, [OTHER]: seq } }, waiters, () => { }, BRANE);
+        assert.equal(sent.length, 1, "settled: must not wake again");
+        assert.equal(client.pendingListens.size, 1, "the second listen should be parked");
+    });
+    it("still wakes a mentioned agent that is not watching the source", () => {
+        // The other half of the contract: recording first must not cost the wake
+        // path, which is the only way a mention reaches someone watching only
+        // their own narrative.
+        const { d, client, sent, waiters, say } = harness();
+        startMcpListen(client, d, "1", { after: { self: 0 } }, waiters, () => { }, BRANE);
+        assert.equal(sent.length, 0);
+        say(`ping @${SELF}`);
+        assert.equal(sent.length, 1, "the mention itself must resolve the listen");
+        assert.equal(sent[0].result.mentions.length, 1);
+        assert.equal(sent[0].result.mentions[0].src, OTHER);
+    });
+});
+//# sourceMappingURL=mentions-listen.test.js.map

package/dist/test/mentions.test.js

@@ -0,0 +1,238 @@
+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 { mentionLinks } from "../shared/markdown-mentions.js";
+import { extractMentions } from "../mentions-scan.js";
+// Two things are under test here, and the second matters more than the first.
+//
+// 1. That `@claude-4c7289d1` links as a mention and a bare `claude-4c7289d1`
+//    still links as a citation — the distinction the whole feature rests on.
+// 2. That `extractMentions` agrees with the renderer on every input. A handle
+//    must fire a notification *iff* the operator sees it as a mention. A
+//    scanner that disagrees with the view produces wakeups nobody can explain,
+//    so `agrees()` below re-runs every interesting case through both.
+const KNOWN = new Set(["claude-4c7289d1", "goose-aa11bb22"]);
+const isKnown = (nid) => KNOWN.has(nid);
+/** Parses the way the app does: autolinks, then mentions, then citations. The
+ *  order is load-bearing — see `mentionLinks`. */
+function render(md, knownIds = KNOWN) {
+    return fromMarkdown(md, {
+        extensions: [gfmAutolinkLiteral()],
+        mdastExtensions: [
+            gfmAutolinkLiteralFromMarkdown(),
+            mentionLinks(knownIds),
+            narrativeIdLinks(knownIds),
+        ],
+    });
+}
+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);
+}
+/** The link labels a reader ends up seeing, which is how a mention is told
+ *  apart from a citation: the `@` survives into the label. */
+function labels(md, knownIds) {
+    const out = [];
+    const walk = (n) => {
+        if (n.type === "link") {
+            out.push(n.children?.map((c) => c.value).join("") ?? "");
+            return;
+        }
+        for (const c of n.children ?? [])
+            walk(c);
+    };
+    walk(render(md, knownIds));
+    return out;
+}
+/** The nids the *renderer* turned into mentions.
+ *
+ *  A link counts only if this pipeline created it: an author-written
+ *  `[@claude-4c7289d1](https://example.com/x)` has a mention-shaped label but
+ *  is someone else's link, and the walker never looked inside it. */
+function renderedMentions(md, knownIds) {
+    const out = [];
+    const walk = (n) => {
+        if (n.type === "link") {
+            const label = n.children?.map((c) => c.value).join("") ?? "";
+            if (label.startsWith("@") && String(n.url).startsWith("brane://nid/")) {
+                out.push(label.slice(1).split(":")[0]);
+            }
+            return;
+        }
+        for (const c of n.children ?? [])
+            walk(c);
+    };
+    walk(render(md, knownIds));
+    return out;
+}
+function mentioned(md) {
+    return extractMentions(md, isKnown);
+}
+/** Asserts the scanner and the renderer say the same thing about `md`. */
+function agrees(md) {
+    assert.deepEqual(mentioned(md).sort(), [...new Set(renderedMentions(md))].sort(), `scanner and renderer disagree on: ${JSON.stringify(md)}`);
+}
+describe("mention linkification", () => {
+    it("links a mention and keeps the @ in the label", () => {
+        assert.deepEqual(labels("ping @claude-4c7289d1 please"), ["@claude-4c7289d1"]);
+        assert.deepEqual(leaves(render("ping @claude-4c7289d1 please")), [
+            ["text", "ping "],
+            ["link", "brane://nid/claude-4c7289d1"],
+            ["text", " please"],
+        ]);
+    });
+    it("still links a bare id as a citation", () => {
+        assert.deepEqual(labels("see claude-4c7289d1"), ["claude-4c7289d1"]);
+    });
+    it("carries a :seq suffix into the link instead of stranding it", () => {
+        // The citation spec would otherwise eat the id and leave ":42" as text.
+        assert.deepEqual(leaves(render("@claude-4c7289d1:42")), [
+            ["link", "brane://nid/claude-4c7289d1/42"],
+        ]);
+        assert.deepEqual(labels("@claude-4c7289d1:42"), ["@claude-4c7289d1:42"]);
+        // ...and the seq says where to look, not who to notify.
+        assert.deepEqual(mentioned("@claude-4c7289d1:42"), ["claude-4c7289d1"]);
+    });
+    it("mentions and citations coexist in one run", () => {
+        assert.deepEqual(labels("@claude-4c7289d1 re goose-aa11bb22:3"), [
+            "@claude-4c7289d1",
+            "goose-aa11bb22:3",
+        ]);
+        assert.deepEqual(mentioned("@claude-4c7289d1 re goose-aa11bb22:3"), ["claude-4c7289d1"]);
+    });
+    it("does not mention an id that names no narrative", () => {
+        assert.deepEqual(mentioned("@claude-deadbeef hello"), []);
+        assert.deepEqual(labels("@claude-deadbeef hello"), []);
+    });
+    it("is case-sensitive, so a capitalized handle is inert", () => {
+        // `[a-z]+-[0-9a-z]{8}` by construction. Pinned so it stays deliberate.
+        assert.deepEqual(mentioned("@Claude-4C7289D1"), []);
+    });
+    it("collapses a repeated handle to one mention", () => {
+        assert.deepEqual(mentioned("@claude-4c7289d1 and again @claude-4c7289d1"), [
+            "claude-4c7289d1",
+        ]);
+    });
+    it("returns several distinct handles", () => {
+        assert.deepEqual(mentioned("@claude-4c7289d1 @goose-aa11bb22").sort(), [
+            "claude-4c7289d1",
+            "goose-aa11bb22",
+        ]);
+    });
+});
+describe("mentions the parser refuses", () => {
+    it("ignores a handle inside a fenced block", () => {
+        // The case that makes a source-level regex unusable: a pasted log.
+        const md = "```\n@claude-4c7289d1\n```";
+        assert.deepEqual(mentioned(md), []);
+        assert.deepEqual(labels(md), []);
+    });
+    it("ignores a handle embedded in a code span", () => {
+        assert.deepEqual(mentioned("`brane revive @claude-4c7289d1`"), []);
+    });
+    it("promotes a code span that is exactly one mention", () => {
+        // Matches how the citation spec treats `` `claude-4c7289d1:42` ``.
+        assert.deepEqual(labels("`@claude-4c7289d1`"), ["@claude-4c7289d1"]);
+        assert.deepEqual(mentioned("`@claude-4c7289d1`"), ["claude-4c7289d1"]);
+    });
+    it("ignores a handle inside an existing link", () => {
+        assert.deepEqual(mentioned("[@claude-4c7289d1](https://example.com/x)"), []);
+        assert.deepEqual(mentioned("https://example.com/@claude-4c7289d1"), []);
+    });
+    it("leaves an email address alone", () => {
+        assert.deepEqual(urls("mail ben@example.com now"), ["mailto:ben@example.com"]);
+        assert.deepEqual(mentioned("mail ben@example.com now"), []);
+    });
+    it("does not fire mid-word", () => {
+        // No dot, so GFM does not claim it as an email — the boundary is the only
+        // thing standing in front of this one.
+        assert.deepEqual(mentioned("ben@claude-4c7289d1"), []);
+        assert.deepEqual(mentioned("path/@claude-4c7289d1"), []);
+        assert.deepEqual(mentioned("v1.@claude-4c7289d1"), []);
+        assert.deepEqual(mentioned("@@claude-4c7289d1"), []);
+    });
+    it("fires at a text-node edge and after punctuation", () => {
+        assert.deepEqual(mentioned("@claude-4c7289d1"), ["claude-4c7289d1"]);
+        assert.deepEqual(mentioned("(@claude-4c7289d1)"), ["claude-4c7289d1"]);
+        assert.deepEqual(mentioned("cc: @claude-4c7289d1."), ["claude-4c7289d1"]);
+        assert.deepEqual(mentioned("*@claude-4c7289d1*"), ["claude-4c7289d1"]);
+        assert.deepEqual(mentioned("> @claude-4c7289d1"), ["claude-4c7289d1"]);
+        assert.deepEqual(mentioned("- @claude-4c7289d1"), ["claude-4c7289d1"]);
+    });
+    it("does not fire on @ followed by a space", () => {
+        assert.deepEqual(mentioned("@ claude-4c7289d1"), []);
+    });
+});
+describe("scanner and renderer agree", () => {
+    // The invariant the feature depends on: a wakeup happens iff the operator
+    // can see why. Every input above, run through both paths at once.
+    const CASES = [
+        "ping @claude-4c7289d1 please",
+        "see claude-4c7289d1",
+        "@claude-4c7289d1:42",
+        "@claude-4c7289d1 re goose-aa11bb22:3",
+        "@claude-deadbeef hello",
+        "@Claude-4C7289D1",
+        "@claude-4c7289d1 and again @claude-4c7289d1",
+        "@claude-4c7289d1 @goose-aa11bb22",
+        "```\n@claude-4c7289d1\n```",
+        "`brane revive @claude-4c7289d1`",
+        "`@claude-4c7289d1`",
+        "[@claude-4c7289d1](https://example.com/x)",
+        "https://example.com/@claude-4c7289d1",
+        "mail ben@example.com now",
+        "ben@claude-4c7289d1",
+        "path/@claude-4c7289d1",
+        "@@claude-4c7289d1",
+        "(@claude-4c7289d1)",
+        "cc: @claude-4c7289d1.",
+        "*@claude-4c7289d1*",
+        "> @claude-4c7289d1",
+        "- @claude-4c7289d1",
+        "@ claude-4c7289d1",
+        "# @claude-4c7289d1",
+        "| @claude-4c7289d1 |",
+        "@claude-4c7289d1\n\n@goose-aa11bb22",
+    ];
+    for (const md of CASES) {
+        it(`agrees on ${JSON.stringify(md)}`, () => agrees(md));
+    }
+});
+describe("citation spec still behaves without the mention spec", () => {
+    // `narrativeIdLinks` is used alone by the HTML exporter. The boundary added
+    // for mentions must not change what it does to ordinary prose.
+    function citeOnly(md) {
+        const tree = fromMarkdown(md, {
+            extensions: [gfmAutolinkLiteral()],
+            mdastExtensions: [gfmAutolinkLiteralFromMarkdown(), narrativeIdLinks(KNOWN)],
+        });
+        return leaves(tree).filter(([t]) => t === "link").map(([, u]) => u);
+    }
+    it("links a bare id and an id:seq", () => {
+        assert.deepEqual(citeOnly("see claude-4c7289d1 and claude-4c7289d1:42"), [
+            "brane://nid/claude-4c7289d1",
+            "brane://nid/claude-4c7289d1/42",
+        ]);
+    });
+    it("declines an @-prefixed id rather than half-linking it", () => {
+        // Before mentions existed this produced a stranded "@" beside a citation
+        // link. With no mention spec installed it is now plain prose.
+        assert.deepEqual(citeOnly("@claude-4c7289d1"), []);
+    });
+});
+//# sourceMappingURL=mentions.test.js.map

package/dist/test/message-selection.test.js

@@ -0,0 +1,114 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { MessageSelection } from "../shared/message-selection.js";
+/** Records which rows were woken, so a test can assert what a tap *didn't*
+ *  touch — which is the entire reason this store exists. */
+function watch(sel, seqs) {
+    const woken = [];
+    const unsubs = seqs.map((seq) => sel.subscribeSeq(seq, () => woken.push(seq)));
+    return { woken, unsubscribe: () => unsubs.forEach((u) => u()) };
+}
+describe("MessageSelection", () => {
+    it("toggles one seq on and off", () => {
+        const sel = new MessageSelection();
+        assert.equal(sel.has(4), false);
+        assert.equal(sel.toggle(4), true);
+        assert.equal(sel.has(4), true);
+        assert.equal(sel.size, 1);
+        assert.equal(sel.toggle(4), false);
+        assert.equal(sel.has(4), false);
+    });
+    it("keeps the selection ascending whatever order it was tapped in", () => {
+        const sel = new MessageSelection();
+        for (const seq of [9, 2, 5])
+            sel.toggle(seq);
+        assert.deepEqual([...sel.getSelected()], [2, 5, 9]);
+    });
+    it("holds the snapshot's identity steady between changes", () => {
+        // useSyncExternalStore compares snapshots by identity; a getter that
+        // allocates on every read re-renders forever.
+        const sel = new MessageSelection();
+        assert.equal(sel.getSelected(), sel.getSelected());
+        sel.toggle(3);
+        const after = sel.getSelected();
+        assert.equal(sel.getSelected(), after);
+        sel.toggle(4);
+        assert.notEqual(sel.getSelected(), after);
+    });
+    it("wakes only the row that changed", () => {
+        const sel = new MessageSelection();
+        const { woken } = watch(sel, [1, 2, 3, 4, 5]);
+        sel.toggle(3);
+        assert.deepEqual(woken, [3], "a tap is not a broadcast");
+        sel.toggle(3);
+        assert.deepEqual(woken, [3, 3]);
+    });
+    it("wakes only the rows a clear actually cleared", () => {
+        const sel = new MessageSelection();
+        sel.toggle(2);
+        sel.toggle(4);
+        const { woken } = watch(sel, [1, 2, 3, 4, 5]);
+        assert.deepEqual(sel.clear(), [2, 4]);
+        assert.deepEqual(woken.sort(), [2, 4]);
+        assert.equal(sel.size, 0);
+    });
+    it("does nothing at all on a clear with nothing selected", () => {
+        const sel = new MessageSelection();
+        const { woken } = watch(sel, [1, 2, 3]);
+        let wholeCalls = 0;
+        sel.subscribe(() => { wholeCalls++; });
+        assert.deepEqual(sel.clear(), []);
+        assert.deepEqual(woken, []);
+        assert.equal(wholeCalls, 0, "an empty clear is not a change");
+    });
+    it("replace wakes the symmetric difference and nothing else", () => {
+        const sel = new MessageSelection();
+        sel.replace([1, 2, 3]);
+        const { woken } = watch(sel, [1, 2, 3, 4]);
+        sel.replace([2, 3, 4]);
+        assert.deepEqual(woken.sort(), [1, 4], "2 and 3 were selected before and after");
+        assert.deepEqual([...sel.getSelected()], [2, 3, 4]);
+    });
+    it("replace with the same set is not a change", () => {
+        const sel = new MessageSelection();
+        sel.replace([5, 6]);
+        let wholeCalls = 0;
+        sel.subscribe(() => { wholeCalls++; });
+        sel.replace([6, 5]);
+        assert.equal(wholeCalls, 0);
+    });
+    it("ignores values that are not seqs", () => {
+        const sel = new MessageSelection();
+        sel.replace([0, -1, 2.5, 7]);
+        assert.deepEqual([...sel.getSelected()], [7]);
+    });
+    it("notifies whole-selection watchers on every change", () => {
+        const sel = new MessageSelection();
+        const seen = [];
+        sel.subscribe(() => seen.push([...sel.getSelected()]));
+        sel.toggle(1);
+        sel.toggle(2);
+        sel.clear();
+        // Each listener sees the value it was woken about, not the previous one.
+        assert.deepEqual(seen, [[1], [1, 2], []]);
+    });
+    it("forgets a row's bucket once nothing is watching it", () => {
+        // Rows unmount as the list scrolls; buckets left behind would grow the map
+        // by every message ever scrolled past.
+        const sel = new MessageSelection();
+        const { unsubscribe } = watch(sel, [42]);
+        unsubscribe();
+        const { woken } = watch(sel, [42]);
+        sel.toggle(42);
+        assert.deepEqual(woken, [42], "re-subscribing still works after the bucket was dropped");
+    });
+    it("survives a listener that unsubscribes while being notified", () => {
+        const sel = new MessageSelection();
+        let calls = 0;
+        const off = sel.subscribeSeq(8, () => { calls++; off(); });
+        sel.toggle(8);
+        sel.toggle(8);
+        assert.equal(calls, 1);
+    });
+});
+//# sourceMappingURL=message-selection.test.js.map

package/dist/test/mo-glyph.test.js

@@ -0,0 +1,22 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { MO_GLYPH_BOX, MO_GLYPH_PATH } from "../shared/mo-glyph.js";
+test("mo-glyph: closed subpaths, absolute commands only, every point inside the box", () => {
+    assert.match(MO_GLYPH_PATH, /^M/);
+    assert.match(MO_GLYPH_PATH, /Z$/);
+    // Only the absolute commands the extractor emits; a relative command or an
+    // arc would mean the data was regenerated by something else.
+    assert.equal(MO_GLYPH_PATH.replace(/[MLCQZ0-9. -]/g, ""), "");
+    const nums = MO_GLYPH_PATH.match(/-?\d+(?:\.\d+)?/g).map(Number);
+    assert.ok(nums.length > 300, `expected a real outline, got ${nums.length} numbers`);
+    for (const n of nums) {
+        assert.ok(n >= 0 && n <= MO_GLYPH_BOX, `${n} falls outside [0, ${MO_GLYPH_BOX}]`);
+    }
+    // The glyph is centered: its extent should be symmetric about the box center.
+    const xs = nums.filter((_, i) => i % 2 === 0);
+    const ys = nums.filter((_, i) => i % 2 === 1);
+    const mid = MO_GLYPH_BOX / 2;
+    assert.ok(Math.abs(Math.min(...xs) + Math.max(...xs) - 2 * mid) < 2);
+    assert.ok(Math.abs(Math.min(...ys) + Math.max(...ys) - 2 * mid) < 2);
+});
+//# sourceMappingURL=mo-glyph.test.js.map