@amg555/frameforge-mcp 2.7.6 → 2.7.8

package/.agent/skills/gstack-make-pdf/src/orchestrator.ts

@@ -1,339 +0,0 @@
-/**
- * Orchestrator — ties render, the diagram pre-pass, asideClient, and the
- * filesystem together.
- *
- *   generate(opts): markdown → PDF on disk. Returns output path.
- *   preview(opts):  markdown → HTML, opens it in a browser.
- *
- * Progress indication (per DX spec):
- *   - stdout: ONLY the output path, printed by cli.ts after this returns.
- *   - stderr: spinner + per-stage status lines, unless opts.quiet.
- *   - --verbose: stage timings.
- *
- * Every browser step is its own lib/aside-render `render()` call (an Aside
- * script when Aside is running, otherwise a tab in gstack's own headless
- * browser; nothing persists between them): one batch for diagram fences, one
- * for oversized-image downscales, one for DOCX rasters, one print. Parallel
- * $P generate calls never share state.
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { spawn } from "node:child_process";
-
-import { render } from "./render";
-import { screenCss } from "./print-css";
-import type { GenerateOptions, PreviewOptions } from "./types";
-import { ExitCode } from "./types";
-import { pickEngine } from "../../lib/aside-render";
-import { renderPdf } from "./asideClient";
-import { printWithTocPages } from "./toc-pages";
-import {
-  bundleRunner,
-  contentWidthInches,
-  convertDiagnosticsForDocx,
-  extractDiagramFences,
-  inlineLocalImages,
-  landscapeContentBox,
-  rasterizeDiagramFigures,
-  renderFenceSlots,
-  substituteSlots,
-} from "./diagram-prepass";
-import { applyImagePolicy } from "./image-policy";
-
-/** Default output location (`$P generate letter.md` → /tmp/letter.pdf). */
-export const OUTPUT_TMP_DIR = process.platform === "win32" ? os.tmpdir() : "/tmp";
-
-class ProgressReporter {
-  private readonly quiet: boolean;
-  private readonly verbose: boolean;
-  private readonly stageStart = new Map<string, number>();
-  private readonly totalStart: number;
-  constructor(opts: { quiet?: boolean; verbose?: boolean }) {
-    this.quiet = opts.quiet === true;
-    this.verbose = opts.verbose === true;
-    this.totalStart = Date.now();
-  }
-  begin(stage: string): void {
-    this.stageStart.set(stage, Date.now());
-    if (this.quiet) return;
-    process.stderr.write(`\r\x1b[K${stage}...`);
-  }
-  end(stage: string, extra?: string): void {
-    const start = this.stageStart.get(stage) ?? Date.now();
-    const ms = Date.now() - start;
-    if (this.quiet) return;
-    if (this.verbose) {
-      process.stderr.write(`\r\x1b[K${stage} (${ms}ms)${extra ? ` — ${extra}` : ""}\n`);
-    }
-  }
-  done(extra: string): void {
-    if (this.quiet) return;
-    const total = ((Date.now() - this.totalStart) / 1000).toFixed(1);
-    process.stderr.write(`\r\x1b[KDone in ${total}s. ${extra}\n`);
-  }
-  fail(stage: string, err: Error): void {
-    if (!this.quiet) process.stderr.write("\r\x1b[K");
-    // Always emit failure info, even in quiet mode — this is an error path.
-    process.stderr.write(`${stage} failed: ${err.message}\n`);
-  }
-}
-
-/**
- * generate — full pipeline. Returns the output PDF path on success.
- */
-export async function generate(opts: GenerateOptions): Promise<string> {
-  const progress = new ProgressReporter(opts);
-  const input = path.resolve(opts.input);
-
-  if (!fs.existsSync(input)) {
-    throw new Error(`input file not found: ${input}`);
-  }
-
-  const to = opts.to ?? "pdf";
-  const outputPath = path.resolve(
-    opts.output ?? path.join(OUTPUT_TMP_DIR, `${deriveSlug(input)}.${to}`),
-  );
-
-  // Stage 1: read markdown
-  progress.begin("Reading markdown");
-  const markdown = fs.readFileSync(input, "utf8");
-  progress.end("Reading markdown");
-
-  // Stage 1.5: diagram pre-pass — extract ```mermaid/```excalidraw fences and
-  // swap in placeholder tokens. Rendering happens in Stage 2.5 below.
-  const extraction = extractDiagramFences(markdown);
-
-  // Stage 2: render HTML
-  progress.begin("Rendering HTML");
-  const rendered = render({
-    markdown: extraction.markdown,
-    title: opts.title,
-    author: opts.author,
-    date: opts.date,
-    cover: opts.cover,
-    toc: opts.toc,
-    watermark: opts.watermark,
-    noChapterBreaks: opts.noChapterBreaks,
-    confidential: opts.confidential,
-    pageSize: opts.pageSize,
-    margins: opts.margins,
-    marginTop: opts.marginTop,
-    marginRight: opts.marginRight,
-    marginBottom: opts.marginBottom,
-    marginLeft: opts.marginLeft,
-    pageNumbers: opts.pageNumbers,
-    footerTemplate: opts.footerTemplate,
-  });
-  progress.end("Rendering HTML", `${rendered.meta.wordCount} words`);
-
-  // Stage 2.5: render diagram fences through the bundle, substitute slots,
-  // then inline + probe + (if oversized) downscale local images. The runner
-  // resolves the bundle lazily, so image-only documents never touch it; a
-  // missing bundle or missing browser surfaces per fence as a diagnostic block.
-  const warn = (msg: string) => {
-    if (!opts.quiet) process.stderr.write(`\r\x1b[K[make-pdf] warning: ${msg}\n`);
-  };
-  const run = bundleRunner();
-  let hasLandscape = false;
-
-  let finalHtml = rendered.html;
-  if (extraction.fences.length > 0) {
-    progress.begin(`Rendering ${extraction.fences.length} diagram(s)`);
-    finalHtml = substituteSlots(finalHtml, await renderFenceSlots(extraction.fences, run, warn));
-    progress.end(`Rendering ${extraction.fences.length} diagram(s)`);
-  }
-
-  progress.begin("Inlining images");
-  const contentWidthIn = contentWidthInches(opts);
-  finalHtml = await inlineLocalImages(finalHtml, {
-    inputDir: path.dirname(input),
-    strict: opts.strict === true,
-    allowNetwork: opts.allowNetwork === true,
-    contentWidthIn,
-    warn,
-    run,
-  });
-  progress.end("Inlining images");
-
-  // Width directives + conservative auto-landscape (image-policy).
-  const policy = applyImagePolicy(finalHtml, {
-    contentWidthIn,
-    landscape: landscapeContentBox(opts),
-    warn,
-  });
-  finalHtml = policy.html;
-  hasLandscape = policy.hasLandscape;
-
-  // DOCX needs rasters, not inline SVG (Word's SVG support is unreliable).
-  if (to === "docx") {
-    if (/<figure class="diagram"|data:image\/svg\+xml/.test(finalHtml)) {
-      progress.begin("Rasterizing diagrams for DOCX");
-      finalHtml = await rasterizeDiagramFigures(finalHtml, run, contentWidthIn, warn);
-      progress.end("Rasterizing diagrams for DOCX");
-    }
-    finalHtml = convertDiagnosticsForDocx(finalHtml);
-  }
-
-  // ─── --to html: write the self-contained document, no print round-trip ──
-  if (to === "html") {
-    const withScreenLayer = finalHtml.replace(
-      "</style>",
-      `</style>\n<style>\n${screenCss()}\n</style>`,
-    );
-    fs.writeFileSync(outputPath, withScreenLayer, "utf8");
-    const kb = Math.round(fs.statSync(outputPath).size / 1024);
-    progress.done(`${rendered.meta.wordCount} words · ${kb}KB · ${outputPath}`);
-    return outputPath;
-  }
-
-  // ─── --to docx: content-fidelity conversion (eng-review P8) ────────────
-  if (to === "docx") {
-    // Print-only surfaces don't survive the conversion. The watermark div
-    // would degrade to a literal body paragraph reading "DRAFT" (worse than
-    // absent) — strip it. Warn once about print-only flags that were set.
-    finalHtml = finalHtml.replace(/<div class="watermark">[\s\S]*?<\/div>/, "");
-    const printOnly: string[] = [];
-    if (opts.watermark) printOnly.push("--watermark");
-    if (opts.headerTemplate) printOnly.push("--header-template");
-    if (opts.footerTemplate) printOnly.push("--footer-template");
-    if (opts.pageSize) printOnly.push("--page-size");
-    if (opts.margins || opts.marginTop || opts.marginRight || opts.marginBottom || opts.marginLeft) printOnly.push("--margins");
-    if (printOnly.length > 0) {
-      warn(`docx is content-fidelity: ${printOnly.join(", ")} do not apply to Word output`);
-    }
-    progress.begin("Converting to DOCX");
-    const { default: HTMLtoDOCX } = await import("html-to-docx");
-    const buf = await HTMLtoDOCX(finalHtml, null, {
-      title: rendered.meta.title,
-      creator: rendered.meta.author || undefined,
-    });
-    const bytes: Uint8Array = buf instanceof Uint8Array ? buf : new Uint8Array(await (buf as Blob).arrayBuffer());
-    fs.writeFileSync(outputPath, bytes);
-    progress.end("Converting to DOCX");
-    const kb = Math.round(fs.statSync(outputPath).size / 1024);
-    progress.done(`${rendered.meta.wordCount} words · ${kb}KB · ${outputPath} (content fidelity — layout is Word's)`);
-    return outputPath;
-  }
-
-  // Stage 3: print — serve the staged HTML over loopback and print through
-  // whichever browser is up. With --toc, toc-pages.ts prints until the TOC's
-  // page-number cells match the pages the PDF itself puts each heading on.
-  const engine = pickEngine().engine;
-  const via = engine === "aside" ? "Aside" : engine === "browse" ? "gstack's browser" : "a browser";
-  progress.begin(`Rendering PDF through ${via}`);
-  const print = (html: string, out: string) => renderPdf(html, {
-    output: out,
-    format: opts.pageSize ?? "letter",
-    marginTop: opts.marginTop ?? opts.margins ?? "1in",
-    marginRight: opts.marginRight ?? opts.margins ?? "1in",
-    marginBottom: opts.marginBottom ?? opts.margins ?? "1in",
-    marginLeft: opts.marginLeft ?? opts.margins ?? "1in",
-    headerTemplate: opts.headerTemplate,
-    footerTemplate: opts.footerTemplate,
-    // CSS is the single source of truth for page numbers (see print-css.ts
-    // @bottom-center). Chromium's native numbering always off to avoid double
-    // footers. The CSS layer honors pageNumbers + footerTemplate via render().
-    pageNumbers: false,
-    tagged: opts.tagged !== false,
-    outline: opts.outline !== false,
-    printBackground: !!opts.watermark,
-    // Named landscape pages only take effect when Chromium honors CSS page
-    // sizes. Flip it ONLY when a promotion exists — minimal behavior change
-    // for every other document.
-    preferCSSPageSize: hasLandscape ? true : undefined,
-  });
-  const used = opts.toc
-    ? await printWithTocPages(finalHtml, outputPath, print)
-    : await print(finalHtml, outputPath);
-  progress.end(`Rendering PDF through ${via}`);
-  if (used && used !== engine) {
-    // render() fell back mid-run (Aside quit or its CLI could not start): say
-    // which browser actually produced the file, since the label above was
-    // decided before the render.
-    process.stderr.write("  Aside was unavailable mid-run; the PDF was rendered through gstack's own browser.\n");
-  }
-
-  const kb = Math.round(fs.statSync(outputPath).size / 1024);
-  progress.done(`${rendered.meta.wordCount} words · ${kb}KB · ${outputPath}`);
-
-  return outputPath;
-}
-
-/**
- * preview — render HTML and open it. No PDF round trip.
- */
-export async function preview(opts: PreviewOptions): Promise<string> {
-  const progress = new ProgressReporter(opts);
-  const input = path.resolve(opts.input);
-  if (!fs.existsSync(input)) {
-    throw new Error(`input file not found: ${input}`);
-  }
-
-  progress.begin("Rendering HTML");
-  const markdown = fs.readFileSync(input, "utf8");
-  // Preview deliberately skips the diagram/image pre-pass (no browser
-  // round-trip — preview is the fast loop). Be loud about the divergence so
-  // nobody signs off on a preview that lacks what the PDF will have.
-  if (!opts.quiet) {
-    const fenceCount = extractDiagramFences(markdown).fences.length;
-    const hasLocalImages = /!\[[^\]]*\]\((?!https?:|data:)[^)]+\)/.test(markdown);
-    if (fenceCount > 0 || hasLocalImages) {
-      process.stderr.write(
-        `[make-pdf] preview note: ${fenceCount > 0 ? `${fenceCount} diagram fence(s) shown as code` : ""}` +
-        `${fenceCount > 0 && hasLocalImages ? "; " : ""}` +
-        `${hasLocalImages ? "local images may not resolve from the preview location" : ""}` +
-        ` — \`generate\` renders them fully.\n`,
-      );
-    }
-  }
-  const rendered = render({
-    markdown,
-    title: opts.title,
-    author: opts.author,
-    date: opts.date,
-    cover: opts.cover,
-    toc: opts.toc,
-    watermark: opts.watermark,
-    noChapterBreaks: opts.noChapterBreaks,
-    confidential: opts.confidential,
-    pageNumbers: opts.pageNumbers,
-  });
-  progress.end("Rendering HTML", `${rendered.meta.wordCount} words`);
-
-  // Write to a stable path under /tmp so the user can reload in the same tab.
-  const previewPath = path.join(OUTPUT_TMP_DIR, `make-pdf-preview-${deriveSlug(input)}.html`);
-  fs.writeFileSync(previewPath, rendered.html, "utf8");
-
-  progress.begin("Opening preview");
-  tryOpen(previewPath);
-  progress.end("Opening preview");
-
-  progress.done(`Preview at ${previewPath}`);
-  return previewPath;
-}
-
-// ─── helpers ──────────────────────────────────────────────
-
-function deriveSlug(p: string): string {
-  const base = path.basename(p).replace(/\.[^.]+$/, "");
-  return base.replace(/[^a-zA-Z0-9-_]+/g, "-").slice(0, 64) || "document";
-}
-
-function tryOpen(pathOrUrl: string): void {
-  const platform = process.platform;
-  const cmd = platform === "darwin" ? "open" :
-              platform === "win32" ? "cmd" :
-              "xdg-open";
-  const args = platform === "win32" ? ["/c", "start", "", pathOrUrl] : [pathOrUrl];
-  try {
-    const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
-    child.unref();
-  } catch {
-    // Non-fatal; the caller already has the path and will print it.
-  }
-}
-
-/** Setup-only re-export so cli.ts can dynamic-import without another file. */
-export { ExitCode };

package/.agent/skills/gstack-make-pdf/src/pdftotext.ts

@@ -1,318 +0,0 @@
-/**
- * pdftotext wrapper — the tool behind the copy-paste CI gate.
- *
- * Codex round 2 surfaced two real problems we address here:
- *
- *   #18: pdftotext (Poppler) vs pdftotext (Xpdf) vs pdftotext-next vary on
- *        whitespace, line wrap, Unicode normalization, form feeds, and
- *        extraction order. Cross-platform exact diffing is a non-starter.
- *        We normalize aggressively and diff the normalized form.
- *
- *   #19: the regex /(?:\b\w\s){4,}/ only catches one failure shape (letters
- *        spaced out). It misses word-order corruption, missing whitespace
- *        between paragraphs, and homoglyph substitution. We add a word-token
- *        diff and a paragraph-boundary assertion on top.
- *
- * Resolution order for the pdftotext binary (v1.24-aligned):
- *   1. $GSTACK_PDFTOTEXT_BIN env override (preferred, matches v1.24 GSTACK_*_BIN pattern)
- *   2. $PDFTOTEXT_BIN env override (back-compat alias)
- *   3. PATH lookup via Bun.which('pdftotext') — handles Windows PATHEXT natively
- *   4. standard POSIX paths (Homebrew + distro) — no Windows candidates because
- *      Poppler scatters across Scoop / Chocolatey / oschwartz10612-poppler-windows
- *      and guessing causes false positives. Set GSTACK_PDFTOTEXT_BIN explicitly.
- *   5. throws a friendly "install poppler" error
- *
- * The wrapper is *optional at runtime*: production renders don't need it.
- * Only the CI gate and unit tests invoke pdftotext.
- */
-
-import { execFileSync, spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-export class PdftotextUnavailableError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "PdftotextUnavailableError";
-  }
-}
-
-export interface PdftotextInfo {
-  bin: string;
-  version: string;        // "pdftotext version 24.02.0" or similar
-  flavor: "poppler" | "xpdf" | "unknown";
-}
-
-/**
- * Probe a base path for executability, honoring Windows extension suffixes.
- */
-export function findExecutable(base: string): string | null {
-  if (isExecutable(base)) return base;
-  if (process.platform === "win32") {
-    for (const ext of [".exe", ".cmd", ".bat"]) {
-      const withExt = base + ext;
-      if (isExecutable(withExt)) return withExt;
-    }
-  }
-  return null;
-}
-
-function resolveOverride(value: string | undefined, env: NodeJS.ProcessEnv): string | null {
-  if (!value?.trim()) return null;
-  const trimmed = value.trim().replace(/^"(.*)"$/, '$1');
-  if (path.isAbsolute(trimmed)) return findExecutable(trimmed);
-  const PATH = env.PATH ?? env.Path ?? '';
-  return Bun.which(trimmed, { PATH }) ?? null;
-}
-
-/**
- * Locate pdftotext. Throws PdftotextUnavailableError if none is found.
- */
-export function resolvePdftotext(env: NodeJS.ProcessEnv = process.env): PdftotextInfo {
-  // 1 + 2: env overrides (GSTACK_PDFTOTEXT_BIN preferred, PDFTOTEXT_BIN back-compat).
-  const overrideRaw = env.GSTACK_PDFTOTEXT_BIN ?? env.PDFTOTEXT_BIN;
-  const override = resolveOverride(overrideRaw, env);
-  if (override) return describeBinary(override);
-
-  // 3: PATH lookup via Bun.which — handles Windows PATHEXT natively.
-  const PATH = env.PATH ?? env.Path ?? '';
-  const onPath = Bun.which('pdftotext', { PATH });
-  if (onPath) return describeBinary(onPath);
-
-  // 4: POSIX-only standard locations. No Windows candidates — Poppler installs
-  // scatter across Scoop/Chocolatey/portable zips and guessing causes false
-  // positives. Windows users set GSTACK_PDFTOTEXT_BIN explicitly.
-  const posixCandidates = [
-    "/opt/homebrew/bin/pdftotext",     // Apple Silicon Homebrew
-    "/usr/local/bin/pdftotext",        // Intel Mac or Linuxbrew
-    "/usr/bin/pdftotext",              // distro package
-  ];
-  for (const candidate of posixCandidates) {
-    if (isExecutable(candidate)) return describeBinary(candidate);
-  }
-
-  throw new PdftotextUnavailableError([
-    "pdftotext not found.",
-    "",
-    "make-pdf needs pdftotext to run the copy-paste CI gate.",
-    "(Runtime rendering does NOT need it. This only affects tests.)",
-    "",
-    "To install:",
-    "  macOS:    brew install poppler",
-    "  Ubuntu:   sudo apt-get install poppler-utils",
-    "  Fedora:   sudo dnf install poppler-utils",
-    "  Windows:  scoop install poppler  (or download from",
-    "            https://github.com/oschwartz10612/poppler-windows)",
-    "",
-    "Or set GSTACK_PDFTOTEXT_BIN to an explicit path:",
-    process.platform === "win32"
-      ? '  setx GSTACK_PDFTOTEXT_BIN "C:\\path\\to\\pdftotext.exe"'
-      : "  export GSTACK_PDFTOTEXT_BIN=/path/to/pdftotext",
-  ].join("\n"));
-}
-
-/**
- * Locate a poppler companion tool (pdffonts, pdfimages, pdftoppm, pdfinfo,
- * pdftotext) used by the e2e render gates. Mirrors resolvePdftotext's resolution order:
- *   1. $GSTACK_<TOOL>_BIN env override (e.g. GSTACK_PDFFONTS_BIN)
- *   2. PATH via Bun.which
- *   3. standard POSIX locations (Homebrew + distro)
- *
- * Returns null (does NOT throw) when the tool is missing — the emoji gate skips
- * cleanly rather than failing on a box without full poppler-utils.
- */
-export function resolvePopplerTool(
-  tool: "pdffonts" | "pdfimages" | "pdftoppm" | "pdfinfo" | "pdftotext",
-  env: NodeJS.ProcessEnv = process.env,
-): string | null {
-  const override = resolveOverride(env[`GSTACK_${tool.toUpperCase()}_BIN`], env);
-  if (override) return override;
-
-  const PATH = env.PATH ?? env.Path ?? "";
-  const onPath = Bun.which(tool, { PATH });
-  if (onPath) return onPath;
-
-  for (const dir of ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin"]) {
-    const candidate = findExecutable(path.join(dir, tool));
-    if (candidate) return candidate;
-  }
-  return null;
-}
-
-function isExecutable(p: string): boolean {
-  try {
-    // access(X_OK) is true for directories (the traverse bit); only regular files count.
-    if (!fs.statSync(p).isFile()) return false;
-    fs.accessSync(p, fs.constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function describeBinary(bin: string): PdftotextInfo {
-  let version = "unknown";
-  let flavor: PdftotextInfo["flavor"] = "unknown";
-
-  // spawnSync, not execFileSync: poppler writes -v output to STDERR and exits 0,
-  // so execFileSync neither returns it (it returns stdout, which is empty) nor
-  // throws (which is what made the stderr fallback below reachable). The result
-  // was version="unknown" flavor="unknown" on every poppler install. spawnSync
-  // hands back both streams regardless of exit status, which also covers the
-  // xpdf builds that exit 99.
-  const res = spawnSync(bin, ["-v"], { encoding: "utf8" });
-  const raw = `${res.stdout ?? ""}\n${res.stderr ?? ""}`;
-
-  // The version banner is not reliably the first line once both streams are in
-  // play, so match it rather than taking line 0.
-  const lines = raw.split("\n").map(l => l.trim()).filter(Boolean);
-  version = lines.find(l => /pdftotext\s+version/i.test(l)) ?? lines[0] ?? "unknown";
-
-  // Flavor comes from the WHOLE banner, never the version line alone: poppler
-  // prints "pdftotext version 26.06.0" on line 1 and only identifies itself on
-  // line 2, "Copyright ... The Poppler Developers".
-  const v = raw.toLowerCase();
-  if (v.includes("poppler")) flavor = "poppler";
-  else if (v.includes("xpdf")) flavor = "xpdf";
-  return { bin, version, flavor };
-}
-
-/**
- * Run pdftotext on a PDF and return the extracted text.
- *
- * Uses `-layout` by default because that's what downstream normalization
- * expects. Callers that need raw text can pass layout=false.
- */
-export function pdftotext(pdfPath: string, opts?: { layout?: boolean }): string {
-  const info = resolvePdftotext();
-  const layout = opts?.layout ?? true;
-  const args: string[] = [];
-  if (layout) args.push("-layout");
-  args.push(pdfPath, "-");   // "-" = stdout
-  try {
-    return execFileSync(info.bin, args, {
-      encoding: "utf8",
-      maxBuffer: 32 * 1024 * 1024,
-    });
-  } catch (err: any) {
-    throw new Error(`pdftotext failed on ${pdfPath}: ${err.message}`);
-  }
-}
-
-/**
- * Normalize extracted text for cross-platform, cross-flavor diffing.
- *
- * What we strip / normalize:
- *   - Unicode: NFC canonical composition (macOS emits NFD; Linux emits NFC;
- *     this dodges the fundamental encoding diff).
- *   - CR and CRLF → LF (Windows Xpdf emits CRLF).
- *   - Form feeds (\f) → double newline (Poppler emits \f at page breaks).
- *   - Trailing spaces on every line.
- *   - Runs of 3+ blank lines → 2 blank lines.
- *   - Leading/trailing whitespace on the whole string.
- *   - Non-breaking space (U+00A0) → regular space.
- *   - Zero-width space (U+200B) and zero-width non-joiner (U+200C) → empty.
- *   - Soft hyphen (U+00AD) → empty (pdftotext -layout sometimes emits these
- *     for hyphens: auto breaks).
- */
-export function normalize(raw: string): string {
-  let s = raw;
-  s = s.normalize("NFC");
-  s = s.replace(/\r\n/g, "\n");
-  s = s.replace(/\r/g, "\n");
-  s = s.replace(/\f/g, "\n\n");
-  s = s.replace(/\u00a0/g, " ");
-  s = s.replace(/[\u200b\u200c\u00ad]/g, "");
-  s = s.replace(/[ \t]+$/gm, "");
-  s = s.replace(/\n{3,}/g, "\n\n");
-  s = s.trim();
-  return s;
-}
-
-/**
- * The canonical copy-paste gate used in the E2E tests.
- *
- * Returns { ok: true } when all three assertions pass; returns
- * { ok: false, reasons: [...] } with one or more failure reasons otherwise.
- */
-export interface GateResult {
-  ok: boolean;
-  reasons: string[];
-  extracted: string;
-}
-
-export function copyPasteGate(pdfPath: string, expected: string): GateResult {
-  const extracted = normalize(pdftotext(pdfPath, { layout: true }));
-  const expectedNorm = normalize(expected);
-  const reasons: string[] = [];
-
-  // Assertion 1: every expected paragraph appears as a whole line or
-  // contiguous block in the extracted text.
-  const expectedParagraphs = splitParagraphs(expectedNorm);
-  for (const paragraph of expectedParagraphs) {
-    const compact = collapseWhitespace(paragraph);
-    const extractedCompact = collapseWhitespace(extracted);
-    if (!extractedCompact.includes(compact)) {
-      reasons.push(
-        `expected paragraph not found in extracted text: ${truncate(paragraph, 80)}`,
-      );
-    }
-  }
-
-  // Assertion 2: no "S a i l i n g"-style single-char runs.
-  // Count groups of 4+ consecutive letter-then-space tokens. False positive
-  // risk on things like "A B C D" (initials) — mitigate by requiring the
-  // letters spell a known-word substring of the expected text.
-  const fragRegex = /((?:\b\w\s){4,})/g;
-  let fragMatch: RegExpExecArray | null;
-  while ((fragMatch = fragRegex.exec(extracted)) !== null) {
-    const letters = fragMatch[1].replace(/\s/g, "");
-    // Only flag if the reassembled letters appear in the expected text.
-    if (expectedNorm.toLowerCase().includes(letters.toLowerCase()) && letters.length >= 4) {
-      reasons.push(
-        `per-glyph emission detected (the "S ai li ng" bug): "${fragMatch[1].trim()}" reassembles to "${letters}"`,
-      );
-    }
-  }
-
-  // Assertion 3: paragraph boundaries preserved. Count double-newlines
-  // in both; they should differ by no more than ±2 (header/footer noise).
-  const expectedBreaks = (expectedNorm.match(/\n\n/g) || []).length;
-  const extractedBreaks = (extracted.match(/\n\n/g) || []).length;
-  if (Math.abs(expectedBreaks - extractedBreaks) > 4) {
-    reasons.push(
-      `paragraph boundary count drift: expected ~${expectedBreaks}, got ${extractedBreaks}`,
-    );
-  }
-
-  return { ok: reasons.length === 0, reasons, extracted };
-}
-
-function splitParagraphs(s: string): string[] {
-  return s.split(/\n\n+/).map(p => p.trim()).filter(p => p.length > 0);
-}
-
-function collapseWhitespace(s: string): string {
-  return s.replace(/\s+/g, " ").trim();
-}
-
-function truncate(s: string, n: number): string {
-  return s.length > n ? s.slice(0, n) + "..." : s;
-}
-
-/**
- * Emit diagnostic info to stderr — useful for CI failure debugging.
- * Call this once before running any gate in a CI log.
- */
-export function logDiagnostics(): void {
-  try {
-    const info = resolvePdftotext();
-    process.stderr.write(
-      `[pdftotext] bin=${info.bin} flavor=${info.flavor} version="${info.version}" ` +
-      `os=${os.platform()}-${os.arch()} node=${process.version}\n`,
-    );
-  } catch (err: any) {
-    process.stderr.write(`[pdftotext] unavailable: ${err.message}\n`);
-  }
-}