@lupinum/nuxt-pdf 0.4.0-beta.1 → 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,41 @@ 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)
+
+### Added
+
+- **fonts:** Support WOFF2 assets ([ad50390](https://github.com/lupinum-dev/nuxt-pdf/commit/ad50390))
+- **diagnostics:** Explain unbreakable layout overflow ([a5ff0b7](https://github.com/lupinum-dev/nuxt-pdf/commit/a5ff0b7))
+
+### Fixed
+
+- **ci:** Harden on-demand Vercel reporting ([#35](https://github.com/lupinum-dev/nuxt-pdf/pull/35))
+- **release:** Repair from certified source evidence ([#36](https://github.com/lupinum-dev/nuxt-pdf/pull/36))
+- **release:** Separate publication from repair ([#37](https://github.com/lupinum-dev/nuxt-pdf/pull/37))
+- **types:** Expose PDF authoring globals ([c427310](https://github.com/lupinum-dev/nuxt-pdf/commit/c427310))
+
+### CI
+
+- **vercel:** Cut library preview build usage ([#34](https://github.com/lupinum-dev/nuxt-pdf/pull/34))
+
 ## 0.4.0-beta.1 - 2026-08-22
 
 ### Added

package/CONFORMANCE.md

@@ -1,11 +1,11 @@
-# Nuxt PDF 0.4.0-beta.1 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.1 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:
@@ -204,7 +217,7 @@ checking.
 
 ### Vue and Nuxt authoring
 
-The 0.4.0-beta.1 tests verify:
+The 0.4.0-beta.2 tests verify:
 
 - `PdfDocument`, `PdfPage`, `PdfView`, `PdfText`, `PdfImage`, `PdfLink`, and
   `PdfNote`;
@@ -326,7 +339,7 @@ point at the source files and re-read them per render, so an edited image
 shows up without a restart. The tested boundary includes:
 
 - PNG and JPEG extension/signature validation and source byte limits;
-- TTF and OTF signature/extension/SFNT table-directory validation,
+- 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;
 - rejection of absolute paths, traversal, missing assets, ambiguous sources,
@@ -437,7 +450,7 @@ parser, not two. Claimed:
 Verified end-to-end against a real rendered template, including assertion
 failure messages, in `test/test-utils-public.test.ts`.
 
-## Explicitly not claimed in 0.4.0-beta.1
+## Explicitly not claimed in 0.4.0-beta.2
 
 - Full React PDF component, hook, browser-helper, or test-suite parity.
 - React runtime compatibility or React-shaped dynamic callback results.

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.1",
+  "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._V584vX4.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.1";
+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,35 +29,6 @@ const existingDirectories = async (directories) => {
   }
   return result;
 };
-const generateAuthoringTypes = (componentsImport) => `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",
@@ -256,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"))
     );
@@ -331,7 +120,9 @@ const module$1 = defineNuxtModule({
     addTypeTemplate({
       filename: "types/nuxt-pdf-authoring.d.ts",
       getContents: () => generateAuthoringTypes(
-        componentsImport
+        componentsImport,
+        composablesImport,
+        definePdfImport
       ),
       write: true
     }, { nitro: true, node: true, nuxt: true });

package/dist/runtime/fonts.d.ts

@@ -7,7 +7,7 @@ export interface PdfFontDeclaration {
     fontStyle?: PdfFontStyle;
     fontWeight?: PdfFontWeight;
 }
-export type PdfFontDataUrl = `data:font/${'otf' | 'ttf'};base64,${string}`;
+export type PdfFontDataUrl = `data:font/${'otf' | 'ttf' | 'woff2'};base64,${string}`;
 export interface BundledPdfFontDescriptor {
     family: string;
     src: PdfFontDataUrl;

package/dist/runtime/renderer/index.d.ts

@@ -1,3 +1,4 @@
 export { mountPdfComponent } from './render-component.js';
+export { PDF_PRIMITIVE_NAMES } from './types.js';
 export type { MountedPdfComponent, PdfComponentProps, } from './render-component.js';
 export type { PdfDocumentNode, PdfElementNode, PdfNode, PdfRoot, PdfTextInstance, } from './types.js';

package/dist/runtime/renderer/index.js

@@ -1 +1,2 @@
 export { mountPdfComponent } from "./render-component.js";
+export { PDF_PRIMITIVE_NAMES } from "./types.js";