nuxt-i18n-micro 3.30.2 → 4.0.0

package/dist/module.mjs

@@ -1,24 +1,377 @@
 import * as fs from 'node:fs';
-import fs__default, { readFileSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
-import path, { dirname, resolve, join } from 'node:path';
+import fs__default, { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import path, { join, dirname, relative, basename, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { defaultPlural, isNoPrefixStrategy, withPrefixStrategy } from '@i18n-micro/core';
-import { generateHmrPlugin } from '@i18n-micro/hmr/generate-plugin';
-import { RouteGenerator, isLocaleAllowedForUnlocalizedRoute, normalizePath, isInternalPath } from '@i18n-micro/route-strategy';
-import { buildTranslationSourceLayers, preMergeLocales } from '@i18n-micro/utils/build';
-import { resolveTranslationPayloadOptions, getTranslationPayloadMisconfigurationWarnings, getTranslationPayloadSizeWarning, resolveTranslationPayloadWarningThresholds, resolveTranslationPayloadPublicRel, shouldReadPayloadsFromPublicDir, shouldRegisterNitroServerAssets, shouldCopyTranslationPayloadsToPublic, resolveTranslationPayloadPublicDir } from '@i18n-micro/utils/payload-config';
-export { resolveTranslationPayloadMode, resolveTranslationPayloadOptions, resolveTranslationPayloadPublicDir, resolveTranslationPayloadPublicRel, shouldCopyTranslationPayloadsToPublic, shouldRegisterNitroServerAssets } from '@i18n-micro/utils/payload-config';
-import { hashTranslationSources, scanTranslationPayloadDirectory, compressTranslationPayloads } from '@i18n-micro/utils/payload-stats';
-import { buildTranslationPayloadCacheControl } from '@i18n-micro/utils/payload-url';
-import { useNuxt, addDevServerHandler, defineNuxtModule, useLogger, createResolver, addImportsDir, addPlugin, addRouteMiddleware, addServerImportsDir, addServerHandler, addComponentsDir, addTemplate, addTypeTemplate, addVitePlugin, resolvePath, addPrerenderRoutes } from '@nuxt/kit';
+import { defaultPlural, isNoPrefixStrategy } from '@i18n-micro/core';
+import { forwardSlashes, trimLeadingSlashes, isInternalPath } from '@i18n-micro/utils/app-path';
+import { readTranslationFile, resolveLiveTranslationDirs, translationRelativePath } from '../dist/runtime/server/internal/translation-watcher.js';
+import { isLocaleAllowedForUnlocalizedRoute, normalizePath, routeKey, nameOfPath, RouteGenerator, localesOutsideMatcher, pageNames } from '@i18n-micro/route-strategy';
+import { configForHost } from '@i18n-micro/utils/domains';
+import { createHash } from 'node:crypto';
 import { globby } from 'globby';
+import { deepMergeTranslationsRecursive } from '@i18n-micro/utils/deep-merge';
+import { PREMERGED_ROOT_PAGE, mergeSourceTranslations, PREMERGED_ROOT_MARK, mergeOverRoot, buildFallbackLocaleChain } from '@i18n-micro/utils/merge-source';
+import { gzipSync, brotliCompressSync, constants } from 'node:zlib';
+import { resolveTranslationPayloadCachePolicy } from '@i18n-micro/utils/payload-url';
+import { useNuxt, addDevServerHandler, defineNuxtModule, useLogger, createResolver, addImportsDir, addPlugin, addRouteMiddleware, addPluginTemplate, addServerImports, addServerHandler, addComponentsDir, addVitePlugin, addTemplate, addTypeTemplate, resolvePath, addPrerenderRoutes } from '@nuxt/kit';
 import sirv from 'sirv';
 import { startSubprocess, addCustomTab, onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
+import { isInsideDir, resolveTranslationFile } from '@i18n-micro/utils/load-dir';
 import { fromNodeMiddleware, defineEventHandler, proxyRequest } from 'h3';
 import { joinURL } from 'ufo';
-import { createUnplugin } from 'unplugin';
+import { DomainPathStrategy, createPathStrategy } from '@i18n-micro/path-strategy';
 import { parse } from '@vue/compiler-sfc';
 
+const TRANSLATIONS_HMR_EVENT = "i18n-micro:update";
+function generateHmrPlugin() {
+  return `
+import { defineNuxtPlugin } from '#imports'
+
+export default defineNuxtPlugin((nuxtApp) => {
+  if (!import.meta.hot) return
+  import.meta.hot.on(${JSON.stringify(TRANSLATIONS_HMR_EVENT)}, () => {
+    try {
+      nuxtApp.$clearCache()
+      console.log('[i18n HMR] Translations reloaded')
+    }
+    catch (e) {
+      console.warn('[i18n HMR] Failed to reload translations', e)
+    }
+  })
+})
+`.trim();
+}
+
+function buildFullConfigSource(config) {
+  const { excludePatterns = [], ...rest } = config;
+  const patterns = excludePatterns.map((pattern) => pattern instanceof RegExp ? String(pattern) : JSON.stringify(pattern));
+  return `{ ...${JSON.stringify(rest)}, excludePatterns: [${patterns.join(", ")}] }`;
+}
+function buildPrivateConfigSource(config, dev) {
+  const { rootDirs, payloadFsDir, ...rest } = config;
+  const read = `export function getI18nPrivateConfig() { return __privateConfig }
+`;
+  if (dev) return `const __privateConfig = ${JSON.stringify(config)}
+${read}`;
+  return `const __privateConfig = ${JSON.stringify(rest)}
+if (import.meta.prerender) Object.assign(__privateConfig, ${JSON.stringify({ rootDirs, payloadFsDir })})
+${read}`;
+}
+
+function mergeAdditionalRootLocaleFiles(rootDirs, additionalDirNames, locale, primaryContent = {}) {
+  if (!additionalDirNames.length) return primaryContent;
+  let content = {};
+  for (const dirName of additionalDirNames) {
+    for (const rootDir of rootDirs) {
+      content = deepMergeTranslationsRecursive(content, readTranslationFile(join(rootDir, dirName, `${locale}.json`)));
+    }
+  }
+  return deepMergeTranslationsRecursive(content, primaryContent);
+}
+function listAdditionalRootLocales(rootDirs, additionalDirNames) {
+  const locales = /* @__PURE__ */ new Set();
+  for (const dirName of additionalDirNames) {
+    for (const rootDir of rootDirs) {
+      const dir = join(rootDir, dirName);
+      if (!existsSync(dir)) continue;
+      for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".json")) continue;
+        locales.add(name.slice(0, -".json".length));
+      }
+    }
+  }
+  return [...locales];
+}
+const isTree = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function diffTree(page, root) {
+  const delta = {};
+  for (const key of Object.keys(page)) {
+    const value = page[key];
+    const base = root[key];
+    if (isTree(value) && isTree(base)) {
+      const nested = diffTree(value, base);
+      if (Object.keys(nested).length) delta[key] = nested;
+    } else if (!Object.hasOwn(root, key) || JSON.stringify(value) !== JSON.stringify(base)) delta[key] = value;
+  }
+  return delta;
+}
+function pageFileOverRoot(page, root, mark) {
+  const delta = diffTree(page, root);
+  const merged = mergeOverRoot(root, delta);
+  const whole = Object.keys(merged).length !== Object.keys(page).length;
+  if (whole || Object.keys(page).some((key) => JSON.stringify(merged[key]) !== JSON.stringify(page[key]))) return page;
+  return { ...delta, [PREMERGED_ROOT_MARK]: mark };
+}
+async function mergedFiles(rootDirs, translationDirName, outputDir, additionalTranslationDirs = []) {
+  if (existsSync(outputDir)) fs__default.rmSync(outputDir, { recursive: true, force: true });
+  mkdirSync(outputDir, { recursive: true });
+  const layerPaths = rootDirs.map((dir) => join(dir, translationDirName));
+  const filesByLayer = await Promise.all(layerPaths.filter((lp) => existsSync(lp)).map((lp) => globby("**/*.json", { cwd: lp })));
+  const merged = /* @__PURE__ */ new Map();
+  for (const file of new Set(filesByLayer.flat())) {
+    let content = {};
+    for (const lp of layerPaths) content = deepMergeTranslationsRecursive(content, readTranslationFile(join(lp, file)));
+    merged.set(file, content);
+  }
+  for (const locale of listAdditionalRootLocales(rootDirs, additionalTranslationDirs))
+    if (!merged.has(`${locale}.json`)) merged.set(`${locale}.json`, {});
+  for (const file of [...merged.keys()].filter((f) => dirname(f) === "."))
+    merged.set(file, mergeAdditionalRootLocaleFiles(rootDirs, additionalTranslationDirs, file.slice(0, -".json".length), merged.get(file)));
+  return merged;
+}
+function depthOf(tree) {
+  let depth = 0;
+  for (let level = [tree]; level.length > 0; depth++)
+    level = level.flatMap((node) => node !== null && typeof node === "object" ? Object.values(node) : []);
+  return depth - 1;
+}
+async function namingDeepFile(rootDirs, dirNames, step) {
+  try {
+    await step();
+  } catch (error) {
+    if (!(error instanceof RangeError) || !error.message.includes("call stack")) throw error;
+    const dirs = rootDirs.flatMap((root) => dirNames.map((name) => join(root, name))).filter((dir) => existsSync(dir));
+    const files = (await Promise.all(dirs.map((cwd) => globby("**/*.json", { cwd, absolute: true })))).flat();
+    const [deepest] = files.map((file) => ({ file, depth: depthOf(readTranslationFile(file)) })).sort((a, b) => b.depth - a.depth);
+    if (!deepest) throw error;
+    throw new Error(`[i18n] ${deepest.file} is nested ${deepest.depth} levels deep, too deep to build. Flatten it.`, { cause: error });
+  }
+}
+async function preMergeLocales(options) {
+  await namingDeepFile(options.rootDirs, [options.translationDirName, ...options.additionalTranslationDirs ?? []], () => writeChunks(options));
+}
+async function writeChunks(options) {
+  const { rootDirs, translationDirName, outputDir, locales, globalFallbackLocale, disablePageLocales, additionalTranslationDirs } = options;
+  const { routeNames = [], rootDelta = false } = options;
+  const merged = await mergedFiles(rootDirs, translationDirName, outputDir, additionalTranslationDirs);
+  const pages = /* @__PURE__ */ new Set([...[...merged.keys()].filter((f) => f.startsWith("pages/")).map((f) => dirname(f).slice("pages/".length)), ...routeNames]);
+  const targets = disablePageLocales || pages.size === 0 ? ["index"] : [...pages, ...pages.has("index") ? [] : ["index"]];
+  const chunk = (page, locale) => mergeSourceTranslations({
+    locale,
+    pageName: page,
+    locales,
+    globalFallbackLocale,
+    disablePageLocales,
+    readLocaleFile: (relativePath) => merged.get(relativePath) ?? {}
+  });
+  const write = (page, locale, data) => {
+    const targetPath = join(outputDir, page, locale, "data.json");
+    mkdirSync(dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, JSON.stringify(data));
+  };
+  const split = rootDelta && !disablePageLocales;
+  await Promise.all(
+    locales.map(async ({ code: locale }) => {
+      const root = await chunk(PREMERGED_ROOT_PAGE, locale);
+      const mark = createHash("sha256").update(JSON.stringify(root)).digest("hex").slice(0, 8);
+      write(PREMERGED_ROOT_PAGE, locale, split ? { ...root, [PREMERGED_ROOT_MARK]: mark } : root);
+      await Promise.all(
+        targets.map(async (page) => {
+          const data = await chunk(page, locale);
+          write(page, locale, split ? pageFileOverRoot(data, root, mark) : data);
+        })
+      );
+    })
+  );
+}
+async function buildTranslationSourceLayers(rootDirs, translationDirName, outputDir, additionalTranslationDirs) {
+  await namingDeepFile(rootDirs, [translationDirName, ...additionalTranslationDirs ?? []], async () => {
+    for (const [file, content] of await mergedFiles(rootDirs, translationDirName, outputDir, additionalTranslationDirs)) {
+      const targetPath = join(outputDir, file);
+      mkdirSync(dirname(targetPath), { recursive: true });
+      writeFileSync(targetPath, JSON.stringify(content));
+    }
+  });
+}
+
+const DEFAULT_TRANSLATION_PAYLOAD_WARN_FILE_COUNT = 500;
+const DEFAULT_TRANSLATION_PAYLOAD_WARN_SIZE_BYTES = 10 * 1024 * 1024;
+function resolveTranslationPayloadOptions(options) {
+  const isSourceMode = options.translationPayloads?.mode === "source";
+  return {
+    mode: isSourceMode ? "source" : "premerged",
+    serverAssets: options.translationPayloads?.serverAssets !== false,
+    serverHandler: options.translationPayloads?.serverHandler !== false,
+    publicAssets: isSourceMode ? options.translationPayloads?.publicAssets === true : options.translationPayloads?.publicAssets !== false,
+    // Off by default: prerendering `/_locales` without a live handler writes empty public stubs.
+    // Opt in when you need static `/{apiBaseUrl}/.../data.json` and payloads are already available.
+    prerenderRoutes: options.translationPayloads?.prerenderRoutes === true,
+    rootDelta: !isSourceMode && options.translationPayloads?.rootDelta !== false
+  };
+}
+const pathSegments = (path) => path.split("/").filter(Boolean).join("/");
+function resolveTranslationPayloadPublicRel(options, apiBaseUrl) {
+  return pathSegments(options.translationPayloads?.publicDir || apiBaseUrl) || "_locales";
+}
+function resolveTranslationPayloadPublicDir(outputPublicDir, options, apiBaseUrl) {
+  return join(outputPublicDir ?? "./dist", resolveTranslationPayloadPublicRel(options, apiBaseUrl));
+}
+function domainPayloadFilter(options) {
+  const { mode, root, served, linkLocales = served, fallbackLocale } = options;
+  const needed = served.flatMap((locale) => mode === "source" ? buildFallbackLocaleChain(locale.code, linkLocales, fallbackLocale) : [locale.code]);
+  const foreign = new Set(linkLocales.map((locale) => locale.code).filter((code) => !needed.includes(code)));
+  return (source) => {
+    const name = basename(source);
+    if (mode === "source") return !name.endsWith(".json") || !foreign.has(name.slice(0, -".json".length));
+    return !foreign.has(name) || dirname(source) === root;
+  };
+}
+function shouldCopyTranslationPayloadsToPublic(translationPayloads, readsPublicDir) {
+  if (translationPayloads.publicAssets) return true;
+  return readsPublicDir && translationPayloads.serverAssets;
+}
+function shouldReadPayloadsFromPublicDir(nitroOptions) {
+  const { node, serveStatic, output } = nitroOptions;
+  return node && !!serveStatic && serveStatic !== "inline" && relative(output.serverDir, output.publicDir) === join("..", "public");
+}
+function shouldRegisterNitroServerAssets(translationPayloads, readsPublicDir) {
+  return !readsPublicDir && translationPayloads.serverAssets;
+}
+function hasLocalTranslationPayloadOutput(translationPayloads) {
+  return translationPayloads.serverAssets || translationPayloads.serverHandler || translationPayloads.publicAssets || translationPayloads.prerenderRoutes;
+}
+function getTranslationPayloadMisconfigurationWarnings(input) {
+  const warnings = [];
+  if (!input.translationPayloads.serverAssets && !input.translationPayloads.publicAssets && !input.apiBaseServerHost) {
+    warnings.push(
+      "translationPayloads.serverAssets and publicAssets are false and apiBaseServerHost is not set. SSR will load empty translations unless you provide an external server payload host."
+    );
+  }
+  if (hasLocalTranslationPayloadOutput(input.translationPayloads)) {
+    return warnings;
+  }
+  if (!input.apiBaseServerHost) {
+    warnings.push(
+      "translationPayloads disabled all local outputs but apiBaseServerHost is not set. SSR will load empty translations unless you provide an external server payload host."
+    );
+  }
+  if (!input.apiBaseClientHost) {
+    warnings.push(
+      "translationPayloads disabled all local outputs but apiBaseClientHost is not set. Client-side navigation may load empty translations unless you provide an external client payload host."
+    );
+  }
+  return warnings;
+}
+function getStaticPayloadWarning(input) {
+  const { mode, publicAssets, prerenderRoutes } = input.translationPayloads;
+  if (input.apiBaseClientHost || prerenderRoutes || mode === "premerged" && publicAssets) return null;
+  return `Static output has no server route, and this build writes no /_locales/<page>/<locale>/data.json (mode: '${mode}', publicAssets: ${publicAssets}): the browser gets a 404 and raw keys, unless something else serves that path. Use the default premerged mode with public assets, translationPayloads.prerenderRoutes, or apiBaseClientHost.`;
+}
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} B`;
+}
+function getTranslationPayloadSizeWarning(stats, thresholds) {
+  const warnFileCount = thresholds?.warnFileCount ?? DEFAULT_TRANSLATION_PAYLOAD_WARN_FILE_COUNT;
+  const warnSizeBytes = thresholds?.warnSizeBytes ?? DEFAULT_TRANSLATION_PAYLOAD_WARN_SIZE_BYTES;
+  if (stats.fileCount < warnFileCount && stats.totalBytes < warnSizeBytes) {
+    return null;
+  }
+  return `Generated translation payloads are large (${stats.fileCount} files, ${formatBytes(stats.totalBytes)}). Consider translationPayloads.mode: 'source' for public output, hosting payloads externally, or disabling unused public/prerender outputs.`;
+}
+
+function collectJsonFiles(dir) {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) return collectJsonFiles(fullPath);
+    return entry.name.endsWith(".json") ? [fullPath] : [];
+  });
+}
+function scanTranslationPayloadDirectory(dir) {
+  const stats = { fileCount: 0, totalBytes: 0 };
+  if (!existsSync(dir)) return stats;
+  for (const file of collectJsonFiles(dir)) {
+    stats.fileCount += 1;
+    stats.totalBytes += statSync(file).size;
+  }
+  return stats;
+}
+const MiB = 1024 * 1024;
+const EMBED_LIMITS = [
+  {
+    preset: (name) => name === "vercel-edge",
+    bytes: 1e6,
+    compressed: true,
+    text: "Vercel Edge allows 1 MB gzip on Hobby, 2 MB on Pro and 4 MB on Enterprise"
+  },
+  { preset: (name) => name === "netlify-edge", bytes: 2e7, compressed: true, text: "Netlify Edge allows 20 MB compressed" },
+  { preset: (name) => name.startsWith("cloudflare-"), bytes: 64 * MiB, compressed: false, text: "Cloudflare Workers allow 64 MiB uncompressed" }
+];
+function getEmbeddedPayloadSizeWarning(preset, dir, mode) {
+  const limit = EMBED_LIMITS.find((entry) => entry.preset(preset));
+  if (!limit) return null;
+  const { totalBytes } = scanTranslationPayloadDirectory(dir);
+  if (totalBytes <= limit.bytes) return null;
+  if (limit.compressed) {
+    const gzipBytes = collectJsonFiles(dir).reduce((sum, file) => sum + gzipSync(readFileSync(file)).length, 0);
+    if (gzipBytes <= limit.bytes) return null;
+    return embeddedSizeMessage(preset, `${(gzipBytes / 1e6).toFixed(1)} MB gzip`, limit.text, mode);
+  }
+  return embeddedSizeMessage(preset, `${(totalBytes / MiB).toFixed(1)} MiB`, limit.text, mode);
+}
+function embeddedSizeMessage(preset, size, limitText, mode) {
+  const advice = mode === "premerged" ? "Use translationPayloads.mode: 'source'" : "Load dictionaries from apiBaseServerHost";
+  return `Preset "${preset}" embeds ${size} of dictionaries in the server bundle, and ${limitText}. ${advice}, or the deploy may be refused.`;
+}
+function hashTranslationSources(rootDirs, translationDirName, additionalTranslationDirs = [], salt = "") {
+  const hash = createHash("sha256").update(salt);
+  let seen = 0;
+  const hashFiles = (baseDir, files) => {
+    files.sort();
+    for (const file of files) {
+      hash.update(relative(baseDir, file));
+      hash.update("\0");
+      hash.update(readFileSync(file));
+      seen += 1;
+    }
+  };
+  const hashDir = (dir) => {
+    if (!existsSync(dir)) return;
+    hashFiles(dir, collectJsonFiles(dir));
+  };
+  const hashAdditionalRootLocales = (dir) => {
+    if (!existsSync(dir)) return;
+    const files = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".json")) files.push(join(dir, entry.name));
+    }
+    hashFiles(dir, files);
+  };
+  for (const rootDir of rootDirs) {
+    hashDir(join(rootDir, translationDirName));
+    for (const extra of additionalTranslationDirs) {
+      hashAdditionalRootLocales(join(rootDir, extra));
+    }
+  }
+  return seen > 0 ? hash.digest("hex").slice(0, 16) : null;
+}
+const NITRO_MIN_COMPRESS_BYTES = 1024;
+function compressTranslationPayloads(dir, compression) {
+  if (!compression || !existsSync(dir)) return 0;
+  const gzip = compression === true || compression.gzip !== false;
+  const brotli = compression === true || compression.brotli !== false;
+  if (!gzip && !brotli) return 0;
+  let compressed = 0;
+  for (const file of collectJsonFiles(dir)) {
+    const raw = readFileSync(file);
+    if (raw.length < NITRO_MIN_COMPRESS_BYTES) continue;
+    if (gzip) writeFileSync(`${file}.gz`, gzipSync(raw, { level: 9 }));
+    if (brotli) {
+      writeFileSync(
+        `${file}.br`,
+        brotliCompressSync(raw, { params: { [constants.BROTLI_PARAM_QUALITY]: 11, [constants.BROTLI_PARAM_SIZE_HINT]: raw.length } })
+      );
+    }
+    compressed += 1;
+  }
+  return compressed;
+}
+
 function buildI18nPluralTemplate(plural, helpersImportPath) {
   if (!plural || plural === defaultPlural) {
     return `export { defaultPlural as plural } from '${helpersImportPath}'
@@ -90,45 +443,30 @@ function setupDevToolsUI(options, rootDirs) {
     }
   });
   onDevToolsInitialized(() => {
-    const dirs = rootDirs.length > 0 ? rootDirs : [nuxt.options.rootDir];
-    extendServerRpc(DEVTOOLS_RPC_NAMESPACE, {
+    const functions = {
+      // Writes only an existing `.json` inside a translation directory: `file` comes from the
+      // client, so `../` and absolute paths must not reach the filesystem. The project layer (listed
+      // last, shown in the tab) wins over extended layers.
       async saveTranslationContent(file, content) {
-        let filePath = null;
-        const additionalMatch = /^additional:([^/]+)\/(.+)$/.exec(file);
-        if (additionalMatch?.[1] && additionalMatch[2]) {
-          const extraDir = additionalMatch[1];
-          const relFile = additionalMatch[2];
-          for (const rootDir of dirs) {
-            const candidatePath = path.join(rootDir, extraDir, relFile);
-            if (fs.existsSync(candidatePath)) {
-              filePath = candidatePath;
-              break;
-            }
-          }
-        } else {
-          for (const rootDir of dirs) {
-            const localesDir = path.join(rootDir, options.translationDir || "locales");
-            const candidatePath = path.join(localesDir, file);
-            if (fs.existsSync(candidatePath)) {
-              filePath = candidatePath;
-              break;
-            }
-          }
-        }
-        if (!filePath) {
-          filePath = path.resolve(file);
-        }
-        if (fs.existsSync(filePath)) {
-          fs.writeFileSync(filePath, JSON.stringify(content, null, 2), "utf-8");
-        } else {
-          throw new Error(`File not found: ${filePath}`);
-        }
+        const extraDir = file.startsWith("additional:") ? (options.additionalTranslationDirs ?? []).find((dir) => file.startsWith(`additional:${dir}/`)) : void 0;
+        if (file.startsWith("additional:") && !extraDir) throw new Error(`Not a configured additional translation directory: ${file}`);
+        const relativeFile = extraDir ? file.slice(`additional:${extraDir}/`.length) : file;
+        const target = [...rootDirs].reverse().map((rootDir) => resolveTranslationFile(path.join(rootDir, extraDir ?? (options.translationDir || "locales")), relativeFile)).find((candidate) => candidate !== null);
+        if (!target) throw new Error(`File not found in the translation directories: ${file}`);
+        fs.writeFileSync(target, JSON.stringify(content, null, 2), "utf-8");
       },
       async getConfigs() {
         return Promise.resolve(options);
       },
       async getLocalesAndTranslations() {
         const filesList = {};
+        const readFile = (key, filePath) => {
+          try {
+            filesList[key] = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+          } catch (e) {
+            console.error(`Error parsing locale file ${filePath}:`, e);
+          }
+        };
         const processDirectory = (dir, baseDir) => {
           if (!fs.existsSync(dir)) return;
           fs.readdirSync(dir).forEach((file) => {
@@ -137,16 +475,11 @@ function setupDevToolsUI(options, rootDirs) {
             if (stat.isDirectory()) {
               processDirectory(filePath, baseDir);
             } else if (file.endsWith(".json")) {
-              try {
-                const relativePath = path.relative(baseDir, filePath).replace(/\\/g, "/");
-                filesList[relativePath] = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-              } catch (e) {
-                console.error(`Error parsing locale file ${filePath}:`, e);
-              }
+              readFile(forwardSlashes(path.relative(baseDir, filePath)), filePath);
             }
           });
         };
-        for (const rootDir of dirs) {
+        for (const rootDir of rootDirs) {
           const localesDir = path.join(rootDir, options.translationDir || "locales");
           const pagesDir = path.join(localesDir, "pages");
           processDirectory(localesDir, localesDir);
@@ -158,35 +491,147 @@ function setupDevToolsUI(options, rootDirs) {
               if (!name.endsWith(".json")) continue;
               const filePath = path.join(extraDir, name);
               if (!fs.statSync(filePath).isFile()) continue;
-              try {
-                filesList[`additional:${extra}/${name}`] = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-              } catch (e) {
-                console.error(`Error parsing locale file ${filePath}:`, e);
-              }
+              readFile(`additional:${extra}/${name}`, filePath);
             }
           }
         }
         return filesList;
       }
+    };
+    const rpc = extendServerRpc(DEVTOOLS_RPC_NAMESPACE, functions);
+    const directories = [options.translationDir || "locales", ...options.additionalTranslationDirs ?? []];
+    const roots = rootDirs.flatMap((root) => directories.map((dir) => resolve(root, dir)));
+    let timer;
+    nuxt.hook("builder:watch", (_event, watched) => {
+      const file = resolve(nuxt.options.srcDir, watched);
+      if (!file.endsWith(".json") || !roots.some((root) => isInsideDir(file, root))) return;
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        functions.getLocalesAndTranslations().then((locales) => rpc.broadcast.localesUpdated.asEvent(locales)).catch((error) => console.error("[i18n-devtools] Failed to push locales:", error));
+      }, 100);
     });
   });
 }
 
-function shouldLocalizeRouteRulePath(originalPath) {
+function shouldLocalizeRouteRulePath(originalPath, localeCodes = []) {
   const routeRulePath = originalPath.trim();
   if (!routeRulePath) return true;
   const path = routeRulePath.startsWith("/") ? routeRulePath : `/${routeRulePath}`;
   if (path === "/api" || path.startsWith("/api/")) return false;
-  const firstSegment = path.replace(/^\/+/, "").split("/")[0] ?? "";
-  return !firstSegment.startsWith("_");
+  const firstSegment = trimLeadingSlashes(path).split("/")[0] ?? "";
+  return !firstSegment.startsWith("_") && !localeCodes.includes(firstSegment);
+}
+function localizedRulePaths(path, generator) {
+  return generator.locales.filter(({ code }) => isLocaleAllowedForUnlocalizedRoute(generator.routeLocales, generator.locales, path, code)).flatMap(({ code }) => generator.resolveLocalizedRulePaths(path, code)).filter((localized) => localized !== path && localized !== normalizePath(path));
+}
+function localizeRouteRules(rules, target, generator, onCopy, noDocuments = false) {
+  const localeCodes = [...generator.locales, ...generator.disabledLocales].map((locale) => locale.code);
+  for (const [path, value] of Object.entries(rules)) {
+    const { redirect: _redirect, ...rule } = value;
+    if (noDocuments) delete rule.prerender;
+    if (!Object.keys(rule).length || !shouldLocalizeRouteRulePath(path, localeCodes)) continue;
+    for (const localized of localizedRulePaths(path, generator)) {
+      target[localized] = { ...target[localized], ...rule };
+      onCopy(localized, rule);
+    }
+  }
+}
+function varyRouteCacheByHost(rule, trustForwardedHost) {
+  if (rule.cache === false || !(rule.swr || rule.cache)) return rule;
+  const hosts = trustForwardedHost ? ["host", "x-forwarded-host"] : ["host"];
+  return { ...rule, cache: { ...rule.cache, varies: [.../* @__PURE__ */ new Set([...rule.cache?.varies ?? [], ...hosts])] } };
 }
-const PAYLOAD_ROUTE_CACHE_MAX_AGE = 60;
 function buildTranslationPayloadRouteRule(input) {
-  if (input.dev) return { cors: true };
+  if (input.dev || !input.cacheControl) return { cors: true };
+  return { cors: true, headers: { "Cache-Control": input.cacheControl } };
+}
+
+function staticPagePaths(pages, parent = "/") {
+  return pages.flatMap((page) => {
+    if (page.redirect || page.path.includes(":")) return [];
+    const path = joinURL(parent, page.path);
+    return [path, ...staticPagePaths(page.children ?? [], path)];
+  });
+}
+function unfixedOriginWarning(locales, defaultLocale, metaBaseUrl, siteUrl) {
+  if (metaBaseUrl || siteUrl || !locales.some((locale) => locale.baseUrl)) return null;
+  if (locales.find((locale) => locale.code === defaultLocale)?.baseUrl) return null;
+  return "locales[].baseUrl is set, but no public origin is fixed: an unknown host reaches canonical and hreflang from the request. Set metaBaseUrl, site.url, or a baseUrl on the default locale.";
+}
+function seedStaticRoutes(routes, staticPaths, options) {
+  const { localize, prerendered } = options;
+  if (prerendered("/")) routes.add("/");
+  for (const path of staticPaths) {
+    if (!prerendered(path)) continue;
+    if (localize.isServed(path)) routes.add(path);
+    addLocalized(routes, path, options);
+  }
+  addLocalized(routes, "/", options);
+}
+function addLocalized(routes, path, { localize, locales, prerendered }) {
+  for (const { code } of locales) {
+    const localized = localize.path(path, code);
+    if (localized && prerendered(localized)) routes.add(localized);
+  }
+}
+function dropUnprefixed(routes, localize) {
+  const removed = [...routes].filter(
+    (route) => route !== "/" && route !== "" && !localize.localeOf(route) && !localize.isUnlocalized(route) && localize.isPage(route)
+  );
+  for (const route of removed) routes.delete(route);
+  return removed;
+}
+function seedPrerenderRoutes(routes, options) {
+  const { localize, staticPaths, prerendered, isInternal } = options;
+  if (staticPaths) seedStaticRoutes(routes, staticPaths, options);
+  for (const route of routes) if (isInternal(route)) routes.delete(route);
+  const additional = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    if (/\.[a-z0-9]+$/i.test(route) || !prerendered(route) || localize.localeOf(route)) continue;
+    addLocalized(additional, route, options);
+  }
+  for (const route of additional) routes.add(route);
+  const { strategy, locales } = options;
+  const prefixedOnly = strategy === "prefix" || strategy === "prefix_and_default" && !locales.some((locale) => locale.baseDefault);
+  return { added: [...additional], removed: prefixedOnly ? dropUnprefixed(routes, localize) : [] };
+}
+const toRecord = (page) => ({
+  path: page.path,
+  name: page.name,
+  meta: page.meta,
+  ...page.redirect ? { redirect: page.redirect } : { component: {} },
+  ...page.alias?.length ? { alias: page.alias } : {},
+  ...page.children?.length ? { children: page.children.map(toRecord) } : {}
+});
+async function createLocalizedPathResolver(pages, ctx) {
+  const { createMemoryHistory, createRouter } = await import('vue-router');
+  const router = createRouter({ history: createMemoryHistory(), routes: pages.map(toRecord) });
+  const strategy = ctx.locales.some((locale) => locale.baseUrl) ? new DomainPathStrategy({ ...ctx, router }) : createPathStrategy({ ...ctx, router });
+  const seen = /* @__PURE__ */ new Map();
+  const matched = (path) => {
+    let records = seen.get(path);
+    if (records) return records;
+    records = strategy.probe(path)?.matched ?? [];
+    seen.set(path, records);
+    return records;
+  };
+  const isPage = (path) => matched(path).length > 0 || strategy.pageLocales({ path }) !== null;
+  const isUnlocalized = (path) => {
+    const records = matched(path);
+    return records.length > 0 && !records.at(-1).meta?.i18n;
+  };
   return {
-    cors: true,
-    ...input.hasCacheBuster ? { cache: { maxAge: PAYLOAD_ROUTE_CACHE_MAX_AGE, swr: true } } : {},
-    ...input.cacheControl ? { headers: { "Cache-Control": input.cacheControl } } : {}
+    path(path, locale) {
+      const served = strategy.pageLocales({ path });
+      if (!isPage(path) || served && !served.includes(locale) || isUnlocalized(path)) return null;
+      const target = strategy.localeRoute(locale, path).fullPath;
+      return target && target !== path && !target.startsWith("https:") && !target.startsWith("http:") ? target : null;
+    },
+    localeOf: (path) => strategy.getLocaleFromPath(path),
+    isUnlocalized,
+    isPage,
+    // a known domain also leaves out what it answers with a 404 or a redirect (another host's URL)
+    isServed: (path) => matched(path).length > 0 && (!ctx.domain || !strategy.shouldReturn404(path) && !strategy.getClientRedirect(path, ctx.defaultLocale))
   };
 }
 
@@ -365,9 +810,12 @@ function evaluateConfig(scriptContent, configStr) {
   const safeScript = `
           const $defineI18nRoute = () => {}
           const defineI18nRoute = () => {}
+          const useNuxtApp = () => ({ $defineI18nRoute })
           const process = { env: { NODE_ENV: 'development' } }
+          {
           ${removeTypeScriptTypes(scriptWithoutImports)}
           return (${cleanConfigStr})
+          }
         `;
   try {
     return { ok: true, config: toPlainConfig(Function(`"use strict";${safeScript}`)()) };
@@ -438,54 +886,48 @@ function extractDefineI18nRouteData(content, filePath) {
     return null;
   }
 }
+const isSeparator = (char) => char === "/" || char === "\\";
+const isIndexPage = (file) => file.endsWith("/index.vue") || file.endsWith("\\index.vue");
+function parentPagePaths(pageFiles, rootDirs) {
+  const candidates = pageFiles.filter((file) => !isIndexPage(file));
+  return candidates.map((file) => pageFilePathToRoutePath(file, resolveRootDir(file, rootDirs) ?? ""));
+}
+function resolveRootDir(filePath, rootDirs) {
+  const beneath = (root) => filePath.startsWith(root) && (isSeparator(root[root.length - 1]) || isSeparator(filePath[root.length]));
+  return [...rootDirs].sort((a, b) => b.length - a.length).find(beneath);
+}
 function pageFilePathToRoutePath(pageFile, rootDir) {
-  const relative = pageFile.replace(rootDir, "").replace(/^[/\\]+/, "");
-  const withoutPagesPrefix = relative.replace(/^(app[/\\])?pages[/\\]/, "");
+  const withoutRoot = pageFile.replace(rootDir, "");
+  let start = 0;
+  while (isSeparator(withoutRoot[start])) start++;
+  const relative = withoutRoot.slice(start);
+  const pagesAt = relative.startsWith("app/") || relative.startsWith("app\\") ? 4 : 0;
+  const inPages = relative.startsWith("pages", pagesAt) && isSeparator(relative[pagesAt + 5]);
+  const withoutPagesPrefix = inPages ? relative.slice(pagesAt + 6) : relative;
   if (withoutPagesPrefix === "index.vue") {
     return "/";
   }
-  const raw = withoutPagesPrefix.replace(/[/\\]index\.vue$/, "").replace(/\.vue$/, "").replace(/[/\\]$/, "").replace(/\\/g, "/");
+  let page = isIndexPage(withoutPagesPrefix) ? withoutPagesPrefix.slice(0, -10) : withoutPagesPrefix;
+  if (page.endsWith(".vue")) page = page.slice(0, -4);
+  if (isSeparator(page[page.length - 1])) page = page.slice(0, -1);
+  const raw = forwardSlashes(page).split("/").filter((segment) => !(segment.length > 2 && segment[0] === "(" && segment.endsWith(")"))).join("/");
   return raw === "" ? "/" : raw;
 }
 
-function resolveRootDir(filePath, rootDirs) {
-  const sorted = [...rootDirs].sort((a, b) => b.length - a.length);
-  return sorted.find((root) => filePath.startsWith(root));
-}
-function createDefineI18nRoutePlugin(options) {
-  const metaByFile = /* @__PURE__ */ new Map();
-  const writeMetaFile = () => {
-    const entries = [...metaByFile.values()].filter((entry) => entry !== null);
-    options.onMetaUpdate?.(entries);
-    const metaPath = join(options.buildDir, "i18n-route-meta.json");
-    mkdirSync(dirname(metaPath), { recursive: true });
-    writeFileSync(metaPath, JSON.stringify(entries, null, 2));
-  };
-  return createUnplugin(() => ({
-    name: "nuxt-i18n-micro-define-route",
-    enforce: "pre",
-    transformInclude(id) {
-      return id.endsWith(".vue") && !id.includes("node_modules");
-    },
-    transform(code, id) {
-      const rootDir = resolveRootDir(id, options.rootDirs);
-      if (!rootDir) return null;
-      const config = extractDefineI18nRouteData(code, id);
-      if (!config) {
-        metaByFile.delete(id);
-      } else {
-        metaByFile.set(id, {
-          routePath: pageFilePathToRoutePath(id, rootDir),
-          config
-        });
-      }
-      writeMetaFile();
-      return null;
-    },
-    buildEnd() {
-      writeMetaFile();
-    }
-  }));
+function mergeDefineI18nRouteMeta(entries, config) {
+  const routeLocales = { ...config.routeLocales };
+  const routeDisableMeta = { ...config.routeDisableMeta };
+  const fromPages = {};
+  for (const { routePath, config: page } of entries) {
+    if (Array.isArray(page.locales)) routeLocales[routePath] = page.locales;
+    else if (page.locales) routeLocales[routePath] = Object.keys(page.locales);
+    if (page.localeRoutes) fromPages[routePath] = page.localeRoutes;
+    if (page.disableMeta !== void 0) routeDisableMeta[routePath] = page.disableMeta;
+  }
+  const configured = config.globalLocaleRoutes ?? {};
+  const configuredKeys = new Set(Object.keys(configured).map(routeKey));
+  for (const key of Object.keys(fromPages)) if (configuredKeys.has(routeKey(key)) || configuredKeys.has(nameOfPath(key))) delete fromPages[key];
+  return { routeLocales, globalLocaleRoutes: { ...fromPages, ...configured }, routeDisableMeta };
 }
 function collectDefineI18nRouteMetaFromFiles(pageFiles, rootDirs) {
   const entries = [];
@@ -506,46 +948,19 @@ function collectDefineI18nRouteMetaFromFiles(pageFiles, rootDirs) {
   return entries;
 }
 
-const strategyFiles = {
-  no_prefix: "no-prefix-strategy.mjs",
-  prefix: "prefix-strategy.mjs",
-  prefix_except_default: "prefix-except-default-strategy.mjs",
-  prefix_and_default: "prefix-and-default-strategy.mjs"
-};
-async function resolveStrategyPath(strategy) {
-  const strategyFile = strategyFiles[strategy] ?? strategyFiles.prefix_except_default;
-  const specifier = `@i18n-micro/path-strategy/dist/${strategyFile}`;
-  let absoluteStrategyPath;
-  try {
-    absoluteStrategyPath = fileURLToPath(import.meta.resolve(specifier));
-  } catch {
-    absoluteStrategyPath = await resolvePath(specifier);
-  }
-  return process.platform === "win32" ? pathToFileURL(absoluteStrategyPath).href : absoluteStrategyPath.replace(/\\/g, "/");
-}
-async function resolveHelpersPath() {
-  const specifier = "@i18n-micro/core/helpers";
-  let absoluteHelpersPath;
+async function resolveEntry(specifier) {
+  let absolutePath;
   try {
-    absoluteHelpersPath = fileURLToPath(import.meta.resolve(specifier));
+    absolutePath = fileURLToPath(import.meta.resolve(specifier));
   } catch {
-    absoluteHelpersPath = await resolvePath(specifier);
+    absolutePath = await resolvePath(specifier);
   }
-  return process.platform === "win32" ? pathToFileURL(absoluteHelpersPath).href : absoluteHelpersPath.replace(/\\/g, "/");
+  return process.platform === "win32" ? pathToFileURL(absolutePath).href : forwardSlashes(absolutePath);
 }
 function generateI18nTypes() {
   return `
 import type { PluginsInjections } from "nuxt-i18n-micro";
 
-declare module 'vue/types/vue' {
-  interface Vue extends PluginsInjections { }
-}
-
-declare module '@nuxt/types' {
-  interface NuxtAppOptions extends PluginsInjections { }
-  interface Context extends PluginsInjections { }
-}
-
 declare module '#app' {
   interface NuxtApp extends PluginsInjections { }
 }
@@ -553,87 +968,71 @@ declare module '#app' {
 export {}`;
 }
 const DEFAULT_CANONICAL_QUERY_WHITELIST = ["page", "sort", "filter", "search", "q", "query", "tag"];
-function resolveDateBuild(options, translationsHash) {
-  return options.dateBuild ?? translationsHash ?? Date.now();
+function isLiveDictionary(options, mode, serverHost) {
+  return mode === "source" || Boolean(options.cacheTtl) || Boolean(serverHost);
 }
 function buildFullConfig(params) {
-  const {
-    options,
-    nuxt,
-    defaultLocale,
-    isSSG,
-    apiConfig,
-    translationPayloadMode,
-    routeLocales,
-    routeDisableMeta,
-    mergedGlobalLocaleRoutes,
-    locales,
-    translationsHash
-  } = params;
-  const dateBuild = resolveDateBuild(options, translationsHash);
+  const { options, nuxt, defaultLocale, apiConfig, translationPayloadMode, locales, translationsHash, publicPayloads, rootDelta } = params;
+  const noScripts = nuxt.options.features.noScripts;
   return {
     locales: locales ?? [],
-    metaBaseUrl: options.metaBaseUrl || void 0,
-    metaTrustForwardedHost: options.metaTrustForwardedHost ?? true,
-    metaTrustForwardedProto: options.metaTrustForwardedProto ?? true,
-    hreflangBaseLanguage: options.hreflangBaseLanguage ?? false,
+    // an unknown host of a build whose default has a domain takes that origin, not the request's
+    metaBaseUrl: options.metaBaseUrl || locales?.find((locale) => locale.code === defaultLocale)?.baseUrl || void 0,
+    metaTrustForwardedHost: options.metaTrustForwardedHost,
+    metaTrustForwardedProto: options.metaTrustForwardedProto,
+    trustForwardedHost: options.trustForwardedHost,
+    hreflangBaseLanguage: options.hreflangBaseLanguage,
     defaultLocale,
     fallbackLocale: options.fallbackLocale ?? void 0,
     localeCookie: options.localeCookie ?? null,
-    autoDetectLanguage: options.autoDetectLanguage ?? true,
-    autoDetectPath: options.autoDetectPath ?? "/",
-    strategy: options.strategy ?? "prefix_except_default",
-    dateBuild,
+    autoDetectLanguage: options.autoDetectLanguage,
+    autoDetectPath: options.autoDetectPath || "/",
+    strategy: options.strategy,
+    // the `?v=` of payload URLs: a fingerprint of the translations, as a timestamp would make clients re-download
+    // what never changed. `options.dateBuild` wins even when it is `0`/`''`: that opts out of busting.
+    dateBuild: options.dateBuild ?? translationsHash ?? Date.now(),
     hashMode: nuxt.options?.router?.options?.hashMode ?? false,
     trailingSlash: options.trailingSlash ?? nuxt.options.experimental?.defaults?.nuxtLink?.trailingSlash,
     apiBaseUrl: apiConfig.apiBaseUrl,
     apiBaseClientHost: apiConfig.apiBaseClientHost,
-    isSSG,
-    disablePageLocales: options.disablePageLocales ?? false,
+    disablePageLocales: options.disablePageLocales,
     canonicalQueryWhitelist: options.canonicalQueryWhitelist ?? DEFAULT_CANONICAL_QUERY_WHITELIST,
     excludePatterns: options.excludePatterns ?? [],
-    routeLocales,
-    routeDisableMeta,
-    globalLocaleRoutes: mergedGlobalLocaleRoutes,
-    missingWarn: options.missingWarn ?? true,
+    missingWarn: options.missingWarn,
     redirects: options.redirects !== false,
-    hooks: options.hooks !== false,
-    hmr: options.hmr ?? true,
-    localizedRouteNamePrefix: options.localizedRouteNamePrefix ?? "localized-",
+    localizedRouteNamePrefix: options.localizedRouteNamePrefix,
     routesLocaleLinks: options.routesLocaleLinks ?? {},
-    noPrefixRedirect: options.noPrefixRedirect ?? false,
-    debug: options.debug ?? false,
+    debug: options.debug,
     customRegexMatcher: options.customRegexMatcher instanceof RegExp ? options.customRegexMatcher.source : options.customRegexMatcher,
     cacheMaxSize: options.cacheMaxSize ?? 0,
     cacheTtl: options.cacheTtl ?? 0,
     httpCacheDuration: options.httpCacheDuration,
+    httpCacheControl: options.httpCacheControl,
     numberFormats: options.numberFormats ?? {},
     datetimeFormats: options.datetimeFormats ?? {},
-    translationPayloadMode
+    timeZone: options.timeZone,
+    translationPayloadMode,
+    publicPayloads,
+    rootDelta,
+    noScripts: noScripts === "all" || !!noScripts && !nuxt.options.dev || void 0
   };
 }
-function buildPrivateConfig(options, nuxt, apiConfig, locales, payloadFsDir, payloadPublicRel) {
+function buildPrivateConfig(options, nuxt, rootDirs, apiConfig, locales, payloadFsDir, payloadPublicRel) {
   return {
-    rootDir: nuxt.options.rootDir,
-    // Same order as build translation merge: extends first, project last (wins).
-    rootDirs: nuxt.options._layers.map((layer) => layer.config.rootDir).reverse(),
+    rootDirs,
     debug: options.debug ?? false,
     locales: locales ?? [],
-    fallbackLocale: options.fallbackLocale ?? void 0,
     translationDir: options.translationDir ?? "locales",
     additionalTranslationDirs: options.additionalTranslationDirs ?? [],
-    customRegexMatcher: options.customRegexMatcher instanceof RegExp ? options.customRegexMatcher.source : options.customRegexMatcher,
-    routesLocaleLinks: options.routesLocaleLinks ?? {},
-    apiBaseUrl: apiConfig.apiBaseUrl,
-    apiBaseClientHost: apiConfig.apiBaseClientHost,
     apiBaseServerHost: apiConfig.apiBaseServerHost,
     serverTranslationPreload: options.serverTranslationPreload ?? false,
+    cacheStorage: options.cacheStorage,
+    cacheStorageBuild: nuxt.options.buildId,
     payloadFsDir,
     payloadPublicRel
   };
 }
-function registerI18nTemplates(options, resolvedStrategyPath, resolvedHelpersPath, fullConfig, privateConfig) {
-  let runtimeFullConfig = fullConfig;
+function registerI18nTemplates(options, resolvedStrategyPath, resolvedHelpersPath, fullConfig, privateConfig, disabledLocales, dev, serverPathFallback) {
   const pluralTemplate = addTemplate({
     filename: "i18n.plural.mjs",
     write: true,
@@ -643,42 +1042,40 @@ function registerI18nTemplates(options, resolvedStrategyPath, resolvedHelpersPat
     filename: "i18n.strategy.mjs",
     write: true,
     getContents: () => {
-      const fullConfigJson = JSON.stringify(runtimeFullConfig);
-      return `import { Strategy } from '${resolvedStrategyPath}'
+      const domains = fullConfig.locales.some((locale) => locale.baseUrl);
+      return `import { ${domains ? "DomainPathStrategy" : "I18nPathStrategy"} as Strategy } from '${resolvedStrategyPath}'
 
-const __fullConfig = ${fullConfigJson}
+const __fullConfig = ${buildFullConfigSource(fullConfig)}
+// disabled at build: no routes and not in the config, but routing must answer for their prefix
+const __disabledLocales = ${JSON.stringify(disabledLocales)}
 
 export function getI18nConfig() { return __fullConfig }
 
-export function createI18nStrategy(router) {
-  const routerAdapter = {
-    hasRoute(name) { return router.hasRoute(name) },
-    resolve(to) {
-      const r = router.resolve(to)
-      return {
-        name: r.name != null ? String(r.name) : null,
-        path: r.path,
-        fullPath: r.fullPath,
-        params: r.params || {},
-        query: r.query || {},
-        hash: r.hash || '',
-      }
-    },
-  }
+// a constant, so a build without locale domains drops their code
+export const domains = ${domains}
+
+// a constant, so a build that keeps the locale in no cookie drops useCookie (no runtime override reaches these two)
+export const cookies = ${fullConfig.localeCookie !== null || fullConfig.hashMode}
+
+// constants too, so a build with these options off drops their code from the loader plugin
+export const hooks = ${options.hooks !== false}
+export const defineRoute = ${options.define !== false}
 
+// Nuxt 4.6+: a client navigation to a URL with no record becomes a document load (experimental.serverPathFallback)
+export const serverPathFallback = ${serverPathFallback}
+
+// vue-router's Router is the adapter as is: no wrapper copying every resolve result.
+// config: the config with runtime overrides (defaultLocale, disabledLocales) \u2014 routing follows them.
+export function createI18nStrategy(router, config = __fullConfig) {
   return new Strategy({
-    strategy: __fullConfig.strategy,
-    defaultLocale: __fullConfig.defaultLocale,
-    locales: __fullConfig.locales,
-    localizedRouteNamePrefix: __fullConfig.localizedRouteNamePrefix,
-    globalLocaleRoutes: __fullConfig.globalLocaleRoutes,
-    routeLocales: __fullConfig.routeLocales,
-    routesLocaleLinks: __fullConfig.routesLocaleLinks,
-    noPrefixRedirect: __fullConfig.noPrefixRedirect,
-    debug: __fullConfig.debug,
-    router: routerAdapter,
-    hashMode: __fullConfig.hashMode,
-    disablePageLocales: __fullConfig.disablePageLocales,
+    strategy: config.strategy,
+    defaultLocale: config.defaultLocale,
+    locales: [...config.locales, ...__disabledLocales],
+    localizedRouteNamePrefix: config.localizedRouteNamePrefix,
+    router,
+    hashMode: config.hashMode,
+    disablePageLocales: config.disablePageLocales,
+    customRegexMatcher: config.customRegexMatcher,${domains ? "\n    domain: config.domain,\n    linkLocales: config.linkLocales," : ""}
   })
 }
 `;
@@ -687,23 +1084,20 @@ export function createI18nStrategy(router) {
   const configTemplate = addTemplate({
     filename: "i18n.config.mjs",
     write: true,
-    getContents: () => `const __privateConfig = ${JSON.stringify(privateConfig)}
-export function getI18nPrivateConfig() { return __privateConfig }
-`
+    getContents: () => buildPrivateConfigSource(privateConfig, dev)
   });
   return {
     pluralTemplate,
     strategyTemplate,
-    configTemplate,
-    setFullConfig(next) {
-      runtimeFullConfig = next;
-    }
+    configTemplate
   };
 }
 const module$1 = defineNuxtModule({
   meta: {
     name: "nuxt-i18n-micro",
-    configKey: "i18n"
+    configKey: "i18n",
+    // Vite environment hotUpdate (HMR) and NuxtPage's ~transitionPromise
+    compatibility: { nuxt: ">=3.18.0" }
   },
   defaults: {
     locales: [],
@@ -724,11 +1118,8 @@ const module$1 = defineNuxtModule({
     disablePageLocales: false,
     disableWatcher: false,
     noPrefixRedirect: false,
-    fallbackLocale: void 0,
     localeCookie: null,
     apiBaseUrl: "_locales",
-    apiBaseClientHost: void 0,
-    apiBaseServerHost: void 0,
     translationPayloads: {
       mode: "premerged",
       serverAssets: true,
@@ -740,20 +1131,18 @@ const module$1 = defineNuxtModule({
     },
     routesLocaleLinks: {},
     globalLocaleRoutes: {},
-    canonicalQueryWhitelist: void 0,
     plural: defaultPlural,
-    customRegexMatcher: void 0,
-    excludePatterns: void 0,
     localizedRouteNamePrefix: "localized-",
     missingWarn: true,
     metaTrustForwardedHost: true,
     metaTrustForwardedProto: true,
+    trustForwardedHost: false,
     hreflangBaseLanguage: false,
     httpCacheDuration: 31536e3
   },
   async setup(options, nuxt) {
-    const defaultLocale = process.env.DEFAULT_LOCALE ?? options.defaultLocale ?? "en";
-    const isSSG = Boolean(nuxt.options.nitro?.static);
+    const defaultLocale = process.env.DEFAULT_LOCALE || options.defaultLocale || "en";
+    let isSSG = false;
     const logger = useLogger("nuxt-i18n-micro");
     nuxt.options.typescript.hoist ||= [];
     for (const pkg of ["@i18n-micro/types", "@i18n-micro/path-strategy"]) {
@@ -761,12 +1150,13 @@ const module$1 = defineNuxtModule({
         nuxt.options.typescript.hoist.push(pkg);
       }
     }
-    if (options.strategy === "no_prefix" && !options.localeCookie) {
+    const cookieOptOut = nuxt.options.i18n?.localeCookie === null;
+    if (options.strategy === "no_prefix" && !options.localeCookie && !cookieOptOut) {
       options.localeCookie = "user-locale";
       logger.info("Strategy 'no_prefix': localeCookie automatically set to 'user-locale' for locale persistence.");
     }
     if (options.strategy !== "no_prefix" && options.redirects !== false && !options.localeCookie) {
-      logger.warn(
+      logger.info(
         "Redirects are enabled but localeCookie is not set. Locale-based redirects will not remember user's locale preference across page reloads. Set `localeCookie: 'user-locale'` to enable cookie-based locale persistence for redirects."
       );
     }
@@ -775,7 +1165,12 @@ const module$1 = defineNuxtModule({
     const mergedLocalesDir = resolve(nuxt.options.buildDir, "i18n-merged");
     const sourceLocalesDir = resolve(nuxt.options.buildDir, "i18n-source");
     const translationDirName = options.translationDir || "locales";
-    const translationsHash = options.dateBuild === void 0 ? hashTranslationSources(rootDirs, translationDirName, options.additionalTranslationDirs) : null;
+    const translationsHash = options.dateBuild === void 0 ? hashTranslationSources(
+      rootDirs,
+      translationDirName,
+      options.additionalTranslationDirs,
+      JSON.stringify([options.fallbackLocale, options.disablePageLocales, (options.locales ?? []).map((l) => [l.code, l.fallbackLocale])])
+    ) : null;
     const translationPayloads = resolveTranslationPayloadOptions(options);
     const publicAssetsDir = translationPayloads.mode === "source" ? sourceLocalesDir : mergedLocalesDir;
     for (const warning of getTranslationPayloadMisconfigurationWarnings({
@@ -783,9 +1178,10 @@ const module$1 = defineNuxtModule({
       apiBaseClientHost: options.apiBaseClientHost,
       apiBaseServerHost: options.apiBaseServerHost
     })) {
-      logger.warn(warning.replace("[nuxt-i18n-micro] ", ""));
+      logger.warn(warning);
     }
-    if (!translationPayloads.serverAssets && !translationPayloads.publicAssets && !(process.env.NUXT_I18N_APP_BASE_SERVER_HOST ?? options.apiBaseServerHost)) {
+    const rawServerHost = process.env.NUXT_I18N_APP_BASE_SERVER_HOST ?? options.apiBaseServerHost ?? void 0;
+    if (!translationPayloads.serverAssets && !translationPayloads.publicAssets && !rawServerHost) {
       throw new Error(
         "nuxt-i18n-micro: local SSR payloads are disabled (serverAssets/publicAssets false) and apiBaseServerHost is not set. SSR would load empty translations."
       );
@@ -799,79 +1195,53 @@ const module$1 = defineNuxtModule({
       const prev = localeInfosByCode.get(locale.code);
       localeInfosByCode.set(locale.code, {
         code: locale.code,
-        fallbackLocale: locale.fallbackLocale ?? prev?.fallbackLocale,
-        disabled: !!(prev?.disabled || locale.disabled)
+        fallbackLocale: prev?.fallbackLocale ?? locale.fallbackLocale,
+        disabled: prev?.disabled ?? locale.disabled
       });
     }
     const localeInfos = [...localeInfosByCode.values()].filter((locale) => !locale.disabled).map(({ code, fallbackLocale }) => ({ code, fallbackLocale }));
+    let routeNames = [];
     nuxt.hook("build:before", async () => {
       if (translationPayloads.mode === "source") {
         await buildTranslationSourceLayers(rootDirs, translationDirName, sourceLocalesDir, options.additionalTranslationDirs);
         logger.info(`Built compact translation source from ${rootDirs.length} layer(s) into ${sourceLocalesDir}`);
       } else {
-        await preMergeLocales(
+        await preMergeLocales({
           rootDirs,
           translationDirName,
-          mergedLocalesDir,
-          localeInfos,
-          options.fallbackLocale,
-          options.disablePageLocales,
-          options.additionalTranslationDirs
-        );
+          outputDir: mergedLocalesDir,
+          locales: localeInfos,
+          globalFallbackLocale: options.fallbackLocale,
+          disablePageLocales: options.disablePageLocales,
+          additionalTranslationDirs: options.additionalTranslationDirs,
+          routeNames,
+          // dev reads live files, and a prerender merges what it reads like any server
+          rootDelta: !nuxt.options.dev && translationPayloads.rootDelta
+        });
         logger.info(`Pre-merged translations from ${rootDirs.length} layer(s) into ${mergedLocalesDir}`);
       }
       const payloadStats = scanTranslationPayloadDirectory(publicAssetsDir);
-      const sizeWarning = getTranslationPayloadSizeWarning(payloadStats, resolveTranslationPayloadWarningThresholds(options.translationPayloads));
-      if (sizeWarning) {
-        logger.warn(sizeWarning.replace("[nuxt-i18n-micro] ", ""));
-      }
+      const sizeWarning = getTranslationPayloadSizeWarning(payloadStats, options.translationPayloads);
+      if (sizeWarning) logger.warn(sizeWarning);
     });
-    const routeLocales = { ...options.routeLocales ?? {} };
-    const globalLocaleRoutes = {};
-    const routeDisableMeta = {};
-    const pageGlobs = rootDirs.flatMap((root) => [join(root, "pages/**/*.vue"), join(root, "app/pages/**/*.vue")]);
-    const pageFiles = await globby(pageGlobs, { absolute: true });
-    for (const { routePath, config } of collectDefineI18nRouteMetaFromFiles(pageFiles, rootDirs)) {
-      try {
-        const { locales: extractedLocales, localeRoutes, disableMeta } = config;
-        if (extractedLocales) {
-          if (Array.isArray(extractedLocales)) {
-            routeLocales[routePath] = extractedLocales;
-          } else if (typeof extractedLocales === "object") {
-            routeLocales[routePath] = Object.keys(extractedLocales);
-          }
-        }
-        if (localeRoutes) {
-          globalLocaleRoutes[routePath] = localeRoutes;
-        }
-        if (disableMeta !== void 0) {
-          routeDisableMeta[routePath] = disableMeta;
-        }
-      } catch (error) {
-        logger.debug(`Failed to parse defineI18nRoute config for ${routePath}:`, error);
-      }
-    }
-    const mergedGlobalLocaleRoutes = { ...globalLocaleRoutes, ...options.globalLocaleRoutes };
-    if (options.debug) {
-      logger.debug("[i18n module] mergedGlobalLocaleRoutes keys:", Object.keys(mergedGlobalLocaleRoutes));
-      logger.debug('[i18n module] mergedGlobalLocaleRoutes["unlocalized"]:', mergedGlobalLocaleRoutes["unlocalized"]);
-      logger.debug("[i18n module] strategy:", options.strategy);
-    }
-    const resolvedStrategyPath = await resolveStrategyPath(options.strategy);
-    const resolvedHelpersPath = await resolveHelpersPath();
+    const pageFiles = (await Promise.all(rootDirs.map((cwd) => globby(["pages/**/*.vue", "app/pages/**/*.vue"], { cwd, absolute: true })))).flat();
+    const {
+      routeLocales,
+      routeDisableMeta,
+      globalLocaleRoutes: mergedGlobalLocaleRoutes
+    } = mergeDefineI18nRouteMeta(collectDefineI18nRouteMetaFromFiles(pageFiles, rootDirs), options);
+    const resolvedStrategyPath = await resolveEntry("@i18n-micro/path-strategy");
+    const resolvedHelpersPath = await resolveEntry("@i18n-micro/core/helpers");
     let apiBaseClientHost = process.env.NUXT_I18N_APP_BASE_CLIENT_HOST ?? options.apiBaseClientHost ?? void 0;
     if (apiBaseClientHost?.endsWith("/")) {
       apiBaseClientHost = apiBaseClientHost.slice(0, -1);
     }
-    let apiBaseServerHost = process.env.NUXT_I18N_APP_BASE_SERVER_HOST ?? options.apiBaseServerHost ?? void 0;
-    if (apiBaseServerHost?.endsWith("/")) {
-      apiBaseServerHost = apiBaseServerHost.slice(0, -1);
-    }
+    const apiBaseServerHost = rawServerHost?.endsWith("/") ? rawServerHost.slice(0, -1) : rawServerHost;
     const rawUrl = process.env.NUXT_I18N_APP_BASE_URL ?? options.apiBaseUrl ?? "_locales";
     if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://")) {
       throw new Error("Nuxt-i18n-micro: Please use NUXT_I18N_APP_BASE_CLIENT_HOST or NUXT_I18N_APP_BASE_SERVER_HOST instead.");
     }
-    const apiBaseUrl = rawUrl.replace(/^\/+|\/+$/g, "").replace(/\/{2,}/g, "/");
+    const apiBaseUrl = pathSegments(rawUrl);
     const apiConfig = { apiBaseUrl, apiBaseClientHost, apiBaseServerHost };
     const payloadPublicRel = resolveTranslationPayloadPublicRel(options, apiBaseUrl);
     const routeGenerator = new RouteGenerator({
@@ -879,31 +1249,50 @@ const module$1 = defineNuxtModule({
       defaultLocaleCode: defaultLocale,
       strategy: options.strategy,
       globalLocaleRoutes: mergedGlobalLocaleRoutes,
-      filesLocaleRoutes: globalLocaleRoutes,
       routeLocales,
+      routeDisableMeta,
       noPrefixRedirect: options.noPrefixRedirect,
+      redirects: options.redirects,
       excludePatterns: options.excludePatterns,
+      apiBaseUrl,
       localizedRouteNamePrefix: options.localizedRouteNamePrefix,
-      customRegexMatcher: options.customRegexMatcher
+      customRegexMatcher: options.customRegexMatcher,
+      parentPaths: parentPagePaths(pageFiles, rootDirs)
     });
     const fullConfig = buildFullConfig({
       options,
       nuxt,
       defaultLocale,
-      isSSG,
       apiConfig,
       translationPayloadMode: translationPayloads.mode,
-      routeLocales,
-      routeDisableMeta,
-      mergedGlobalLocaleRoutes,
+      publicPayloads: translationPayloads.mode === "premerged" && translationPayloads.publicAssets,
+      rootDelta: !nuxt.options.dev && translationPayloads.mode === "premerged" && translationPayloads.rootDelta && !options.disablePageLocales && (translationPayloads.publicAssets || Boolean(options.apiBaseClientHost)),
       locales: routeGenerator.locales ?? [],
       translationsHash
     });
-    const privateConfig = buildPrivateConfig(options, nuxt, apiConfig, routeGenerator.locales ?? [], publicAssetsDir, payloadPublicRel);
-    const templates = registerI18nTemplates(options, resolvedStrategyPath, resolvedHelpersPath, fullConfig, privateConfig);
+    const generateDomain = process.env.NUXT_I18N_DOMAIN;
+    const buildConfig = generateDomain ? configForHost(fullConfig, generateDomain) : fullConfig;
+    if (generateDomain && !buildConfig.domain)
+      logger.warn(`NUXT_I18N_DOMAIN "${generateDomain}" is no host of locales[].baseUrl: the build config applies.`);
+    const siteUrl = nuxt.options.site?.url || process.env.NUXT_PUBLIC_SITE_URL || process.env.NUXT_SITE_URL;
+    const originWarning = buildConfig.domain ? null : unfixedOriginWarning(routeGenerator.locales, defaultLocale, options.metaBaseUrl, siteUrl);
+    if (originWarning) logger.warn(originWarning);
+    const privateConfig = buildPrivateConfig(options, nuxt, rootDirs, apiConfig, routeGenerator.locales ?? [], publicAssetsDir, payloadPublicRel);
+    const templates = registerI18nTemplates(
+      options,
+      resolvedStrategyPath,
+      resolvedHelpersPath,
+      fullConfig,
+      privateConfig,
+      routeGenerator.disabledLocales,
+      nuxt.options.dev,
+      nuxt.options.experimental.serverPathFallback === true && !nuxt.options.router?.options?.hashMode
+    );
     if (typeof options.customRegexMatcher !== "undefined") {
-      const localeCodes = routeGenerator.locales.map((l) => l.code);
-      const failedCodes = localeCodes.filter((code) => !code.match(options.customRegexMatcher));
+      const failedCodes = localesOutsideMatcher(
+        routeGenerator.locales.map((l) => l.code),
+        options.customRegexMatcher
+      );
       if (failedCodes.length > 0) {
         throw new Error(
           "Nuxt-i18n-micro: customRegexMatcher does not match the following locale codes: " + failedCodes.join(", ") + ". The regex must match ALL locale codes in your configuration."
@@ -917,51 +1306,48 @@ const module$1 = defineNuxtModule({
         name: "i18n-plugin-loader",
         order: -5
       });
-    }
-    if (options.hooks) {
-      addPlugin({
-        src: resolver.resolve("./runtime/plugins/05.hooks"),
-        name: "i18n-plugin-hooks",
-        order: 1
-      });
-    }
-    if (options.meta) {
-      addPlugin({
-        src: resolver.resolve("./runtime/plugins/02.meta"),
-        name: "i18n-plugin-meta",
-        order: 2
-      });
-    }
-    if (options.define) {
-      addPlugin({
-        src: resolver.resolve("./runtime/plugins/03.define"),
-        name: "i18n-plugin-define",
-        mode: "all",
-        order: 3
-      });
-    }
-    if (nuxt.options.dev && options.plugin !== false && options.vueDevtools !== false) {
+      if (options.meta) {
+        addPlugin({
+          src: resolver.resolve("./runtime/plugins/02.meta"),
+          name: "i18n-plugin-meta",
+          order: 2
+        });
+      }
+      if (nuxt.options.dev && options.vueDevtools !== false) {
+        addPlugin({
+          src: resolver.resolve("./runtime/plugins/04.vue-devtools"),
+          name: "i18n-vue-devtools",
+          mode: "client",
+          order: 5
+        });
+      }
       addPlugin({
-        src: resolver.resolve("./runtime/plugins/04.vue-devtools"),
-        name: "i18n-vue-devtools",
-        mode: "client",
-        order: 5
+        src: resolver.resolve("./runtime/plugins/06.redirect"),
+        mode: "server",
+        name: "i18n-plugin-redirect",
+        order: 10
       });
-    }
-    addPlugin({
-      src: resolver.resolve("./runtime/plugins/06.redirect"),
-      mode: "server",
-      name: "i18n-plugin-redirect",
-      order: 10
-    });
-    if (options.redirects !== false && options.plugin !== false) {
-      addRouteMiddleware({
-        name: "i18n-redirect",
-        path: resolver.resolve("./runtime/middleware/i18n-redirect.global"),
-        global: true
+      if (options.redirects !== false && options.strategy !== "no_prefix") {
+        addRouteMiddleware({
+          name: "i18n-redirect",
+          path: resolver.resolve("./runtime/middleware/i18n-redirect.global"),
+          global: true
+        });
+      }
+    } else if (options.define) {
+      addPluginTemplate({
+        filename: "i18n.define.mjs",
+        getContents: () => `import { defineNuxtPlugin } from '#imports'
+export default defineNuxtPlugin(() => ({ provide: { defineI18nRoute: async () => {} } }))
+`
       });
     }
-    addServerImportsDir(resolver.resolve("./runtime/server/utils"));
+    addServerImports([
+      { name: "useLocaleServerMiddleware", from: resolver.resolve("./runtime/server/utils/locale-server-middleware") },
+      { name: "useTranslationServerMiddleware", from: resolver.resolve("./runtime/server/utils/translation-server-middleware") },
+      { name: "loadTranslationsFromServer", from: resolver.resolve("./runtime/server/utils/server-loader") },
+      { name: "detectCurrentLocale", from: resolver.resolve("./runtime/server/utils/locale-detector") }
+    ]);
     if (translationPayloads.serverHandler) {
       addServerHandler({
         route: `/${apiBaseUrl}/:page/:locale/data.json`,
@@ -976,30 +1362,26 @@ const module$1 = defineNuxtModule({
       });
     }
     if (nuxt.options.dev && (options.hmr ?? true)) {
-      const files = (await Promise.all(
-        rootDirs.map(async (layerRoot) => {
-          const translationsDir = join(layerRoot, options.translationDir || "locales");
-          if (!existsSync(translationsDir)) return [];
-          return globby(["**/*.json"], { cwd: translationsDir, absolute: true });
-        })
-      )).flat();
-      const additionalRootFiles = (await Promise.all(
-        (options.additionalTranslationDirs ?? []).flatMap(
-          (extra) => rootDirs.map(async (layerRoot) => {
-            const extraDir = join(layerRoot, extra);
-            if (!existsSync(extraDir)) return [];
-            const extras = await globby(["*.json"], { cwd: extraDir, absolute: true, onlyFiles: true, deep: 0 });
-            return extras.map((f) => f.replace(/\\/g, "/"));
-          })
-        )
-      )).flat();
+      const translationDirs = resolveLiveTranslationDirs({
+        rootDirs,
+        translationDir: translationDirName,
+        additionalTranslationDirs: options.additionalTranslationDirs
+      });
+      addVitePlugin(
+        {
+          name: "i18n-micro:translations-hmr",
+          hotUpdate({ file }) {
+            if (this.environment.name !== "client" || !translationRelativePath(file, translationDirs)) return;
+            this.environment.hot.send({ type: "custom", event: TRANSLATIONS_HMR_EVENT });
+            return [];
+          }
+        },
+        { server: false }
+      );
       const tpl = addTemplate({
         filename: "i18n.hmr.mjs",
         write: true,
-        getContents: () => generateHmrPlugin(
-          files.map((f) => f.replace(/\\/g, "/")),
-          { additionalRootFiles }
-        )
+        getContents: () => generateHmrPlugin()
       });
       addPlugin({
         src: tpl.dst,
@@ -1015,13 +1397,19 @@ const module$1 = defineNuxtModule({
       });
       addTypeTemplate({
         filename: "types/h3.d.ts",
-        getContents: () => `import type { Translations } from '@i18n-micro/types'
+        getContents: () => `import type { ResolvedI18nConfig, Translations } from '@i18n-micro/types'
 
 declare module 'h3' {
   interface H3EventContext {
     i18n?: {
       locale: string
       translations: Translations
+      /** Loads a chunk for this request's render (the server loader, no local HTTP round trip), or \`null\` when the host has no file for it. */
+      load?: (locale: string, routeName: string) => Promise<Translations | null>
+      /** The module config with runtime overrides, resolved once for this request. */
+      config?: ResolvedI18nConfig
+      /** A dictionary of this page render could not be read: no cache may keep the page. */
+      failedRead?: boolean
     }
   }
 }
@@ -1033,60 +1421,77 @@ export {}
     addTypeTemplate({
       filename: "types/i18n-internal.d.ts",
       getContents: () => {
-        return `import type { ModuleOptionsExtend, ModulePrivateOptionsExtend, Params, Getter, PluralFunc } from '@i18n-micro/types'
+        const strategyDeclaration = `
+  export const domains: boolean
+  export const cookies: boolean
+  export const hooks: boolean
+  export const defineRoute: boolean
+  export const serverPathFallback: boolean
+  export function getI18nConfig(): ResolvedI18nConfig
+  export function createI18nStrategy(router: I18nStrategyRouter, config?: ModuleOptionsExtend): PathStrategy
+`;
+        return `import type { ModuleOptionsExtend, ModulePrivateOptionsExtend, Params, Getter, PluralFunc, ResolvedI18nConfig } from '@i18n-micro/types'
 import type { PathStrategy } from '@i18n-micro/path-strategy'
+import type { Router } from 'vue-router'
+
+/** The app's vue-router: createI18nStrategy reads hasRoute, resolve and getRoutes from it. */
+type I18nStrategyRouter = Pick<Router, 'hasRoute' | 'resolve' | 'getRoutes'>
 
 declare module '#build/i18n.plural.mjs' {
   export function plural(key: string, count: number, params: Params, locale: string, getter: Getter): string | null
 }
 
-declare module '#build/i18n.strategy.mjs' {
-  export function getI18nConfig(): ModuleOptionsExtend
-  export function createI18nStrategy(router: { hasRoute: (name: string) => boolean, resolve: (to: unknown) => { name: string | null, path: string, fullPath: string, params?: Record<string, unknown>, query?: Record<string, unknown>, hash?: string } }): PathStrategy
-}
+declare module '#build/i18n.strategy.mjs' {${strategyDeclaration}}
 
 declare module '#i18n-internal/config' {
   export function getI18nPrivateConfig(): ModulePrivateOptionsExtend
 }
 
-declare module '#i18n-internal/strategy' {
-  export function getI18nConfig(): ModuleOptionsExtend
-  export function createI18nStrategy(router: { hasRoute: (name: string) => boolean, resolve: (to: unknown) => { name: string | null, path: string, fullPath: string, params?: Record<string, unknown>, query?: Record<string, unknown>, hash?: string } }): PathStrategy
-}
+declare module '#i18n-internal/strategy' {${strategyDeclaration}}
 
 declare module '#i18n-internal/plural' {
   export const plural: PluralFunc
 }
 
 declare module '#i18n-internal/payload-source' {
+  export const embeddedPayloads: boolean
   export function readPayload(relPath: string): Promise<Record<string, unknown>>
 }
 `;
       }
     });
+    let generatedPages = [];
+    let staticPaths = [];
+    const createBuildStrategy = () => createLocalizedPathResolver(generatedPages, {
+      strategy: options.strategy,
+      defaultLocale: buildConfig.defaultLocale,
+      locales: buildConfig.locales,
+      domain: buildConfig.domain,
+      linkLocales: buildConfig.linkLocales,
+      localizedRouteNamePrefix: options.localizedRouteNamePrefix,
+      customRegexMatcher: fullConfig.customRegexMatcher
+    });
+    const unlinked = (name) => !options.routesLocaleLinks?.[name];
     const addDataRoutes = (pages = []) => {
       if (!translationPayloads.prerenderRoutes) return;
-      const pagesForDataRoutes = pages.filter((p) => p.name !== void 0 && (!options.routesLocaleLinks || !options.routesLocaleLinks[p.name]));
+      const pagesForDataRoutes = pages.filter((p) => p.name !== void 0 && unlinked(p.name));
       const dataRoutes = routeGenerator.generateDataRoutes(pagesForDataRoutes, apiBaseUrl, !!options.disablePageLocales);
       addPrerenderRoutes(dataRoutes);
     };
     nuxt.hook("pages:resolved", (pages) => {
-      const pagesNames = pages.map((page) => page.name).filter((name) => name !== void 0 && (!options.routesLocaleLinks || !options.routesLocaleLinks[name]));
+      const pagesNames = pages.map((page) => page.name).filter((name) => name !== void 0 && unlinked(name));
       if (!options.disableWatcher) {
-        routeGenerator.ensureTranslationFilesExist(pagesNames, options.translationDir, nuxt.options.rootDir, options.disablePageLocales);
+        routeGenerator.ensureTranslationFilesExist(pagesNames, translationDirName, nuxt.options.rootDir, options.disablePageLocales);
       }
       addDataRoutes(pages);
+      routeNames = pageNames(pages).filter(unlinked);
+      staticPaths = staticPagePaths(pages);
       routeGenerator.extendPages(pages);
+      generatedPages = pages;
     });
     if (options.disablePageLocales) {
       nuxt.hook("build:before", () => addDataRoutes([]));
     }
-    addVitePlugin(
-      createDefineI18nRoutePlugin({
-        buildDir: nuxt.options.buildDir,
-        rootDirs
-      }).vite()
-    );
     const { pluralTemplate, strategyTemplate, configTemplate } = templates;
     nuxt.hook("nitro:config", (nitroConfig) => {
       nitroConfig.alias = nitroConfig.alias || {};
@@ -1095,39 +1500,35 @@ declare module '#i18n-internal/payload-source' {
       nitroConfig.alias["#i18n-internal/config"] = configTemplate.dst;
       nitroConfig.alias["#i18n-internal/payload-source"] = resolver.resolve("./runtime/server/payload-source.fs");
       nitroConfig.plugins = nitroConfig.plugins || [];
+      nitroConfig.plugins.push(resolver.resolve("./runtime/server/plugins/failed-read"));
+      if (!nuxt.options.dev) nitroConfig.plugins.push(resolver.resolve("./runtime/server/plugins/payload-cache"));
       if (nuxt.options.dev && (options.hmr ?? true)) {
         nitroConfig.plugins.push(resolver.resolve("./runtime/server/plugins/watcher.dev"));
       }
       nitroConfig.routeRules = nitroConfig.routeRules || {};
-      const httpCacheDuration = Math.floor(options.httpCacheDuration ?? 0);
-      const hasCacheBuster = Boolean(resolveDateBuild(options, translationsHash));
-      const cacheControl = buildTranslationPayloadCacheControl(httpCacheDuration, false);
+      const { file: cacheControl } = resolveTranslationPayloadCachePolicy({
+        httpCacheDuration: options.httpCacheDuration,
+        httpCacheControl: options.httpCacheControl,
+        dateBuild: fullConfig.dateBuild,
+        live: isLiveDictionary(options, translationPayloads.mode, rawServerHost)
+      });
       nitroConfig.routeRules[`/${apiBaseUrl}/**`] = {
         ...nitroConfig.routeRules[`/${apiBaseUrl}/**`] || {},
-        ...buildTranslationPayloadRouteRule({ dev: nuxt.options.dev, hasCacheBuster, cacheControl })
+        ...buildTranslationPayloadRouteRule({ dev: nuxt.options.dev, cacheControl })
       };
-      const routeRules = nuxt.options.routeRules || {};
-      const strategy = options.strategy;
-      if (routeRules && Object.keys(routeRules).length && !isNoPrefixStrategy(strategy)) {
-        for (const [originalPath, ruleValue] of Object.entries(routeRules)) {
-          if (!shouldLocalizeRouteRulePath(originalPath)) continue;
-          routeGenerator.locales.forEach((localeObj) => {
-            const localeCode = localeObj.code;
-            if (!isLocaleAllowedForUnlocalizedRoute(routeGenerator.routeLocales, routeGenerator.locales, originalPath, localeCode)) {
-              return;
-            }
-            const localizedPath = routeGenerator.resolveLocalizedPath(originalPath, localeCode);
-            if (localizedPath === originalPath || localizedPath === normalizePath(originalPath)) {
-              return;
-            }
-            const { redirect, ...restRuleValue } = ruleValue;
-            if (!Object.keys(restRuleValue).length) return;
-            nitroConfig.routeRules[localizedPath] = {
-              ...nitroConfig.routeRules[localizedPath],
-              ...restRuleValue
-            };
-            logger.debug(`Replicated routeRule for ${localizedPath}: ${JSON.stringify(restRuleValue)}`);
-          });
+      const noDocuments = Boolean(buildConfig.hashMode) && options.strategy === "prefix";
+      localizeRouteRules(
+        nuxt.options.routeRules || {},
+        nitroConfig.routeRules,
+        routeGenerator,
+        (path, rule) => {
+          logger.debug(`Replicated routeRule for ${path}: ${JSON.stringify(rule)}`);
+        },
+        noDocuments
+      );
+      if (routeGenerator.locales.some((locale) => locale.baseUrl)) {
+        for (const [path, rule] of Object.entries(nitroConfig.routeRules)) {
+          nitroConfig.routeRules[path] = varyRouteCacheByHost(rule, Boolean(options.trustForwardedHost));
         }
       }
       nitroConfig.handlers = nitroConfig.handlers || [];
@@ -1137,10 +1538,30 @@ declare module '#i18n-internal/payload-source' {
       });
     });
     nuxt.hook("nitro:init", (nitro) => {
-      if (nitro.options.static) return;
+      if (buildConfig.domain) {
+        let localize;
+        nitro.hooks.hook("prerender:generate", async (route) => {
+          localize ??= await createBuildStrategy();
+          if (route.route !== "/" && localize.isPage(route.route) && !localize.isServed(route.route)) route.skip = true;
+        });
+      }
+      isSSG = Boolean(nitro.options.static);
+      if (isSSG) {
+        if (!generateDomain && routeGenerator.locales.some((locale) => locale.baseUrl)) {
+          logger.warn(
+            "locales[].baseUrl in a static build without NUXT_I18N_DOMAIN: the build config applies, and locales with a baseUrl are links. Generate once per domain."
+          );
+        }
+        const staticWarning = getStaticPayloadWarning({ translationPayloads, apiBaseClientHost });
+        if (staticWarning) logger.warn(staticWarning);
+        return;
+      }
       const readsPublicDir = shouldReadPayloadsFromPublicDir(nitro.options);
       if (!readsPublicDir) {
         nitro.options.alias["#i18n-internal/payload-source"] = resolver.resolve("./runtime/server/payload-source.assets");
+        if (options.cacheStorage && !apiBaseServerHost) {
+          logger.info("cacheStorage: dictionaries are embedded on this preset, so the shared cache only applies with apiBaseServerHost.");
+        }
       }
       if (shouldRegisterNitroServerAssets(translationPayloads, readsPublicDir)) {
         nitro.options.serverAssets.push({
@@ -1148,11 +1569,6 @@ declare module '#i18n-internal/payload-source' {
           // Same layout as public (`mode`): premerged matrix or compact source.
           dir: publicAssetsDir
         });
-        if (translationPayloads.mode === "premerged") {
-          logger.warn(
-            `Preset "${nitro.options.preset}" does not ship public/ with the server, so translationPayloads.mode:"premerged" embeds the full page/locale matrix via Nitro serverAssets (Rollup raw:). Prefer mode:'source' for large catalogs.`
-          );
-        }
       }
       if (readsPublicDir && translationPayloads.serverAssets && !translationPayloads.publicAssets) {
         logger.info("translationPayloads.serverAssets: on Node, payloads are served from public/ (publicAssets copy enabled for SSR).");
@@ -1162,11 +1578,22 @@ declare module '#i18n-internal/payload-source' {
       const isProd = nuxt.options.dev === false;
       const readsPublicDir = shouldReadPayloadsFromPublicDir(nitro.options);
       const copyPublicPayloads = shouldCopyTranslationPayloadsToPublic(translationPayloads, readsPublicDir);
+      if (isProd && !isSSG && shouldRegisterNitroServerAssets(translationPayloads, readsPublicDir)) {
+        const sizeWarning = getEmbeddedPayloadSizeWarning(nitro.options.preset, publicAssetsDir, translationPayloads.mode);
+        if (sizeWarning) logger.warn(sizeWarning);
+      }
       if (isProd && copyPublicPayloads) {
         const publicDir = resolveTranslationPayloadPublicDir(nitro.options.output.publicDir, options, apiBaseUrl);
         try {
           if (existsSync(publicAssetsDir)) {
-            fs__default.cpSync(publicAssetsDir, publicDir, { recursive: true });
+            const filter = domainPayloadFilter({
+              mode: translationPayloads.mode,
+              root: publicAssetsDir,
+              served: buildConfig.locales,
+              linkLocales: buildConfig.linkLocales,
+              fallbackLocale: options.fallbackLocale
+            });
+            fs__default.cpSync(publicAssetsDir, publicDir, { recursive: true, filter });
             logger.log(`Translation payloads copied to public directory`);
             const compressed = compressTranslationPayloads(publicDir, nitro.options.compressPublicAssets);
             if (compressed > 0) {
@@ -1184,73 +1611,21 @@ declare module '#i18n-internal/payload-source' {
       if (isNoPrefixStrategy(options.strategy)) {
         return;
       }
-      const routesSet = prerenderRoutes.routes;
       const routeRules = nuxt.options.routeRules || {};
-      const additionalRoutes = /* @__PURE__ */ new Set();
-      const localeCodes = new Set(routeGenerator.locales.map((locale) => locale.code));
-      if (isSSG) {
-        if (routeRules["/"]?.prerender !== false) {
-          routesSet.add("/");
-        }
-        for (const locale of routeGenerator.locales) {
-          if (!isLocaleAllowedForUnlocalizedRoute(routeGenerator.routeLocales, routeGenerator.locales, "/", locale.code)) {
-            continue;
-          }
-          const localizedRoot = routeGenerator.resolveLocalizedPath("/", locale.code);
-          if (localizedRoot && localizedRoot !== "/" && routeRules[localizedRoot]?.prerender !== false) {
-            routesSet.add(localizedRoot);
-          }
-        }
-      }
-      for (const route of routesSet) {
-        if (isInternalPath(route, options.excludePatterns)) {
-          routesSet.delete(route);
-        }
-      }
-      for (const route of routesSet) {
-        if (/\.[a-z0-9]+$/i.test(route)) {
-          continue;
-        }
-        if (routeRules[route]?.prerender === false) {
-          continue;
-        }
-        const firstSegment = route.replace(/^\//, "").split("/")[0];
-        if (firstSegment && localeCodes.has(firstSegment)) {
-          continue;
-        }
-        for (const locale of routeGenerator.locales) {
-          if (!isLocaleAllowedForUnlocalizedRoute(routeGenerator.routeLocales, routeGenerator.locales, route, locale.code)) {
-            continue;
-          }
-          const localizedRoute = routeGenerator.resolveLocalizedPath(route, locale.code);
-          if (localizedRoute === route) {
-            continue;
-          }
-          if (routeRules[localizedRoute]?.prerender === false) {
-            continue;
-          }
-          additionalRoutes.add(localizedRoute);
-        }
-      }
-      if (additionalRoutes.size > 0) {
-        logger.debug("[i18n prerender:routes] added localized routes:", [...additionalRoutes].sort().join(", "));
-      }
-      for (const route of additionalRoutes) {
-        routesSet.add(route);
+      const { added, removed } = seedPrerenderRoutes(prerenderRoutes.routes, {
+        // the same router and strategy the app runs: custom paths, `false` pages and routeLocales as generated
+        localize: await createBuildStrategy(),
+        locales: buildConfig.locales,
+        staticPaths: isSSG ? staticPaths : null,
+        strategy: options.strategy,
+        prerendered: (route) => routeRules[route]?.prerender !== false,
+        isInternal: (route) => isInternalPath(route, options.excludePatterns, apiBaseUrl)
+      });
+      if (added.length > 0) {
+        logger.debug("[i18n prerender:routes] added localized routes:", [...added].sort().join(", "));
       }
-      if (withPrefixStrategy(options.strategy)) {
-        const deleted = [];
-        for (const route of routesSet) {
-          if (route === "/" || route === "") continue;
-          const firstSegment = route.replace(/^\//, "").split("/")[0];
-          if (firstSegment && !localeCodes.has(firstSegment)) {
-            routesSet.delete(route);
-            deleted.push(route);
-          }
-        }
-        if (deleted.length > 0) {
-          logger.info(`[i18n prerender:routes] removed from prerender list (no locale prefix): ${deleted.join(", ")}`);
-        }
+      if (removed.length > 0) {
+        logger.info(`[i18n prerender:routes] removed from prerender list (no locale prefix): ${removed.join(", ")}`);
       }
     });
     const devtoolsOptions = nuxt.options.devtools;