@lupinum/nuxt-email 1.0.0-beta.1 → 1.0.0-beta.3

package/CHANGELOG.md

@@ -1,8 +1,46 @@
 # Changelog
 
+## v1.0.0-beta.3
+
+[compare changes](https://github.com/lupinum-dev/nuxt-email/compare/v1.0.0-beta.2...v1.0.0-beta.3)
+
+### 🩹 Fixes
+
+- **deps:** Enforce expiring quarantine exceptions ([#47](https://github.com/lupinum-dev/nuxt-email/pull/47))
+- **preview:** Bundle configured renderer during development ([#48](https://github.com/lupinum-dev/nuxt-email/pull/48))
+- **compatibility:** Prove supported Nuxt and Vue ranges ([#50](https://github.com/lupinum-dev/nuxt-email/pull/50))
+
+### 🏡 Chore
+
+- **maintenance:** Verify Email commands without repeated CI work ([#49](https://github.com/lupinum-dev/nuxt-email/pull/49))
+
+### ❤️ Contributors
+
+- Matthias Amon
+
+## v1.0.0-beta.2
+
+### Added
+
+- Added `@lupinum/nuxt-email/build` to compile the existing typed email
+  registry for Node runtimes outside Nitro.
+- Added `@lupinum/nuxt-email/render` so compiled templates reuse the same
+  deterministic renderer, metadata, plain-text generation, and email-safe
+  components as Nuxt applications.
+
+### Production boundaries
+
+- Keep delivery, retries, idempotency, provider credentials, and audit state
+  application-owned. The package compiles and renders email; it does not send.
+- Reject source directories outside the application root, refuse to replace
+  output not owned by Nuxt Email, and preserve the last valid registry when a
+  build fails.
+- Exclude preview fixtures and source templates from the generated production
+  registry.
+
 ## v1.0.0-beta.1
 
-Status: certified beta candidate. Feature development is frozen until stable `1.0.0`; manual email-client QA and the external transactional beta remain pending.
+Status: published on npm's `next` tag. Feature development is frozen until stable `1.0.0`. The three-client beta smoke test passed; the full eight-client checklist and external transactional beta remain pending.
 
 ### Added
 
@@ -89,6 +127,6 @@ Status: pre-1.0 candidate. The package identity is `@lupinum/nuxt-email`; the un
 
 - Node.js `^22.18.0 || ^24.11.0 || ^26.0.0`.
 - Nuxt `>=4.5.1 <5`.
-- Vue `^3.5.35`.
+- Vue `^3.5.40`.
 
 The repository's v1.0 readiness gate records the current contract and remaining approval steps; the live release ledger is intentionally excluded from the npm tarball.

package/README.md

@@ -25,7 +25,7 @@
 </p>
 
 > [!WARNING]
-> Nuxt Email is in the `1.0.0-beta.1` contract freeze. Review the changelog before each upgrade. Manual inbox QA and the external beta are still pending. The unscoped `nuxt-email` package on npm is unrelated to this project.
+> [`1.0.0-beta.2`](https://www.npmjs.com/package/@lupinum/nuxt-email/v/1.0.0-beta.2) is published on npm's `next` tag. The [three-client beta smoke test](https://github.com/lupinum-dev/nuxt-email/blob/main/docs/release/client-qa-checklist.md#100-beta1-smoke-test) passed against beta.1; the full eight-client checklist and an external transactional beta still block stable `1.0.0`. The unscoped `nuxt-email` package on npm is unrelated to this project.
 
 ## Why use Nuxt Email?
 
@@ -43,16 +43,16 @@ Do not use it for marketing campaigns or a workflow shared by non-Nuxt applicati
 
 - Node.js `^22.18.0 || ^24.11.0 || ^26.0.0`.
 - Nuxt `>=4.5.1 <5`.
-- Vue `^3.5.35`.
+- Vue `^3.5.40`.
 
-CI tests every supported Node major. The release consumer installs Nuxt `4.5.2` without a dependency shim.
+CI tests every supported Node major. Release consumers verify the declared minimum and current Nuxt 4 and Vue 3 versions without a dependency shim.
 
 ## Installation
 
 Install and register the module:
 
 ```bash
-pnpm add @lupinum/nuxt-email
+pnpm add @lupinum/nuxt-email@next
 ```
 
 ```ts
@@ -69,19 +69,30 @@ Create `app/emails/welcome.vue`:
 <script setup lang="ts">
 import { defineEmail } from '@lupinum/nuxt-email/define-email'
 
-const props = defineProps<{ firstName: string; activationUrl: string }>()
+const props = defineProps<{
+  firstName: string
+  activationUrl: string
+}>()
 
-defineEmail({ subject: () => `Welcome, ${props.firstName}` })
+defineEmail({
+  subject: () => `Welcome aboard, ${props.firstName}`,
+})
 </script>
 
 <template>
   <ETailwind>
     <EHtml lang="en">
-      <EBody class="bg-slate-100 p-6">
+      <EHead>
+        <title>Activate your account</title>
+      </EHead>
+      <EBody class="m-0 bg-slate-100 p-6">
         <EPreview>Your account is ready.</EPreview>
-        <EContainer class="bg-white p-6">
-          <EHeading>Welcome, {{ firstName }}</EHeading>
-          <EButton :href="activationUrl">Activate account</EButton>
+        <EContainer class="rounded-lg bg-white p-6">
+          <EHeading class="m-0 text-2xl text-slate-900">Welcome, {{ firstName }}</EHeading>
+          <EText class="text-slate-600">Finish setting up your account.</EText>
+          <EButton class="rounded-md bg-blue-600 px-5 py-3 text-white" :href="activationUrl">
+            Activate account
+          </EButton>
         </EContainer>
       </EBody>
     </EHtml>
@@ -100,7 +111,7 @@ export default defineEventHandler(async () => {
 })
 ```
 
-The template name and props are generated from the Vue file. Invalid names and props fail during type checking.
+The template name and props are generated from the Vue file. Invalid names and props fail during type checking. Use a sibling fixture to inspect it in `/__email`, then [pass the rendered result to your provider](https://nuxt-email.lupinum.com/docs/guides/sending-email).
 
 ## Discord
 
@@ -175,14 +186,11 @@ Complete the [manual client QA checklist](https://github.com/lupinum-dev/nuxt-em
 
 ## Package exports
 
-- `@lupinum/nuxt-email` provides the Nuxt module plus the `RenderedEmail` and `EmailComponentProps` types.
-- `@lupinum/nuxt-email/define-email` provides typed template metadata.
-- `@lupinum/nuxt-email/testing` provides standalone component rendering.
-- `@lupinum/nuxt-email/errors` provides supported runtime error classes.
+The package has a module entry point plus focused build, production rendering, metadata, testing, and error subpaths. Use `@lupinum/nuxt-email/build` to compile a server registry and `@lupinum/nuxt-email/render` for compiled components outside Nitro. The [standalone guide](https://nuxt-email.lupinum.com/docs/guides/standalone-rendering) explains the build and runtime boundaries. The [canonical entry-point table](https://nuxt-email.lupinum.com/docs/reference/module#package-entry-points) lists every runtime and type-only export.
 
 ## Documentation
 
-Read the [Nuxt Email documentation](https://nuxt-email.lupinum.com/docs). It contains the [installation guide](https://nuxt-email.lupinum.com/docs/getting-started/installation), [component reference](https://nuxt-email.lupinum.com/docs/components), [preview guide](https://nuxt-email.lupinum.com/docs/guides/preview-workflow), [testing guide](https://nuxt-email.lupinum.com/docs/guides/testing-your-emails), and [sending guide](https://nuxt-email.lupinum.com/docs/guides/sending-email).
+Read the [Nuxt Email documentation](https://nuxt-email.lupinum.com/docs). Start with the [installation guide](https://nuxt-email.lupinum.com/docs/getting-started/installation) and [component reference](https://nuxt-email.lupinum.com/docs/components). Use the guides for [preview](https://nuxt-email.lupinum.com/docs/guides/preview-workflow), [testing](https://nuxt-email.lupinum.com/docs/guides/testing-your-emails), and [sending](https://nuxt-email.lupinum.com/docs/guides/sending-email).
 
 See the [changelog](CHANGELOG.md) for released changes.
 

package/dist/build.d.mts

@@ -0,0 +1,13 @@
+interface BuildEmailRegistryOptions {
+    /** Application/project root, without loading its Nuxt configuration. */
+    rootDir: string;
+    /** Template directory relative to rootDir. Defaults to app/emails. */
+    templatesDir?: string;
+    /** Dedicated directory inside rootDir. Must be absent or previously created by this helper. */
+    outDir: string;
+}
+/** Compile trusted application templates. Never call this from a request or action. */
+declare function buildEmailRegistry(options: BuildEmailRegistryOptions): Promise<void>;
+
+export { buildEmailRegistry };
+export type { BuildEmailRegistryOptions };

package/dist/build.mjs

@@ -0,0 +1,218 @@
+import { execFile } from 'node:child_process';
+import { readFile, lstat, mkdir, mkdtemp, writeFile, rm, readdir, rename } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { relative, dirname, resolve, isAbsolute, join } from 'node:path';
+import { promisify } from 'node:util';
+import { build } from 'esbuild';
+import ts from 'typescript';
+import { d as discoverEmailTemplates, g as generateEmailRegistry, a as generateEmailTypes } from './shared/nuxt-email.B5ux0eBv.mjs';
+import { createHash } from 'node:crypto';
+import { parse, compileScript, compileTemplate } from 'vue/compiler-sfc';
+import '@nuxt/kit';
+
+function emailTemplatesPlugin(directory) {
+  return {
+    name: "nuxt-email-templates",
+    setup(build) {
+      build.onLoad({ filter: /\.vue$/ }, async ({ path }) => {
+        const { descriptor, errors } = parse(await readFile(path, "utf8"), { filename: path });
+        if (errors.length > 0) throw errors[0];
+        if (descriptor.styles.length || descriptor.customBlocks.length) {
+          throw new Error("Standalone email templates do not support style or custom blocks. Use ETailwind or inline styles.");
+        }
+        if ([descriptor.script, descriptor.scriptSetup, descriptor.template].some((block) => block?.src)) {
+          throw new Error("Standalone email templates do not support external SFC blocks. Import local components instead.");
+        }
+        if ([descriptor.script, descriptor.scriptSetup].some((block) => block?.lang && !["js", "ts"].includes(block.lang)) || descriptor.template?.lang && descriptor.template.lang !== "html") {
+          throw new Error("Standalone email templates support JavaScript/TypeScript scripts and HTML templates only.");
+        }
+        const id = createHash("sha256").update(relative(directory, path).replaceAll("\\", "/")).digest("hex").slice(0, 8);
+        const script = descriptor.script || descriptor.scriptSetup ? compileScript(descriptor, { id, genDefaultAs: "__emailComponent", inlineTemplate: false, isProd: true }) : void 0;
+        const template = descriptor.template ? compileTemplate({
+          source: descriptor.template.content,
+          filename: path,
+          id,
+          isProd: true,
+          compilerOptions: { bindingMetadata: script?.bindings },
+          transformAssetUrls: false
+        }) : void 0;
+        if (template?.errors.length) throw template.errors[0];
+        return {
+          contents: [
+            script?.content ?? "const __emailComponent = {}",
+            template?.code ?? "",
+            template ? "__emailComponent.render = render" : "",
+            "export default __emailComponent"
+          ].join("\n"),
+          loader: "ts",
+          resolveDir: dirname(path)
+        };
+      });
+    }
+  };
+}
+
+const execute = promisify(execFile);
+const require$1 = createRequire(import.meta.url);
+const renderImport = "@lupinum/nuxt-email/render";
+const ownershipMarker = ".nuxt-email-generated";
+const ownershipContent = "Generated by @lupinum/nuxt-email/build. Do not edit.\n";
+function contains(parent, child) {
+  const path = relative(parent, child);
+  return path === "" || !path.startsWith(`..`) && !isAbsolute(path);
+}
+async function replaceOutputDirectory(staging, outDir, replaceOutput) {
+  const previousRoot = await mkdtemp(join(dirname(outDir), ".nuxt-email-previous-"));
+  const previous = join(previousRoot, "output");
+  let removePreviousRoot = true;
+  try {
+    if (replaceOutput) await rename(outDir, previous);
+    try {
+      await rename(staging, outDir);
+    } catch (error) {
+      if (replaceOutput) {
+        try {
+          await rename(previous, outDir);
+        } catch (restoreError) {
+          removePreviousRoot = false;
+          throw new AggregateError(
+            [error, restoreError],
+            `Failed to replace generated email 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 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}. Keep local imports inside the email directory.`);
+            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();
+    }
+  }
+}
+async function buildEmailRegistry(options) {
+  if (Object.keys(options).some((key) => key !== "rootDir" && key !== "outDir" && key !== "templatesDir")) {
+    throw new TypeError("buildEmailRegistry accepts only rootDir, outDir and templatesDir.");
+  }
+  const rootDir = resolve(options.rootDir);
+  const templatesDir = options.templatesDir ?? "app/emails";
+  if (isAbsolute(templatesDir)) throw new TypeError("templatesDir must be relative to rootDir.");
+  const directory = resolve(rootDir, templatesDir);
+  if (!contains(rootDir, directory)) throw new TypeError("templatesDir must remain inside rootDir.");
+  const outDir = resolve(rootDir, options.outDir);
+  if (!contains(rootDir, outDir)) throw new TypeError("outDir must remain inside rootDir so the generated module can resolve project dependencies.");
+  if (contains(directory, outDir) || contains(outDir, directory)) {
+    throw new TypeError("Generated output must be outside and must not contain the email directory.");
+  }
+  let replaceOutput = false;
+  try {
+    const output = await lstat(outDir);
+    if (!output.isDirectory() || output.isSymbolicLink()) throw new TypeError("outDir must be a generated directory, not a file or symlink.");
+    const marker = await readFile(join(outDir, ownershipMarker), "utf8").catch(() => "");
+    if (marker !== ownershipContent) throw new TypeError("Refusing to replace an outDir not owned by this build.");
+    replaceOutput = true;
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+  }
+  const templates = await discoverEmailTemplates(directory);
+  if (templates.length === 0) throw new TypeError("The email directory contains no templates.");
+  await mkdir(dirname(outDir), { recursive: true });
+  const staging = await mkdtemp(join(dirname(outDir), ".nuxt-email-build-"));
+  try {
+    const declarations = join(staging, "types");
+    const globals = join(staging, "components.d.ts");
+    await writeFile(globals, `import type { EmailComponents } from '${renderImport}'
+declare module 'vue' { interface GlobalComponents extends EmailComponents {} }
+export {}
+`);
+    const config = join(staging, "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: directory,
+        declarationDir: declarations,
+        types: [],
+        lib: ["ES2022", "DOM", "DOM.Iterable"]
+      },
+      vueCompilerOptions: { strictTemplates: true },
+      files: [globals, ...templates.map((template) => template.sourcePath)]
+    }));
+    try {
+      await execute(process.execPath, [require$1.resolve("vue-tsc/bin/vue-tsc.js"), "-p", config], {
+        cwd: directory,
+        maxBuffer: 4 * 1024 * 1024
+      });
+    } catch (error) {
+      const diagnostics = error instanceof Error && "stdout" in error && typeof error.stdout === "string" ? error.stdout.trim() : "";
+      throw new Error(`Email declaration build failed${diagnostics ? `:
+${diagnostics}` : "."}`, { cause: error });
+    }
+    await normalizeDeclarationImports(declarations);
+    const registry = generateEmailRegistry(templates, {
+      emailRenderError: renderImport,
+      renderEmailComponent: renderImport,
+      templateRegistryErrors: renderImport
+    });
+    await build({
+      absWorkingDir: rootDir,
+      tsconfigRaw: { compilerOptions: { target: "ES2022", module: "ESNext" } },
+      stdin: { contents: registry, resolveDir: directory, sourcefile: "email-registry.js" },
+      outfile: join(staging, "index.mjs"),
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node22",
+      packages: "external",
+      logLevel: "silent",
+      plugins: [emailTemplatesPlugin(directory)]
+    });
+    await writeFile(join(staging, "index.d.mts"), generateEmailTypes(
+      templates.map((template) => ({
+        name: template.name,
+        sourcePath: `./types/${template.name}.vue.js`
+      })),
+      { renderedEmail: renderImport }
+    ));
+    await writeFile(join(staging, ownershipMarker), ownershipContent);
+    await rm(config);
+    await rm(globals);
+    await replaceOutputDirectory(staging, outDir, replaceOutput);
+  } finally {
+    await rm(staging, { recursive: true, force: true });
+  }
+}
+
+export { buildEmailRegistry };

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=4.5.1 <5"
   },
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,8 +1,9 @@
-import { relative, isAbsolute, sep, resolve } from 'node:path';
-import { resolveFiles, defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, addServerImports, addComponent, addServerHandler, useNitro, updateTemplates } from '@nuxt/kit';
+import { resolve, isAbsolute, relative } from 'node:path';
+import { defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, addServerImports, addComponent, addServerHandler, useNitro, updateTemplates } from '@nuxt/kit';
 import vueRollup from 'unplugin-vue/rollup';
 import { stat } from 'node:fs/promises';
 import { EMAIL_COMPONENT_NAMES } from '../dist/runtime/components/email-component-names.js';
+import { g as generateEmailRegistry, a as generateEmailTypes, d as discoverEmailTemplates } from './shared/nuxt-email.B5ux0eBv.mjs';
 
 function previewFixturePath(sourcePath) {
   return `${sourcePath.slice(0, -".vue".length)}.fixtures.ts`;
@@ -26,135 +27,6 @@ async function attachPreviewFixtures(templates) {
   }));
 }
 
-class DuplicateEmailTemplateError extends Error {
-  templateName;
-  sourcePaths;
-  constructor(templateName, sourcePaths) {
-    const sortedSourcePaths = [...sourcePaths].sort();
-    super(`Duplicate email template name "${templateName}" from: ${sortedSourcePaths.join(", ")}`);
-    this.name = "DuplicateEmailTemplateError";
-    this.templateName = templateName;
-    this.sourcePaths = sortedSourcePaths;
-  }
-}
-class EmailTemplateDiscoveryError extends Error {
-  sourcePath;
-  constructor(sourcePath, cause) {
-    super(`Failed to discover email templates under ${sourcePath}`, { cause });
-    this.name = "EmailTemplateDiscoveryError";
-    this.sourcePath = sourcePath;
-  }
-}
-
-function compareCodePoints(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function normalizeSeparators(value) {
-  return value.split(sep).join("/").replaceAll("\\", "/");
-}
-function templatesFromSourcePaths(emailDirectory, sourcePaths) {
-  const templates = sourcePaths.map((sourcePath) => {
-    const relativePath = normalizeSeparators(relative(emailDirectory, sourcePath));
-    if (relativePath.startsWith("../") || relativePath === ".." || isAbsolute(relativePath)) {
-      throw new EmailTemplateDiscoveryError(sourcePath, new TypeError("Template path is outside app/emails"));
-    }
-    return {
-      name: relativePath.slice(0, -".vue".length),
-      sourcePath: normalizeSeparators(sourcePath)
-    };
-  }).sort((left, right) => {
-    return compareCodePoints(left.name, right.name) || compareCodePoints(left.sourcePath, right.sourcePath);
-  });
-  const pathsByName = /* @__PURE__ */ new Map();
-  for (const template of templates) {
-    const paths = pathsByName.get(template.name) ?? [];
-    paths.push(template.sourcePath);
-    pathsByName.set(template.name, paths);
-  }
-  const duplicate = [...pathsByName.entries()].filter(([, paths]) => paths.length > 1).sort(([left], [right]) => compareCodePoints(left, right))[0];
-  if (duplicate) {
-    throw new DuplicateEmailTemplateError(duplicate[0], duplicate[1]);
-  }
-  return templates;
-}
-async function discoverEmailTemplates(emailDirectory) {
-  let sourcePaths;
-  try {
-    sourcePaths = await resolveFiles(emailDirectory, "**/*.vue", {
-      followSymbolicLinks: false,
-      ignore: ["components/**"]
-    });
-  } catch (error) {
-    throw new EmailTemplateDiscoveryError(emailDirectory, error);
-  }
-  return templatesFromSourcePaths(emailDirectory, sourcePaths);
-}
-
-function importPath(path) {
-  return JSON.stringify(path.replaceAll("\\", "/"));
-}
-function generateEmailRegistry(templates, runtimePaths) {
-  const entries = templates.map((template) => {
-    const fixture = template.fixturePath ? `
-    fixture: () => import(${importPath(template.fixturePath)}),` : "";
-    return `  [${JSON.stringify(template.name)}]: {
-    component: () => import(${importPath(template.sourcePath)}),${fixture}
-  },`;
-  });
-  return `import { EmailRenderError } from ${importPath(runtimePaths.emailRenderError)}
-import { renderEmailComponent } from ${importPath(runtimePaths.renderEmailComponent)}
-import { UnknownEmailTemplateError } from ${importPath(runtimePaths.templateRegistryErrors)}
-
-export const emailTemplates = Object.freeze({
-${entries.join("\n")}
-})
-
-export async function renderEmail(name, props) {
-  const loader = typeof name === 'string' && Object.hasOwn(emailTemplates, name)
-    ? emailTemplates[name]
-    : undefined
-  if (!loader) {
-    throw new UnknownEmailTemplateError(String(name), Object.keys(emailTemplates))
-  }
-
-  try {
-    const templateModule = await loader.component()
-    return await renderEmailComponent(templateModule.default, props)
-  }
-  catch (error) {
-    throw new EmailRenderError(name, error instanceof EmailRenderError ? error.cause : error)
-  }
-}
-`;
-}
-function generateEmailTypes(templates, typePaths) {
-  const entries = templates.map((template) => {
-    const fixture = template.fixturePath ? `
-    fixture: () => Promise<typeof import(${importPath(template.fixturePath)})>` : "";
-    return `  ${JSON.stringify(template.name)}: {
-    component: () => Promise<typeof import(${importPath(template.sourcePath)})>${fixture}
-  }`;
-  });
-  return `export const emailTemplates: Readonly<{
-${entries.join("\n")}
-}>
-
-export type EmailTemplateName = keyof typeof emailTemplates
-type _EmailProps<Component> = keyof import(${importPath(typePaths.renderedEmail)}).EmailComponentProps<Component> extends never
-  ? Record<string, never>
-  : import(${importPath(typePaths.renderedEmail)}).EmailComponentProps<Component>
-
-export type EmailTemplateProps = {
-  [Name in EmailTemplateName]: _EmailProps<Awaited<ReturnType<(typeof emailTemplates)[Name]['component']>>['default']>
-}
-
-export function renderEmail<Name extends EmailTemplateName>(
-  name: Name,
-  props: NoInfer<EmailTemplateProps[Name]>,
-): Promise<import(${importPath(typePaths.renderedEmail)}).RenderedEmail>
-`;
-}
-
 function configureEmailTypeProject(tsConfig, emailDirectory, registryId, registryPath) {
   const normalizedDirectory = emailDirectory.replaceAll("\\", "/");
   const include = tsConfig.include ??= [];
@@ -199,10 +71,12 @@ const module$1 = defineNuxtModule({
     const resolver = createResolver(import.meta.url);
     const defineEmailPublicPath = await resolver.resolvePath("./runtime/define-email");
     const errorsPublicPath = await resolver.resolvePath("./runtime/errors");
-    let renderEmailComponentPath = await resolver.resolvePath("./runtime/testing");
+    let renderEmailComponentPath = await resolver.resolvePath("./runtime/render/index");
+    let testingRendererPath = await resolver.resolvePath("./runtime/testing");
     if (options.codeBlock !== void 0) {
       const { setupCodeBlock } = await import('./chunks/setup.mjs');
       renderEmailComponentPath = setupCodeBlock(options.codeBlock, resolver);
+      testingRendererPath = renderEmailComponentPath;
     }
     const emailDirectory = resolve(nuxt.options.srcDir, "emails");
     const loadTemplates = async () => {
@@ -312,20 +186,20 @@ const module$1 = defineNuxtModule({
     const nuxtOptions = nuxt.options;
     const nitro = nuxtOptions.nitro ??= {};
     const alias = nitro.alias ??= {};
-    alias["#nuxt-email/testing"] = renderEmailComponentPath;
+    alias["#nuxt-email/testing"] = testingRendererPath;
     alias["@lupinum/nuxt-email/define-email"] = defineEmailPublicPath;
     alias["@lupinum/nuxt-email/errors"] = errorsPublicPath;
     const externals = nitro.externals ??= {};
     const inline = externals.inline ??= [];
-    for (const publicRuntimePath of [defineEmailPublicPath, errorsPublicPath]) {
-      if (!inline.includes(publicRuntimePath)) {
-        inline.push(publicRuntimePath);
+    for (const runtimePath of [defineEmailPublicPath, errorsPublicPath, testingRendererPath]) {
+      if (!inline.includes(runtimePath)) {
+        inline.push(runtimePath);
       }
     }
     const typescript = nitro.typescript ??= {};
     const tsConfig = typescript.tsConfig ??= {};
     const paths = configureEmailTypeProject(tsConfig, emailDirectory, registryId, typeTemplate.dst);
-    paths["#nuxt-email/testing"] = [renderEmailComponentPath];
+    paths["#nuxt-email/testing"] = [testingRendererPath];
     nitro.rollupConfig ??= {};
     const existingPlugins = nitro.rollupConfig.plugins;
     nitro.rollupConfig.plugins = existingPlugins ? [existingPlugins, vueRollup()] : [vueRollup()];

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

@@ -0,0 +1,6 @@
+/** Server-only production rendering of already compiled Vue components. */
+export { renderEmailComponent } from './render-email-component.js';
+export { EmailRenderError } from './errors.js';
+export { UnknownEmailTemplateError } from '../template-registry/errors.js';
+export type { EmailComponentProps, RenderedEmail } from './types.js';
+export type EmailComponents = typeof import('../components/email-component-registry').emailComponentRegistry;

package/dist/runtime/render/index.js

@@ -0,0 +1,3 @@
+export { renderEmailComponent } from "./render-email-component.js";
+export { EmailRenderError } from "./errors.js";
+export { UnknownEmailTemplateError } from "../template-registry/errors.js";

package/dist/runtime/tailwind/css-tree.d.ts

@@ -0,0 +1,10 @@
+import type * as CssTree from 'css-tree';
+export declare const parse: typeof CssTree.parse;
+export declare const generate: typeof CssTree.generate;
+export declare const walk: typeof CssTree.walk;
+export declare const find: typeof CssTree.find;
+export declare const clone: typeof CssTree.clone;
+export declare const List: typeof CssTree.List;
+export type List<T> = CssTree.List<T>;
+export declare const string: typeof CssTree.string;
+export type * from 'css-tree';

package/dist/runtime/tailwind/css-tree.js

@@ -0,0 +1,11 @@
+import parser from "css-tree/parser";
+import generator from "css-tree/generator";
+import walker from "css-tree/walker";
+import { clone as cloneNode, List as NodeList, string as cssString } from "css-tree/utils";
+export const parse = parser;
+export const generate = generator;
+export const walk = walker;
+export const find = walker.find;
+export const clone = cloneNode;
+export const List = NodeList;
+export const string = cssString;

package/dist/runtime/tailwind/engine/css/downlevel-for-email-clients.d.ts

@@ -3,7 +3,7 @@
  * can parse. The transform is deliberately strict: leaving one nested rule in
  * the output is worse than failing the render with an actionable error.
  */
-import { type StyleSheet } from 'css-tree';
+import { type StyleSheet } from '../../css-tree.js';
 /**
  * css-tree 3.x parses media range syntax, but the currently published type
  * package does not expose the corresponding nodes yet.

package/dist/runtime/tailwind/engine/css/downlevel-for-email-clients.js

@@ -4,7 +4,7 @@ import {
   List,
   parse,
   walk
-} from "css-tree";
+} from "../../css-tree.js";
 export function downlevelForEmailClients(styleSheet) {
   styleSheet.children = flattenStyleSheet(styleSheet);
   downlevelRangeMediaQueries(styleSheet);

package/dist/runtime/tailwind/engine/css/extract-rules-per-class.d.ts

@@ -1,4 +1,4 @@
-import { type CssNode, type Rule } from 'css-tree';
+import { type CssNode, type Rule } from '../../css-tree.js';
 export interface ExtractedRules {
     inlinable: Map<string, Rule[]>;
     nonInlinable: Map<string, Rule[]>;

package/dist/runtime/tailwind/engine/css/extract-rules-per-class.js

@@ -1,4 +1,4 @@
-import { string, walk } from "css-tree";
+import { string, walk } from "../../css-tree.js";
 import { isRuleInlinable } from "./is-rule-inlinable.js";
 import { splitMixedRule } from "./split-mixed-rule.js";
 export function extractRulesPerClass(root, classes) {

package/dist/runtime/tailwind/engine/css/get-custom-properties.d.ts

@@ -1,4 +1,4 @@
-import { type CssNode, type Declaration } from 'css-tree';
+import { type CssNode, type Declaration } from '../../css-tree.js';
 export interface CustomProperty {
     syntax?: Declaration;
     inherits?: Declaration;

package/dist/runtime/tailwind/engine/css/get-custom-properties.js

@@ -1,4 +1,4 @@
-import { generate, walk } from "css-tree";
+import { generate, walk } from "../../css-tree.js";
 export function getCustomProperties(node) {
   const customProperties = /* @__PURE__ */ new Map();
   walk(node, {

package/dist/runtime/tailwind/engine/css/is-part-inlinable.d.ts

@@ -1,2 +1,2 @@
-import { type CssNode } from 'css-tree';
+import { type CssNode } from '../../css-tree.js';
 export declare function isPartInlinable(part: CssNode): boolean;

package/dist/runtime/tailwind/engine/css/is-part-inlinable.js

@@ -1,4 +1,4 @@
-import { find } from "css-tree";
+import { find } from "../../css-tree.js";
 export function isPartInlinable(part) {
   const hasAtRuleInside = find(part, (node) => node.type === "Atrule") !== null;
   const hasPseudoSelector = find(

package/dist/runtime/tailwind/engine/css/is-rule-inlinable.d.ts

@@ -1,2 +1,2 @@
-import { type Rule } from 'css-tree';
+import { type Rule } from '../../css-tree.js';
 export declare function isRuleInlinable(rule: Rule): boolean;

package/dist/runtime/tailwind/engine/css/is-rule-inlinable.js

@@ -1,4 +1,4 @@
-import { find } from "css-tree";
+import { find } from "../../css-tree.js";
 export function isRuleInlinable(rule) {
   const hasAtRuleInside = find(rule, (node) => node.type === "Atrule") !== null;
   const hasPseudoSelector = find(

package/dist/runtime/tailwind/engine/css/make-inline-styles-for.d.ts

@@ -1,4 +1,4 @@
-import { type CssNode } from 'css-tree';
+import { type CssNode } from '../../css-tree.js';
 import type { CustomProperties } from './get-custom-properties.js';
 /**
  * Adapted from React Email's `make-inline-styles-for.ts`.

package/dist/runtime/tailwind/engine/css/make-inline-styles-for.js

@@ -1,4 +1,4 @@
-import { generate, walk } from "css-tree";
+import { generate, walk } from "../../css-tree.js";
 import { getCssProperty } from "./get-css-property.js";
 import { stripEmptyTailwindVars } from "./strip-empty-tailwind-vars.js";
 import { unwrapValue } from "./unwrap-value.js";

package/dist/runtime/tailwind/engine/css/resolve-all-css-variables.d.ts

@@ -1,4 +1,4 @@
-import { type CssNode, type Declaration } from 'css-tree';
+import { type CssNode, type Declaration } from '../../css-tree.js';
 export interface VariableDefinition {
     declaration: Declaration;
     path: CssNode[];

package/dist/runtime/tailwind/engine/css/resolve-all-css-variables.js

@@ -2,7 +2,7 @@ import {
   generate,
   parse,
   walk
-} from "css-tree";
+} from "../../css-tree.js";
 function doSelectorsIntersect(first, second) {
   const firstStringified = generate(first);
   const secondStringified = generate(second);

package/dist/runtime/tailwind/engine/css/resolve-calc-expressions.d.ts

@@ -1,4 +1,4 @@
-import { type CssNode } from 'css-tree';
+import { type CssNode } from '../../css-tree.js';
 /**
  * Intentionally only resolves `*` and `/` operations without dealing with parenthesis, because this is the only thing required to run Tailwind v4
  */

package/dist/runtime/tailwind/engine/css/resolve-calc-expressions.js

@@ -1,4 +1,4 @@
-import { walk } from "css-tree";
+import { walk } from "../../css-tree.js";
 export function resolveCalcExpressions(node) {
   walk(node, {
     visit: "Function",

package/dist/runtime/tailwind/engine/css/sanitize-declarations.d.ts

@@ -1,4 +1,4 @@
-import { type CssNode } from 'css-tree';
+import { type CssNode } from '../../css-tree.js';
 /**
  * Meant to do all the things necessary, in a per-declaration basis, to have the best email client
  * support possible.

package/dist/runtime/tailwind/engine/css/sanitize-declarations.js

@@ -3,7 +3,7 @@ import {
   List,
   parse,
   walk
-} from "css-tree";
+} from "../../css-tree.js";
 function rgbNode(r, g, b, alpha) {
   const children = new List();
   children.appendData({

package/dist/runtime/tailwind/engine/css/sanitize-non-inlinable-rules.d.ts

@@ -1,4 +1,4 @@
-import { type CssNode } from 'css-tree';
+import { type CssNode } from '../../css-tree.js';
 /**
  * This function goes through a few steps to ensure the best email client support and
  * to ensure that media queries and pseudo classes are applied correctly alongside

package/dist/runtime/tailwind/engine/css/sanitize-non-inlinable-rules.js

@@ -1,4 +1,4 @@
-import { string, walk } from "css-tree";
+import { string, walk } from "../../css-tree.js";
 import { sanitizeClassName } from "../compatibility/sanitize-class-name.js";
 import { isRuleInlinable } from "./is-rule-inlinable.js";
 import { stripEmptyTailwindVars } from "./strip-empty-tailwind-vars.js";

package/dist/runtime/tailwind/engine/css/split-mixed-rule.d.ts

@@ -1,4 +1,4 @@
-import { type Rule } from 'css-tree';
+import { type Rule } from '../../css-tree.js';
 /**
  * Split a rule into inlinable and non-inlinable parts. Caller must only pass rules
  * for which isRuleInlinable(rule) is false. Returns clones so the original stylesheet is never mutated.

package/dist/runtime/tailwind/engine/css/split-mixed-rule.js

@@ -1,4 +1,4 @@
-import { clone, find, List } from "css-tree";
+import { clone, find, List } from "../../css-tree.js";
 import { isPartInlinable } from "./is-part-inlinable.js";
 export function splitMixedRule(rule) {
   const selectorHasPseudo = rule.prelude !== null && find(

package/dist/runtime/tailwind/engine/css/strip-empty-tailwind-vars.d.ts

@@ -1,4 +1,4 @@
-import { type CssNode } from 'css-tree';
+import { type CssNode } from '../../css-tree.js';
 /**
  * Tailwind v4 emits variant-stacking idioms like
  *   font-variant-numeric: var(--tw-ordinal,) var(--tw-slashed-zero,) tabular-nums var(--tw-numeric-fraction,)

package/dist/runtime/tailwind/engine/css/strip-empty-tailwind-vars.js

@@ -1,4 +1,4 @@
-import { generate, walk } from "css-tree";
+import { generate, walk } from "../../css-tree.js";
 export function stripEmptyTailwindVars(node) {
   walk(node, {
     visit: "Function",

package/dist/runtime/tailwind/engine/index.js

@@ -3,7 +3,7 @@ import {
   generate,
   List,
   walk
-} from "css-tree";
+} from "../css-tree.js";
 import { downlevelForEmailClients } from "./css/downlevel-for-email-clients.js";
 import { extractRulesPerClass } from "./css/extract-rules-per-class.js";
 import { getCustomProperties } from "./css/get-custom-properties.js";

package/dist/runtime/tailwind/engine/setup-tailwind.d.ts

@@ -1,4 +1,4 @@
-import { type StyleSheet } from 'css-tree';
+import { type StyleSheet } from '../css-tree.js';
 import type { TailwindConfig } from './types.js';
 export type TailwindSetup = Awaited<ReturnType<typeof setupTailwind>>;
 interface CSSConfigs {

package/dist/runtime/tailwind/engine/setup-tailwind.js

@@ -1,4 +1,4 @@
-import { parse } from "css-tree";
+import { parse } from "../css-tree.js";
 import { compile } from "tailwindcss";
 import {
   indexCss,

package/dist/runtime/tailwind/post-render.js

@@ -1,4 +1,4 @@
-import { generate, parse, walk } from "css-tree";
+import { generate, parse, walk } from "./css-tree.js";
 import { Parser } from "htmlparser2";
 import { classTokens, mergeInlinableStyle, residualClasses } from "./inline-utils.js";
 import { TailwindMissingHeadError } from "./errors.js";

package/dist/shared/nuxt-email.B5ux0eBv.mjs

@@ -0,0 +1,133 @@
+import { relative, isAbsolute, sep } from 'node:path';
+import { resolveFiles } from '@nuxt/kit';
+
+class DuplicateEmailTemplateError extends Error {
+  templateName;
+  sourcePaths;
+  constructor(templateName, sourcePaths) {
+    const sortedSourcePaths = [...sourcePaths].sort();
+    super(`Duplicate email template name "${templateName}" from: ${sortedSourcePaths.join(", ")}`);
+    this.name = "DuplicateEmailTemplateError";
+    this.templateName = templateName;
+    this.sourcePaths = sortedSourcePaths;
+  }
+}
+class EmailTemplateDiscoveryError extends Error {
+  sourcePath;
+  constructor(sourcePath, cause) {
+    super(`Failed to discover email templates under ${sourcePath}`, { cause });
+    this.name = "EmailTemplateDiscoveryError";
+    this.sourcePath = sourcePath;
+  }
+}
+
+function compareCodePoints(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function normalizeSeparators(value) {
+  return value.split(sep).join("/").replaceAll("\\", "/");
+}
+function templatesFromSourcePaths(emailDirectory, sourcePaths) {
+  const templates = sourcePaths.map((sourcePath) => {
+    const relativePath = normalizeSeparators(relative(emailDirectory, sourcePath));
+    if (relativePath.startsWith("../") || relativePath === ".." || isAbsolute(relativePath)) {
+      throw new EmailTemplateDiscoveryError(sourcePath, new TypeError("Template path is outside app/emails"));
+    }
+    return {
+      name: relativePath.slice(0, -".vue".length),
+      sourcePath: normalizeSeparators(sourcePath)
+    };
+  }).sort((left, right) => {
+    return compareCodePoints(left.name, right.name) || compareCodePoints(left.sourcePath, right.sourcePath);
+  });
+  const pathsByName = /* @__PURE__ */ new Map();
+  for (const template of templates) {
+    const paths = pathsByName.get(template.name) ?? [];
+    paths.push(template.sourcePath);
+    pathsByName.set(template.name, paths);
+  }
+  const duplicate = [...pathsByName.entries()].filter(([, paths]) => paths.length > 1).sort(([left], [right]) => compareCodePoints(left, right))[0];
+  if (duplicate) {
+    throw new DuplicateEmailTemplateError(duplicate[0], duplicate[1]);
+  }
+  return templates;
+}
+async function discoverEmailTemplates(emailDirectory) {
+  let sourcePaths;
+  try {
+    sourcePaths = await resolveFiles(emailDirectory, "**/*.vue", {
+      followSymbolicLinks: false,
+      ignore: ["components/**"]
+    });
+  } catch (error) {
+    throw new EmailTemplateDiscoveryError(emailDirectory, error);
+  }
+  return templatesFromSourcePaths(emailDirectory, sourcePaths);
+}
+
+function importPath(path) {
+  return JSON.stringify(path.replaceAll("\\", "/"));
+}
+function generateEmailRegistry(templates, runtimePaths) {
+  const entries = templates.map((template) => {
+    const fixture = template.fixturePath ? `
+    fixture: () => import(${importPath(template.fixturePath)}),` : "";
+    return `  [${JSON.stringify(template.name)}]: {
+    component: () => import(${importPath(template.sourcePath)}),${fixture}
+  },`;
+  });
+  return `import { EmailRenderError } from ${importPath(runtimePaths.emailRenderError)}
+import { renderEmailComponent } from ${importPath(runtimePaths.renderEmailComponent)}
+import { UnknownEmailTemplateError } from ${importPath(runtimePaths.templateRegistryErrors)}
+
+export const emailTemplates = Object.freeze({
+${entries.join("\n")}
+})
+
+export async function renderEmail(name, props) {
+  const loader = typeof name === 'string' && Object.hasOwn(emailTemplates, name)
+    ? emailTemplates[name]
+    : undefined
+  if (!loader) {
+    throw new UnknownEmailTemplateError(String(name), Object.keys(emailTemplates))
+  }
+
+  try {
+    const templateModule = await loader.component()
+    return await renderEmailComponent(templateModule.default, props)
+  }
+  catch (error) {
+    throw new EmailRenderError(name, error instanceof EmailRenderError ? error.cause : error)
+  }
+}
+`;
+}
+function generateEmailTypes(templates, typePaths) {
+  const entries = templates.map((template) => {
+    const fixture = template.fixturePath ? `
+    fixture: () => Promise<typeof import(${importPath(template.fixturePath)})>` : "";
+    return `  ${JSON.stringify(template.name)}: {
+    component: () => Promise<typeof import(${importPath(template.sourcePath)})>${fixture}
+  }`;
+  });
+  return `export const emailTemplates: Readonly<{
+${entries.join("\n")}
+}>
+
+export type EmailTemplateName = keyof typeof emailTemplates
+type _EmailProps<Component> = keyof import(${importPath(typePaths.renderedEmail)}).EmailComponentProps<Component> extends never
+  ? Record<string, never>
+  : import(${importPath(typePaths.renderedEmail)}).EmailComponentProps<Component>
+
+export type EmailTemplateProps = {
+  [Name in EmailTemplateName]: _EmailProps<Awaited<ReturnType<(typeof emailTemplates)[Name]['component']>>['default']>
+}
+
+export function renderEmail<Name extends EmailTemplateName>(
+  name: Name,
+  props: NoInfer<EmailTemplateProps[Name]>,
+): Promise<import(${importPath(typePaths.renderedEmail)}).RenderedEmail>
+`;
+}
+
+export { generateEmailTypes as a, discoverEmailTemplates as d, generateEmailRegistry as g };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/nuxt-email",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "description": "Typed transactional email for Nuxt with email-safe Tailwind v4",
   "keywords": [
     "email",
@@ -27,6 +27,14 @@
     "node": "^22.18.0 || ^24.11.0 || ^26.0.0"
   },
   "exports": {
+    "./build": {
+      "types": "./dist/build.d.mts",
+      "import": "./dist/build.mjs"
+    },
+    "./render": {
+      "types": "./dist/runtime/render/index.d.ts",
+      "import": "./dist/runtime/render/index.js"
+    },
     ".": {
       "types": "./dist/module.d.mts",
       "import": "./dist/module.mjs"
@@ -53,7 +61,7 @@
   ],
   "peerDependencies": {
     "nuxt": ">=4.5.1 <5",
-    "vue": "^3.5.35"
+    "vue": "^3.5.40"
   },
   "dependencies": {
     "@nuxt/kit": ">=4.5.1 <5",
@@ -62,12 +70,15 @@
     "@shikijs/langs": "4.3.1",
     "@shikijs/themes": "4.3.1",
     "css-tree": "3.2.1",
+    "esbuild": "0.28.1",
     "h3": "1.15.11",
     "html-to-text": "9.0.5",
     "htmlparser2": "^10.1.0",
     "marked": "15.0.12",
     "tailwindcss": "4.1.18",
-    "unplugin-vue": "7.2.0"
+    "typescript": "~5.9.3",
+    "unplugin-vue": "7.2.0",
+    "vue-tsc": "^3.3.3"
   },
   "devDependencies": {
     "@nuxt/eslint-config": "^1.15.2",
@@ -89,10 +100,8 @@
     "react-dom": "19.2.7",
     "react-email": "6.9.0",
     "tsx": "4.23.1",
-    "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"
   },
   "scripts": {
@@ -111,15 +120,18 @@
     "proofs:generate": "node --import tsx scripts/proofs/generate.ts",
     "proofs:send": "node --import tsx scripts/proofs/send.ts",
     "repo:check": "node scripts/check-repository-policy.mjs",
-    "release:verify": "pnpm verify && node --import tsx scripts/verify-release.ts",
+    "release:verify": "pnpm verify && pnpm release:pack",
     "release:prepare": "changelogen --bump --clean --hideAuthorEmail",
     "release:artifact": "pnpm release:verify --output .release/lupinum-nuxt-email.tgz && node scripts/write-release-manifest.mjs",
     "lint": "eslint .",
-    "test": "vitest run --exclude test/preview.test.ts && pnpm test:preview",
+    "test": "pnpm prepack && vitest run --exclude test/preview.test.ts --reporter=default --reporter=./test/conformance/tooling/reporter.ts && pnpm test:preview",
     "test:preview": "vitest run test/preview.test.ts",
     "test:conformance": "vitest run test/conformance",
     "test:watch": "vitest watch",
     "test:types": "pnpm dev:prepare && nuxt prepare test/fixtures/basic && nuxt prepare test/fixtures/code-block && nuxt prepare test/fixtures/preview && vue-tsc --noEmit && vue-tsc --noEmit -p test/fixtures/basic/.nuxt/tsconfig.server.json && vue-tsc --noEmit -p test/fixtures/code-block/.nuxt/tsconfig.server.json && vue-tsc --noEmit -p test/fixtures/preview/.nuxt/tsconfig.server.json && cd playground && vue-tsc --noEmit",
-    "verify": "pnpm audit:all && pnpm repo:check && pnpm lint && pnpm test:types && pnpm test && pnpm conformance:check && pnpm docs:build"
+    "verify": "pnpm check:dependencies && pnpm audit:all && pnpm repo:check && pnpm lint && pnpm test:types && pnpm test && pnpm docs:build",
+    "check:dependencies": "node scripts/check-dependency-policy.mjs",
+    "build": "nuxt-module-build build",
+    "release:pack": "node --import tsx scripts/verify-release.ts"
   }
 }