@amg555/frameforge-mcp 2.7.6 → 2.7.8

package/.agent/skills/gstack-make-pdf/test/setup-smoke.test.ts

@@ -1,259 +0,0 @@
-/**
- * `$P setup` smoke flow — make-pdf/src/setup.ts runSetup() — with no real
- * browser probed or launched.
- *
- * runSetup() reads the engine through lib/aside-render's process-wide cache
- * (pickEngine() with no arguments, and render() which consults the same
- * cache), so `pickEngine(true, deps)` is the intended seam: prime it once with
- * a stubbed Aside probe and a stubbed browse-binary resolver, then call
- * runSetup(). A fake `browse` shell script plays gstack's own headless
- * browser for the [2/5] render smoke and the [4/5] smoke PDF. process.exit is
- * stubbed to throw so the exit code is observable; process.stderr.write is
- * captured for the step lines.
- *
- * Also pins renderPdf()'s return value — the engine that actually rendered —
- * which the orchestrator compares against the engine it announced.
- */
-
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import {
-  NO_BROWSER,
-  NO_BROWSER_HELP,
-  pickEngine,
-  renderTmpDir,
-  type AsideProbe,
-  type RenderResult,
-  type RenderSpec,
-} from "../../lib/aside-render";
-import { renderPdf } from "../src/asideClient";
-import { OUTPUT_TMP_DIR } from "../src/orchestrator";
-import { runSetup } from "../src/setup";
-import { ExitCode } from "../src/types";
-
-const isWin = process.platform === "win32";
-const PROBE_DETAIL = "primed by setup-smoke.test.ts";
-const noAside = (): AsideProbe => ({ ok: false, reason: "NEEDS_ASIDE", detail: PROBE_DETAIL });
-
-let tmp: string;
-
-beforeAll(() => {
-  tmp = fs.mkdtempSync(path.join(os.tmpdir(), "make-pdf-setup-smoke-"));
-});
-
-afterAll(() => {
-  fs.rmSync(tmp, { recursive: true, force: true });
-  // The engine cache is process-wide. The free runner gives every test file
-  // its own process, but under a bare multi-file `bun test` a later in-process
-  // caller must not inherit a fake binary that no longer exists: re-resolve
-  // gstack's real browse binary (Aside probe still stubbed — never a round-trip).
-  pickEngine(true, { probe: noAside });
-});
-
-// ─── helpers ──────────────────────────────────────────────────────────────────
-
-class ExitSentinel extends Error {
-  constructor(readonly code: number) {
-    super(`process.exit(${code})`);
-    this.name = "ExitSentinel";
-  }
-}
-
-/** Run `fn` with process.exit throwing a sentinel and process.stderr.write captured. Restores both. */
-async function captureRun<T>(fn: () => Promise<T>): Promise<{ result?: T; exit?: number; error?: unknown; stderr: string }> {
-  const chunks: string[] = [];
-  const origWrite = process.stderr.write;
-  const origExit = process.exit;
-  process.stderr.write = ((chunk: string | Uint8Array) => {
-    chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
-    return true;
-  }) as typeof process.stderr.write;
-  process.exit = ((code?: number) => {
-    throw new ExitSentinel(code ?? 0);
-  }) as typeof process.exit;
-  try {
-    const result = await fn();
-    return { result, stderr: chunks.join("") };
-  } catch (e) {
-    if (e instanceof ExitSentinel) return { exit: e.code, stderr: chunks.join("") };
-    return { error: e, stderr: chunks.join("") };
-  } finally {
-    process.stderr.write = origWrite;
-    process.exit = origExit;
-  }
-}
-
-/**
- * A stand-in for gstack's browse daemon CLI: `newtab --json` hands out a tab,
- * `js` answers with `pageText`, `pdf --from-file <payload>` writes a fake PDF
- * at the payload's `output` path when `pdf` is set (and nothing otherwise).
- */
-function writeFakeBrowse(name: string, opts: { pageText?: string; pdf?: boolean; newtabFails?: boolean }): string {
-  const body = ["#!/bin/sh", 'case "$1" in'];
-  body.push(opts.newtabFails
-    ? '  newtab) echo "daemon refused: boom" >&2; exit 1 ;;'
-    : `  newtab) echo '{"tabId":7}' ;;`);
-  body.push(`  js) echo '${opts.pageText ?? "browser-ok"}' ;;`);
-  if (opts.pdf) {
-    body.push(
-      "  pdf)",
-      '    read -r payload < "$3"',
-      '    out="${payload#*\\"output\\":\\"}"',
-      '    out="${out%%\\"*}"',
-      "    printf '%%PDF-1.4 fake\\n' > \"$out\"",
-      "    ;;",
-    );
-  }
-  body.push("esac", "exit 0", "");
-  const file = path.join(tmp, name);
-  fs.writeFileSync(file, body.join("\n"), { mode: 0o755 });
-  return file;
-}
-
-/** The [2/5] smoke staging dirs currently under renderTmpDir(). */
-function smokeDirs(stage: string): string[] {
-  return fs.readdirSync(stage).filter((n) => n.startsWith("make-pdf-setup-")).sort();
-}
-
-const smokePdf = () => path.join(OUTPUT_TMP_DIR, `make-pdf-smoke-${process.pid}.pdf`);
-const smokeFixture = () => path.join(OUTPUT_TMP_DIR, `make-pdf-smoke-${process.pid}.md`);
-
-// ─── [1/5] browser check ──────────────────────────────────────────────────────
-
-describe("runSetup [1/5]: no browser at all", () => {
-  test("Aside absent and no browse binary: FAIL, the NO_BROWSER text with both remedies, exit 4, never reaches [2/5]", async () => {
-    pickEngine(true, { probe: noAside, resolveBin: () => null });
-    const run = await captureRun(() => runSetup());
-    expect(run.error).toBeUndefined();
-    expect(run.exit).toBe(ExitCode.BrowserUnavailable);
-    expect(run.exit).toBe(4);
-    expect(run.stderr).toContain("make-pdf setup — verifying install");
-    expect(run.stderr).toContain("[1/5] Checking for a browser... FAIL");
-    expect(run.stderr).toContain(NO_BROWSER);
-    expect(run.stderr).toContain("no browser available");
-    expect(run.stderr).toContain(NO_BROWSER_HELP);
-    expect(run.stderr).toContain(`(NEEDS_ASIDE: ${PROBE_DETAIL})`);
-    expect(run.stderr).not.toContain("[2/5]");
-  });
-});
-
-// ─── [2/5] render smoke through the fallback browser ──────────────────────────
-
-describe.skipIf(isWin)("runSetup [2/5]: render smoke through gstack's own browser", () => {
-  test("a browser that answers but the page text is wrong: FAIL, `could not render a page` + remedy, exit 4, smoke dir removed", async () => {
-    const fake = writeFakeBrowse("browse-wrong-text", { pageText: "not-the-smoke-page" });
-    pickEngine(true, { probe: noAside, resolveBin: () => fake });
-    const stage = renderTmpDir();
-    const before = smokeDirs(stage);
-
-    const run = await captureRun(() => runSetup());
-    expect(run.error).toBeUndefined();
-    expect(run.exit).toBe(ExitCode.BrowserUnavailable);
-    expect(run.stderr).toContain(`[1/5] Checking for a browser... gstack browser OK (fallback: ${fake}; Aside is not running)`);
-    expect(run.stderr).toContain("[2/5] Rendering through gstack browser... FAIL");
-    expect(run.stderr).toContain("gstack browser could not render a page: unexpected page text: not-the-smoke-page");
-    expect(run.stderr).toContain(`To fix: ${NO_BROWSER_HELP}`);
-    expect(run.stderr).toContain("open the Aside app");
-    expect(run.stderr).toContain("./setup");
-    expect(run.stderr).not.toContain("[3/5]");
-    expect(smokeDirs(stage)).toEqual(before); // finally { rmSync(smokeDir) } ran despite the exit
-  });
-
-  test("a daemon that refuses to open a tab surfaces browse's own error on the same FAIL path (exit 4)", async () => {
-    const fake = writeFakeBrowse("browse-refuses-newtab", { newtabFails: true });
-    pickEngine(true, { probe: noAside, resolveBin: () => fake });
-    const stage = renderTmpDir();
-    const before = smokeDirs(stage);
-
-    const run = await captureRun(() => runSetup());
-    expect(run.exit).toBe(ExitCode.BrowserUnavailable);
-    expect(run.stderr).toContain("[2/5] Rendering through gstack browser... FAIL");
-    expect(run.stderr).toContain("gstack browser could not render a page: browse newtab failed: daemon refused: boom");
-    expect(run.stderr).toContain(`To fix: ${NO_BROWSER_HELP}`);
-    expect(smokeDirs(stage)).toEqual(before);
-  });
-});
-
-// ─── [3/5]–[5/5] the rest of the flow with a fake browser ─────────────────────
-
-describe.skipIf(isWin)("runSetup [3/5]-[5/5]: pdftotext, smoke PDF, cheatsheet", () => {
-  test("happy path: every step reports, the smoke PDF lands at OUTPUT_TMP_DIR, the fixture is removed, no exit", async () => {
-    const fake = writeFakeBrowse("browse-happy", { pageText: "browser-ok", pdf: true });
-    pickEngine(true, { probe: noAside, resolveBin: () => fake });
-    const outPath = smokePdf();
-    const fixturePath = smokeFixture();
-    try {
-      const run = await captureRun(() => runSetup());
-      expect(run.error).toBeUndefined();
-      expect(run.exit).toBeUndefined();
-      expect(run.stderr).toContain(`[1/5] Checking for a browser... gstack browser OK (fallback: ${fake}; Aside is not running)`);
-      expect(run.stderr).toContain("[2/5] Rendering through gstack browser... OK");
-      // pdftotext is optional: OK where poppler is installed, SKIP with install hints otherwise.
-      expect(run.stderr).toMatch(/\[3\/5\] Checking pdftotext \(optional\)\.\.\. (OK \(|SKIP\n)/);
-      expect(run.stderr).toContain("[4/5] Generating smoke-test PDF...");
-      expect(run.stderr).toContain(`PASSED. Smoke test saved to ${outPath}`);
-      expect(run.stderr).toContain("[5/5] All checks passed.");
-      expect(run.stderr).toContain("make-pdf is ready. Try:");
-      expect(run.stderr).toContain(`Smoke-test PDF: ${outPath}`);
-      // The announced engine (browse) is the one that rendered: no mid-run note.
-      expect(run.stderr).not.toContain("mid-run");
-      expect(fs.readFileSync(outPath, "utf8")).toBe("%PDF-1.4 fake\n");
-      expect(fs.existsSync(fixturePath)).toBe(false);
-    } finally {
-      fs.rmSync(outPath, { force: true });
-      fs.rmSync(fixturePath, { force: true });
-    }
-  });
-
-  test("[4/5] smoke PDF failure (browser up, print produced nothing): FAILED with the render error, exit 2, fixture removed", async () => {
-    // Same fake, but `pdf` writes no artifact — a render error, not a missing browser.
-    const fake = writeFakeBrowse("browse-no-artifact", { pageText: "browser-ok", pdf: false });
-    pickEngine(true, { probe: noAside, resolveBin: () => fake });
-    const outPath = smokePdf();
-    const fixturePath = smokeFixture();
-    try {
-      const run = await captureRun(() => runSetup());
-      expect(run.error).toBeUndefined();
-      expect(run.exit).toBe(ExitCode.RenderError);
-      expect(run.exit).toBe(2);
-      expect(run.stderr).toContain("[2/5] Rendering through gstack browser... OK");
-      expect(run.stderr).toContain("[4/5] Generating smoke-test PDF...");
-      expect(run.stderr).toContain("        FAILED: PDF render failed: step 0 produced no artifact");
-      expect(run.stderr).not.toContain("[5/5]");
-      expect(fs.existsSync(outPath)).toBe(false);
-      expect(fs.existsSync(fixturePath)).toBe(false); // finally { unlinkSync(fixturePath) } ran despite the exit
-    } finally {
-      fs.rmSync(outPath, { force: true });
-      fs.rmSync(fixturePath, { force: true });
-    }
-  });
-});
-
-// ─── renderPdf returns the engine that rendered ───────────────────────────────
-
-describe("renderPdf reports which engine rendered", () => {
-  const injected = (engine: RenderResult["engine"]) => async (spec: RenderSpec): Promise<RenderResult> => {
-    const step = spec.steps[0];
-    return { ok: true, engine, outputs: step.kind === "pdf" ? [step.out] : [], evals: {}, stdout: "" };
-  };
-
-  test("resolves 'browse' when gstack's own browser printed the PDF", async () => {
-    await expect(renderPdf("<p>x</p>", { output: path.join(tmp, "browse.pdf") }, injected("browse"))).resolves.toBe("browse");
-  });
-
-  test("resolves 'aside' when Aside printed it", async () => {
-    await expect(renderPdf("<p>x</p>", { output: path.join(tmp, "aside.pdf") }, injected("aside"))).resolves.toBe("aside");
-  });
-
-  test("resolves undefined when the result names no engine (older render shapes)", async () => {
-    await expect(renderPdf("<p>x</p>", { output: path.join(tmp, "none.pdf") }, injected(undefined))).resolves.toBeUndefined();
-  });
-
-  test("a failed result still throws (the engine is never returned for a failure)", async () => {
-    const failing = async (): Promise<RenderResult> => ({ ok: false, engine: "browse", outputs: [], evals: {}, stdout: "", error: "browse pdf failed: boom" });
-    await expect(renderPdf("<p>x</p>", { output: path.join(tmp, "fail.pdf") }, failing)).rejects.toThrow(/PDF render failed: browse pdf failed: boom/);
-  });
-});

package/.agent/skills/gstack-make-pdf/test/toc-anchors.test.ts

@@ -1,95 +0,0 @@
-/**
- * #2903: TOC labels and link targets come from ONE heading inventory. Before
- * the fix, addHeadingIds() numbered every H1-H3 while extractHeadings()
- * dropped empty ones, so one empty heading shifted every later link
- * (`#toc-0` pointed at the empty H1, the "Alpha" entry at nothing named
- * Alpha); a user `id="toc-1"` or a `data-id` attribute did the same.
- *
- * The oracle here is the HTML fragment rule: a link `#x` lands on the FIRST
- * element whose id is x. Every TOC entry must land on a heading with the
- * entry's own text.
- */
-import { describe, expect, test } from "bun:test";
-import { render } from "../src/render";
-
-function stripTags(s: string): string {
-  return s.replace(/<[^>]+>/g, "").trim();
-}
-
-function decode(s: string): string {
-  return s.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
-}
-
-/** [entry label, text of the element the link lands on] for every TOC entry. */
-function tocLandings(html: string): Array<{ label: string; landsOn: string | null }> {
-  const toc = html.match(/<section class="toc">[\s\S]*?<\/section>/)?.[0] ?? "";
-  const body = html.slice(html.indexOf(toc) + toc.length);
-  const entries = [...toc.matchAll(/<a href="#([^"]*)">([\s\S]*?)<\/a>/g)];
-  return entries.map(([, href, label]) => {
-    const id = decode(href);
-    let landsOn: string | null = null;
-    for (const m of body.matchAll(/<([a-zA-Z][a-zA-Z0-9]*)\b([^>]*)>/g)) {
-      const attr = m[2].match(/\sid\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i);
-      if (!attr || decode(attr[1] ?? attr[2] ?? attr[3]) !== id) continue;
-      const rest = body.slice(m.index! + m[0].length);
-      landsOn = /^h[1-3]$/i.test(m[1]) ? decode(stripTags(rest.slice(0, rest.search(new RegExp(`</${m[1]}>`, "i"))))) : `<${m[1]}>`;
-      break;
-    }
-    return { label: decode(label), landsOn };
-  });
-}
-
-describe("TOC anchors: one inventory for labels and targets (#2903)", () => {
-  test("an empty H1 does not shift the links after it", () => {
-    const { html } = render({ markdown: `#\n\n# Alpha\n\nx\n\n# Beta\n\ny\n`, toc: true });
-    const landings = tocLandings(html);
-    expect(landings.map((l) => l.label)).toEqual(["Alpha", "Beta"]);
-    for (const l of landings) expect(l.landsOn).toBe(l.label);
-  });
-
-  test("an image-only heading gets no entry and shifts nothing", () => {
-    const { html } = render({ markdown: `# ![logo](data:image/png;base64,AAAA)\n\n## Real\n\nx\n`, toc: true });
-    expect(tocLandings(html)).toEqual([{ label: "Real", landsOn: "Real" }]);
-  });
-
-  test("custom ids are kept; a user id that squats toc-N never captures a generated link", () => {
-    const md = [
-      "# Intro", "",
-      "## Plain", "",
-      `<h2 id="toc-1">Squatter</h2>`, "",
-      `<h2 id="custom">Custom</h2>`, "",
-    ].join("\n");
-    const { html } = render({ markdown: md, toc: true });
-    const landings = tocLandings(html);
-    expect(landings.map((l) => l.label)).toEqual(["Intro", "Plain", "Squatter", "Custom"]);
-    for (const l of landings) expect(l.landsOn).toBe(l.label);
-    expect(html).toContain(`<a href="#custom">Custom</a>`);
-    expect(html).toContain(`<a href="#toc-1">Squatter</a>`);
-  });
-
-  test("a duplicate id (first owner wins) gets a fresh id instead of linking to the first heading", () => {
-    const md = [`<h2 id="dup">First</h2>`, "", `<h2 id="dup">Second</h2>`, "", `<div id="taken">x</div>`, "", `<h2 id="taken">Third</h2>`, ""].join("\n");
-    const { html } = render({ markdown: md, toc: true });
-    const landings = tocLandings(html);
-    expect(landings.map((l) => l.label)).toEqual(["First", "Second", "Third"]);
-    for (const l of landings) expect(l.landsOn).toBe(l.label);
-  });
-
-  test("data-id, unquoted and empty id attributes are read as what they are", () => {
-    const md = [`<h2 data-id="z">DataId</h2>`, "", `<h2 id=bare>Bare</h2>`, "", `<h2 id="">EmptyId</h2>`, ""].join("\n");
-    const { html } = render({ markdown: md, toc: true });
-    const landings = tocLandings(html);
-    expect(landings.map((l) => l.label)).toEqual(["DataId", "Bare", "EmptyId"]);
-    for (const l of landings) expect(l.landsOn).toBe(l.label);
-    expect(html).toContain(`<a href="#bare">Bare</a>`);
-  });
-
-  test("each TOC page cell targets the same id as its link", () => {
-    const { html } = render({ markdown: `#\n\n# A\n\n<h2 id="k&amp;v">B</h2>\n`, toc: true });
-    const toc = html.match(/<section class="toc">[\s\S]*?<\/section>/)![0];
-    const hrefs = [...toc.matchAll(/href="#([^"]*)"/g)].map((m) => m[1]);
-    const cells = [...toc.matchAll(/data-toc-target="([^"]*)"/g)].map((m) => m[1]);
-    expect(cells).toEqual(hrefs);
-    expect(hrefs).toHaveLength(2);
-  });
-});

package/.agent/skills/gstack-make-pdf/test/toc-pages.test.ts

@@ -1,148 +0,0 @@
-/**
- * #2903: TOC page numbers. The PDF reader and the print loop, driven by
- * synthetic PDFs laid out the way Chromium/Skia writes them (classic xref,
- * catalog /Dests dictionary, `#xx`-escaped percent-encoded names). The real
- * browser path is make-pdf/test/e2e/toc-gate.test.ts.
- */
-import { describe, expect, test } from "bun:test";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { render } from "../src/render";
-import {
-  MAX_PRINTS,
-  TocPaginationError,
-  fillTocPages,
-  pdfDestinationPages,
-  printWithTocPages,
-  tocTargets,
-} from "../src/toc-pages";
-
-/** A minimal classic-xref PDF: `pages` leaf pages under `fanout`-wide intermediate nodes. */
-function syntheticPdf(opts: { pages: number; dests: Record<string, number>; fanout?: number }): Uint8Array {
-  const objs: string[] = [];
-  const add = (body: string) => objs.push(body) - 1 + 1; // object numbers start at 1
-  const leaf: number[] = [];
-  for (let i = 0; i < opts.pages; i++) leaf.push(add("<</Type /Page /Parent 0 0 R>>"));
-  let level = leaf;
-  const fanout = opts.fanout ?? opts.pages;
-  do {
-    const next: number[] = [];
-    for (let i = 0; i < level.length; i += fanout) {
-      const kids = level.slice(i, i + fanout);
-      next.push(add(`<</Type /Pages /Count ${kids.length} /Kids [${kids.map((k) => `${k} 0 R`).join(" ")}]>>`));
-    }
-    level = next;
-  } while (level.length > 1);
-  const destEntries = Object.entries(opts.dests).map(([name, page]) => `/${name} [${leaf[page - 1]} 0 R /XYZ 0 792 0]`);
-  const dests = add(`<<${destEntries.join("\n")}>>`);
-  const catalog = add(`<</Type /Catalog\n/Pages ${level[0]} 0 R\n/Dests ${dests} 0 R>>`);
-
-  let out = "%PDF-1.4\n%\xe2\xe3\xcf\xd3\n";
-  const offsets: number[] = [];
-  objs.forEach((body, i) => {
-    offsets.push(out.length);
-    out += `${i + 1} 0 obj\n${body}\nendobj\n`;
-  });
-  const xref = out.length;
-  out += `xref\n0 ${objs.length + 1}\n0000000000 65535 f \n`;
-  for (const o of offsets) out += `${String(o).padStart(10, "0")} 00000 n \n`;
-  out += `trailer\n<</Size ${objs.length + 1}\n/Root ${catalog} 0 R>>\nstartxref\n${xref}\n%%EOF`;
-  return Buffer.from(out, "latin1");
-}
-
-describe("pdfDestinationPages", () => {
-  test("maps each named destination to its 1-based page through a nested page tree", () => {
-    const pdf = syntheticPdf({ pages: 40, fanout: 3, dests: { "toc-0": 3, "toc-1": 17, custom: 40 } });
-    expect(Object.fromEntries(pdfDestinationPages(pdf))).toEqual({ "toc-0": 3, "toc-1": 17, custom: 40 });
-  });
-
-  test("decodes #xx name escapes and the percent-encoding Chromium applies to fragments", () => {
-    // Skia writes id="café-ü" as /caf#25C3#25A9-#25C3#25BC and id="a b" as /a#2520b.
-    const pdf = syntheticPdf({ pages: 2, dests: { "caf#25C3#25A9-#25C3#25BC": 1, "a#2520b": 2, "p#28q#29": 2 } });
-    expect(Object.fromEntries(pdfDestinationPages(pdf))).toEqual({ "café-ü": 1, "a b": 2, "p(q)": 2 });
-  });
-
-  test("a cross-reference-stream PDF fails explicitly instead of yielding no pages", () => {
-    const pdf = Buffer.from("%PDF-1.5\n1 0 obj\n<</Type /XRef>>\nendobj\nstartxref\n9\n%%EOF", "latin1");
-    expect(() => pdfDestinationPages(pdf)).toThrow(TocPaginationError);
-    expect(() => pdfDestinationPages(Buffer.from("not a pdf"))).toThrow(/could not read TOC page numbers/);
-  });
-});
-
-describe("fillTocPages / tocTargets", () => {
-  const { html } = render({ markdown: `# One\n\n## Two\n\n<h2 id="café">Three</h2>\n`, toc: true });
-
-  test("targets come from the TOC section in order; cells fill from the map, 0 when unknown", () => {
-    const targets = tocTargets(html);
-    expect(targets).toHaveLength(3);
-    expect(targets[2]).toBe("café");
-    const filled = fillTocPages(html, new Map([[targets[0], 4], [targets[2], 12]]));
-    const cells = [...filled.matchAll(/<span class="toc-page" data-toc-target="[^"]*">([^<]*)<\/span>/g)].map((m) => m[1]);
-    expect(cells).toEqual(["4", "0", "12"]);
-    // Refilling replaces, never appends.
-    const refilled = fillTocPages(filled, new Map([[targets[0], 5]]));
-    expect([...refilled.matchAll(/data-toc-target="[^"]*">([^<]*)</g)].map((m) => m[1])).toEqual(["5", "0", "0"]);
-  });
-
-  test("a look-alike span in the document body is never filled", () => {
-    const fake = `<span class="toc-page" data-toc-target="toc-0"></span>`;
-    const { html: withFake } = render({ markdown: `# One\n\n${fake}\n`, toc: true });
-    const filled = fillTocPages(withFake, new Map([["toc-0", 9]]));
-    expect(filled).toContain(fake);
-    expect(tocTargets(withFake)).toEqual(["toc-0"]);
-  });
-});
-
-describe("printWithTocPages", () => {
-  const { html } = render({ markdown: `# One\n\n## Two\n\n# Three\n`, toc: true });
-  const targets = tocTargets(html);
-  const work = () => fs.mkdtempSync(path.join(os.tmpdir(), "toc-pages-"));
-  const cellsOf = (h: string) => [...h.matchAll(/data-toc-target="[^"]*">([^<]*)</g)].map((m) => m[1]);
-
-  test("prints until the cells match the printed pages, then writes exactly that PDF", async () => {
-    const dir = work();
-    const out = path.join(dir, "out.pdf");
-    const seen: string[][] = [];
-    const layout = { [targets[0]]: 3, [targets[1]]: 3, [targets[2]]: 5 };
-    const r = await printWithTocPages(html, out, async (h, o) => {
-      seen.push(cellsOf(h));
-      fs.writeFileSync(o, syntheticPdf({ pages: 6, dests: layout }));
-      return "browse" as const;
-    });
-    expect(r).toBe("browse");
-    expect(seen).toEqual([["0", "0", "0"], ["3", "3", "5"]]);
-    expect(Object.fromEntries(pdfDestinationPages(fs.readFileSync(out)))).toEqual(layout);
-    expect(fs.readdirSync(dir)).toEqual(["out.pdf"]);
-  });
-
-  test("numbers that keep moving fail after MAX_PRINTS and leave no output", async () => {
-    const dir = work();
-    const out = path.join(dir, "out.pdf");
-    let n = 0;
-    const p = printWithTocPages(html, out, async (_h, o) => {
-      n++;
-      fs.writeFileSync(o, syntheticPdf({ pages: 10, dests: Object.fromEntries(targets.map((t) => [t, n])) }));
-    });
-    await expect(p).rejects.toThrow(/did not settle after 3 prints/);
-    expect(n).toBe(MAX_PRINTS);
-    expect(fs.readdirSync(dir)).toEqual([]);
-  });
-
-  test("a TOC target with no PDF destination fails and names the target", async () => {
-    const dir = work();
-    const p = printWithTocPages(html, path.join(dir, "out.pdf"), async (_h, o) => {
-      fs.writeFileSync(o, syntheticPdf({ pages: 3, dests: { [targets[0]]: 2 } }));
-    });
-    await expect(p).rejects.toThrow(new RegExp(`no destination for TOC target\\(s\\) #${targets[1]}, #${targets[2]}`));
-    expect(fs.readdirSync(dir)).toEqual([]);
-  });
-
-  test("a document without TOC entries prints once, straight to the output", async () => {
-    const plain = render({ markdown: `#\n\nno headings with text\n`, toc: true }).html;
-    const outs: string[] = [];
-    await printWithTocPages(plain, "/nowhere/out.pdf", async (_h, o) => { outs.push(o); });
-    expect(outs).toEqual(["/nowhere/out.pdf"]);
-  });
-});