@lupinum/nuxt-pdf 0.4.0-beta.2 → 0.4.0-beta.4

package/API_REPORT.md

@@ -260,3 +260,39 @@ declare function comparePdfSnapshot(input: PdfInput, baselineDir: string, option
 export { PdfAssertionError, comparePdfSnapshot, expectPdf, loadPdfSfc, parsePdf, rasterizePdf, renderPdfSfc, renderPdfTemplate, toPdfBytes };
 export type { ComparePdfSnapshotOptions, LinkQuery, OutlineShape, ParsedPdf, ParsedPdfLink, ParsedPdfPage, ParsedPdfTextRun, PdfExpectation, PdfInput, PdfOutlineItem, PdfPageImage, PdfSnapshotResult, RasterizePdfOptions, RenderPdfSfcOptions, RenderPdfTemplateOptions, RenderedPdfTemplate, ToContainTextOptions };
 ```
+
+## Standalone build entry
+
+Source: `dist/build.d.mts`
+
+```ts
+import { PdfFontDeclaration } from '../dist/runtime/fonts.js';
+import { RemoteAssetOptions } from '../dist/runtime/server/assets/remote.js';
+import { PdfLimitsOptions } from '../dist/runtime/server/render-limits.js';
+
+interface BuildPdfRegistryOptions {
+    /** Trusted application root containing pdfs/. Not request input. */
+    rootDir: string;
+    /** Dedicated generated directory inside rootDir and outside pdfs/. */
+    outDir: string;
+    fonts?: readonly PdfFontDeclaration[];
+    limits?: PdfLimitsOptions;
+    remote?: RemoteAssetOptions;
+}
+/** Compile trusted templates and embed admitted resources before deployment. */
+declare function buildPdfRegistry(options: BuildPdfRegistryOptions): Promise<void>;
+
+export { buildPdfRegistry };
+export type { BuildPdfRegistryOptions };
+```
+
+## Standalone server entry
+
+Source: `dist/server.d.mts`
+
+```ts
+export { PdfRegistry, PdfRegistryEntries, createPdfRegistry, createPdfTemplate } from '../dist/runtime/server/registry.js';
+export { NuxtPdfError, PDF_ERROR_CODES, PdfErrorCode } from '../dist/runtime/shared/errors.js';
+export { usePdfPageNumbers } from '../dist/runtime/composables/index.js';
+export { PdfComponentProps, PdfDefinition, PdfRenderResult, PdfTemplate } from '../dist/runtime/shared/template.js';
+```

package/CHANGELOG.md

@@ -4,6 +4,43 @@ All notable changes to `@lupinum/nuxt-pdf` are recorded here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project adheres
 to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.4.0-beta.4
+
+[compare changes](https://github.com/lupinum-dev/nuxt-pdf/compare/v0.4.0-beta.3...0.4.0-beta.4)
+
+### Fixed
+
+- **deps:** Enforce quarantine in package consumers ([#48](https://github.com/lupinum-dev/nuxt-pdf/pull/48))
+- **assets:** Revalidate disk images across renders ([#49](https://github.com/lupinum-dev/nuxt-pdf/pull/49))
+- **dev:** Export registered PDF component guards ([#50](https://github.com/lupinum-dev/nuxt-pdf/pull/50))
+- **preview:** Rebuild watched templates before refreshing ([#51](https://github.com/lupinum-dev/nuxt-pdf/pull/51))
+- **release:** Bind package evidence to its source graph ([#52](https://github.com/lupinum-dev/nuxt-pdf/pull/52))
+
+### Maintenance
+
+- **maintenance:** Verify PDF commands without repeated work ([#53](https://github.com/lupinum-dev/nuxt-pdf/pull/53))
+
+### Tests
+
+- **compatibility:** Verify declared PDF consumer versions ([#54](https://github.com/lupinum-dev/nuxt-pdf/pull/54))
+- **assets:** Describe per-render disk validation ([#55](https://github.com/lupinum-dev/nuxt-pdf/pull/55))
+- **production:** Tolerate fixture text whitespace ([#56](https://github.com/lupinum-dev/nuxt-pdf/pull/56))
+
+## 0.4.0-beta.3 - 2026-09-03
+
+### Added
+
+- Add a standalone registry build and Node production runtime entry. Reuse the
+  existing PDF compiler, embedded resource admission, and rendering engine.
+- Emit backend-consumable TypeScript declarations without requiring Vue source
+  or a Vue type checker during backend compilation.
+
+### Fixed
+
+- Keep the registry documentation example compatible with strict Markdown style
+  validation and update vulnerable documentation parser dependencies.
+- Prepare the package build export before clean-checkout type checking.
+
 ## 0.4.0-beta.2 - 2026-08-27
 
 [compare changes](https://github.com/lupinum-dev/nuxt-pdf/compare/v0.4.0-beta.1...v0.4.0-beta.2)

package/CONFORMANCE.md

@@ -1,11 +1,11 @@
-# Nuxt PDF 0.4.0-beta.2 conformance
+# Nuxt PDF 0.4.0-beta.4 conformance
 
 Nuxt PDF claims behavioral compatibility for a deliberately small, tested
 corpus. It does not claim full React PDF API or test-suite compatibility.
 
 ## Version boundary
 
-| Layer | 0.4.0-beta.2 boundary |
+| Layer | 0.4.0-beta.4 boundary |
 |---|---|
 | Node.js | `^22.14.0`, `^24.0.0`, or `^26.0.0` |
 | Nuxt | `^4.4.8` |
@@ -22,6 +22,19 @@ any of them changes.
 
 ## Verified corpus
 
+### Standalone registry
+
+`test/standalone-build.test.ts` compiles the production registry and removes
+template, font, and image sources before rendering. It checks custom fonts,
+Unicode, embedded images, long text, pagination, equivalent extracted content,
+and concurrent prop isolation. Plain NodeNext TypeScript checks inferred inline
+and imported props without Vue source. Invalid resources, output limits, failed
+build preservation, and generated-directory ownership have focused tests.
+
+This is local Node evidence, not a deployed Convex or serverless certification.
+Largest-realistic-document sizing, cold/warm timing, and platform memory limits
+remain application deployment checks. The existing Nitro path is unchanged.
+
 ### Compatibility kernel
 
 The paired React/Vue fixture verifies:
@@ -248,6 +261,10 @@ The 0.4.0-beta.2 tests verify:
   content type;
 - development preview index, viewer, raw PDF, and named scenarios, backed by a
   separate internal development sidecar;
+- development guards for every global PDF component, including Nuxt
+  auto-import misuse outside a PDF template;
+- watched template rebuilds and whole-viewer refreshes that keep the selected
+  scenario and replace document bytes with their matching diagnostics;
 - a production Nitro route rendering through the generated registry;
 - structural removal of `sampleData` and `scenarios` during production SFC
   compilation, with unique fixture canaries and preview-only API tokens rejected
@@ -329,6 +346,8 @@ shows up without a restart. The tested boundary includes:
 - TTF, OTF, and WOFF2 signature/extension/structure validation,
   registration validation, source byte limits, and source-removal rendering;
 - explicit local `pdfs/assets` and `pdfs/fonts` roots;
+- independent image validation across roots and after same-size,
+  same-timestamp development edits;
 - rejection of absolute paths, traversal, missing assets, ambiguous sources,
   unsupported URLs, and symlink escapes; and
 - font rendering after its source file is removed, and image resolution from

package/dist/build.d.mts

@@ -0,0 +1,18 @@
+import { PdfFontDeclaration } from '../dist/runtime/fonts.js';
+import { RemoteAssetOptions } from '../dist/runtime/server/assets/remote.js';
+import { PdfLimitsOptions } from '../dist/runtime/server/render-limits.js';
+
+interface BuildPdfRegistryOptions {
+    /** Trusted application root containing pdfs/. Not request input. */
+    rootDir: string;
+    /** Dedicated generated directory inside rootDir and outside pdfs/. */
+    outDir: string;
+    fonts?: readonly PdfFontDeclaration[];
+    limits?: PdfLimitsOptions;
+    remote?: RemoteAssetOptions;
+}
+/** Compile trusted templates and embed admitted resources before deployment. */
+declare function buildPdfRegistry(options: BuildPdfRegistryOptions): Promise<void>;
+
+export { buildPdfRegistry };
+export type { BuildPdfRegistryOptions };

package/dist/build.mjs

@@ -0,0 +1,220 @@
+import { execFile } from 'node:child_process';
+import { readdir, readFile, writeFile, mkdir, mkdtemp, rm, lstat, rename } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { join, relative, dirname, resolve, isAbsolute } from 'node:path';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+import { d as discoverPdfTemplates, a as discoverPdfImageFiles, b as bundlePdfFonts, c as compilePdfSfc } from './shared/nuxt-pdf.C-E8MM_K.mjs';
+import ts from 'typescript';
+import { p as preparePdfImageAssets, g as generatePdfRuntimeRegistry, a as generateAuthoringTypes, b as generatePdfRegistryTypes } from './shared/nuxt-pdf.CjVyPF31.mjs';
+import { normalizeRemoteAssetPolicy } from '../dist/runtime/server/assets/remote.js';
+import { normalizePdfLimits, DEFAULT_PDF_RENDER_LIMITS } from '../dist/runtime/server/render-limits.js';
+import 'node:buffer';
+import 'node:fs';
+import '@vue/compiler-sfc';
+import '@jridgewell/remapping';
+import 'unimport';
+import '../dist/runtime/shared/template.js';
+import '../dist/runtime/components/stubs.js';
+import 'ufo';
+import '../dist/runtime/server/assets/resolve-asset.js';
+
+async function normalizeDeclarationImports(directory) {
+  for (const file of await readdir(directory, { recursive: true })) {
+    if (!/\.d\.[cm]?ts$/.test(file)) continue;
+    const path = join(directory, file);
+    const source = ts.createSourceFile(path, await readFile(path, "utf8"), ts.ScriptTarget.Latest, true);
+    const transformed = ts.transform(source, [(context) => {
+      const visit = (node) => {
+        if (ts.isStringLiteral(node) && node.text.startsWith(".")) {
+          const parent = node.parent;
+          const isImport = ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent) || ts.isLiteralTypeNode(parent) && ts.isImportTypeNode(parent.parent);
+          if (isImport && !node.text.endsWith(".json")) {
+            const module = ts.resolveModuleName(node.text, path, { moduleResolution: ts.ModuleResolutionKind.Bundler }, ts.sys).resolvedModule;
+            if (!module) throw new Error(`Cannot resolve emitted declaration import ${JSON.stringify(node.text)} from ${path}. Use a relative TypeScript source file inside rootDir.`);
+            const target = relative(dirname(path), module.resolvedFileName).replaceAll("\\", "/").replace(/\.d\.([cm]?)ts$/, ".$1js");
+            return ts.factory.createStringLiteral(target.startsWith(".") ? target : `./${target}`);
+          }
+        }
+        return ts.visitEachChild(node, visit, context);
+      };
+      return (node) => ts.visitNode(node, visit);
+    }]);
+    try {
+      await writeFile(path, ts.createPrinter().printFile(transformed.transformed[0]));
+    } finally {
+      transformed.dispose();
+    }
+  }
+}
+
+const runtimeImport = "@lupinum/nuxt-pdf/server";
+const execute = promisify(execFile);
+const ownershipMarker = ".nuxt-pdf-generated";
+const ownershipContent = "Generated by @lupinum/nuxt-pdf/build. Do not edit.\n";
+function contains(parent, child) {
+  const path = relative(parent, child);
+  return path === "" || path !== ".." && !path.startsWith("../") && !path.startsWith("..\\") && !isAbsolute(path);
+}
+async function checkOutputDirectory(outDir) {
+  const info = await lstat(outDir).catch((error) => {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
+    throw error;
+  });
+  if (!info) return;
+  if (!info.isDirectory() || info.isSymbolicLink()) {
+    throw new TypeError("buildPdfRegistry outDir must be a directory, not a file or symlink.");
+  }
+  try {
+    const marker = await readFile(join(outDir, ownershipMarker), "utf8");
+    if (marker !== ownershipContent) throw new Error("invalid ownership marker");
+  } catch (error) {
+    throw new TypeError("buildPdfRegistry refuses to replace a directory it did not generate.", { cause: error });
+  }
+}
+async function replaceOutputDirectory(staging, outDir) {
+  const parent = dirname(outDir);
+  const previousRoot = await mkdtemp(join(parent, ".nuxt-pdf-previous-"));
+  const previous = join(previousRoot, "output");
+  let removePreviousRoot = true;
+  try {
+    const exists = await lstat(outDir).then(() => true, (error) => {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+      throw error;
+    });
+    if (exists) await rename(outDir, previous);
+    try {
+      await rename(staging, outDir);
+    } catch (error) {
+      if (exists) {
+        try {
+          await rename(previous, outDir);
+        } catch (restoreError) {
+          removePreviousRoot = false;
+          throw new AggregateError(
+            [error, restoreError],
+            `Failed to replace generated PDF output and restore it. The prior output remains at ${previous}.`,
+            { cause: restoreError }
+          );
+        }
+      }
+      throw error;
+    }
+  } finally {
+    if (removePreviousRoot) await rm(previousRoot, { recursive: true, force: true });
+  }
+}
+async function buildPdfRegistry(options) {
+  const allowed = /* @__PURE__ */ new Set(["rootDir", "outDir", "fonts", "limits", "remote"]);
+  for (const key of Object.keys(options)) {
+    if (!allowed.has(key)) throw new TypeError(`buildPdfRegistry: unsupported option ${JSON.stringify(key)}.`);
+  }
+  if (!options.rootDir?.trim() || !options.outDir?.trim()) {
+    throw new TypeError("buildPdfRegistry requires rootDir and outDir.");
+  }
+  const rootDir = resolve(options.rootDir);
+  const outDir = resolve(rootDir, options.outDir);
+  const pdfRoot = join(rootDir, "pdfs");
+  if (!contains(rootDir, outDir) || contains(pdfRoot, outDir) || contains(outDir, pdfRoot)) {
+    throw new TypeError("buildPdfRegistry outDir must be a dedicated directory inside rootDir and outside pdfs/.");
+  }
+  await checkOutputDirectory(outDir);
+  const layers = [{ rootDir }];
+  const templates = await discoverPdfTemplates(layers);
+  if (templates.length === 0) throw new TypeError("buildPdfRegistry found no templates in pdfs/.");
+  const limits = normalizePdfLimits(options.limits);
+  const [assets, fonts] = await Promise.all([
+    discoverPdfImageFiles(layers).then((images) => preparePdfImageAssets(images, limits ?? DEFAULT_PDF_RENDER_LIMITS, false)),
+    bundlePdfFonts(options.fonts ?? [], { fontRoots: [join(pdfRoot, "fonts")] })
+  ]);
+  const source = generatePdfRuntimeRegistry(templates, {
+    assets,
+    fonts,
+    limits,
+    remote: normalizeRemoteAssetPolicy(options.remote),
+    runtimeImport,
+    development: false
+  });
+  const entries = new Set(templates.map((template) => template.filePath));
+  const result = await build({
+    absWorkingDir: rootDir,
+    stdin: { contents: source, resolveDir: rootDir, sourcefile: "pdf-registry.js" },
+    bundle: true,
+    packages: "external",
+    platform: "node",
+    format: "esm",
+    target: "node22",
+    tsconfigRaw: {},
+    write: false,
+    plugins: [{
+      name: "nuxt-pdf:standalone",
+      setup(builder) {
+        builder.onLoad({ filter: /\.vue$/ }, async ({ path }) => ({
+          contents: (await compilePdfSfc(await readFile(path, "utf8"), path, entries.has(path) ? "template" : "component", true, runtimeImport)).code,
+          loader: "js",
+          resolveDir: dirname(path)
+        }));
+      }
+    }]
+  });
+  const output = result.outputFiles[0];
+  if (!output) throw new Error("PDF registry compilation produced no output.");
+  await mkdir(dirname(outDir), { recursive: true });
+  const staging = await mkdtemp(join(dirname(outDir), ".nuxt-pdf-build-"));
+  try {
+    await emitDeclarations(rootDir, staging, templates);
+    await writeFile(join(staging, "index.mjs"), output.contents);
+    await writeFile(join(staging, ownershipMarker), ownershipContent);
+    await checkOutputDirectory(outDir);
+    await replaceOutputDirectory(staging, outDir);
+  } finally {
+    await rm(staging, { recursive: true, force: true });
+  }
+}
+async function emitDeclarations(rootDir, outDir, templates) {
+  const temporary = await mkdtemp(join(outDir, ".types-"));
+  try {
+    const globals = join(temporary, "authoring.d.ts");
+    const runtimeDirectory = join(dirname(fileURLToPath(import.meta.resolve(runtimeImport))), "runtime");
+    await writeFile(globals, generateAuthoringTypes(
+      join(runtimeDirectory, "components/index"),
+      join(runtimeDirectory, "composables/index"),
+      join(runtimeDirectory, "define-pdf")
+    ));
+    const config = join(temporary, "tsconfig.json");
+    await writeFile(config, JSON.stringify({
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        strict: true,
+        skipLibCheck: true,
+        declaration: true,
+        emitDeclarationOnly: true,
+        noEmitOnError: true,
+        rootDir,
+        declarationDir: join(outDir, "types"),
+        types: []
+      },
+      files: [...templates.map((template) => template.filePath), globals]
+    }));
+    try {
+      await execute(process.execPath, [createRequire(import.meta.url).resolve("vue-tsc/bin/vue-tsc.js"), "--project", config], { cwd: rootDir, maxBuffer: 4 * 1024 * 1024 });
+    } catch (error) {
+      const diagnostics = error instanceof Error && "stdout" in error ? String(error.stdout) : "";
+      throw new Error(`PDF template type checking failed.
+${diagnostics}`, { cause: error });
+    }
+    await normalizeDeclarationImports(join(outDir, "types"));
+    const declarationTemplates = templates.map((template) => ({
+      ...template,
+      filePath: `./types/${relative(rootDir, template.filePath).replaceAll("\\", "/")}.js`
+    }));
+    await writeFile(join(outDir, "index.d.mts"), generatePdfRegistryTypes(declarationTemplates, { runtimeImport }));
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+
+export { buildPdfRegistry };

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/nuxt-pdf",
-  "version": "0.4.0-beta.2",
+  "version": "0.4.0-beta.4",
   "configKey": "pdf",
   "docs": "https://nuxt-pdf.lupinum.com",
   "compatibility": {

package/dist/module.mjs

@@ -1,188 +1,23 @@
 import { stat } from 'node:fs/promises';
-import { Buffer } from 'node:buffer';
 import { join, isAbsolute, resolve, relative } from 'node:path';
 import { defineNuxtModule, createResolver, getLayerDirectories, createIsIgnored, addServerTemplate, addTemplate, addImports, addTypeTemplate, logger, addServerHandler, addComponent } from '@nuxt/kit';
 import { joinURL } from 'ufo';
-import { d as discoverPdfTemplates, a as discoverPdfComponentFiles, b as discoverPdfImageFiles, c as bundlePdfFonts, e as createPdfSfcPlugin, f as classifyPdfWatchEvent } from './shared/nuxt-pdf.D0zmsct0.mjs';
-import { pdfImageFormatFromKey, loadPdfImageAsset } from '../dist/runtime/server/assets/resolve-asset.js';
-import { PDF_STUB_NAMES } from '../dist/runtime/components/stubs.js';
+import { d as discoverPdfTemplates, e as discoverPdfComponentFiles, a as discoverPdfImageFiles, b as bundlePdfFonts, f as createPdfSfcPlugin, g as classifyPdfWatchEvent } from './shared/nuxt-pdf.C-E8MM_K.mjs';
+import { p as preparePdfImageAssets, g as generatePdfRuntimeRegistry, b as generatePdfRegistryTypes, a as generateAuthoringTypes, c as generatePdfPreviewConfig } from './shared/nuxt-pdf.CjVyPF31.mjs';
+import * as pdfStubs from '../dist/runtime/components/stubs.js';
 import { normalizeRemoteAssetPolicy } from '../dist/runtime/server/assets/remote.js';
 import { normalizePdfLimits, DEFAULT_PDF_RENDER_LIMITS } from '../dist/runtime/server/render-limits.js';
+import 'node:buffer';
 import 'node:fs';
 import '@vue/compiler-sfc';
 import '@jridgewell/remapping';
 import 'esbuild';
 import 'unimport';
 import '../dist/runtime/shared/template.js';
+import '../dist/runtime/server/assets/resolve-asset.js';
 
-const version = "0.4.0-beta.2";
+const version = "0.4.0-beta.4";
 
-const compareText = (left, right) => {
-  if (left < right) return -1;
-  if (left > right) return 1;
-  return 0;
-};
-const quote$1 = (value) => JSON.stringify(value);
-const generatePdfPreviewConfig = (baseURL, buildAssetsDir) => `export const hmrClientPath = ${quote$1(joinURL(
-  baseURL.replace(/^\.\//, "/") || "/",
-  buildAssetsDir,
-  "@vite/client"
-))}
-`;
-const importPath = (filePath) => filePath.replaceAll("\\", "/");
-const runtimeOptionsSource = (options) => {
-  const assets = options.assets ?? [];
-  const fonts = options.fonts ?? [];
-  const { remote, limits } = options;
-  for (const asset of assets) {
-    if (asset.root !== void 0 === (asset.dataB64 !== void 0)) {
-      throw new TypeError(
-        `PDF image asset "${asset.key}" must declare exactly one of root or dataB64.`
-      );
-    }
-  }
-  if (assets.length === 0 && fonts.length === 0 && !remote && !limits) return [];
-  const lines = ["", "const __pdfRuntimeOptions = Object.freeze({"];
-  if (assets.length > 0) {
-    lines.push("  assets: Object.freeze({");
-    for (const asset of assets) {
-      const entry = asset.root !== void 0 ? `{ format: ${quote$1(asset.format)}, root: ${quote$1(asset.root)} }` : `{ dataB64: ${quote$1(asset.dataB64 ?? "")}, format: ${quote$1(asset.format)} }`;
-      lines.push(`    ${quote$1(asset.key)}: Object.freeze(${entry}),`);
-    }
-    lines.push("  }),");
-  }
-  if (fonts.length > 0) {
-    lines.push("  fonts: Object.freeze([");
-    for (const font of fonts) {
-      lines.push(`    Object.freeze(${JSON.stringify(font)}),`);
-    }
-    lines.push("  ]),");
-  }
-  if (remote) {
-    lines.push(`  remote: Object.freeze(${JSON.stringify(remote)}),`);
-  }
-  if (limits) {
-    lines.push(`  limits: Object.freeze(${JSON.stringify(limits)}),`);
-  }
-  lines.push("})");
-  return lines;
-};
-const orderedTemplates = (templates) => {
-  const result = [...templates].sort(
-    (left, right) => compareText(left.key, right.key)
-  );
-  const keys = /* @__PURE__ */ new Map();
-  for (const template of result) {
-    const duplicate = keys.get(template.key);
-    if (duplicate) {
-      throw new TypeError(
-        `Cannot generate duplicate PDF template key "${template.key}" from "${duplicate.filePath}" and "${template.filePath}".`
-      );
-    }
-    keys.set(template.key, template);
-  }
-  return result;
-};
-const validateOptions = (options) => {
-  if (options.runtimeImport.trim() === "") {
-    throw new TypeError("runtimeImport is required to generate the PDF registry.");
-  }
-};
-const generatePdfRuntimeRegistry = (templates, options) => {
-  validateOptions(options);
-  const ordered = orderedTemplates(templates);
-  const runtimeImports = options.development ? "createPdfPreviewEntry, createPdfRegistry, createPdfTemplate" : "createPdfRegistry, createPdfTemplate";
-  const lines = [
-    `import { ${runtimeImports} } from ${quote$1(options.runtimeImport)}`
-  ];
-  ordered.forEach((template, index) => {
-    lines.push(
-      `import __pdfTemplate${index} from ${quote$1(importPath(template.filePath))}`
-    );
-  });
-  const runtimeOptions = runtimeOptionsSource(options);
-  lines.push(...runtimeOptions, "", "const registry = createPdfRegistry({");
-  ordered.forEach((template, index) => {
-    const file = quote$1(`pdfs/${template.relativePath}`);
-    const runtimeArgument = options.development ? runtimeOptions.length > 0 ? `, { ...__pdfRuntimeOptions, file: ${file} }` : `, { file: ${file} }` : runtimeOptions.length > 0 ? ", __pdfRuntimeOptions" : "";
-    lines.push(
-      `  ${quote$1(template.key)}: createPdfTemplate(${quote$1(template.key)}, __pdfTemplate${index}${runtimeArgument}),`
-    );
-  });
-  lines.push("})");
-  if (options.development) {
-    lines.push("", "export const pdfPreview = Object.freeze({");
-    ordered.forEach((template, index) => {
-      lines.push(
-        `  ${quote$1(template.key)}: createPdfPreviewEntry(registry.pdf[${quote$1(template.key)}], __pdfTemplate${index}, { file: ${quote$1(`pdfs/${template.relativePath}`)} }),`
-      );
-    });
-    lines.push("})");
-  }
-  lines.push(
-    "",
-    "export const pdf = registry.pdf",
-    "export const renderPdf = registry.renderPdf",
-    "export const getPdfTemplate = registry.getPdfTemplate",
-    "export const pdfTemplateKeys = registry.pdfTemplateKeys",
-    `export { NuxtPdfError, PDF_ERROR_CODES } from ${quote$1(options.runtimeImport)}`,
-    ""
-  );
-  return lines.join("\n");
-};
-const generatePdfRegistryTypes = (templates, options) => {
-  validateOptions(options);
-  const ordered = orderedTemplates(templates);
-  const lines = [
-    `import type { PdfComponentProps, PdfRenderResult, PdfTemplate } from ${quote$1(options.runtimeImport)}`
-  ];
-  ordered.forEach((template, index) => {
-    lines.push(
-      "",
-      `type PdfComponent${index} = typeof import(${quote$1(importPath(template.filePath))})['default']`,
-      `type PdfProps${index} = PdfComponentProps<PdfComponent${index}>`
-    );
-  });
-  lines.push("", "export declare const pdf: {");
-  ordered.forEach((template, index) => {
-    lines.push(
-      `  readonly ${quote$1(template.key)}: PdfTemplate<PdfProps${index}>`
-    );
-  });
-  lines.push("}", "");
-  if (ordered.length === 0) {
-    lines.push(
-      "export declare function renderPdf(name: never, props: never): Promise<PdfRenderResult>",
-      "export declare function getPdfTemplate(name: never): never"
-    );
-  } else {
-    ordered.forEach((template, index) => {
-      lines.push(
-        `export declare function renderPdf(name: ${quote$1(template.key)}, props: PdfProps${index}): Promise<PdfRenderResult>`
-      );
-    });
-    lines.push(
-      "export declare function renderPdf(name: string, props: Record<string, unknown>, escapeHatch: { readonly unsafe: true }): Promise<PdfRenderResult>"
-    );
-    lines.push("");
-    ordered.forEach((template, index) => {
-      lines.push(
-        `export declare function getPdfTemplate(name: ${quote$1(template.key)}): PdfTemplate<PdfProps${index}>`
-      );
-    });
-  }
-  lines.push(
-    "",
-    `export declare const pdfTemplateKeys: readonly [${ordered.map((template) => quote$1(template.key)).join(", ")}]`,
-    "export type PdfTemplateKey = typeof pdfTemplateKeys[number]",
-    `export { NuxtPdfError, PDF_ERROR_CODES } from ${quote$1(options.runtimeImport)}`,
-    `export type { PdfErrorCode } from ${quote$1(options.runtimeImport)}`,
-    ""
-  );
-  return lines.join("\n");
-};
-
-const quote = (value) => JSON.stringify(value);
 const existingDirectories = async (directories) => {
   const result = [];
   for (const directory of directories) {
@@ -194,40 +29,6 @@ const existingDirectories = async (directories) => {
   }
   return result;
 };
-const generateAuthoringTypes = (componentsImport, composablesImport, definePdfImport) => `declare global {
-  const definePdf: typeof import(${quote(definePdfImport)})['definePdf']
-  const usePdfPageNumbers: typeof import(${quote(composablesImport)})['usePdfPageNumbers']
-}
-
-declare module 'vue' {
-  interface GlobalComponents {
-    PdfDocument: typeof import(${quote(componentsImport)})['PdfDocument']
-    PdfImage: typeof import(${quote(componentsImport)})['PdfImage']
-    PdfLink: typeof import(${quote(componentsImport)})['PdfLink']
-    PdfNote: typeof import(${quote(componentsImport)})['PdfNote']
-    PdfPage: typeof import(${quote(componentsImport)})['PdfPage']
-    PdfText: typeof import(${quote(componentsImport)})['PdfText']
-    PdfView: typeof import(${quote(componentsImport)})['PdfView']
-    PdfSvg: typeof import(${quote(componentsImport)})['PdfSvg']
-    PdfG: typeof import(${quote(componentsImport)})['PdfG']
-    PdfPath: typeof import(${quote(componentsImport)})['PdfPath']
-    PdfRect: typeof import(${quote(componentsImport)})['PdfRect']
-    PdfCircle: typeof import(${quote(componentsImport)})['PdfCircle']
-    PdfEllipse: typeof import(${quote(componentsImport)})['PdfEllipse']
-    PdfLine: typeof import(${quote(componentsImport)})['PdfLine']
-    PdfPolyline: typeof import(${quote(componentsImport)})['PdfPolyline']
-    PdfPolygon: typeof import(${quote(componentsImport)})['PdfPolygon']
-    PdfDefs: typeof import(${quote(componentsImport)})['PdfDefs']
-    PdfClipPath: typeof import(${quote(componentsImport)})['PdfClipPath']
-    PdfLinearGradient: typeof import(${quote(componentsImport)})['PdfLinearGradient']
-    PdfRadialGradient: typeof import(${quote(componentsImport)})['PdfRadialGradient']
-    PdfStop: typeof import(${quote(componentsImport)})['PdfStop']
-    PdfTspan: typeof import(${quote(componentsImport)})['PdfTspan']
-  }
-}
-
-export {}
-`;
 const module$1 = defineNuxtModule({
   meta: {
     name: "@lupinum/nuxt-pdf",
@@ -261,24 +62,7 @@ const module$1 = defineNuxtModule({
     const limits = normalizePdfLimits(options.limits);
     const resolvedLimits = limits ?? DEFAULT_PDF_RENDER_LIMITS;
     const imageFiles = await discoverPdfImageFiles(layers, isIgnored);
-    const assetEntries = [];
-    for (const image of imageFiles) {
-      const format = pdfImageFormatFromKey(image.key);
-      if (nuxt.options.dev) {
-        assetEntries.push({ format, key: image.key, root: image.rootDir });
-      } else {
-        const loaded = await loadPdfImageAsset(image.key, {
-          roots: [image.rootDir],
-          maxBytes: resolvedLimits.maxImageBytes,
-          maxPixels: resolvedLimits.maxImagePixels
-        });
-        assetEntries.push({
-          dataB64: Buffer.from(loaded.data).toString("base64"),
-          format,
-          key: image.key
-        });
-      }
-    }
+    const assetEntries = await preparePdfImageAssets(imageFiles, resolvedLimits, nuxt.options.dev);
     const fontRoots = await existingDirectories(
       layers.map((layer) => join(layer.rootDir, "pdfs", "fonts"))
     );
@@ -359,6 +143,14 @@ const module$1 = defineNuxtModule({
       nuxt.hook("vite:serverCreated", (viteServer, environment) => {
         if (environment.isClient) clientViteServer = viteServer;
       });
+      const refreshPreview = () => clientViteServer?.ws.send({
+        type: "custom",
+        event: "nuxt-pdf:update",
+        data: {}
+      });
+      nuxt.hook("nitro:init", (nitro) => {
+        nitro.hooks.hook("dev:reload", refreshPreview);
+      });
       nuxt.hook("builder:watch", async (event, path) => {
         const absolutePath = isAbsolute(path) ? path : resolve(nuxt.options.srcDir, path);
         const action = classifyPdfWatchEvent(
@@ -374,12 +166,7 @@ const module$1 = defineNuxtModule({
           await nuxt.callHook("restart");
           return;
         }
-        if (action !== "refresh") return;
-        clientViteServer?.ws.send({
-          type: "custom",
-          event: "nuxt-pdf:update",
-          data: {}
-        });
+        if (action === "refresh" && /\.(?:png|jpe?g)$/i.test(absolutePath)) refreshPreview();
       });
       addServerTemplate({
         filename: "#pdf-preview-config",
@@ -398,7 +185,7 @@ const module$1 = defineNuxtModule({
           view: { type: "iframe", src: joinURL(nuxt.options.app.baseURL || "/", "_pdf") }
         });
       });
-      for (const name of PDF_STUB_NAMES) {
+      for (const name of Object.keys(pdfStubs)) {
         addComponent({
           name,
           export: name,

package/dist/runtime/components/stubs.d.ts

@@ -1,10 +1,22 @@
-import { defineComponent } from 'vue';
-/**
- * Development-only guards for the global `Pdf*` component names. Types declare
- * these names globally so `pdfs/*.vue` templates typecheck, which means an
- * accidental `<PdfText>` inside an ordinary app component also typechecks —
- * while resolving to nothing at runtime. Registering these stubs turns that
- * silent failure into an immediate, actionable error.
- */
-export declare const PDF_STUB_NAMES: readonly ["PdfCircle", "PdfClipPath", "PdfDefs", "PdfDocument", "PdfEllipse", "PdfG", "PdfImage", "PdfLine", "PdfLinearGradient", "PdfLink", "PdfNote", "PdfPage", "PdfPath", "PdfPolygon", "PdfPolyline", "PdfRadialGradient", "PdfRect", "PdfStop", "PdfSvg", "PdfText", "PdfTspan", "PdfView"];
-export declare const createPdfStubs: () => Record<string, ReturnType<typeof defineComponent>>;
+export declare const PdfCircle: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfClipPath: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfDefs: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfDocument: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfEllipse: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfG: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfImage: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfLine: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfLinearGradient: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfLink: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfNote: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfPage: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfPath: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfPolygon: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfPolyline: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfRadialGradient: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfRect: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfStop: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfSvg: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfText: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfTspan: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const PdfView: import("vue").DefineComponent<{}, never, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/stubs.js

@@ -1,29 +1,5 @@
 import { defineComponent } from "vue";
 import { NuxtPdfError, PDF_ERROR_CODES } from "../shared/errors.js";
-export const PDF_STUB_NAMES = [
-  "PdfCircle",
-  "PdfClipPath",
-  "PdfDefs",
-  "PdfDocument",
-  "PdfEllipse",
-  "PdfG",
-  "PdfImage",
-  "PdfLine",
-  "PdfLinearGradient",
-  "PdfLink",
-  "PdfNote",
-  "PdfPage",
-  "PdfPath",
-  "PdfPolygon",
-  "PdfPolyline",
-  "PdfRadialGradient",
-  "PdfRect",
-  "PdfStop",
-  "PdfSvg",
-  "PdfText",
-  "PdfTspan",
-  "PdfView"
-];
 const stubMessage = (name) => `<${name}> only works inside a discovered pdfs/*.vue template rendered by @lupinum/nuxt-pdf. Move this component under pdfs/, or replace it with ordinary Vue/HTML components.`;
 const createPdfStub = (name) => defineComponent({
   name,
@@ -32,6 +8,25 @@ const createPdfStub = (name) => defineComponent({
   },
   render: () => null
 });
-export const createPdfStubs = () => Object.fromEntries(
-  PDF_STUB_NAMES.map((name) => [name, createPdfStub(name)])
-);
+export const PdfCircle = createPdfStub("PdfCircle");
+export const PdfClipPath = createPdfStub("PdfClipPath");
+export const PdfDefs = createPdfStub("PdfDefs");
+export const PdfDocument = createPdfStub("PdfDocument");
+export const PdfEllipse = createPdfStub("PdfEllipse");
+export const PdfG = createPdfStub("PdfG");
+export const PdfImage = createPdfStub("PdfImage");
+export const PdfLine = createPdfStub("PdfLine");
+export const PdfLinearGradient = createPdfStub("PdfLinearGradient");
+export const PdfLink = createPdfStub("PdfLink");
+export const PdfNote = createPdfStub("PdfNote");
+export const PdfPage = createPdfStub("PdfPage");
+export const PdfPath = createPdfStub("PdfPath");
+export const PdfPolygon = createPdfStub("PdfPolygon");
+export const PdfPolyline = createPdfStub("PdfPolyline");
+export const PdfRadialGradient = createPdfStub("PdfRadialGradient");
+export const PdfRect = createPdfStub("PdfRect");
+export const PdfStop = createPdfStub("PdfStop");
+export const PdfSvg = createPdfStub("PdfSvg");
+export const PdfText = createPdfStub("PdfText");
+export const PdfTspan = createPdfStub("PdfTspan");
+export const PdfView = createPdfStub("PdfView");

package/dist/runtime/server/assets/resolve-asset.js

@@ -276,29 +276,7 @@ export const loadPdfImageAsset = async (relativePath, options) => {
     "The local PDF image was not found in a configured asset root."
   );
 };
-const RESOLVED_IMAGE_CACHE_BYTES = 32 * 1024 * 1024;
-const resolvedImageCache = /* @__PURE__ */ new Map();
-let resolvedImageCacheBytes = 0;
 const embeddedImageCache = /* @__PURE__ */ new WeakMap();
-const rememberResolvedImage = (cacheKey, image) => {
-  if (resolvedImageCache.has(cacheKey)) return;
-  resolvedImageCache.set(cacheKey, image);
-  resolvedImageCacheBytes += image.data.byteLength;
-  while (resolvedImageCacheBytes > RESOLVED_IMAGE_CACHE_BYTES && resolvedImageCache.size > 1) {
-    const oldest = resolvedImageCache.keys().next().value;
-    if (oldest === void 0) break;
-    resolvedImageCacheBytes -= resolvedImageCache.get(oldest).data.byteLength;
-    resolvedImageCache.delete(oldest);
-  }
-};
-const cachedResolvedImage = (cacheKey) => {
-  const cached = resolvedImageCache.get(cacheKey);
-  if (!cached) return void 0;
-  return {
-    ...cached,
-    data: Buffer.from(cached.data)
-  };
-};
 const resolveLocalImage = async (source, assets, maxBytes, maxPixels, declaredFormat) => {
   const key = canonicalAssetKey(source);
   const pathFormat = formatFromExtension(key);
@@ -328,8 +306,8 @@ const resolveLocalImage = async (source, assets, maxBytes, maxPixels, declaredFo
       byLimits = /* @__PURE__ */ new Map();
       embeddedImageCache.set(entry, byLimits);
     }
-    const cached2 = byLimits.get(limitsKey);
-    if (cached2) return { ...cached2, data: Buffer.from(cached2.data) };
+    const cached = byLimits.get(limitsKey);
+    if (cached) return { ...cached, data: Buffer.from(cached.data) };
     const resolved2 = validateImageBytes(
       Buffer.from(entry.dataB64, "base64"),
       maxBytes,
@@ -339,21 +317,6 @@ const resolveLocalImage = async (source, assets, maxBytes, maxPixels, declaredFo
     byLimits.set(limitsKey, resolved2);
     return { ...resolved2, data: Buffer.from(resolved2.data) };
   }
-  let fileStat;
-  try {
-    fileStat = await stat(resolve(entry.root, ...key.split("/")));
-  } catch (error) {
-    if (isMissingFileError(error)) {
-      return invalid(`The local PDF image "${key}" was not found under pdfs/assets.`);
-    }
-    return invalid("The local PDF image cannot be inspected.", error);
-  }
-  if (!fileStat.isFile()) {
-    return invalid("The local PDF image is not a regular file.");
-  }
-  const cacheKey = `disk\0${key}\0${fileStat.mtimeMs}\0${fileStat.size}\0${maxBytes}\0${maxPixels}`;
-  const cached = cachedResolvedImage(cacheKey);
-  if (cached) return cached;
   const loaded = await loadPdfImageAsset(key, {
     roots: [entry.root],
     maxBytes,
@@ -366,7 +329,6 @@ const resolveLocalImage = async (source, assets, maxBytes, maxPixels, declaredFo
     pixels: loaded.pixels,
     width: loaded.width
   });
-  rememberResolvedImage(cacheKey, resolved);
   return { ...resolved, data: Buffer.from(resolved.data) };
 };
 const isRemoteCandidate = (source) => /^https?:/i.test(source);

package/dist/runtime/server/preview.js

@@ -233,7 +233,7 @@ const viewerPage = async (template, props, rootPath, scenario, hmrClientPath2 =
   }
   return htmlResponse(
     title,
-    `<header><h1>${escapeHtml(title)}</h1>${actions}</header>${nav}${body}<script type="module">import { createHotContext } from ${JSON.stringify(hmrClientPath2)};createHotContext('/_pdf').on('nuxt-pdf:update',()=>{const frame=document.querySelector('iframe');if(frame&&frame.contentWindow){frame.contentWindow.location.reload();}else{location.reload();}});<\/script>`
+    `<header><h1>${escapeHtml(title)}</h1>${actions}</header>${nav}${body}<script type="module">import { createHotContext } from ${JSON.stringify(hmrClientPath2)};createHotContext('/_pdf').on('nuxt-pdf:update',()=>{location.reload();});<\/script>`
   );
 };
 export const renderPdfPreview = async (registry, request = {}) => {

package/dist/server.d.mts

@@ -0,0 +1,4 @@
+export { PdfRegistry, PdfRegistryEntries, createPdfRegistry, createPdfTemplate } from '../dist/runtime/server/registry.js';
+export { NuxtPdfError, PDF_ERROR_CODES, PdfErrorCode } from '../dist/runtime/shared/errors.js';
+export { usePdfPageNumbers } from '../dist/runtime/composables/index.js';
+export { PdfComponentProps, PdfDefinition, PdfRenderResult, PdfTemplate } from '../dist/runtime/shared/template.js';

package/dist/server.mjs

@@ -0,0 +1,3 @@
+export { createPdfRegistry, createPdfTemplate } from '../dist/runtime/server/registry.js';
+export { NuxtPdfError, PDF_ERROR_CODES } from '../dist/runtime/shared/errors.js';
+export { usePdfPageNumbers } from '../dist/runtime/composables/index.js';

package/dist/shared/{nuxt-pdf.D0zmsct0.mjs → nuxt-pdf.C-E8MM_K.mjs}

@@ -1,7 +1,7 @@
 import { readdir, realpath, open, stat, readFile } from 'node:fs/promises';
 import { resolve, join, relative, isAbsolute, posix, sep, dirname, extname, win32 } from 'node:path';
 import { Buffer } from 'node:buffer';
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, statSync, readFileSync } from 'node:fs';
 import { parse, compileScript, compileTemplate, babelParse } from '@vue/compiler-sfc';
 import remapping from '@jridgewell/remapping';
 import { transform } from 'esbuild';
@@ -493,6 +493,10 @@ const bundlePdfFonts = async (declarations, options) => {
 };
 
 const authoringImportContexts = /* @__PURE__ */ new Map();
+const compilerFileSystem = {
+  fileExists: (file) => statSync(file, { throwIfNoEntry: false })?.isFile() ?? false,
+  readFile: (file) => readFileSync(file, "utf8")
+};
 class PdfSfcCompileError extends Error {
   column;
   filename;
@@ -536,6 +540,7 @@ const createPdfSfcPlugin = (options) => ({
     if (!filename) return null;
     const kind = options.files.get(filename);
     if (!kind) return null;
+    this.addWatchFile(filename);
     return compilePdfSfc(
       await readFile(filename, "utf8"),
       filename,
@@ -882,6 +887,7 @@ function assertMetadataHoistable(source, descriptor, filename, macro) {
   try {
     const validation = parsePdfSfc(validationSource, filename);
     compileScript(validation, {
+      fs: compilerFileSystem,
       id: "nuxt-pdf-metadata-hoist",
       sourceMap: false
     });
@@ -976,6 +982,7 @@ function compileComponent(descriptor, filename, isProduction) {
   if (descriptor.scriptSetup) {
     try {
       const result = compileScript(descriptor, {
+        fs: compilerFileSystem,
         genDefaultAs: COMPONENT_VARIABLE,
         id: "nuxt-pdf",
         inlineTemplate: true,
@@ -1001,6 +1008,7 @@ function compileComponent(descriptor, filename, isProduction) {
   if (descriptor.script) {
     try {
       const script = compileScript(descriptor, {
+        fs: compilerFileSystem,
         genDefaultAs: COMPONENT_VARIABLE,
         id: "nuxt-pdf",
         isProd: isProduction,
@@ -1171,4 +1179,4 @@ function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 
-export { discoverPdfComponentFiles as a, discoverPdfImageFiles as b, bundlePdfFonts as c, discoverPdfTemplates as d, createPdfSfcPlugin as e, classifyPdfWatchEvent as f, compilePdfSfc as g, templateKeyFromRelativePath as t };
+export { discoverPdfImageFiles as a, bundlePdfFonts as b, compilePdfSfc as c, discoverPdfTemplates as d, discoverPdfComponentFiles as e, createPdfSfcPlugin as f, classifyPdfWatchEvent as g, templateKeyFromRelativePath as t };

package/dist/shared/nuxt-pdf.CjVyPF31.mjs

@@ -0,0 +1,203 @@
+import * as pdfStubs from '../../dist/runtime/components/stubs.js';
+import { joinURL } from 'ufo';
+import { Buffer } from 'node:buffer';
+import { pdfImageFormatFromKey, loadPdfImageAsset } from '../../dist/runtime/server/assets/resolve-asset.js';
+
+const generateAuthoringTypes = (componentsImport, composablesImport, definePdfImport) => `declare global {
+  const definePdf: typeof import(${JSON.stringify(definePdfImport)})['definePdf']
+  const usePdfPageNumbers: typeof import(${JSON.stringify(composablesImport)})['usePdfPageNumbers']
+}
+
+declare module 'vue' {
+  interface GlobalComponents {
+${Object.keys(pdfStubs).map((name) => `    ${name}: typeof import(${JSON.stringify(componentsImport)})['${name}']`).join("\n")}
+  }
+}
+
+export {}
+`;
+
+const compareText = (left, right) => {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+};
+const quote = (value) => JSON.stringify(value);
+const generatePdfPreviewConfig = (baseURL, buildAssetsDir) => `export const hmrClientPath = ${quote(joinURL(
+  baseURL.replace(/^\.\//, "/") || "/",
+  buildAssetsDir,
+  "@vite/client"
+))}
+`;
+const importPath = (filePath) => filePath.replaceAll("\\", "/");
+const runtimeOptionsSource = (options) => {
+  const assets = options.assets ?? [];
+  const fonts = options.fonts ?? [];
+  const { remote, limits } = options;
+  for (const asset of assets) {
+    if (asset.root !== void 0 === (asset.dataB64 !== void 0)) {
+      throw new TypeError(
+        `PDF image asset "${asset.key}" must declare exactly one of root or dataB64.`
+      );
+    }
+  }
+  if (assets.length === 0 && fonts.length === 0 && !remote && !limits) return [];
+  const lines = ["", "const __pdfRuntimeOptions = Object.freeze({"];
+  if (assets.length > 0) {
+    lines.push("  assets: Object.freeze({");
+    for (const asset of assets) {
+      const entry = asset.root !== void 0 ? `{ format: ${quote(asset.format)}, root: ${quote(asset.root)} }` : `{ dataB64: ${quote(asset.dataB64 ?? "")}, format: ${quote(asset.format)} }`;
+      lines.push(`    ${quote(asset.key)}: Object.freeze(${entry}),`);
+    }
+    lines.push("  }),");
+  }
+  if (fonts.length > 0) {
+    lines.push("  fonts: Object.freeze([");
+    for (const font of fonts) {
+      lines.push(`    Object.freeze(${JSON.stringify(font)}),`);
+    }
+    lines.push("  ]),");
+  }
+  if (remote) {
+    lines.push(`  remote: Object.freeze(${JSON.stringify(remote)}),`);
+  }
+  if (limits) {
+    lines.push(`  limits: Object.freeze(${JSON.stringify(limits)}),`);
+  }
+  lines.push("})");
+  return lines;
+};
+const orderedTemplates = (templates) => {
+  const result = [...templates].sort(
+    (left, right) => compareText(left.key, right.key)
+  );
+  const keys = /* @__PURE__ */ new Map();
+  for (const template of result) {
+    const duplicate = keys.get(template.key);
+    if (duplicate) {
+      throw new TypeError(
+        `Cannot generate duplicate PDF template key "${template.key}" from "${duplicate.filePath}" and "${template.filePath}".`
+      );
+    }
+    keys.set(template.key, template);
+  }
+  return result;
+};
+const validateOptions = (options) => {
+  if (options.runtimeImport.trim() === "") {
+    throw new TypeError("runtimeImport is required to generate the PDF registry.");
+  }
+};
+const generatePdfRuntimeRegistry = (templates, options) => {
+  validateOptions(options);
+  const ordered = orderedTemplates(templates);
+  const runtimeImports = options.development ? "createPdfPreviewEntry, createPdfRegistry, createPdfTemplate" : "createPdfRegistry, createPdfTemplate";
+  const lines = [
+    `import { ${runtimeImports} } from ${quote(options.runtimeImport)}`
+  ];
+  ordered.forEach((template, index) => {
+    lines.push(
+      `import __pdfTemplate${index} from ${quote(importPath(template.filePath))}`
+    );
+  });
+  const runtimeOptions = runtimeOptionsSource(options);
+  lines.push(...runtimeOptions, "", "const registry = createPdfRegistry({");
+  ordered.forEach((template, index) => {
+    const file = quote(`pdfs/${template.relativePath}`);
+    const runtimeArgument = options.development ? runtimeOptions.length > 0 ? `, { ...__pdfRuntimeOptions, file: ${file} }` : `, { file: ${file} }` : runtimeOptions.length > 0 ? ", __pdfRuntimeOptions" : "";
+    lines.push(
+      `  ${quote(template.key)}: createPdfTemplate(${quote(template.key)}, __pdfTemplate${index}${runtimeArgument}),`
+    );
+  });
+  lines.push("})");
+  if (options.development) {
+    lines.push("", "export const pdfPreview = Object.freeze({");
+    ordered.forEach((template, index) => {
+      lines.push(
+        `  ${quote(template.key)}: createPdfPreviewEntry(registry.pdf[${quote(template.key)}], __pdfTemplate${index}, { file: ${quote(`pdfs/${template.relativePath}`)} }),`
+      );
+    });
+    lines.push("})");
+  }
+  lines.push(
+    "",
+    "export const pdf = registry.pdf",
+    "export const renderPdf = registry.renderPdf",
+    "export const getPdfTemplate = registry.getPdfTemplate",
+    "export const pdfTemplateKeys = registry.pdfTemplateKeys",
+    `export { NuxtPdfError, PDF_ERROR_CODES } from ${quote(options.runtimeImport)}`,
+    ""
+  );
+  return lines.join("\n");
+};
+const generatePdfRegistryTypes = (templates, options) => {
+  validateOptions(options);
+  const ordered = orderedTemplates(templates);
+  const lines = [
+    `import type { PdfComponentProps, PdfRenderResult, PdfTemplate } from ${quote(options.runtimeImport)}`
+  ];
+  ordered.forEach((template, index) => {
+    lines.push(
+      "",
+      `type PdfComponent${index} = typeof import(${quote(importPath(template.filePath))})['default']`,
+      `type PdfProps${index} = PdfComponentProps<PdfComponent${index}>`
+    );
+  });
+  lines.push("", "export declare const pdf: {");
+  ordered.forEach((template, index) => {
+    lines.push(
+      `  readonly ${quote(template.key)}: PdfTemplate<PdfProps${index}>`
+    );
+  });
+  lines.push("}", "");
+  if (ordered.length === 0) {
+    lines.push(
+      "export declare function renderPdf(name: never, props: never): Promise<PdfRenderResult>",
+      "export declare function getPdfTemplate(name: never): never"
+    );
+  } else {
+    ordered.forEach((template, index) => {
+      lines.push(
+        `export declare function renderPdf(name: ${quote(template.key)}, props: PdfProps${index}): Promise<PdfRenderResult>`
+      );
+    });
+    lines.push(
+      "export declare function renderPdf(name: string, props: Record<string, unknown>, escapeHatch: { readonly unsafe: true }): Promise<PdfRenderResult>"
+    );
+    lines.push("");
+    ordered.forEach((template, index) => {
+      lines.push(
+        `export declare function getPdfTemplate(name: ${quote(template.key)}): PdfTemplate<PdfProps${index}>`
+      );
+    });
+  }
+  lines.push(
+    "",
+    `export declare const pdfTemplateKeys: readonly [${ordered.map((template) => quote(template.key)).join(", ")}]`,
+    "export type PdfTemplateKey = typeof pdfTemplateKeys[number]",
+    `export { NuxtPdfError, PDF_ERROR_CODES } from ${quote(options.runtimeImport)}`,
+    `export type { PdfErrorCode } from ${quote(options.runtimeImport)}`,
+    ""
+  );
+  return lines.join("\n");
+};
+
+async function preparePdfImageAssets(images, limits, development) {
+  const entries = [];
+  for (const image of images) {
+    const format = pdfImageFormatFromKey(image.key);
+    if (development) {
+      entries.push({ format, key: image.key, root: image.rootDir });
+      continue;
+    }
+    const loaded = await loadPdfImageAsset(image.key, {
+      roots: [image.rootDir],
+      maxBytes: limits.maxImageBytes,
+      maxPixels: limits.maxImagePixels
+    });
+    entries.push({ dataB64: Buffer.from(loaded.data).toString("base64"), format, key: image.key });
+  }
+  return entries;
+}
+
+export { generateAuthoringTypes as a, generatePdfRegistryTypes as b, generatePdfPreviewConfig as c, generatePdfRuntimeRegistry as g, preparePdfImageAssets as p };

package/dist/test.mjs

@@ -10,7 +10,7 @@ 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.D0zmsct0.mjs';
+import { t as templateKeyFromRelativePath, a as discoverPdfImageFiles, b as bundlePdfFonts, c as compilePdfSfc } from './shared/nuxt-pdf.C-E8MM_K.mjs';
 import { pdfImageFormatFromKey } from '../dist/runtime/server/assets/resolve-asset.js';
 import '@vue/compiler-sfc';
 import '@jridgewell/remapping';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/nuxt-pdf",
-  "version": "0.4.0-beta.2",
+  "version": "0.4.0-beta.4",
   "description": "Author and render PDFs with Vue components in Nuxt",
   "keywords": [
     "nuxt",
@@ -30,6 +30,14 @@
     "./test": {
       "types": "./dist/test.d.mts",
       "import": "./dist/test.mjs"
+    },
+    "./build": {
+      "types": "./dist/build.d.mts",
+      "import": "./dist/build.mjs"
+    },
+    "./server": {
+      "types": "./dist/server.d.mts",
+      "import": "./dist/server.mjs"
     }
   },
   "main": "./dist/module.mjs",
@@ -68,15 +76,14 @@
     "release:notes": "node scripts/write-release-notes.mjs",
     "release:pack": "pnpm build && node scripts/check-release-artifact.mjs release-artifacts",
     "release:prepare": "changelogen --bump --clean",
-    "release:verify": "pnpm verify && pnpm release:pack",
+    "release:verify": "pnpm check:dependencies && pnpm audit:all && pnpm check:source && node scripts/check-release-artifact.mjs release-artifacts",
     "test:artifact": "node scripts/check-release-artifact.mjs",
     "test:dependencies": "node scripts/check-production-dependencies.mjs",
-    "test:docs": "node scripts/check-documentation.mjs && pnpm docs:theme && pnpm --dir docs check",
+    "test:docs": "node scripts/check-documentation.mjs && pnpm --dir docs check",
     "test:package": "node scripts/check-package.mjs",
-    "test:package-metadata": "node scripts/check-api-report.mjs",
     "test:performance": "node --expose-gc ./node_modules/vitest/vitest.mjs run --config vitest.performance.config.ts",
     "test:prepare": "pnpm dev:prepare && nuxt prepare test/fixtures/layers",
-    "test:production": "vitest run --config vitest.production.config.ts",
+    "test:production": "pnpm build && vitest run --config vitest.production.config.ts",
     "test:quickstart": "node scripts/test-package-quickstart.mjs",
     "test:raster": "vitest run --config vitest.raster.config.ts",
     "test:version-headings": "node scripts/check-version-headings.mjs",
@@ -84,10 +91,12 @@
     "check:vercel": "node scripts/check-vercel-config.mjs",
     "test:serverless": "vitest run --config vitest.serverless.config.ts",
     "test:watch": "vitest watch",
-    "typecheck": "nuxt prepare && vue-tsc --noEmit && nuxt prepare test/fixtures/basic && vue-tsc --noEmit -p test/fixtures/basic/tsconfig.json && pnpm test:prepare && pnpm --dir playground exec vue-tsc --noEmit",
+    "typecheck": "pnpm test:prepare && nuxt prepare && vue-tsc --noEmit && nuxt prepare test/fixtures/basic && vue-tsc --noEmit -p test/fixtures/basic/tsconfig.json && pnpm --dir playground exec vue-tsc --noEmit",
     "audit:all": "pnpm audit",
-    "verify": "pnpm audit:all && pnpm check",
-    "check": "pnpm format:check && pnpm check:vercel && pnpm typecheck && pnpm test:docs && pnpm test:version-headings && pnpm test:workflows && pnpm test:dependencies && pnpm test && pnpm test:production && pnpm test:serverless && pnpm build && pnpm test:package-metadata && pnpm dev:build && pnpm test:artifact"
+    "check:dependencies": "node scripts/check-dependency-policy.mjs",
+    "verify": "pnpm check:dependencies && pnpm audit:all && pnpm check",
+    "check": "pnpm check:source && pnpm test:artifact",
+    "check:source": "pnpm format:check && pnpm check:vercel && pnpm typecheck && pnpm test:docs && pnpm test:version-headings && pnpm test:workflows && pnpm test:dependencies && pnpm test && pnpm test:production && pnpm test:serverless && pnpm build && pnpm test:api && pnpm dev:build"
   },
   "dependencies": {
     "@jridgewell/remapping": "2.3.5",
@@ -97,11 +106,13 @@
     "@react-pdf/pdfkit": "5.1.1",
     "@react-pdf/primitives": "4.3.0",
     "@react-pdf/render": "4.5.1",
-    "@vue/compiler-sfc": "3.5.40",
+    "@vue/compiler-sfc": "3.5.42",
     "esbuild": "0.28.1",
     "h3": "1.15.11",
     "ufo": "1.6.4",
-    "unimport": "6.3.0"
+    "unimport": "6.3.0",
+    "typescript": "~5.9.3",
+    "vue-tsc": "^3.3.3"
   },
   "peerDependencies": {
     "@napi-rs/canvas": "^0.1.97",
@@ -137,10 +148,8 @@
     "publint": "^0.3.21",
     "react": "19.2.0",
     "source-code-pro": "2.42.0",
-    "typescript": "~5.9.3",
     "vitest": "^4.1.8",
-    "vue": "3.5.40",
-    "vue-tsc": "^3.3.3",
+    "vue": "3.5.42",
     "yaml": "2.9.0"
   }
 }