brane 0.0.2 → 0.3.0

package/dist/test/listen-own-words.test.js

@@ -0,0 +1,147 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestDb } from "./helpers.js";
+import { handleMcpNarrate, startMcpListen, wakeListenWaiters, } from "../daemon/server.js";
+import { appendEvent } from "../db/events.js";
+import { recordMentions, pendingMentions } from "../db/mentions.js";
+// A read returns what is in range, the caller's own narrations included, but
+// the caller's own narrations never interrupt its waiting. #515 got the second
+// by filtering them out of every forward read, which also lost them for an
+// agent resuming after compaction with a remembered cursor; nothing
+// server-side can tell that read from any other. Now they come back, and only
+// someone else's event is an arrival. The one thing never returned is the event
+// a narrate just wrote, to that narrate (#508's receipt, #509's `omit`).
+const SELF = "claude-aaaaaaaa";
+const OTHER = "claude-bbbbbbbb";
+const BRANE = "brane-home";
+function fakeClient() {
+    const sent = [];
+    const ws = {
+        readyState: 1,
+        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,
+        ws,
+    };
+}
+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;
+}
+const say = (d, text, extra = {}) => handleMcpNarrate({ say: text, ...extra }, d, SELF, () => { });
+const signal = (d, text) => appendEvent(d, SELF, "human_signal", { content: text, source: "web" });
+const listen = (c, d, id, args, waiters = new Map()) => startMcpListen(c, d, id, args, waiters, () => { }, BRANE);
+const wakeAll = (waiters, nid) => {
+    for (const w of [...(waiters.get(nid) ?? [])])
+        w();
+};
+describe("a read returns the agent's own words", () => {
+    it("a non-blocking read hands back an earlier narration", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        signal(d, "a"); // 1
+        say(d, "b"); // 2
+        signal(d, "c"); // 3
+        listen(client, d, "1", { after: 1, wait: false });
+        assert.deepEqual(sent[0].result.events.self.map((e) => e.content), ["b", "c"]);
+    });
+    it("even when they are all that is in range", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        signal(d, "a"); // 1
+        say(d, "b"); // 2
+        listen(client, d, "1", { after: 1, wait: false });
+        assert.deepEqual(sent[0].result.events.self.map((e) => e.content), ["b"]);
+    });
+    it("the narrate receipt leaves out only the narration it wrote", () => {
+        const d = db();
+        signal(d, "a"); // 1
+        say(d, "b"); // 2
+        signal(d, "c"); // 3
+        const r = say(d, "e", { after: 1 }); // 4
+        assert.equal(r.seq, 4);
+        assert.deepEqual(r.events.self.map((e) => e.content), ["b", "c"]);
+    });
+});
+describe("the agent's own words never interrupt its waiting", () => {
+    it("a parked listen does not wake on its own narration, and brings it back with the next signal", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        const waiters = new Map();
+        const notify = (nid) => wakeListenWaiters(waiters, nid);
+        signal(d, "go"); // 1
+        listen(client, d, "1", { after: 1 }, waiters);
+        handleMcpNarrate({ say: "working on it" }, d, SELF, notify); // 2, fires the wakeup
+        assert.equal(sent.length, 0, "its own words are not an arrival");
+        signal(d, "status?"); // 3
+        notify(SELF); // still registered: no 500 ms poller wait
+        assert.equal(sent.length, 1);
+        assert.deepEqual(sent[0].result.events.self.map((e) => e.seq), [2, 3]);
+    });
+    it("a blocking listen whose cursor trails its own narration parks instead of returning at once", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        signal(d, "question?"); // 1
+        say(d, "progress…", { after: 1 }); // 2
+        listen(client, d, "1", { after: 1 });
+        assert.equal(sent.length, 0);
+    });
+    it("nor does a waiting narrate: the lagging cursor #508 leaves behind", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        signal(d, "question?"); // 1
+        say(d, "progress…", { after: 1 }); // 2
+        const plan = handleMcpNarrate({ say: "done", after: 1, wait: true }, d, SELF, () => { });
+        const { park, ...extra } = plan;
+        startMcpListen(client, d, "w", { after: park.after }, new Map(), () => { }, BRANE, { omit: park.omit, extra });
+        assert.equal(sent.length, 0, "parked, rather than returning seq 2 at waited_ms 0");
+    });
+    it("covers foreign narration: what the agent said in another narrative wakes nothing either", () => {
+        const d = db();
+        const { client, sent } = fakeClient();
+        const waiters = new Map();
+        listen(client, d, "1", { after: { self: 0, [OTHER]: 0 } }, waiters);
+        say(d, "a question for you", { nid: OTHER }); // OTHER 1
+        wakeAll(waiters, OTHER);
+        assert.equal(sent.length, 0);
+        appendEvent(d, OTHER, "narration", { content: "the answer", source: OTHER });
+        wakeAll(waiters, OTHER);
+        assert.deepEqual(sent[0].result.events[OTHER].map((e) => e.content), ["a question for you", "the answer"]);
+    });
+});
+describe("a listen whose socket has closed", () => {
+    it("does not run its receipt, so a mention is never marked delivered to nobody", () => {
+        const d = db();
+        const { client, sent, ws } = fakeClient();
+        const waiters = new Map();
+        signal(d, "go"); // SELF 1
+        listen(client, d, "1", { after: { self: 1, [OTHER]: 0 } }, waiters);
+        ws.readyState = 3; // CLOSED, close handler not yet run
+        const ev = appendEvent(d, OTHER, "narration", { content: `@${SELF} look`, source: OTHER });
+        recordMentions(d, { srcNarrative: OTHER, srcSeq: ev.seq, author: OTHER, mentionedNids: [SELF], time: ev.time });
+        wakeAll(waiters, OTHER);
+        assert.equal(sent.length, 0);
+        assert.equal(pendingMentions(d, SELF, 10).total, 1, "still owed: nobody received it");
+    });
+    it("can be retired: cleanup unregisters its wakeups", () => {
+        const d = db();
+        const { client } = fakeClient();
+        const waiters = new Map();
+        listen(client, d, "1", { after: { self: 0, [OTHER]: 0 } }, waiters);
+        assert.equal(waiters.get(SELF)?.size, 1);
+        for (const p of client.pendingListens.values())
+            p.cleanup();
+        assert.equal(waiters.get(SELF)?.size, 0);
+        assert.equal(waiters.get(OTHER)?.size, 0);
+    });
+});
+//# sourceMappingURL=listen-own-words.test.js.map

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

@@ -0,0 +1,33 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { listenTimeoutFor } from "../daemon/server.js";
+describe("listenTimeoutFor", () => {
+    // claude's stdio idle timeout is raised to 1h by the .mcp.json `timeout`
+    // knob (spawn.ts, MCP_TOOL_TIMEOUT_MS), so claude can hold ~1h. 3400s sits
+    // under that ceiling and under the 1h prompt-cache TTL.
+    it("holds claude for ~1h (3400s)", () => {
+        assert.equal(listenTimeoutFor("claude"), 3_400_000);
+    });
+    // Every other agent keeps the conservative 270s hold until it has been
+    // observed honoring its own timeout knob — codex/copilot default to ~60s
+    // and would abort a longer hold every idle cycle. A raise must be per-type,
+    // never a global flip, so unknown/other types must fall through to default.
+    it("keeps non-claude agents at 270s", () => {
+        assert.equal(listenTimeoutFor("codex"), 270_000);
+        assert.equal(listenTimeoutFor("copilot"), 270_000);
+        assert.equal(listenTimeoutFor("goose"), 270_000);
+        assert.equal(listenTimeoutFor("gemini"), 270_000);
+        assert.equal(listenTimeoutFor("amp"), 270_000);
+    });
+    it("defaults to 270s for unknown or missing agent type", () => {
+        assert.equal(listenTimeoutFor(undefined), 270_000);
+        assert.equal(listenTimeoutFor(""), 270_000);
+        assert.equal(listenTimeoutFor("some-future-agent"), 270_000);
+    });
+    it("chosen claude hold stays under the 1h cache TTL and the 1h client ceiling", () => {
+        // If this ever fails, an idle self-wake would race the cache TTL / the
+        // client's tool-call abort instead of landing safely under both.
+        assert.ok(listenTimeoutFor("claude") < 3_600_000);
+    });
+});
+//# sourceMappingURL=listen-timeout.test.js.map

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

@@ -0,0 +1,121 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { diagnoseMarkdown } from "../markdown-diagnostics.js";
+import { prepareMathMarkdown, renderMathHtml } from "../shared/markdown-math.js";
+// Every renderer here fails silently on purpose — that is what keeps a stray
+// `$5` from turning into red error markup in the operator's face. These tests
+// pin the other side of that bargain: the author of a narration finds out, and
+// finds out precisely enough to decide whether it is worth correcting.
+function kinds(md) {
+    return diagnoseMarkdown(md).map((d) => d.kind);
+}
+describe("diagnoseMarkdown — silence on anything that renders as written", () => {
+    it("says nothing about prose with no math in it", () => {
+        assert.deepEqual(kinds("Just a paragraph, with a `code span` and a [link](x)."), []);
+    });
+    it("says nothing about math that parses", () => {
+        assert.deepEqual(kinds("Euler: $e^{i\\pi} + 1 = 0$, and $$\\int_0^1 x\\,dx$$"), []);
+    });
+    /** The guard rejects far more currency and shell syntax than mathematics, so
+     *  warning on every rejection would bury the real findings under noise. */
+    it("says nothing about the dollars that were never math", () => {
+        for (const md of ["Costs $5 and $10.", "Set $PATH and ${HOME}.", "awk '{print $1, $9}'"]) {
+            assert.deepEqual(kinds(md), [], md);
+        }
+    });
+    it("says nothing about a closed fence, of either flavour", () => {
+        assert.deepEqual(kinds("```js\nconst x = 1;\n```\n"), []);
+        assert.deepEqual(kinds("~~~\nplain\n~~~"), []);
+        assert.deepEqual(kinds("```js\nconst x = 1;\n```"), []);
+    });
+});
+describe("diagnoseMarkdown — what it reports", () => {
+    it("reports LaTeX KaTeX refused, in KaTeX's own words", () => {
+        const [d] = diagnoseMarkdown("Broken: $\\bogusmacro{x}$ here");
+        assert.equal(d.kind, "math_parse_error");
+        assert.match(d.message, /Undefined control sequence/);
+        // KaTeX's prefix and its combining-underline position marker are stripped:
+        // one reads as boilerplate, the other as mojibake outside a browser.
+        assert.ok(!d.message.startsWith("KaTeX parse error"), d.message);
+        assert.ok(!/̲/.test(d.message), "no combining underline");
+    });
+    it("reports a run that looks like math but was demoted, and why", () => {
+        const [d] = diagnoseMarkdown("Spaced: $ \\theta $ there");
+        assert.equal(d.kind, "math_demoted");
+        assert.match(d.message, /a space sits just inside the delimiters/);
+    });
+    it("reports TeX delimiters with no partner", () => {
+        assert.deepEqual(kinds("Unclosed: \\(x + y and the sentence goes on"), ["math_unclosed"]);
+        assert.deepEqual(kinds("Runaway:\n$$ x + y and no closer"), ["math_unclosed"]);
+    });
+    it("reports an unclosed fence, whose damage is not local", () => {
+        const [d] = diagnoseMarkdown("```js\nconst x = 1;\nand the rest of the message");
+        assert.equal(d.kind, "fence_unclosed");
+        assert.match(d.message, /everything after it renders as one code block/);
+    });
+    it("stays quiet on `$$` that cannot swallow anything", () => {
+        // Found by sweeping the corpus: a price tier, and a mid-sentence pair.
+        assert.deepEqual(kinds("- **$$$**: battery emulators, only if serious.\n\nStill prose."), []);
+        assert.deepEqual(kinds("costs $$ unless volume)\n\nnext para"), []);
+        // ...but at a line start it is a flow fence, list marker or not.
+        assert.deepEqual(kinds("- $$ x = 1 and\n\nnext para"), ["math_unclosed"]);
+    });
+    it("does not let a stray backtick run in prose hide a real fence", () => {
+        const md = "The file has its own ```lua block.\n\n````md\n# doc\n\n```lua\nx\n```\n\nend\n````\n\nafter";
+        assert.deepEqual(kinds(md), []);
+    });
+    it("points at the failed run, not an earlier listing of the same LaTeX", () => {
+        const [d] = diagnoseMarkdown("```latex\n\\frac{a}{b}\n```\n\nbroken: $\\frac{a}{$ here");
+        assert.equal(d.kind, "math_parse_error");
+        assert.equal(d.line, 5);
+    });
+    it("points at the line, so a long narration can be found in", () => {
+        const [d] = diagnoseMarkdown("one\ntwo\n\nthree $ \\theta $ four\n");
+        assert.equal(d.line, 4);
+    });
+    it("caps what one narration can produce", () => {
+        const md = Array.from({ length: 30 }, () => "$ \\theta $").join("\n\n");
+        assert.ok(diagnoseMarkdown(md).length <= 10);
+    });
+});
+/** The warning is only worth acting on if it describes the operator's actual
+ *  view. Both halves of that come from the real pipeline rather than a second
+ *  scanner written to approximate it — this is the test that they agree. */
+describe("diagnoseMarkdown — the fallback is what will really be shown", () => {
+    it("hands back the literal source a failed render falls back to", () => {
+        const [d] = diagnoseMarkdown("Broken: $\\bogusmacro{x}$ here");
+        assert.equal(d.fallback, "$\\bogusmacro{x}$");
+        // …which is exactly what the renderer emits for it, HTML-escaped.
+        assert.equal(renderMathHtml("\\bogusmacro{x}", false), "$\\bogusmacro{x}$");
+    });
+    it("hands back the demoted run as the prose it becomes", () => {
+        const [d] = diagnoseMarkdown("Spaced: $ \\theta $ there");
+        assert.equal(d.fallback, "$ \\theta $");
+        // The opener is escaped, and `\$` renders as a plain `$`.
+        assert.ok(prepareMathMarkdown("Spaced: $ \\theta $ there").includes("\\$ \\theta"));
+    });
+});
+/** Collecting must not change what anyone sees. The export and the app call
+ *  these same two functions, and a diagnostic pass that perturbed either would
+ *  be a rendering bug wearing a linter's clothes. */
+describe("collecting is free of side effects", () => {
+    it("leaves prepareMathMarkdown's output identical with and without a collector", () => {
+        const sources = [
+            "Costs $5 and $10.",
+            "Euler: $e^{i\\pi}+1=0$",
+            "\\[B = m\\ddot U\\]",
+            "```js\nunclosed",
+            "$$ runaway",
+            "Spaced: $ \\theta $",
+        ];
+        for (const md of sources) {
+            assert.equal(prepareMathMarkdown(md, () => { }), prepareMathMarkdown(md), md);
+        }
+    });
+    it("leaves renderMathHtml's output identical with and without an onError", () => {
+        for (const [value, display] of [["x^2", false], ["\\bogusmacro{", false], ["\\int_0^1", true]]) {
+            assert.equal(renderMathHtml(value, display, () => { }), renderMathHtml(value, display));
+        }
+    });
+});
+//# sourceMappingURL=markdown-diagnostics.test.js.map

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

@@ -0,0 +1,182 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { micromark } from "micromark";
+import { gfmTaskListItem, gfmTaskListItemHtml } from "micromark-extension-gfm-task-list-item";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmTaskListItemFromMarkdown } from "mdast-util-gfm-task-list-item";
+import { listIsLoose, listItemRowMarginTop, listParagraphOverride, } from "../shared/markdown-lists.js";
+// Lists are rendered twice by two unrelated pieces of machinery: micromark
+// straight to HTML for the export, and mdast through react-native primitives
+// for the app. Nothing forces them to agree, and the ways they can disagree are
+// invisible in a unit test of either one alone — so the tests below check the
+// app's inputs *against micromark's output*, which is the only shared ground.
+function html(md) {
+    return micromark(md, {
+        extensions: [gfmTaskListItem()],
+        htmlExtensions: [gfmTaskListItemHtml()],
+    });
+}
+function tree(md) {
+    return fromMarkdown(md, {
+        extensions: [gfmTaskListItem()],
+        mdastExtensions: [gfmTaskListItemFromMarkdown()],
+    });
+}
+/** The first list in a document, as the app's renderer would receive it. */
+function firstList(md) {
+    return tree(md).children.find((n) => n.type === "list");
+}
+/** Whether micromark wrapped this document's list items in paragraphs — its
+ *  own, independent verdict on looseness, and the thing `listIsLoose` has to
+ *  reproduce from the tree. */
+function htmlIsLoose(md) {
+    return /<li>\n<p>/.test(html(md));
+}
+describe("task list items", () => {
+    it("parses the checked state the app renders from", () => {
+        const list = firstList("- [x] done\n- [ ] pending\n- plain\n");
+        assert.deepEqual(list.children.map((i) => i.checked), [true, false, null]);
+    });
+    it("leaves `checked` null for an ordinary item, which is what keeps its bullet", () => {
+        // The app swaps the marker for a checkbox on `checked != null`. `false` is
+        // an unticked box and `null` is a bullet, so the two must not be conflated
+        // — a `!checked` test would draw bullets over every unticked task.
+        const list = firstList("- plain\n");
+        assert.equal(list.children[0].checked, null);
+    });
+    it("accepts an uppercase X, as GFM does", () => {
+        assert.equal(firstList("- [X] done\n").children[0].checked, true);
+    });
+    it("renders a real checkbox input in the export", () => {
+        const out = html("- [x] done\n- [ ] pending\n");
+        assert.match(out, /<li><input type="checkbox" disabled="" checked="" \/> done<\/li>/);
+        assert.match(out, /<li><input type="checkbox" disabled="" \/> pending<\/li>/);
+    });
+    it("puts the input inside the paragraph when the list is loose", () => {
+        // Both shapes exist, which is why src/export.ts needs two `list-style: none`
+        // selectors rather than one.
+        assert.match(html("- [x] one\n\n- [ ] two\n"), /<li>\n<p><input type="checkbox"/);
+    });
+    it("nests", () => {
+        const list = firstList("- [ ] parent\n  - [x] child\n");
+        assert.equal(list.children[0].checked, false);
+        const nested = list.children[0].children.find((n) => n.type === "list");
+        assert.equal(nested.children[0].checked, true);
+    });
+    it("does not fire on a bracket that isn't a task marker", () => {
+        // `[x]` mid-item, and a link reference — neither is a checkbox.
+        assert.equal(firstList("- see [x] here\n").children[0].checked, null);
+        assert.doesNotMatch(html("- see [x] here\n"), /input type="checkbox"/);
+    });
+});
+describe("listIsLoose", () => {
+    // Each case is checked twice: once against micromark's HTML, which is what
+    // the export ships, and once against `listIsLoose`, which is what the app
+    // decides. A case where the two disagree is the bug this exists to catch.
+    const cases = [
+        ["tight", "- one\n- two\n"],
+        ["loose", "- one\n\n- two\n"],
+        ["tight, ordered", "1. one\n2. two\n"],
+        ["loose, ordered", "1. one\n\n2. two\n"],
+        ["tight task list", "- [x] one\n- [ ] two\n"],
+        ["loose task list", "- [x] one\n\n- [ ] two\n"],
+        ["single item", "- only\n"],
+        ["item holding two blocks", "- one\n\n  still one\n- two\n"],
+    ];
+    for (const [name, md] of cases) {
+        it(`agrees with micromark: ${name}`, () => {
+            assert.equal(listIsLoose(firstList(md)), htmlIsLoose(md), md);
+        });
+    }
+    it("is a property of the list, not of the item", () => {
+        // CommonMark: one blank line anywhere makes the *whole* list loose, so the
+        // second item gets paragraph margins even though it is not itself spread.
+        // Reading `item.spread` per item — the obvious shortcut — would space the
+        // two differently, and differently from the export.
+        const list = firstList("- one\n\n  still one\n- two\n");
+        assert.equal(list.children[1].spread, false);
+        assert.equal(listIsLoose(list), true);
+    });
+    it("falls back to the child count for a hand-built tree", () => {
+        assert.equal(listIsLoose({ children: [{ children: [{}, {}] }] }), true);
+        assert.equal(listIsLoose({ children: [{ children: [{}] }] }), false);
+    });
+    it("treats a missing list as tight", () => {
+        assert.equal(listIsLoose(undefined), false);
+        assert.equal(listIsLoose(null), false);
+    });
+});
+describe("list item marker alignment", () => {
+    // A list item row is `[marker <Text>][content <View>]`, top-aligned, so a
+    // margin *inside* the content column moves the text and leaves the marker
+    // behind. These pin the arithmetic that keeps the two on the same line —
+    // the defect was a `1.` sitting ~8px above the line it numbered, on every
+    // item of every loose list.
+    const PARA = 8; // styles.paragraph.marginVertical
+    /** Where the marker and the item's first line land, in the row's own
+     *  coordinates. `beforeFix` models what the renderer used to do: no margin on
+     *  the row, the full paragraph margin on the first block. */
+    function layout(loose, beforeFix = false) {
+        const rowMarginTop = beforeFix ? 0 : listItemRowMarginTop(loose, PARA);
+        const override = beforeFix
+            ? loose
+                ? null
+                : { marginVertical: 0 }
+            : listParagraphOverride({ inListItem: true, firstBlock: true, loose });
+        const paraMarginTop = override && "marginVertical" in override
+            ? override.marginVertical
+            : override && "marginTop" in override
+                ? override.marginTop
+                : PARA;
+        return { marker: rowMarginTop, text: rowMarginTop + paraMarginTop };
+    }
+    for (const loose of [false, true]) {
+        it(`puts the marker on its own first line (${loose ? "loose" : "tight"})`, () => {
+            const { marker, text } = layout(loose);
+            assert.equal(marker, text);
+        });
+    }
+    it("reproduces the defect it fixes", () => {
+        // The guard against a "fix" that changes nothing: before, a loose item's
+        // text sat a full paragraph margin below its marker.
+        const before = layout(true, true);
+        assert.equal(before.text - before.marker, PARA);
+        // Tight lists were always fine — which is why this looked like a new bug.
+        const tight = layout(false, true);
+        assert.equal(tight.text - tight.marker, 0);
+    });
+    for (const loose of [false, true]) {
+        it(`leaves the text exactly where it was (${loose ? "loose" : "tight"})`, () => {
+            // The margin moved from the paragraph to the row; it was not removed. If
+            // this drifts, loose lists have quietly retightened and the app no longer
+            // matches the export.
+            assert.equal(layout(loose).text, layout(loose, true).text);
+        });
+    }
+    it("only the first block of an item gives up its top margin", () => {
+        // `- one\n\n  still one` — the second paragraph sits below the marker, not
+        // beside it, so it keeps the margin that separates the two blocks.
+        assert.deepEqual(listParagraphOverride({ inListItem: true, firstBlock: false, loose: true }), null);
+        assert.deepEqual(listParagraphOverride({ inListItem: true, firstBlock: true, loose: true }), { marginTop: 0 });
+    });
+    it("flattens every paragraph of a tight item, first or not", () => {
+        for (const firstBlock of [true, false]) {
+            assert.deepEqual(listParagraphOverride({ inListItem: true, firstBlock, loose: false }), { marginVertical: 0 });
+        }
+    });
+    it("leaves a paragraph outside any list alone", () => {
+        for (const loose of [true, false]) {
+            assert.equal(listParagraphOverride({ inListItem: false, firstBlock: true, loose }), null);
+        }
+    });
+    it("gives a tight row no margin of its own", () => {
+        assert.equal(listItemRowMarginTop(false, PARA), 0);
+        assert.equal(listItemRowMarginTop(true, PARA), PARA);
+    });
+    it("keeps the gap between loose items at what two paragraph margins gave", () => {
+        // Item N's trailing paragraph margin plus item N+1's row margin. RN does no
+        // margin collapsing, so this was 8+8 before and has to stay 8+8.
+        assert.equal(PARA + listItemRowMarginTop(true, PARA), PARA + PARA);
+    });
+});
+//# sourceMappingURL=markdown-lists.test.js.map