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

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,21 @@ 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.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.3 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.3 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:

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.DMC_Rdsz.mjs';
+import ts from 'typescript';
+import { p as preparePdfImageAssets, g as generatePdfRuntimeRegistry, a as generateAuthoringTypes, b as generatePdfRegistryTypes } from './shared/nuxt-pdf.D3hUPqOJ.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.3",
   "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 { d as discoverPdfTemplates, e as discoverPdfComponentFiles, a as discoverPdfImageFiles, b as bundlePdfFonts, f as createPdfSfcPlugin, g as classifyPdfWatchEvent } from './shared/nuxt-pdf.DMC_Rdsz.mjs';
+import { p as preparePdfImageAssets, g as generatePdfRuntimeRegistry, b as generatePdfRegistryTypes, a as generateAuthoringTypes, c as generatePdfPreviewConfig } from './shared/nuxt-pdf.D3hUPqOJ.mjs';
 import { PDF_STUB_NAMES } 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.3";
 
-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"))
     );

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.D3hUPqOJ.mjs

@@ -0,0 +1,203 @@
+import { PDF_STUB_NAMES } 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 {
+${PDF_STUB_NAMES.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/shared/{nuxt-pdf.D0zmsct0.mjs → nuxt-pdf.DMC_Rdsz.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;
@@ -882,6 +886,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 +981,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 +1007,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 +1178,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/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.DMC_Rdsz.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.3",
   "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",
@@ -76,7 +84,7 @@
     "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,7 +92,7 @@
     "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"
@@ -97,11 +105,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 +147,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"
   }
 }