@lupinum/nuxt-pdf 0.3.0

package/dist/test.mjs

@@ -0,0 +1,696 @@
+import { createRequire } from 'node:module';
+import { defineComponent, h } from 'vue';
+import { normalizeRemoteAssetPolicy } from '../dist/runtime/server/assets/remote.js';
+import { createPdfTemplate } from '../dist/runtime/server/registry.js';
+import { normalizePdfLimits, resolvePdfRenderLimits } from '../dist/runtime/server/render-limits.js';
+import { PDF_DEFINITION_PROPERTY } from '../dist/runtime/shared/template.js';
+import { Buffer } from 'node:buffer';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile, rm, readFile, readdir } from 'node:fs/promises';
+import { resolve, dirname, join, relative, basename } from 'node:path';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+import { t as templateKeyFromRelativePath, b as discoverPdfImageFiles, c as bundlePdfFonts, g as compilePdfSfc } from './shared/nuxt-pdf.D2ZziYn4.mjs';
+import { loadPdfImageAsset } from '../dist/runtime/server/assets/resolve-asset.js';
+import '@vue/compiler-sfc';
+import '@jridgewell/remapping';
+import 'unimport';
+
+const DEFAULT_CHANNEL_THRESHOLD = 25;
+const DEFAULT_MAX_CHANGED_PIXEL_RATIO = 5e-3;
+const require_ = createRequire(import.meta.url);
+let pdfJsPromise;
+let canvasModule;
+const missingPeerMessage = (name) => `@lupinum/nuxt-pdf/test needs the optional peer dependency "${name}", which is not installed. Install it in the project under test, e.g. \`pnpm add -D ${name}\`.`;
+const isModuleNotFound = (error) => typeof error === "object" && error !== null && "code" in error && (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND");
+function loadCanvas() {
+  if (canvasModule) return canvasModule;
+  try {
+    canvasModule = require_("@napi-rs/canvas");
+  } catch (error) {
+    if (isModuleNotFound(error)) {
+      throw new Error(missingPeerMessage("@napi-rs/canvas"), { cause: error });
+    }
+    throw error;
+  }
+  return canvasModule;
+}
+class NapiCanvasFactory {
+  create(width, height) {
+    const canvas = loadCanvas().createCanvas(width, height);
+    return {
+      canvas,
+      context: canvas.getContext("2d")
+    };
+  }
+  reset(canvasAndContext, width, height) {
+    canvasAndContext.canvas.width = width;
+    canvasAndContext.canvas.height = height;
+  }
+  destroy(canvasAndContext) {
+    canvasAndContext.canvas.width = 0;
+    canvasAndContext.canvas.height = 0;
+  }
+}
+function installPdfCanvasGlobals() {
+  const { DOMMatrix, ImageData, Path2D } = loadCanvas();
+  const globals = globalThis;
+  globals.DOMMatrix ??= DOMMatrix;
+  globals.ImageData ??= ImageData;
+  globals.Path2D ??= Path2D;
+}
+function normalizePdfText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+async function toPdfBytes(input) {
+  if (input instanceof Uint8Array) return input;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (typeof input === "object" && input !== null && "toUint8Array" in input && typeof input.toUint8Array === "function") {
+    return input.toUint8Array();
+  }
+  throw new TypeError(
+    "parsePdf expected PDF bytes (Uint8Array/ArrayBuffer) or a PdfRenderResult."
+  );
+}
+const simplifyOutline = (items) => items.map((item) => {
+  const children = Array.isArray(item.items) ? simplifyOutline(item.items) : [];
+  return {
+    title: typeof item.title === "string" ? item.title : "",
+    ...children.length === 0 ? {} : { expanded: typeof item.count === "number" && item.count > 0 },
+    children
+  };
+});
+const flattenLinks = (pages) => pages.flatMap(
+  (page) => page.annotations.filter((annotation) => annotation.subtype === "Link").map((annotation) => {
+    const destination = typeof annotation.destination === "string" ? annotation.destination : void 0;
+    return {
+      page: page.number,
+      ...destination === void 0 ? {} : { destination },
+      ...annotation.url === void 0 ? {} : { url: annotation.url }
+    };
+  })
+);
+async function parsePdf(input) {
+  return withPdfDocument(await toPdfBytes(input), async (document) => {
+    const pages = [];
+    for (let pageNumber = 1; pageNumber <= document.numPages; pageNumber += 1) {
+      const page = await document.getPage(pageNumber);
+      try {
+        const textContent = await page.getTextContent();
+        const textItems = textContent.items.flatMap((item) => "str" in item ? [item.str] : []);
+        const textRuns = textContent.items.flatMap((item) => {
+          if (!("str" in item)) return [];
+          const [scaleX = 0, scaleY = 0, , , x = 0, y = 0] = item.transform;
+          return [{
+            direction: item.dir,
+            fontName: item.fontName,
+            fontSize: roundCoordinate(Math.hypot(scaleX, scaleY)),
+            height: roundCoordinate(item.height),
+            text: item.str,
+            width: roundCoordinate(item.width),
+            x: roundCoordinate(x),
+            y: roundCoordinate(y)
+          }];
+        });
+        const rawText = textContent.items.flatMap((item) => "str" in item ? [item.str, item.hasEOL ? "\n" : ""] : []).join("");
+        const annotations = (await page.getAnnotations({ intent: "display" })).map(normalizeAnnotation);
+        const viewport = page.getViewport({ scale: 1 });
+        pages.push({
+          annotations,
+          height: roundCoordinate(viewport.height),
+          number: pageNumber,
+          rawText,
+          text: normalizePdfText(rawText),
+          textItems,
+          textRuns,
+          width: roundCoordinate(viewport.width)
+        });
+      } finally {
+        page.cleanup();
+      }
+    }
+    const outline = await document.getOutline();
+    return {
+      pageCount: document.numPages,
+      pages,
+      links: flattenLinks(pages),
+      outline: outline ? simplifyOutline(outline) : []
+    };
+  });
+}
+async function rasterizePdf(input, options = {}) {
+  const scale = options.scale ?? 1;
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new RangeError("PDF raster scale must be a finite number greater than zero");
+  }
+  const { createCanvas } = loadCanvas();
+  return withPdfDocument(await toPdfBytes(input), async (document) => {
+    const images = [];
+    for (let pageNumber = 1; pageNumber <= document.numPages; pageNumber += 1) {
+      const page = await document.getPage(pageNumber);
+      try {
+        const viewport = page.getViewport({ scale });
+        const width = Math.ceil(viewport.width);
+        const height = Math.ceil(viewport.height);
+        const canvas = createCanvas(width, height);
+        const context = canvas.getContext("2d");
+        await page.render({
+          background: options.background ?? "#ffffff",
+          canvas: null,
+          canvasContext: context,
+          viewport
+        }).promise;
+        images.push({
+          height,
+          number: pageNumber,
+          pixels: new Uint8ClampedArray(context.getImageData(0, 0, width, height).data),
+          png: new Uint8Array(canvas.encodeSync("png")),
+          width
+        });
+      } finally {
+        page.cleanup();
+      }
+    }
+    return images;
+  });
+}
+async function decodePngPage(data, number) {
+  if (!Number.isInteger(number) || number < 1) {
+    throw new RangeError("PNG page number must be a positive integer");
+  }
+  const { createCanvas, loadImage } = loadCanvas();
+  const png = copyPdfData(data);
+  const image = await loadImage(png);
+  const canvas = createCanvas(image.width, image.height);
+  const context = canvas.getContext("2d");
+  context.drawImage(image, 0, 0);
+  return {
+    height: image.height,
+    number,
+    pixels: new Uint8ClampedArray(
+      context.getImageData(0, 0, image.width, image.height).data
+    ),
+    png,
+    width: image.width
+  };
+}
+function encodePngPage(image) {
+  assertPageImage(image, "encoded");
+  const { createCanvas } = loadCanvas();
+  const canvas = createCanvas(image.width, image.height);
+  const context = canvas.getContext("2d");
+  const data = context.createImageData(image.width, image.height);
+  data.data.set(image.pixels);
+  context.putImageData(data, 0, 0);
+  return new Uint8Array(canvas.encodeSync("png"));
+}
+function comparePageImages(actual, expected, options = {}) {
+  const channelThreshold = options.channelThreshold ?? DEFAULT_CHANNEL_THRESHOLD;
+  const maxChangedPixelRatio = options.maxChangedPixelRatio ?? DEFAULT_MAX_CHANGED_PIXEL_RATIO;
+  assertThreshold(channelThreshold, 255, "channelThreshold");
+  assertThreshold(maxChangedPixelRatio, 1, "maxChangedPixelRatio");
+  assertPageImage(actual, "actual");
+  assertPageImage(expected, "expected");
+  const pageNumbersMatch = actual.number === expected.number;
+  const dimensionsMatch = actual.width === expected.width && actual.height === expected.height;
+  if (!dimensionsMatch) {
+    const totalPixels2 = Math.max(actual.width * actual.height, expected.width * expected.height);
+    return {
+      changedPixelRatio: totalPixels2 === 0 ? 0 : 1,
+      changedPixels: totalPixels2,
+      dimensionsMatch: false,
+      matches: false,
+      maxChannelDifference: 255,
+      pageNumbersMatch,
+      totalPixels: totalPixels2
+    };
+  }
+  const totalPixels = actual.width * actual.height;
+  let changedPixels = 0;
+  let maxChannelDifference = 0;
+  for (let offset = 0; offset < actual.pixels.length; offset += 4) {
+    let pixelChanged = false;
+    for (let channel = 0; channel < 4; channel += 1) {
+      const difference = Math.abs(
+        actual.pixels[offset + channel] - expected.pixels[offset + channel]
+      );
+      maxChannelDifference = Math.max(maxChannelDifference, difference);
+      pixelChanged ||= difference > channelThreshold;
+    }
+    if (pixelChanged) changedPixels += 1;
+  }
+  const changedPixelRatio = totalPixels === 0 ? 0 : changedPixels / totalPixels;
+  return {
+    changedPixelRatio,
+    changedPixels,
+    dimensionsMatch,
+    matches: pageNumbersMatch && changedPixelRatio <= maxChangedPixelRatio,
+    maxChannelDifference,
+    pageNumbersMatch,
+    totalPixels
+  };
+}
+async function getPdfJs() {
+  installPdfCanvasGlobals();
+  if (!pdfJsPromise) {
+    pdfJsPromise = import('pdfjs-dist/legacy/build/pdf.mjs').catch((error) => {
+      pdfJsPromise = void 0;
+      if (isModuleNotFound(error)) {
+        throw new Error(missingPeerMessage("pdfjs-dist"), { cause: error });
+      }
+      throw error;
+    });
+  }
+  return pdfJsPromise;
+}
+async function withPdfDocument(data, read) {
+  const pdfJs = await getPdfJs();
+  const loadingTask = pdfJs.getDocument({
+    CanvasFactory: NapiCanvasFactory,
+    data: copyPdfData(data),
+    isEvalSupported: false,
+    stopAtErrors: true,
+    useWorkerFetch: false,
+    verbosity: 0
+  });
+  try {
+    return await read(await loadingTask.promise);
+  } finally {
+    await loadingTask.destroy();
+  }
+}
+function copyPdfData(data) {
+  return data instanceof Uint8Array ? Uint8Array.from(data) : new Uint8Array(data.slice(0));
+}
+function normalizeAnnotation(value) {
+  const annotation = isRecord(value) ? value : {};
+  const annotationType = typeof annotation.annotationType === "number" ? annotation.annotationType : void 0;
+  const destination = normalizeDestination(annotation.dest);
+  const rect = Array.isArray(annotation.rect) ? annotation.rect.filter((item) => typeof item === "number").map(roundCoordinate) : void 0;
+  const unsafeUrl = asUrl(annotation.unsafeUrl);
+  const url = asUrl(annotation.url);
+  return {
+    ...annotationType === void 0 ? {} : { annotationType },
+    ...destination === void 0 ? {} : { destination },
+    ...rect?.length === 4 ? { rect } : {},
+    subtype: typeof annotation.subtype === "string" ? annotation.subtype : "Unknown",
+    ...unsafeUrl === void 0 ? {} : { unsafeUrl },
+    ...url === void 0 ? {} : { url }
+  };
+}
+function normalizeDestination(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return void 0;
+  const destination = [];
+  for (const part of value) {
+    if (part === null || typeof part === "string" || typeof part === "number") {
+      destination.push(part);
+      continue;
+    }
+    if (isRecord(part) && typeof part.num === "number" && typeof part.gen === "number") {
+      destination.push({ generation: part.gen, number: part.num });
+    }
+  }
+  return destination;
+}
+function asUrl(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof URL) return value.href;
+  return void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function roundCoordinate(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function assertThreshold(value, maximum, name) {
+  if (!Number.isFinite(value) || value < 0 || value > maximum) {
+    throw new RangeError(`${name} must be between 0 and ${maximum}`);
+  }
+}
+function assertPageImage(image, name) {
+  if (!Number.isInteger(image.number) || image.number < 1) {
+    throw new RangeError(`${name} page number must be a positive integer`);
+  }
+  if (!Number.isInteger(image.width) || image.width < 1 || !Number.isInteger(image.height) || image.height < 1) {
+    throw new RangeError(`${name} page dimensions must be positive integers`);
+  }
+  const expectedLength = image.width * image.height * 4;
+  if (image.pixels.length !== expectedLength) {
+    throw new RangeError(`${name} page pixels must contain ${expectedLength} RGBA channels`);
+  }
+}
+
+class PdfAssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PdfAssertionError";
+  }
+}
+const truncate = (value, max = 200) => value.length > max ? `${value.slice(0, max)}\u2026` : value;
+const pageText = (parsed, page) => parsed.pages.find((candidate) => candidate.number === page)?.text;
+const linkMatches = (link, query) => {
+  if ("destination" in query && link.destination !== query.destination) return false;
+  if ("url" in query && link.url !== query.url) return false;
+  if (query.page !== void 0 && link.page !== query.page) return false;
+  return true;
+};
+const describeQuery = (query) => {
+  const parts = [];
+  if ("destination" in query) parts.push(`destination=${JSON.stringify(query.destination)}`);
+  if ("url" in query) parts.push(`url=${JSON.stringify(query.url)}`);
+  if (query.page !== void 0) parts.push(`page=${query.page}`);
+  return parts.join(", ");
+};
+const describeLinks = (links) => links.length === 0 ? "(no links found)" : links.map((link) => `{ page: ${link.page}${link.destination ? `, destination: ${JSON.stringify(link.destination)}` : ""}${link.url ? `, url: ${JSON.stringify(link.url)}` : ""} }`).join(", ");
+const outlineMismatch = (actual, shape, path) => {
+  if (actual.length !== shape.length) {
+    return `expected ${shape.length} item(s) at ${path}, found ${actual.length} (${actual.map((item) => JSON.stringify(item.title)).join(", ") || "none"})`;
+  }
+  for (let index = 0; index < shape.length; index += 1) {
+    const expected = shape[index];
+    const found = actual[index];
+    const here = `${path}[${index}]`;
+    if (found.title !== expected.title) {
+      return `expected outline title ${JSON.stringify(expected.title)} at ${here}, found ${JSON.stringify(found.title)}`;
+    }
+    if (expected.expanded !== void 0 && found.expanded !== expected.expanded) {
+      return `expected outline expanded=${expected.expanded} at ${here}, found ${String(found.expanded)}`;
+    }
+    if (expected.children !== void 0) {
+      const nested = outlineMismatch(found.children, expected.children, `${here}.children`);
+      if (nested) return nested;
+    }
+  }
+  return void 0;
+};
+function expectPdf(parsed) {
+  const expectation = {
+    toHavePageCount(count) {
+      if (parsed.pageCount !== count) {
+        throw new PdfAssertionError(
+          `Expected the PDF to have ${count} page(s), but it has ${parsed.pageCount}.`
+        );
+      }
+      return expectation;
+    },
+    toContainText(text, options = {}) {
+      if (options.page !== void 0) {
+        const target = pageText(parsed, options.page);
+        if (target === void 0) {
+          throw new PdfAssertionError(
+            `Expected text ${JSON.stringify(text)} on page ${options.page}, but the PDF has no page ${options.page} (page count: ${parsed.pageCount}).`
+          );
+        }
+        if (!target.includes(text)) {
+          throw new PdfAssertionError(
+            `Expected page ${options.page} to contain ${JSON.stringify(text)}, but its text was ${JSON.stringify(truncate(target))}.`
+          );
+        }
+        return expectation;
+      }
+      const found = parsed.pages.some((page) => page.text.includes(text));
+      if (!found) {
+        const all = parsed.pages.map((page) => `p${page.number}: ${truncate(page.text, 120)}`).join(" | ");
+        throw new PdfAssertionError(
+          `Expected some page to contain ${JSON.stringify(text)}, but none did. Pages: ${all}`
+        );
+      }
+      return expectation;
+    },
+    toHaveLink(query) {
+      if (!parsed.links.some((link) => linkMatches(link, query))) {
+        throw new PdfAssertionError(
+          `Expected a link matching { ${describeQuery(query)} }, but found: ${describeLinks(parsed.links)}.`
+        );
+      }
+      return expectation;
+    },
+    toHaveOutline(shape) {
+      const mismatch = outlineMismatch(parsed.outline, shape, "outline");
+      if (mismatch) {
+        throw new PdfAssertionError(`Outline did not match: ${mismatch}.`);
+      }
+      return expectation;
+    }
+  };
+  return expectation;
+}
+
+const RENDER_PDF_TEMPLATE_OPTION_KEYS = ["limits", "remote"];
+const hasDefinition = (component) => typeof component === "object" && component !== null && PDF_DEFINITION_PROPERTY in component;
+const ensurePdfComponent = (component) => {
+  if (hasDefinition(component)) return component;
+  const wrapper = defineComponent({
+    name: "RenderPdfTemplateHost",
+    inheritAttrs: false,
+    setup(_props, { attrs }) {
+      return () => h(component, attrs);
+    }
+  });
+  const definition = {};
+  return Object.assign(wrapper, { [PDF_DEFINITION_PROPERTY]: definition });
+};
+const componentName = (component) => {
+  const name = component.name;
+  return typeof name === "string" && name !== "" ? name : "template";
+};
+function assertRenderOptionKeys(helper, options, allowedKeys) {
+  const unsupportedKey = Object.keys(options).find((key) => !allowedKeys.includes(key));
+  if (unsupportedKey === void 0) return;
+  throw new TypeError(
+    `${helper} received unsupported option ${JSON.stringify(unsupportedKey)}. Supported options: ${allowedKeys.join(", ")}.`
+  );
+}
+async function renderPreparedPdfTemplate(component, props, options = {}) {
+  const { key = componentName(component), ...runtimeOptions } = options;
+  const template = createPdfTemplate(
+    key,
+    ensurePdfComponent(component),
+    runtimeOptions
+  );
+  const result = await template.render(props);
+  const bytes = await result.toUint8Array();
+  const parsed = await parsePdf(bytes);
+  return { bytes, parsed, result };
+}
+async function renderPdfTemplate(component, props, options = {}) {
+  assertRenderOptionKeys(
+    "renderPdfTemplate",
+    options,
+    RENDER_PDF_TEMPLATE_OPTION_KEYS
+  );
+  return renderPreparedPdfTemplate(component, props, {
+    limits: normalizePdfLimits(options.limits),
+    remote: normalizeRemoteAssetPolicy(options.remote)
+  });
+}
+
+const RENDER_PDF_SFC_OPTION_KEYS = ["fonts", "limits", "remote"];
+const findPdfRoot = (filename) => {
+  let directory = dirname(filename);
+  while (dirname(directory) !== directory) {
+    if (basename(directory) === "pdfs") return directory;
+    directory = dirname(directory);
+  }
+  throw new Error(`PDF SFC ${JSON.stringify(filename)} must be inside a pdfs directory.`);
+};
+const resolveComposablesImport = () => {
+  const directory = dirname(fileURLToPath(import.meta.url));
+  const built = join(directory, "runtime", "composables", "index.js");
+  if (existsSync(built)) return built;
+  const source = resolve(directory, "..", "runtime", "composables", "index.ts");
+  if (existsSync(source)) return source;
+  throw new Error("Unable to locate the Nuxt PDF composables runtime.");
+};
+const sfcCompilerPlugin = (entry, composablesImport) => ({
+  name: "nuxt-pdf:test-sfc",
+  setup(build2) {
+    build2.onResolve({ filter: /^(?:@[^/]+\/)?[^./][^:]*/ }, ({ path }) => ({
+      external: true,
+      path
+    }));
+    build2.onLoad({ filter: /\.vue$/ }, async ({ path }) => {
+      const result = await compilePdfSfc(
+        await readFile(path, "utf8"),
+        path,
+        path === entry ? "template" : "component",
+        true,
+        composablesImport
+      );
+      const sourceMap = result.map ? `
+//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(result.map)).toString("base64")}` : "";
+      return {
+        contents: result.code + sourceMap,
+        loader: "js",
+        resolveDir: dirname(path)
+      };
+    });
+  }
+});
+async function loadPdfSfc(filename) {
+  const entry = resolve(filename);
+  const composablesImport = resolveComposablesImport();
+  const result = await build({
+    absWorkingDir: dirname(entry),
+    bundle: true,
+    entryPoints: [entry],
+    format: "esm",
+    packages: "external",
+    platform: "node",
+    plugins: [sfcCompilerPlugin(entry, composablesImport)],
+    sourcemap: "inline",
+    target: "node22",
+    write: false
+  });
+  const output = result.outputFiles?.[0];
+  if (!output) throw new Error(`PDF SFC ${JSON.stringify(entry)} produced no JavaScript output.`);
+  const appRoot = dirname(findPdfRoot(entry));
+  const cacheDirectory = join(appRoot, "node_modules", ".cache");
+  const compiledFile = join(cacheDirectory, `nuxt-pdf-sfc-${process.pid}-${Date.now()}.mjs`);
+  await mkdir(cacheDirectory, { recursive: true });
+  await writeFile(compiledFile, output.contents);
+  try {
+    const loaded = await import(`${pathToFileURL(compiledFile).href}?v=${Date.now()}`);
+    if (!loaded.default || typeof loaded.default !== "object" && typeof loaded.default !== "function") {
+      throw new Error(`PDF SFC ${JSON.stringify(entry)} has no component default export.`);
+    }
+    return loaded.default;
+  } finally {
+    await rm(compiledFile, { force: true });
+  }
+}
+async function renderPdfSfc(filename, props, options = {}) {
+  assertRenderOptionKeys("renderPdfSfc", options, RENDER_PDF_SFC_OPTION_KEYS);
+  const entry = resolve(filename);
+  const pdfRoot = findPdfRoot(entry);
+  const rootDir = dirname(pdfRoot);
+  const relativePath = relative(pdfRoot, entry).replaceAll("\\", "/");
+  const key = templateKeyFromRelativePath(relativePath);
+  if (key === null) {
+    throw new Error(`PDF SFC ${JSON.stringify(entry)} must be a template directly inside pdfs/ or one of its feature directories.`);
+  }
+  const normalizedLimits = normalizePdfLimits(options.limits);
+  const limits = resolvePdfRenderLimits(normalizedLimits);
+  const [component, imageFiles, fonts] = await Promise.all([
+    loadPdfSfc(entry),
+    discoverPdfImageFiles([{ name: "test", rootDir }]),
+    bundlePdfFonts(options.fonts ?? [], { fontRoots: [join(rootDir, "pdfs", "fonts")] })
+  ]);
+  const loadedAssets = await Promise.all(imageFiles.map((image) => loadPdfImageAsset(image.key, {
+    roots: [image.rootDir],
+    maxBytes: limits.maxImageBytes,
+    maxPixels: limits.maxImagePixels
+  })));
+  const assets = Object.fromEntries(loadedAssets.map((asset) => [asset.key, asset]));
+  return renderPreparedPdfTemplate(component, props, {
+    assets,
+    file: `pdfs/${relativePath}`,
+    fonts,
+    key,
+    limits: normalizedLimits,
+    remote: normalizeRemoteAssetPolicy(options.remote)
+  });
+}
+
+const pageFileName = (pageNumber) => `page-${pageNumber}.png`;
+const isPageBaseline = (name) => /^page-\d+\.png$/.test(name);
+const differenceImage = (actual, expected) => {
+  const width = Math.max(actual.width, expected.width);
+  const height = Math.max(actual.height, expected.height);
+  const pixels = new Uint8ClampedArray(width * height * 4);
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const output = (y * width + x) * 4;
+      const actualOffset = (y * actual.width + x) * 4;
+      const expectedOffset = (y * expected.width + x) * 4;
+      const inActual = x < actual.width && y < actual.height;
+      const inExpected = x < expected.width && y < expected.height;
+      if (!inActual || !inExpected) {
+        pixels.set([255, 0, 0, 255], output);
+        continue;
+      }
+      const difference = Math.max(
+        ...[0, 1, 2, 3].map((channel) => Math.abs(
+          actual.pixels[actualOffset + channel] - expected.pixels[expectedOffset + channel]
+        ))
+      );
+      const intensity = Math.min(255, difference * 4);
+      pixels.set([255, 255 - intensity, 255 - intensity, 255], output);
+    }
+  }
+  return { height, number: actual.number, pixels, png: new Uint8Array(), width };
+};
+const writeFailureArtifacts = async (artifactDir, failures, thresholds) => {
+  await rm(artifactDir, { force: true, recursive: true });
+  await mkdir(artifactDir, { recursive: true });
+  await Promise.all(failures.flatMap(({ actual, expected }) => {
+    const page = `page-${actual.number}`;
+    return [
+      writeFile(join(artifactDir, `${page}-actual.png`), actual.png),
+      writeFile(join(artifactDir, `${page}-expected.png`), expected.png),
+      writeFile(
+        join(artifactDir, `${page}-diff.png`),
+        encodePngPage(differenceImage(actual, expected))
+      )
+    ];
+  }));
+  await writeFile(join(artifactDir, "metrics.json"), `${JSON.stringify({
+    pages: failures.map(({ actual, comparison }) => ({
+      page: actual.number,
+      ...comparison
+    })),
+    thresholds
+  }, null, 2)}
+`);
+};
+async function comparePdfSnapshot(input, baselineDir, options = {}) {
+  const update = options.update ?? process.env.UPDATE_PDF_BASELINES === "1";
+  const thresholds = {
+    channelThreshold: options.channelThreshold ?? 25,
+    maxChangedPixelRatio: options.threshold ?? 5e-3
+  };
+  const artifactDir = options.artifactDir ?? join(process.cwd(), "reports", "pdf-snapshots", basename(baselineDir));
+  const pages = await rasterizePdf(input, { scale: options.scale ?? 1 });
+  if (update) {
+    await mkdir(baselineDir, { recursive: true });
+    const stale = (await readdir(baselineDir).catch(() => [])).filter((name) => isPageBaseline(name));
+    const kept = new Set(pages.map((page) => pageFileName(page.number)));
+    await Promise.all([
+      ...pages.map((page) => writeFile(join(baselineDir, pageFileName(page.number)), page.png)),
+      ...stale.filter((name) => !kept.has(name)).map((name) => rm(join(baselineDir, name)))
+    ]);
+    return { matches: true, updated: true, pages: [] };
+  }
+  const baselineNames = (await readdir(baselineDir).catch(() => {
+    throw new PdfAssertionError(
+      `No reviewed PDF baseline found at ${JSON.stringify(baselineDir)}. Create it by running with UPDATE_PDF_BASELINES=1.`
+    );
+  })).filter(isPageBaseline).sort();
+  if (baselineNames.length !== pages.length) {
+    throw new PdfAssertionError(
+      `Rendered ${pages.length} page(s) but the baseline in ${JSON.stringify(baselineDir)} has ${baselineNames.length}. Re-run with UPDATE_PDF_BASELINES=1 if this change is intended.`
+    );
+  }
+  const comparisons = [];
+  const failures = [];
+  for (const page of pages) {
+    const baselinePath = join(baselineDir, pageFileName(page.number));
+    const baseline = await decodePngPage(await readFile(baselinePath), page.number);
+    const comparison = comparePageImages(page, baseline, thresholds);
+    comparisons.push(comparison);
+    if (!comparison.matches) {
+      failures.push({ actual: page, comparison, expected: baseline });
+    }
+  }
+  if (failures.length > 0) {
+    await writeFailureArtifacts(artifactDir, failures, thresholds);
+    throw new PdfAssertionError(
+      `${failures.length} page(s) do not match their reviewed baselines. Expected, actual, diff, and metrics artifacts were written to ${JSON.stringify(artifactDir)}. Re-run with UPDATE_PDF_BASELINES=1 if this change is intended.`
+    );
+  }
+  return { matches: true, updated: false, pages: comparisons };
+}
+
+export { PdfAssertionError, comparePdfSnapshot, expectPdf, loadPdfSfc, parsePdf, rasterizePdf, renderPdfSfc, renderPdfTemplate, toPdfBytes };