switchroom 0.21.8 → 0.21.10

package/telegram-plugin/tests/render/guard-composition.test.ts

@@ -135,4 +135,106 @@ describe("guardAccidentalFormatting composition (#3252)", () => {
     // And re-wrapping (streaming re-render) is byte-stable.
     expect(richMessage(wire.markdown).markdown).toBe(wire.markdown);
   });
+
+  // ── Wire-verified NATIVE constructs survive the FULL pipeline ────────────
+  // Raw sendRichMessage probes (2026-08-13) proved Telegram's rich markdown
+  // path natively renders `<details>`, `$…$` inline math, and footnotes. The
+  // pre-fix pipeline destroyed all three (details → the unsupported `**>`
+  // marker, `$x^2+y^2$` → `\$x^2+y^2\$`, `[^n1]` deleted) — each assertion
+  // below FAILS on that pipeline.
+  describe("native constructs pass through the full composed guard", () => {
+    it("<details open><summary> block survives byte-identical", () => {
+      const src = "<details open><summary>S</summary>\n\nbody\n\n</details>";
+      expect(guardAccidentalFormatting(src)).toBe(src);
+      expect(richMessage(src).markdown).toBe(src);
+    });
+
+    it("compact $math$ span survives byte-identical", () => {
+      const src = "inline $x^2+y^2$ done";
+      expect(guardAccidentalFormatting(src)).toBe(src);
+    });
+
+    it("footnote reference + definition survive byte-identical", () => {
+      const src = "claim[^n1]\n\n[^n1]: body";
+      expect(guardAccidentalFormatting(src)).toBe(src);
+    });
+
+    it("`**>` is never emitted for any input the pipeline repairs", () => {
+      const out = guardAccidentalFormatting(
+        "<details><summary>T</summary>\nbody\n</details>",
+      );
+      expect(out).not.toContain("**>");
+    });
+  });
+
+  // ── Guard-interaction cases for the now-passing-through constructs ───────
+  // Removing the old token conversions changes what the sibling guards see (a
+  // surviving `$`, a surviving `<`). These prove the emphasis / heading /
+  // block-construct / inline-pair / dollar guards do not mangle the natives,
+  // while their own repairs still fire in the SAME message.
+  describe("native constructs vs sibling guards (interaction)", () => {
+    it("math span is exempt while surrounding currency is still broken apart", () => {
+      const src = "sum $x^2+y^2$ costs $5 and $10 total";
+      const out = guardAccidentalFormatting(src);
+      // The math span reaches the wire byte-identical…
+      expect(out).toContain("$x^2+y^2$");
+      // …while the accidental currency pair is still defused (#3252).
+      expect(out).toContain("\$5");
+      expect(out).toContain("\$10");
+    });
+
+    it("currency-shaped adjacent amounts are NOT mistaken for math", () => {
+      // `$5M-$10M` has a whitespace-free `$…$` pair (`$5M-$`) — the currency
+      // shape must keep it guardable, else #3252 regresses.
+      const out = guardAccidentalFormatting("range is $5M-$10M this year");
+      expect(out).not.toMatch(/(?<!\\)\$/);
+    });
+
+    it("math span interior is protected from the emphasis and caret guards", () => {
+      // `a_b*c` inside math would trip the intra-word `_`/`*` escapes, and
+      // `^2y^` is an alphanumeric caret pair the token guard would strip —
+      // both must stay verbatim inside the protected span. The `_`/`*`
+      // OUTSIDE the span are still guarded — note the protected span's
+      // delimiters do NOT count toward the 2+ pairing threshold, so the
+      // prose needs its own pairable signals (`2*3 and 4*5`).
+      const src = "$a_b*c$ and file_name_here times 2*3 and 4*5";
+      const out = guardAccidentalFormatting(src);
+      expect(out).toContain("$a_b*c$");
+      expect(out).toContain("file\\_name\\_here");
+      expect(out).toContain("2\\*3");
+      expect(out).toContain("4\\*5");
+      expect(guardAccidentalFormatting("inline $x^2y^2$ done")).toBe(
+        "inline $x^2y^2$ done",
+      );
+    });
+
+    it("<details> lines are invisible to the line-start and heading guards", () => {
+      // A details block whose body carries genuine accidental signals: the
+      // guards must fire on the BODY prose without touching the tags.
+      const src =
+        "<details open><summary>Stats</summary>\n\n>2x growth and #1 priority\n\n</details>";
+      const out = guardAccidentalFormatting(src);
+      expect(out).toContain("<details open><summary>Stats</summary>");
+      expect(out).toContain("</details>");
+      // Line-start `>2x` and glued `#1` are still repaired inside the body.
+      expect(out).toContain("\>2x");
+      expect(out).toContain("\#1");
+    });
+
+    it("footnote markers survive alongside a firing dollar guard", () => {
+      const src = "cost[^1] was $5 then $9\n\n[^1]: the note";
+      const out = guardAccidentalFormatting(src);
+      expect(out).toContain("cost[^1]");
+      expect(out).toContain("[^1]: the note");
+      expect(out).toContain("\$5");
+      expect(out).toContain("\$9");
+    });
+
+    it("the whole composition stays idempotent with natives present", () => {
+      const src =
+        "claim[^1] and $x^2+y^2$ in <details><summary>T</summary>\nb\n</details> with $5 and $10\n\n[^1]: n";
+      const once = guardAccidentalFormatting(src);
+      expect(guardAccidentalFormatting(once)).toBe(once);
+    });
+  });
 });

package/telegram-plugin/tests/render/html-dialect-content-loss.test.ts

@@ -0,0 +1,253 @@
+// Outcome tests for the content-loss regressions found in the raw-HTML
+// dialect fold (#4691, merged as fa9018a7, unreleased).
+//
+// Every assertion here FAILS on fa9018a7. They drive the real `renderOutbound`
+// (`parse` -> `renderSafe`), i.e. exactly what the live send path calls, so
+// they assert the WIRE OUTCOME rather than an internal code path.
+//
+// The through-line: fa9018a7's degrade bucket DELETED any token it could not
+// fold or pass through. That is safe for markup but catastrophic for prose —
+// `<service>/<key>`, `<agent>` and "the `<b>` tag" are pervasive in this
+// project's own agent output, and they were silently vanishing from replies.
+// The discriminator is now MATCHING, not the tag name: a balanced pair is
+// markup (drop it, keep the content), an unmatched marker is prose (keep it,
+// HTML-entity-escaped so the wire cannot read it as a tag).
+
+import { describe, it, expect } from "vitest";
+import { renderOutbound } from "../../render/rich-render.js";
+import { parse } from "../../render/parse.js";
+import { escapeLinkHref } from "../../format.js";
+
+const render = (src: string): string => renderOutbound(src).text;
+
+describe("BLOCKER: angle-bracket placeholders in prose survive (#4691 regression)", () => {
+  it("keeps a `<service>/<key>` convention line intact", () => {
+    // fa9018a7: "Use the / convention."
+    expect(render("Use the <service>/<key> convention.")).toBe(
+      "Use the &lt;service&gt;/&lt;key&gt; convention.",
+    );
+  });
+
+  it("keeps a trailing `<key>` placeholder on a command line", () => {
+    // fa9018a7: "run switchroom vault get "
+    expect(render("run switchroom vault get <key>")).toBe(
+      "run switchroom vault get &lt;key&gt;",
+    );
+  });
+
+  it("keeps an `<agent>` path segment", () => {
+    // fa9018a7: "logs live at /host-home/.switchroom/logs//"
+    expect(render("logs live at /host-home/.switchroom/logs/<agent>/")).toBe(
+      "logs live at /host-home/.switchroom/logs/&lt;agent&gt;/",
+    );
+  });
+
+  it("keeps a tag NAMED in prose when nothing closes it", () => {
+    // fa9018a7: "The  tag is bold and  is italic"
+    expect(render("The <b> tag is bold and <i> is italic")).toBe(
+      "The &lt;b&gt; tag is bold and &lt;i&gt; is italic",
+    );
+  });
+
+  it("never emits a bare `<` for a token it kept as prose", () => {
+    // The escape is what makes keeping the token safe: Rich HTML documents
+    // `&lt;`/`&gt;`/`&amp;` as supported named entities, so this cannot trip
+    // `unsupported start tag` the way a bare `<service>` would.
+    const out = render("Use <service>/<key> and <agent>.");
+    expect(out).not.toMatch(/<[A-Za-z/]/);
+    expect(out).toBe("Use &lt;service&gt;/&lt;key&gt; and &lt;agent&gt;.");
+  });
+
+  it("does not double-escape when its own output is re-parsed", () => {
+    // Re-parsing decodes `&lt;` back to a text-node `<`, which never reaches
+    // the fold at all (the documented residual in html-fold.ts's header), so
+    // the second pass is NOT byte-idempotent. What must never happen is a
+    // compounding `&amp;lt;` that the reader actually sees.
+    const once = render("Use the <service>/<key> convention.");
+    expect(once).toBe("Use the &lt;service&gt;/&lt;key&gt; convention.");
+    expect(render(once)).not.toContain("&amp;");
+  });
+
+  it("still DROPS the markup of a balanced unknown pair (content kept)", () => {
+    // The other half of the discriminator: a matched pair really is markup.
+    expect(render("<marquee>scrolling</marquee>")).toBe("scrolling");
+    expect(render(`<span data-x="1">t</span>`)).toBe("t");
+  });
+});
+
+describe("MAJOR 1: `<pre>` folds to a fenced block, not a broken code span", () => {
+  it("renders `<pre><code>` as a real fence", () => {
+    // fa9018a7: "`const a = 1;\nconst b = 2;`" — a backtick span wrapping a
+    // newline, which Telegram will not parse, so the reader sees literal
+    // backticks around broken text.
+    expect(render("<pre><code>const a = 1;\nconst b = 2;</code></pre>")).toBe(
+      "```\nconst a = 1;\nconst b = 2;\n```",
+    );
+  });
+
+  it("never emits a code span containing a newline", () => {
+    const out = render("<pre><code>a\nb</code></pre>");
+    expect(out).not.toMatch(/(^|[^`])`[^`]*\n[^`]*`/);
+  });
+
+  it("carries the `class=\"language-…\"` hint into the fence info string", () => {
+    expect(
+      render(`<pre><code class="language-python">print(1)</code></pre>`),
+    ).toBe("```python\nprint(1)\n```");
+  });
+
+  it("handles a bare `<pre>` with no inner `<code>`", () => {
+    expect(render("<pre>one\ntwo</pre>")).toBe("```\none\ntwo\n```");
+  });
+
+  it("leaves no stray leading or trailing newline around the fence", () => {
+    // The layout newlines a `<pre>` block carries are not content.
+    expect(render("<pre>\nbody\n</pre>")).toBe("```\nbody\n```");
+    expect(render("<pre>\nbody\n</pre>")).not.toMatch(/^\n|\n$/);
+  });
+
+  it("degrades to an inline code span where a fence cannot survive", () => {
+    // A fence inside a `#` line or a table cell would end the block/row.
+    expect(render("# a <pre>x</pre> b")).toBe("# a `x` b");
+    expect(render("| h |\n| --- |\n| <pre>x</pre> |")).toContain("| `x` |");
+  });
+});
+
+describe("MAJOR 2: structural tags do not glue their content together", () => {
+  it("separates list items instead of emitting `onetwo`", () => {
+    expect(render("<ul><li>one</li><li>two</li></ul>")).toBe("one  \ntwo");
+  });
+
+  it("separates paragraphs instead of emitting `para onepara two`", () => {
+    expect(render("<p>para one</p><p>para two</p>")).toBe(
+      "para one  \npara two",
+    );
+  });
+
+  it("separates table cells", () => {
+    expect(render("<table><tr><td>a</td><td>b</td></tr></table>")).toBe(
+      "a  \nb",
+    );
+  });
+
+  it("leaves no separator hanging at the edges of the block", () => {
+    const out = render("<div>only</div>");
+    expect(out).toBe("only");
+  });
+
+  it("still renders a markup-only block to nothing", () => {
+    // Regression guard for the separator: an empty structural block must not
+    // become a whitespace-only paragraph and a spurious `\n\n`.
+    expect(render("a\n\n<div></div>\n\nb")).toBe("a\n\nb");
+    expect(render("a\n\n<!-- c -->\n\nb")).toBe("a\n\nb");
+  });
+
+  it("uses a space, not a newline, inside a table cell", () => {
+    // A newline in a cell ends the row.
+    const out = render("| h |\n| --- |\n| <p>x</p><p>y</p> |");
+    expect(out).toContain("| x y |");
+  });
+});
+
+describe("MAJOR 3: the passthrough bucket is balance-checked", () => {
+  it("does not ship an unmatched `<u>` raw", () => {
+    // fa9018a7 emitted this verbatim -> `unclosed start tag` 400 -> the
+    // fallback resends the WHOLE message as plain text. One stray marker in
+    // relayed content was a denial-of-formatting on the agent's reply.
+    expect(render("hello <u>world")).toBe("hello &lt;u&gt;world");
+  });
+
+  it("does not ship a stray close marker raw", () => {
+    expect(render("</details>")).toBe("&lt;/details&gt;");
+  });
+
+  it("keeps the balanced inner pair and escapes only the unmatched outer", () => {
+    expect(render("<u><u>x</u>")).toBe("&lt;u&gt;<u>x</u>");
+  });
+
+  it("still passes a BALANCED allowlist tag through raw", () => {
+    for (const src of [
+      "<u>under</u>",
+      "H<sub>2</sub>O",
+      "x<sup>2</sup>",
+      "<aside><cite>note</cite></aside>",
+    ]) {
+      expect(render(src)).toBe(src);
+    }
+  });
+
+  it("passes a `<details>` block through even though it spans mdast blocks", () => {
+    // The balance check MUST be document-level: micromark splits this into
+    // three separate `html` nodes, so a per-node check would wrongly call the
+    // open and close markers unmatched and escape them.
+    const src = "<details open><summary>S</summary>\n\nbody\n\n</details>";
+    expect(render(src)).toBe(src);
+  });
+
+  it("does not let a tag inside a code fence balance a prose marker", () => {
+    // Tags in a fence are not markup and must not satisfy anything outside it.
+    const out = render("```\n</u>\n```\n\nhello <u>world");
+    expect(out).toContain("```\n</u>\n```");
+    expect(out).toContain("hello &lt;u&gt;world");
+  });
+});
+
+describe("MAJOR 4: the fence comment's claimed safety property (pinned)", () => {
+  it("PINS the lazy-continuation counterexample the comment gets wrong", () => {
+    // The `**>` rewrite tracks TOP-LEVEL fences only, so the `> ``` ` opener
+    // here is invisible to it and the column-0 `**> lazy` line is rewritten,
+    // eating the `**`. CommonMark forbids lazy continuation into fenced code,
+    // so that line should CLOSE the blockquote and stay literal.
+    //
+    // This is PRE-EXISTING and identical before #4691 — NOT a regression — and
+    // fixing it needs real container tracking, not a wider fence regex. Pinned
+    // so any future container-aware rewrite has to decide it deliberately;
+    // `FENCE_DELIM_RE`'s doc comment now describes this instead of claiming
+    // the case cannot happen.
+    expect(render("> ```\n**> lazy\n> ```")).toBe("> ```\n> lazy\n> ```");
+  });
+});
+
+describe("nits: breaks, nested links, and href hygiene", () => {
+  it("does not break a heading block with `<br>`", () => {
+    // fa9018a7: "# a  \nb" — the hard break ends the heading and orphans `b`.
+    expect(render("# a<br>b")).toBe("# a b");
+    expect(parse("# a<br>b").blocks).toHaveLength(1);
+  });
+
+  it("keeps a `<br>` a real break in ordinary prose", () => {
+    expect(render("one<br>two")).toBe("one  \ntwo");
+    // Two explicit breaks are the author's, not synthesized separators — they
+    // must not be collapsed by the separator normalizer.
+    expect(render("a<br><br>b")).toBe("a  \n  \nb");
+  });
+
+  it("does not silently drop a nested `<a>`'s href", () => {
+    // fa9018a7: "[out in](https://o.example)" — the inner URL vanished.
+    const out = render(
+      '<a href="https://o.example">out <a href="https://i.example">in</a></a>',
+    );
+    expect(out).toContain("i.example");
+  });
+
+  it("percent-encodes whitespace in a link destination", () => {
+    // A bare destination ends at the first whitespace character, so a raw
+    // space turned the rest of the URL into a title and a raw newline
+    // terminated the link outright.
+    expect(render('<a href="https://ex.com/a b">x</a>')).toBe(
+      "[x](https://ex.com/a%20b)",
+    );
+    expect(render('<a href="https://ex.com/a\nb">x</a>')).toBe(
+      "[x](https://ex.com/a%0Ab)",
+    );
+  });
+
+  it("escapeLinkHref still balances parens and is a no-op for clean URLs", () => {
+    expect(escapeLinkHref("https://e.com/a_(b)")).toBe(
+      "https://e.com/a_\\(b\\)",
+    );
+    expect(escapeLinkHref("https://e.com/plain?a=1&b=2")).toBe(
+      "https://e.com/plain?a=1&b=2",
+    );
+  });
+});

package/telegram-plugin/tests/render/html-dialect.test.ts

@@ -0,0 +1,283 @@
+// Outcome tests for the three v0.21.9 outbound-render residuals:
+//
+//   1. `markExpandableQuotes` rewrote `**>` lines INSIDE fenced code blocks,
+//      corrupting documented examples into `  >` on the wire.
+//   2. `escapeMarkdown` ran over raw-HTML `plain` nodes and escaped `=`, so
+//      `<a href="…">` shipped as `<a href\="…">` — an unreadable attribute.
+//   3. Raw HTML tags reached the wire byte-verbatim with nothing establishing
+//      that Telegram's rich parser accepts them.
+//
+// Every assertion here FAILS on the v0.21.9 pipeline. They drive the real
+// `renderOutbound` (`parse` -> `renderSafe`), i.e. exactly what the live send
+// path calls, so they assert the wire OUTCOME, not an internal code path.
+
+import { describe, it, expect } from "vitest";
+import { renderOutbound } from "../../render/rich-render.js";
+import { parse } from "../../render/parse.js";
+import { classifyHtmlTag, hrefOf } from "../../render/html-fold.js";
+
+describe("fenced code blocks are immune to the `**>` input repair (defect 1)", () => {
+  it("keeps a `**>` line inside a fence byte-identical", () => {
+    // The exact corruption: on v0.21.9 this came back as "```md\n  > tap…".
+    const src = "```md\n**> tap to expand\n> body\n```";
+    expect(renderOutbound(src).text).toBe(src);
+    const code = parse(src).blocks[0] as { type: string; text: string };
+    expect(code.type).toBe("code-block");
+    expect(code.text).toBe("**> tap to expand\n> body");
+  });
+
+  it("keeps a `**>` line inside a TILDE fence byte-identical", () => {
+    const src = "~~~\n**> quoted\n~~~";
+    const code = parse(src).blocks[0] as { type: string; text: string };
+    expect(code.type).toBe("code-block");
+    expect(code.text).toBe("**> quoted");
+  });
+
+  it("still repairs a `**>` quote OUTSIDE the fence in the same document", () => {
+    const src = "```\n**> literal\n```\n\n**> repaired";
+    const out = renderOutbound(src).text;
+    expect(out).toContain("```\n**> literal\n```");
+    expect(out).toContain("> repaired");
+    // The repaired quote is a real quote, not a literal `**>` paragraph.
+    expect(out.split("\n\n").at(-1)).toBe("> repaired");
+  });
+
+  it("does not lose the repair after a CLOSED fence earlier in the body", () => {
+    // Guards the fence tracker's close detection: a stuck-open scanner would
+    // silently stop repairing every legacy quote after the first fence.
+    const src = "```js\nconst a = 1;\n```\n\n**> still repaired";
+    expect(renderOutbound(src).text.endsWith("> still repaired")).toBe(true);
+  });
+
+  it("treats an UNCLOSED fence as running to end of document", () => {
+    const src = "```\n**> never repaired";
+    const code = parse(src).blocks[0] as { type: string; text: string };
+    expect(code.type).toBe("code-block");
+    expect(code.text).toBe("**> never repaired");
+  });
+
+  it("keeps a fence's `**>` content intact through an inline code round-trip", () => {
+    // A wider fence in the source must not change the content bytes.
+    const src = "````\n```\n**> nested\n```\n````";
+    const code = parse(src).blocks[0] as { type: string; text: string };
+    expect(code.text).toBe("```\n**> nested\n```");
+  });
+});
+
+describe("raw HTML links fold to native markdown links (defect 2)", () => {
+  it("`<a href>` becomes a working link with no escaped `=`", () => {
+    const out = renderOutbound(
+      `<a href="https://example.com">label</a>`,
+    ).text;
+    expect(out).toBe("[label](https://example.com)");
+    expect(out).not.toContain("\\=");
+  });
+
+  it("an `<a href>` embedded in prose keeps its surroundings", () => {
+    const out = renderOutbound(
+      `see <a href="https://example.com/a_b">the docs</a> now`,
+    ).text;
+    expect(out).toBe("see [the docs](https://example.com/a_b) now");
+    expect(out).not.toContain("\\=");
+  });
+
+  it("accepts a single-quoted href", () => {
+    expect(renderOutbound(`<a href='https://e.com'>x</a>`).text).toBe(
+      "[x](https://e.com)",
+    );
+  });
+
+  it("reads an unquoted href value (tokenizer level)", () => {
+    // Exercised directly: an UNQUOTED href never reaches the fold through
+    // micromark — GFM's autolink-literal extension consumes
+    // `https://e.com>x` before the tag can become an mdast `html` node (a
+    // documented upstream limitation, not something this layer can reach).
+    // The attribute reader still handles the form for the block-HTML path.
+    expect(hrefOf(classifyHtmlTag(`<a href=https://e.com>`))).toBe(
+      "https://e.com",
+    );
+    expect(hrefOf(classifyHtmlTag(`<a href="https://e.com/a(b)">`))).toBe(
+      "https://e.com/a(b)",
+    );
+    expect(hrefOf(classifyHtmlTag(`<a name="x">`))).toBeNull();
+  });
+
+  it("an `<a>` with no href degrades to its label, not to broken markup", () => {
+    expect(renderOutbound(`<a name="anchor">label</a>`).text).toBe("label");
+  });
+
+  it("a wire-verified allowlist tag keeps its `=` attribute unescaped", () => {
+    // `<details open="open">` on v0.21.9 shipped as `open\="open"`.
+    const src = `<details open="open"><summary>S</summary>body</details>`;
+    expect(renderOutbound(src).text).toBe(src);
+  });
+});
+
+describe("markdown-equivalent HTML tags fold to native constructs (defect 3)", () => {
+  it("folds bold / italic / strike / code", () => {
+    expect(renderOutbound("<b>bold</b>").text).toBe("**bold**");
+    expect(renderOutbound("<strong>bold</strong>").text).toBe("**bold**");
+    expect(renderOutbound("<i>it</i>").text).toBe("*it*");
+    expect(renderOutbound("<em>it</em>").text).toBe("*it*");
+    expect(renderOutbound("<s>gone</s>").text).toBe("~~gone~~");
+    expect(renderOutbound("<del>gone</del>").text).toBe("~~gone~~");
+    expect(renderOutbound("<code>x_y</code>").text).toBe("`x_y`");
+  });
+
+  it("folds a tag mid-sentence without disturbing the prose", () => {
+    expect(renderOutbound("the <b>only</b> way").text).toBe("the **only** way");
+  });
+
+  it("folds nested tags", () => {
+    expect(renderOutbound("<b>bold <i>and italic</i></b>").text).toBe(
+      "**bold *and italic***",
+    );
+  });
+
+  it("handles same-name nesting without closing on the inner tag", () => {
+    // Depth tracking matters: matching the FIRST `</b>` would leave a dangling
+    // ` c` outside the bold run. The inner bold collapses into the outer one
+    // (see the asterisk-soup test below) so every byte lands inside `**…**`.
+    expect(renderOutbound("<b>a <b>b</b> c</b>").text).toBe("**a b c**");
+  });
+
+  it("passes the wire-verified allowlist through raw", () => {
+    for (const src of [
+      "<u>under</u>",
+      "H<sub>2</sub>O",
+      "x<sup>2</sup>",
+      "<aside><cite>note</cite></aside>",
+    ]) {
+      expect(renderOutbound(src).text).toBe(src);
+    }
+  });
+
+  it("drops the markup of an unrecognised tag but keeps its content", () => {
+    // Never ship a construct we cannot guarantee: an unknown tag risks the
+    // `unsupported start tag` 400 whose fallback resends PLAIN text, showing
+    // the reader literal markup.
+    expect(renderOutbound(`<marquee>scrolling</marquee>`).text).toBe("scrolling");
+    expect(renderOutbound(`<div class="x">body</div>`).text).toBe("body");
+    expect(renderOutbound(`<span data-x="1">t</span>`).text).toBe("t");
+  });
+
+  it("drops an HTML comment entirely", () => {
+    expect(renderOutbound("before <!-- hidden --> after").text).toBe(
+      "before  after",
+    );
+  });
+
+  it("keeps an unmatched open or close marker as escaped literal text", () => {
+    // An unmatched marker delimits nothing, so it is PROSE, not markup —
+    // deleting it silently mangles the author's sentence. Entity-escaped so
+    // the wire still cannot read it as an unsupported start tag.
+    expect(renderOutbound("<b>dangling").text).toBe("&lt;b&gt;dangling");
+    expect(renderOutbound("dangling</b>").text).toBe("dangling&lt;/b&gt;");
+  });
+
+  it("turns `<br>` into a GFM HARD break rather than deleting it", () => {
+    // A bare `\n` would be collapsed to a space by Telegram — the renderer
+    // runs after `normalizeParagraphBreaks`, so nothing downstream promotes
+    // it. Two trailing spaces are the GFM hard-break syntax.
+    expect(renderOutbound("one<br>two").text).toBe("one  \ntwo");
+    expect(renderOutbound("one<br/>two").text).toBe("one  \ntwo");
+  });
+
+  it("folds a block-level HTML line (not just inline runs)", () => {
+    // A paragraph that is entirely a tag is a mdast `html` BLOCK, a different
+    // fold path from an inline `html` phrasing node.
+    expect(renderOutbound("para\n\n<b>alone</b>\n\nmore").text).toBe(
+      "para\n\n**alone**\n\nmore",
+    );
+  });
+
+  it("escapes prose around a folded tag as prose (no smuggled formatting)", () => {
+    // Text between tags is still ordinary prose and must be escaped, or a
+    // `[`/`*` in it could re-trigger formatting downstream.
+    expect(renderOutbound("<b>a [b] c</b>").text).toBe("**a \\[b\\] c**");
+  });
+
+  it("never emits nested same-kind emphasis (asterisk soup)", () => {
+    // `**a **b** c**` renders as literal asterisks on the reader's screen.
+    expect(renderOutbound("<b>**already**</b>").text).toBe("**already**");
+    expect(renderOutbound("<b>a <b>b</b> c</b>").text).toBe("**a b c**");
+    expect(renderOutbound("<i>*x*</i>").text).toBe("*x*");
+    // DIFFERENT kinds still nest, as markdown allows.
+    expect(renderOutbound("<b><i>bi</i></b>").text).toBe("***bi***");
+  });
+
+  it("never swallows an inner code span's backticks into `<code>`", () => {
+    // Folding the inner `code` node's text would DELETE its backticks
+    // (`a b c`). Degrade to the children instead — every byte survives.
+    expect(renderOutbound("<code>a `b` c</code>").text).toBe("a `b` c");
+    expect(renderOutbound("<code><u>x</u></code>").text).toBe("<u>x</u>");
+  });
+
+  it("does not leave a blank-line hole where a dropped block used to be", () => {
+    // A block that is nothing but dropped markup must not contribute an empty
+    // paragraph and a spurious `\n\n` separator.
+    expect(renderOutbound("a\n\n<!-- c -->\n\nb").text).toBe("a\n\nb");
+    expect(renderOutbound("a\n\n<div></div>\n\nb").text).toBe("a\n\nb");
+  });
+
+  it("does not treat `a < b` as a tag", () => {
+    expect(renderOutbound("if a < b then c").text).toBe("if a < b then c");
+  });
+
+  it("leaves an autolink alone", () => {
+    expect(renderOutbound("<https://example.com>").text).toBe(
+      "[https://example.com](https://example.com)",
+    );
+  });
+
+  it("leaves tags inside a fenced code block completely untouched", () => {
+    const src = '```html\n<a href="https://e.com">x</a>\n<b>y</b>\n```';
+    expect(renderOutbound(src).text).toBe(src);
+  });
+
+  it("leaves tags inside an inline code span untouched", () => {
+    expect(renderOutbound("use `<b>bold</b>` here").text).toBe(
+      "use `<b>bold</b>` here",
+    );
+  });
+});
+
+describe("the blank-line-separated expandable shape (majority corpus shape)", () => {
+  // `**> header`, a BLANK line, then the `> …` body. Existing coverage only
+  // pinned the contiguous and lone-marker variants; this shape is what the
+  // corpus actually carries, and nothing locked it in.
+  const src = "**> tap to expand\n\n> line one\n> line two";
+
+  it("emits no `**>` marker anywhere", () => {
+    expect(renderOutbound(src).text).not.toContain("**>");
+  });
+
+  it("renders the header and the body as quotes, content intact", () => {
+    const out = renderOutbound(src).text;
+    expect(out).toBe("> tap to expand\n\n> line one\n> line two");
+  });
+
+  it("marks the header blockquote expandable and leaves the body plain", () => {
+    const blocks = parse(src).blocks as Array<{
+      type: string;
+      expandable?: boolean;
+    }>;
+    expect(blocks.map((b) => b.type)).toEqual(["blockquote", "blockquote"]);
+    expect(blocks[0].expandable).toBe(true);
+    expect(blocks[1].expandable).toBe(false);
+  });
+
+  it("survives a body carrying formatting and a link", () => {
+    const rich =
+      "**> tap to expand\n\n> **bold** body\n> see [docs](https://e.com)";
+    const out = renderOutbound(rich).text;
+    expect(out).not.toContain("**>");
+    expect(out).toContain("> **bold** body");
+    expect(out).toContain("> see [docs](https://e.com)");
+  });
+
+  it("is idempotent — re-rendering the output does not re-quote it", () => {
+    const once = renderOutbound(src).text;
+    expect(renderOutbound(once).text).toBe(once);
+  });
+});