gstack/make-pdf/test/render.test.ts

/**
 * Renderer unit tests — pure-function assertions for render.ts, smartypants.ts,
 * and print-css.ts. No browser, no PDF generation.
 */

import { describe, expect, test } from "bun:test";

import { render, sanitizeUntrustedHtml } from "../src/render";
import { smartypants } from "../src/smartypants";
import { printCss, screenCss } from "../src/print-css";

// ─── smartypants ──────────────────────────────────────────────

describe("smartypants", () => {
  test("converts straight double quotes to curly", () => {
    const out = smartypants(`<p>She said "hello" to him.</p>`);
    expect(out).toContain("\u201chello\u201d");
  });

  test("converts em dash (--)", () => {
    const out = smartypants(`<p>This is it -- the answer.</p>`);
    expect(out).toContain("\u2014");
  });

  test("converts ellipsis (...)", () => {
    const out = smartypants(`<p>Wait...</p>`);
    expect(out).toContain("\u2026");
  });

  test("converts apostrophes in contractions", () => {
    const out = smartypants(`<p>don't you know?</p>`);
    expect(out).toContain("don\u2019t");
  });

  test("does NOT touch content inside <code> blocks", () => {
    const input = `<pre><code>const x = "hello"; // it's fine</code></pre>`;
    const out = smartypants(input);
    expect(out).toBe(input); // unchanged
  });

  test("does NOT touch content inside <pre> blocks", () => {
    const input = `<pre>"quoted" -- don't</pre>`;
    const out = smartypants(input);
    expect(out).toBe(input);
  });

  test("does NOT touch inline code", () => {
    const out = smartypants(`<p>Use <code>it's</code> like this: "hello".</p>`);
    expect(out).toContain("<code>it's</code>");
    expect(out).toContain("\u201chello\u201d");
  });

  test("does NOT touch URLs", () => {
    const out = smartypants(`<p>Visit https://example.com/it's-page for "details".</p>`);
    expect(out).toContain("https://example.com/it's-page");
    expect(out).toContain("\u201cdetails\u201d");
  });

  // A URL flush against a following tag (no whitespace between) used to let
  // URL_RE's \S+ swallow the placeholder standing in for that tag. The
  // placeholder never restored, so the tag vanished and its styling bled
  // into the rest of the document. The test above misses this because its
  // URL is followed by a space.
  test("does not leak placeholders for a bare autolinked URL", () => {
    const input = `<p>see <a href="https://ex.com">https://ex.com</a> ok</p>`;
    const out = smartypants(input);
    expect(out).not.toContain("SMARTPANTS_PRESERVED");
    expect(out).toContain("</a>");
    expect(out).toBe(input);
  });

  test("does not leak placeholders for a bold URL", () => {
    const input = `<p>see <strong><a href="https://ex.com">https://ex.com</a></strong> ok</p>`;
    const out = smartypants(input);
    expect(out).not.toContain("SMARTPANTS_PRESERVED");
    expect(out).toContain("</a></strong>");
    expect(out).toBe(input);
  });

  test("does not leak placeholders when a URL is followed by punctuation", () => {
    const input = `<p>see <a href="https://ex.com">https://ex.com</a>, ok</p>`;
    const out = smartypants(input);
    expect(out).not.toContain("SMARTPANTS_PRESERVED");
    expect(out).toContain("</a>");
  });

  test("does NOT touch HTML attribute values", () => {
    const out = smartypants(`<a href="it's-a-test.html">link</a>`);
    expect(out).toContain(`href="it's-a-test.html"`);
  });

  test("does NOT convert -- in CLI flags", () => {
    // Prose like "try --verbose mode" should not turn -- into em dash
    const out = smartypants(`<p>Try --verbose mode.</p>`);
    // Since "--" is followed by a word char but not preceded by word/space,
    // it should remain intact. We're lenient here — acceptable either way.
    expect(out).toMatch(/--verbose|—verbose/);
  });
});

// ─── sanitizer ──────────────────────────────────────────────

describe("sanitizeUntrustedHtml", () => {
  test("strips <script> tags and content", () => {
    const input = `<p>hello</p><script>alert(1)</script><p>world</p>`;
    const out = sanitizeUntrustedHtml(input);
    expect(out).not.toContain("<script");
    expect(out).not.toContain("alert");
    expect(out).toContain("<p>hello</p>");
    expect(out).toContain("<p>world</p>");
  });

  test("strips <iframe>", () => {
    const input = `<p>hi</p><iframe src="evil.com"></iframe>`;
    expect(sanitizeUntrustedHtml(input)).not.toContain("<iframe");
  });

  test("strips onclick attribute", () => {
    const input = `<a href="#" onclick="alert(1)">click</a>`;
    const out = sanitizeUntrustedHtml(input);
    expect(out).not.toContain("onclick");
    expect(out).toContain("href=\"#\"");
  });

  test("strips event handlers with mixed case (onClick, ONCLICK)", () => {
    const input1 = `<a href="#" onClick="x()">a</a>`;
    const input2 = `<a href="#" ONCLICK="x()">b</a>`;
    expect(sanitizeUntrustedHtml(input1)).not.toContain("onClick");
    expect(sanitizeUntrustedHtml(input2)).not.toContain("ONCLICK");
  });

  test("rewrites javascript: URLs in href to #", () => {
    const input = `<a href="javascript:alert(1)">bad</a>`;
    const out = sanitizeUntrustedHtml(input);
    expect(out).not.toContain("javascript:");
    expect(out).toContain('href="#"');
  });

  test("strips inline SVG <script>", () => {
    const input = `<svg><script>alert(1)</script><circle r="5"/></svg>`;
    const out = sanitizeUntrustedHtml(input);
    expect(out).not.toContain("<script");
    expect(out).toContain("<circle");
  });

  test("strips <object>, <embed>, <link>, <meta>, <base>, <form>", () => {
    const input = `
      <object data="x.swf"></object>
      <embed src="y.mov">
      <link rel="stylesheet" href="evil.css">
      <meta http-equiv="refresh" content="0;url=evil">
      <base href="evil.com">
      <form action="evil"><input/></form>
    `;
    const out = sanitizeUntrustedHtml(input);
    expect(out).not.toContain("<object");
    expect(out).not.toContain("<embed");
    expect(out).not.toContain("<link");
    expect(out).not.toContain("<meta");
    expect(out).not.toContain("<base");
    expect(out).not.toContain("<form");
  });

  test("strips srcdoc attribute (iframe escape vector)", () => {
    const input = `<div srcdoc="<script>bad</script>">hi</div>`;
    expect(sanitizeUntrustedHtml(input)).not.toContain("srcdoc");
  });
});

// ─── end-to-end render ──────────────────────────────────────────────

describe("render (end-to-end)", () => {
  test("produces a full HTML document with title, body, and CSS", () => {
    const result = render({
      markdown: `# Hello\n\nA paragraph with "quotes" and -- dashes.\n`,
    });
    expect(result.html).toContain("<!doctype html>");
    expect(result.html).toContain("<title>Hello</title>");
    expect(result.html).toContain("<h1");
    expect(result.html).toContain("Hello");
    // CSS should be inlined as <style>...
    expect(result.html).toMatch(/<style>[\s\S]*font-family: Helvetica/);
    // Smartypants ran
    expect(result.html).toContain("\u201cquotes\u201d");
    expect(result.html).toContain("\u2014");
  });

  test("derives title from first H1 when --title is not passed", () => {
    const result = render({ markdown: `# My Title\n\nBody.` });
    expect(result.meta.title).toBe("My Title");
  });

  test("uses --title override when provided", () => {
    const result = render({
      markdown: `# Auto-derived\n\nBody.`,
      title: "Explicit Title",
    });
    expect(result.meta.title).toBe("Explicit Title");
  });

  test("includes cover block when cover=true", () => {
    const result = render({
      markdown: `# Doc\n\nBody.`,
      cover: true,
      subtitle: "A subtitle",
      author: "Garry Tan",
    });
    expect(result.html).toContain(`class="cover"`);
    expect(result.html).toContain(`class="cover-title"`);
    expect(result.html).toContain("A subtitle");
    expect(result.html).toContain("Garry Tan");
  });

  test("omits cover block when cover=false", () => {
    const result = render({ markdown: `# Memo\n\nBody.` });
    expect(result.html).not.toContain(`class="cover"`);
  });

  test("injects watermark element when --watermark is set", () => {
    const result = render({ markdown: `# Doc`, watermark: "DRAFT" });
    expect(result.html).toContain(`class="watermark"`);
    expect(result.html).toContain("DRAFT");
    // And the CSS rule for it must be present
    expect(result.html).toContain("position: fixed");
    expect(result.html).toContain("rotate(-30deg)");
  });

  test("wraps each H1 in its own .chapter section (default)", () => {
    const result = render({
      markdown: `# One\n\nbody 1\n\n# Two\n\nbody 2\n`,
    });
    const chapterMatches = result.html.match(/class="chapter"/g);
    expect(chapterMatches).toBeTruthy();
    if (chapterMatches) expect(chapterMatches.length).toBe(2);
  });

  test("does NOT create chapter sections when noChapterBreaks=true", () => {
    const result = render({
      markdown: `# One\n\nbody\n\n# Two\n\nbody\n`,
      noChapterBreaks: true,
    });
    const chapterMatches = result.html.match(/class="chapter"/g) ?? [];
    expect(chapterMatches.length).toBe(1);
  });

  test("builds a TOC with H1/H2 entries when toc=true", () => {
    const result = render({
      markdown: `# One\n\n## Sub\n\nbody\n\n# Two\n\nbody\n`,
      toc: true,
    });
    expect(result.html).toContain(`class="toc"`);
    expect(result.html).toContain(`<h2>Contents</h2>`);
    expect(result.html).toContain("One");
    expect(result.html).toContain("Sub");
    expect(result.html).toContain("Two");
  });

  test("strips dangerous HTML from untrusted markdown", () => {
    const result = render({
      markdown: `# Safe\n\n<script>alert('xss')</script>\n\nBody.`,
    });
    expect(result.html).not.toContain("<script");
    expect(result.html).not.toContain("alert");
    expect(result.html).toContain("Safe");
  });

  test("respects text-align: left — no justify in print CSS", () => {
    const result = render({ markdown: `para1\n\npara2\n` });
    // The rule from the design-review fix: no p + p indent, text-align: left.
    expect(result.printCss).toContain("text-align: left");
    expect(result.printCss).not.toContain("text-align: justify");
    expect(result.printCss).not.toContain("text-indent");
  });

  test("includes CJK font fallback in body", () => {
    const result = render({ markdown: `body` });
    expect(result.printCss).toContain("Hiragino Kaku Gothic");
    expect(result.printCss).toContain("Noto Sans CJK");
  });

  // ─── blank-first-page regression (#1904) ────────────────────────
  // Any content before the first <h1> used to become a standalone preamble
  // .chapter. That section takes the `:first-of-type { break-before: auto }`
  // exception, so the first real chapter inherits `break-before: page` and
  // starts on page 2 — leaving a blank/near-blank page 1.

  test("a leading <style> preamble does not get its own chapter (no blank page 1)", () => {
    const result = render({ markdown: `<style>h1{color:#000}</style>\n\n# Hello\n\nBody.\n` });
    const chapters = result.html.match(/class="chapter"/g) ?? [];
    // One chapter, not two — the invisible <style> no longer forces a page break.
    expect(chapters.length).toBe(1);
    // ...and the style is preserved (folded into the first chapter, not dropped).
    expect(result.html).toContain("<style>h1{color:#000}</style>");
    expect(result.html).toMatch(/<section class="chapter"><style>[\s\S]*?<\/style>[\s\S]*?<h1/);
  });

  test("leading YAML frontmatter is stripped, not rendered as body text", () => {
    const result = render({
      markdown: `---\ntitle: My Doc\ntype: memo\ntags: [a, b]\n---\n\n# Hello\n\nBody.\n`,
    });
    // Frontmatter keys must not leak into the rendered body.
    expect(result.html).not.toContain("type: memo");
    expect(result.html).not.toContain("tags: [a, b]");
    // No preamble chapter -> single chapter, first H1 on page 1.
    const chapters = result.html.match(/class="chapter"/g) ?? [];
    expect(chapters.length).toBe(1);
    expect(result.meta.title).toBe("Hello");
  });

  test("a real text preamble still gets its own chapter (unchanged behavior)", () => {
    const result = render({ markdown: `Intro paragraph.\n\n# Hello\n\nBody.\n` });
    const chapters = result.html.match(/class="chapter"/g) ?? [];
    expect(chapters.length).toBe(2);
  });

  test("a `---` thematic break that is not frontmatter is left intact", () => {
    // Opening with visible text means the later `---` is a real <hr>, not frontmatter.
    const result = render({ markdown: `# Hello\n\nBefore.\n\n---\n\nAfter.\n` });
    expect(result.html).toContain("<hr>");
    expect(result.html).toContain("After.");
  });
});

// ─── print-css ──────────────────────────────────────────────

describe("printCss", () => {
  test("emits 1in margins by default", () => {
    const css = printCss();
    expect(css).toContain("margin: 1in");
  });

  test("respects custom margins flag", () => {
    const css = printCss({ margins: "72pt" });
    expect(css).toContain("margin: 72pt");
  });

  test("per-side margins reach the CSS @page rule (preferCSSPageSize parity)", () => {
    // Under a landscape promotion Chromium honors the CSS margins, not the
    // CDP per-side options — render() must compose them into the shorthand.
    const r = render({ markdown: "# T", marginLeft: "0.5in", marginRight: "0.5in" });
    expect(r.printCss).toContain("margin: 1in 0.5in 1in 0.5in");
  });

  test("emits letter page size by default", () => {
    const css = printCss();
    expect(css).toContain("size: letter");
  });

  test("respects custom page size", () => {
    const css = printCss({ pageSize: "a4" });
    expect(css).toContain("size: a4");
  });

  test("suppresses running header and footer on cover page", () => {
    const css = printCss();
    expect(css).toMatch(/@page\s*:first\s*\{[\s\S]*?content:\s*none[\s\S]*?content:\s*none/);
  });

  test("omits CONFIDENTIAL when confidential=false", () => {
    const css = printCss({ confidential: false });
    expect(css).not.toContain("CONFIDENTIAL");
  });

  test("emits watermark CSS only when watermark is set", () => {
    const withWatermark = printCss({ watermark: "DRAFT" });
    expect(withWatermark).toContain(".watermark");
    expect(withWatermark).toContain("rotate(-30deg)");

    const withoutWatermark = printCss();
    expect(withoutWatermark).not.toContain(".watermark");
  });

  test("drops chapter break rule when noChapterBreaks=true", () => {
    const on = printCss({ noChapterBreaks: false });
    expect(on).toContain("break-before: page");

    const off = printCss({ noChapterBreaks: true });
    expect(off).not.toContain(".chapter { break-before: page");
  });

  test("always sets p { text-align: left }", () => {
    const css = printCss();
    expect(css).toContain("text-align: left");
  });

  test("never sets text-indent on p", () => {
    const css = printCss();
    // Confirm no p-indent slipped in
    expect(css).not.toMatch(/p\s*\+\s*p\s*\{[^}]*text-indent/);
  });

  test("emits @bottom-center page-number rule by default", () => {
    const css = printCss();
    expect(css).toMatch(/@bottom-center\s*\{\s*content:\s*counter\(page\)/);
  });

  test("suppresses @bottom-center page-number rule when pageNumbers=false", () => {
    const css = printCss({ pageNumbers: false });
    expect(css).not.toMatch(/@bottom-center\s*\{\s*content:\s*counter\(page\)/);
  });

  test("still emits @bottom-center when pageNumbers=true (explicit)", () => {
    const css = printCss({ pageNumbers: true });
    expect(css).toMatch(/@bottom-center\s*\{\s*content:\s*counter\(page\)/);
  });

  // Zero image truncation, ever: the cap must be a GLOBAL img rule. Markdown
  // images render as <p><img> (no figure), so a figure-scoped cap alone lets
  // wide screenshots run off the page edge — the exact regression this pins.
  test("emits a global img max-width cap (zero truncation invariant)", () => {
    const css = printCss();
    expect(css).toMatch(/(^|\n)img\s*\{\s*max-width:\s*100%;\s*height:\s*auto;\s*\}/);
  });

  test("typography floor: body 12pt, poster cover, readable TOC", () => {
    const css = printCss({ cover: true, toc: true });
    expect(css).toContain("font-size: 12pt"); // body
    expect(css).toMatch(/\.cover h1\.cover-title\s*\{[^}]*font-size:\s*56pt/);
    expect(css).toMatch(/\.cover \.cover-meta\s*\{[^}]*font-size:\s*13pt/);
    expect(css).toMatch(/\.toc li\s*\{[^}]*font-size:\s*12pt/);
  });

  test("page-wide carries the named page and NO height/flex centering", () => {
    const css = printCss();
    expect(css).toMatch(/\.page-wide\s*\{[^}]*page:\s*wide/);
    // Centering is computed by image-policy as an inline margin-top. CSS
    // flex/min-height centering fragments into phantom empty landscape pages
    // in Chromium — this pins the regression (landscape-gate: 5 pages for 3
    // promotions, bisected to min-height at any value).
    expect(css).not.toMatch(/\.page-wide\s*\{[^}]*min-height/);
    expect(css).not.toMatch(/\.page-wide\s*\{[^}]*flex/);
  });

  test("font stacks include Liberation Sans adjacent to Helvetica", () => {
    const css = printCss({ confidential: true });
    // Body stack
    expect(css).toMatch(/font-family:\s*Helvetica,\s*"Liberation Sans",\s*Arial/);
    // At least one @page margin box (running header / page number / CONFIDENTIAL)
    // should also have the updated stack.
    const marginBoxStacks = css.match(/@(top|bottom)-(center|right)\s*\{[^}]*Liberation Sans/g) ?? [];
    expect(marginBoxStacks.length).toBeGreaterThanOrEqual(1);
  });

  test("all four original Helvetica stacks now include Liberation Sans", () => {
    const css = printCss({ runningHeader: "Running Title", confidential: true });
    // Count: body (1) + running header (1) + page numbers (1) + confidential (1) = 4
    const occurrences = (css.match(/"Liberation Sans"/g) ?? []).length;
    expect(occurrences).toBeGreaterThanOrEqual(4);
  });

  // ─── emoji fallback (fix/make-pdf-emoji-tofu) ────────────────
  // Body + @top-center running header get the color-emoji families so
  // Chromium has a glyph source for emoji code points instead of tofu (▯).
  // The @bottom-* boxes hold counters / "CONFIDENTIAL" only — no emoji.

  test("body stack includes all three emoji families before sans-serif", () => {
    const css = printCss();
    expect(css).toContain(`"Apple Color Emoji"`);
    expect(css).toContain(`"Segoe UI Emoji"`);
    expect(css).toContain(`"Noto Color Emoji"`);
    // Emoji families must precede the generic family so per-character fallback
    // reaches them before terminating at sans-serif.
    expect(css).toMatch(/"Noto Color Emoji",\s*sans-serif/);
  });

  test("@top-center running header includes emoji families", () => {
    const css = printCss({ runningHeader: "Q3 Report 🚀" });
    const topCenter = css.match(/@top-center\s*\{[^}]*\}/)?.[0] ?? "";
    expect(topCenter).toContain(`"Apple Color Emoji"`);
    expect(topCenter).toContain(`"Noto Color Emoji"`);
  });

  test("@bottom-center and @bottom-right do NOT include emoji families", () => {
    const css = printCss({ confidential: true });
    const bottomCenter = css.match(/@bottom-center\s*\{[^}]*\}/)?.[0] ?? "";
    const bottomRight = css.match(/@bottom-right\s*\{[^}]*\}/)?.[0] ?? "";
    expect(bottomCenter).not.toContain("Emoji");
    expect(bottomRight).not.toContain("Emoji");
    // ...but they still share the sans stack via the SANS_STACK constant.
    expect(bottomCenter).toContain(`"Liberation Sans"`);
    expect(bottomRight).toContain(`"Liberation Sans"`);
  });

  test("emoji families appear in exactly the two emoji-bearing stacks", () => {
    const css = printCss({ runningHeader: "Title", confidential: true });
    // body (1) + @top-center (1) = 2 occurrences of the emoji group.
    const occurrences = (css.match(/"Apple Color Emoji"/g) ?? []).length;
    expect(occurrences).toBe(2);
  });
});

// ─── render() — pageNumbers / footerTemplate data flow ───────────────

describe("render() — pageNumbers data flow", () => {
  test("CSS footer renders by default", () => {
    const result = render({ markdown: `# Doc\n\nBody.` });
    expect(result.printCss).toMatch(/@bottom-center\s*\{\s*content:\s*counter\(page\)/);
  });

  test("--no-page-numbers reaches the CSS layer", () => {
    const result = render({ markdown: `# Doc\n\nBody.`, pageNumbers: false });
    expect(result.printCss).not.toMatch(/@bottom-center\s*\{\s*content:\s*counter\(page\)/);
  });

  test("footerTemplate suppresses CSS page numbers (custom footer wins)", () => {
    const result = render({
      markdown: `# Doc\n\nBody.`,
      footerTemplate: `<div class="foo">custom</div>`,
    });
    expect(result.printCss).not.toMatch(/@bottom-center\s*\{\s*content:\s*counter\(page\)/);
  });

  test("pageNumbers=true + no footerTemplate keeps CSS footer", () => {
    const result = render({ markdown: `# Doc`, pageNumbers: true });
    expect(result.printCss).toMatch(/@bottom-center\s*\{\s*content:\s*counter\(page\)/);
  });
});

// ─── render() — HTML entity handling in titles, cover, TOC ───────────

describe("render() — no double HTML entity escaping", () => {
  type Case = { char: string; inTitle: string; expectedTitleMeta: string };

  // Only characters that should flow through unchanged. `"` and `'` are
  // omitted from this set because smartypants converts them to curly quotes
  // before heading extraction — asserted separately below.
  const cases: Case[] = [
    { char: "&", inTitle: "A & B", expectedTitleMeta: "A & B" },
    { char: "<", inTitle: "A < B", expectedTitleMeta: "A < B" },
    { char: ">", inTitle: "A > B", expectedTitleMeta: "A > B" },
    { char: "©", inTitle: "A © B", expectedTitleMeta: "A © B" },
    { char: "—", inTitle: "A — B", expectedTitleMeta: "A — B" },
  ];

  for (const { char, inTitle, expectedTitleMeta } of cases) {
    test(`"${char}" in H1 has no double-escape in <title> or cover`, () => {
      const result = render({
        markdown: `# ${inTitle}\n\nBody.`,
        cover: true,
        author: "A",
      });
      // Meta: decoded plain text.
      expect(result.meta.title).toBe(expectedTitleMeta);
      // HTML: <title>...</title> never contains double-escape patterns.
      expect(result.html).not.toMatch(/<title>[^<]*&amp;amp;/);
      expect(result.html).not.toMatch(/<title>[^<]*&amp;lt;/);
      expect(result.html).not.toMatch(/<title>[^<]*&amp;gt;/);
      expect(result.html).not.toMatch(/<title>[^<]*&amp;#\d+;/);
      expect(result.html).not.toMatch(/<title>[^<]*&amp;#x[0-9a-fA-F]+;/);
      // Cover block also single-escape.
      expect(result.html).not.toMatch(/class="cover-title"[^>]*>[^<]*&amp;amp;/);
    });
  }

  test('ampersand in <title> renders as exactly one "&amp;"', () => {
    const result = render({ markdown: `# Faber & Faber\n\nBody.` });
    expect(result.html).toContain("<title>Faber &amp; Faber</title>");
    expect(result.html).not.toContain("&amp;amp;");
  });

  test("TOC entries have no double-escape when a heading contains '&'", () => {
    const result = render({
      markdown: `# Doc\n\n## Faber & Faber\n\nBody.\n\n## Other\n\nMore.`,
      toc: true,
    });
    // TOC renders the heading text through escapeHtml; must be single-escaped.
    expect(result.html).toContain("Faber &amp; Faber");
    expect(result.html).not.toContain("&amp;amp;");
  });

  test('numeric entity in H1 (e.g. "&#169;") decodes cleanly to <title>', () => {
    // Marked passes through numeric entities verbatim in the HTML output,
    // so the decoder must handle them.
    const result = render({ markdown: `# A &#169; B\n\nBody.` });
    expect(result.meta.title).toBe("A © B");
    expect(result.html).toContain("<title>A © B</title>");
  });

  test("smartypants converts raw quotes in title BEFORE extraction (contract)", () => {
    // We do NOT assert raw `"` survives — smartypants is expected to convert it.
    // The contract is: no double-escape of the encoded form.
    const result = render({ markdown: `# Say "hi"\n\nBody.` });
    expect(result.html).not.toContain("&amp;quot;");
    expect(result.html).not.toContain("&amp;#39;");
    // And <title> contains exactly one level of escaping.
    const titleMatch = result.html.match(/<title>([^<]*)<\/title>/);
    expect(titleMatch).toBeTruthy();
    if (titleMatch) {
      // Never contains a double-encoded entity.
      expect(titleMatch[1]).not.toMatch(/&amp;(amp|lt|gt|quot|#\d+);/);
    }
  });
});

describe("screenCss", () => {
  test("screenCss is media-scoped and readable-width", () => {
    const css = screenCss();
    expect(css).toContain("@media screen");
    // 42em at 12pt ≈ 70-75 chars/line — the readable ceiling (design review).
    expect(css).toContain("max-width: 42em");
    expect(css).toContain(".watermark { display: none; }");
  });
});