nuxt-i18n-micro 3.30.2 → 4.0.0

package/dist/runtime/server/middleware/i18n.global.js

@@ -1,43 +1,27 @@
-import { getEnabledLocaleCodes } from "@i18n-micro/utils/active-locales";
 import { isInternalPath, withoutAppBaseURL } from "@i18n-micro/utils/app-path";
-import { getLocaleCookieName } from "@i18n-micro/utils/cookie";
-import { resolveServerLocale } from "@i18n-micro/utils/resolve-locale";
-import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
-import { defineEventHandler, getCookie, getHeader, getQuery, getRequestURL } from "h3";
+import { defineEventHandler } from "h3";
 import { getI18nPrivateConfig } from "#i18n-internal/config";
-import { getI18nConfig } from "#i18n-internal/strategy";
-import { useRuntimeConfig } from "#imports";
-import { loadTranslationsFromServer } from "../utils/server-loader.js";
+import { domains } from "#i18n-internal/strategy";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { requestURL } from "../../utils/request-url.js";
+import { detectRequestLocale, getI18nServerConfig } from "../utils/locale-detector.js";
+import { loadTranslationsFromServer, NO_FILE } from "../utils/server-loader.js";
+async function load(locale, routeName) {
+  const entry = await loadTranslationsFromServer(locale, routeName);
+  return entry === NO_FILE ? null : entry.data;
+}
 export default defineEventHandler(async (event) => {
-  const appBaseURL = useRuntimeConfig(event).app.baseURL;
-  const rawPath = getRequestURL(event).pathname;
-  const path = withoutAppBaseURL(rawPath, appBaseURL);
-  if (isInternalPath(path)) return;
-  const config = resolveI18nConfigWithRuntimeOverrides(
-    getI18nConfig(),
-    useRuntimeConfig(event).public
-  );
-  const privateConfig = getI18nPrivateConfig();
-  const validLocales = getEnabledLocaleCodes(config.locales);
-  const defaultLocale = config.defaultLocale || "en";
-  const pathSegments = path.split("/").filter(Boolean);
-  const firstSegment = pathSegments[0];
-  const hasLocaleInUrl = Boolean(firstSegment && validLocales.includes(firstSegment));
-  const cookieName = getLocaleCookieName(config);
-  const queryLocale = getQuery(event).locale ? String(getQuery(event).locale) : null;
-  const cookieLocale = cookieName ? getCookie(event, cookieName) : null;
-  const locale = resolveServerLocale({
-    defaultLocale,
-    validLocales,
-    autoDetectLanguage: config.autoDetectLanguage,
-    hasLocaleInUrl,
-    urlLocale: firstSegment ?? null,
-    queryLocale,
-    cookieLocale,
-    acceptLanguageHeader: getHeader(event, "accept-language")
-  });
+  const config = getI18nServerConfig(event);
+  const path = withoutAppBaseURL(requestURL(event).pathname, useRuntimeConfig().app.baseURL);
+  const { serverTranslationPreload } = getI18nPrivateConfig();
+  if (isInternalPath(path, void 0, config.apiBaseUrl)) {
+    event.context.i18n = domains ? { load, config } : { load };
+    return;
+  }
+  if (config.hashMode && config.strategy === "prefix" && path === "/") event.context.nuxt = { ...event.context.nuxt, noSSR: true };
+  const locale = detectRequestLocale(event, config, "page", path);
   let translations = {};
-  if (privateConfig.serverTranslationPreload) {
+  if (serverTranslationPreload) {
     try {
       const loaded = await loadTranslationsFromServer(locale, "index");
       translations = loaded.data;
@@ -47,6 +31,9 @@ export default defineEventHandler(async (event) => {
   }
   event.context.i18n = {
     locale,
-    translations
+    translations,
+    load,
+    // the render reuses this request's resolved config (runtime overrides applied once)
+    config
   };
 });

package/dist/runtime/server/payload-source.assets.d.ts

@@ -1 +1,2 @@
+export declare const embeddedPayloads = true;
 export declare function readPayload(relPath: string): Promise<Record<string, unknown>>;

package/dist/runtime/server/payload-source.assets.js

@@ -1,18 +1,13 @@
 import { resolveContainedRelPath } from "@i18n-micro/utils/app-path";
 import { useStorage } from "nitropack/runtime";
+export const embeddedPayloads = true;
 export async function readPayload(relPath) {
   const safeRel = resolveContainedRelPath(relPath);
   if (!safeRel) return {};
-  const key = safeRel.replace(/\//g, ":");
+  const key = safeRel.split("/").join(":");
   const value = await useStorage().getItem(`assets:i18n:${key}`);
   if (value === null || value === void 0) return {};
-  if (typeof value === "string") {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return {};
-    }
-  }
+  if (typeof value === "string") return JSON.parse(value);
   if (typeof value === "object") return value;
   return {};
 }

package/dist/runtime/server/payload-source.fs.d.ts

@@ -1 +1,2 @@
+export declare const embeddedPayloads = false;
 export declare function readPayload(relPath: string): Promise<Record<string, unknown>>;

package/dist/runtime/server/payload-source.fs.js

@@ -1,8 +1,11 @@
-import { readFile } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveContainedRelPath } from "@i18n-micro/utils/app-path";
 import { getI18nPrivateConfig } from "#i18n-internal/config";
+export const embeddedPayloads = false;
+const MISSING_FILE = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR", "ENAMETOOLONG"]);
+let treeChecked = false;
 function baseDir() {
   const cfg = getI18nPrivateConfig();
   if (import.meta.dev || import.meta.prerender) {
@@ -10,17 +13,25 @@ function baseDir() {
   }
   return join(dirname(fileURLToPath(import.meta.url)), "..", "public", cfg.payloadPublicRel);
 }
+async function reportMissingTree(dir) {
+  if (treeChecked) return;
+  treeChecked = true;
+  await access(dir).catch(
+    () => console.error(
+      `[nuxt-i18n-micro] ${dir} does not exist: public/ is not deployed next to the server, so pages render raw keys. Build with nitro.serveStatic: false to embed the dictionaries.`
+    )
+  );
+}
 export async function readPayload(relPath) {
   const rel = resolveContainedRelPath(relPath);
   if (!rel) return {};
-  const path = join(baseDir(), rel);
+  const dir = baseDir();
   try {
-    return JSON.parse(await readFile(path, "utf8"));
+    return JSON.parse(await readFile(join(dir, rel), "utf8"));
   } catch (error) {
-    const err = error;
-    if (err.code !== "ENOENT") {
-      console.error(`[nuxt-i18n-micro] cannot read ${relPath} from ${baseDir()}:`, error);
-    }
+    const { code } = error;
+    if (!MISSING_FILE.has(code)) throw error;
+    if (code === "ENOENT") await reportMissingTree(dir);
     return {};
   }
 }

package/dist/runtime/server/plugins/failed-read.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A page rendered with a dictionary that could not be read keeps its HTML, and the browser reads the dictionary again
+ * on hydration. A 200 would be kept by a route rule and a CDN for their TTL, raw keys included.
+ * An island has no `render:response`: it stays a 200, as a 503 would take it out of the page that embeds it.
+ */
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/failed-read.js

@@ -0,0 +1,23 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { getResponseHeader, removeResponseHeader, setResponseHeaders } from "h3";
+const MARK = "x-i18n-failed-read";
+const NOT_KEPT = {
+  "Cache-Control": "no-store",
+  "CDN-Cache-Control": "no-store",
+  "Cloudflare-CDN-Cache-Control": "no-store",
+  "Netlify-CDN-Cache-Control": "no-store",
+  "Vercel-CDN-Cache-Control": "no-store",
+  "Surrogate-Control": "no-store"
+};
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("render:response", (response, { event }) => {
+    if (!event.context.i18n?.failedRead || (response.statusCode ?? 200) !== 200) return;
+    response.statusCode = 503;
+    response.headers = { ...response.headers, [MARK]: "1" };
+  });
+  nitroApp.hooks.hook("beforeResponse", (event) => {
+    if (!getResponseHeader(event, MARK)) return;
+    removeResponseHeader(event, MARK);
+    setResponseHeaders(event, { ...NOT_KEPT, "Retry-After": "60" });
+  });
+});

package/dist/runtime/server/plugins/payload-cache.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Nitro's static handler ignores the query, and answers before any middleware. The response of a payload file takes
+ * its header here, on its way out: only what serves `public/` from this process gets one, a host stays on the route rule.
+ */
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/payload-cache.js

@@ -0,0 +1,16 @@
+import { joinURL } from "ufo";
+import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
+import { removeResponseHeader, setResponseHeader } from "h3";
+import { getI18nServerConfig } from "../utils/locale-detector.js";
+import { payloadCacheControl } from "../utils/payload-cache.js";
+export default defineNitroPlugin((nitroApp) => {
+  let prefix;
+  nitroApp.hooks.hook("beforeResponse", (event) => {
+    prefix ??= `${joinURL(useRuntimeConfig().app.baseURL, getI18nServerConfig().apiBaseUrl)}/`;
+    if (!event.path.startsWith(prefix) || event.node.res.statusCode >= 400) return;
+    removeResponseHeader(event, "Content-Length");
+    const config = getI18nServerConfig(event);
+    const cacheControl = config.httpCacheControl !== false && payloadCacheControl(event, config);
+    if (cacheControl) setResponseHeader(event, "Cache-Control", cacheControl);
+  });
+});

package/dist/runtime/server/plugins/watcher.dev.js

@@ -1,114 +1,50 @@
-import { existsSync, readdirSync } from "node:fs";
-import path from "node:path";
-import { STORAGE_CC_KEY } from "@i18n-micro/hmr/cache-keys";
+import { existsSync } from "node:fs";
+import { STORAGE_CC_KEY } from "../../utils/cache-keys.js";
 import {
-  createTranslationDirReader,
   handleTranslationWatchChange,
   resolveLiveTranslationDirs,
-  TranslationContentTracker
-} from "@i18n-micro/hmr/watcher";
-import { parseTranslationRelativePath } from "@i18n-micro/utils/parse-path";
+  TranslationContentTracker,
+  translationRelativePath
+} from "../internal/translation-watcher.js";
 import { watch } from "chokidar";
 import { defineNitroPlugin } from "nitropack/runtime";
 import { getI18nPrivateConfig } from "#i18n-internal/config";
-import { getI18nConfig } from "#i18n-internal/strategy";
-import { getOrCreateServerTranslationCache } from "../utils/server-translation-cache.js";
-function getCacheByKey(key) {
-  const g = globalThis;
-  const cc = g[key];
-  if (cc && typeof cc === "object" && "keys" in cc && "set" in cc) {
-    return cc;
-  }
-  return null;
-}
-function getStorageCache() {
-  return getCacheByKey(STORAGE_CC_KEY);
-}
+import { getOrCreateServerTranslationCache } from "../internal/server-translation-cache.js";
 let watcherInstance = null;
 export default defineNitroPlugin((nitroApp) => {
   if (watcherInstance) {
     return;
   }
   const i18nConfig = getI18nPrivateConfig();
-  if (process.env.NODE_ENV !== "development") {
-    return;
-  }
   const log = (...args) => i18nConfig.debug && console.log("[i18n-hmr]", ...args);
   const warn = (...args) => i18nConfig.debug && console.warn("[i18n-hmr]", ...args);
-  const rawLocales = i18nConfig.locales;
-  const configuredLocales = new Set(
-    (Array.isArray(rawLocales) ? rawLocales : []).map((l) => l.code).filter((code) => typeof code === "string" && code.length > 0)
-  );
-  const routesLocaleLinks = i18nConfig.routesLocaleLinks || {};
+  const configuredLocales = new Set((i18nConfig.locales ?? []).map((l) => l.code));
   const { translationRoots, additionalRoots } = resolveLiveTranslationDirs({
-    rootDirs: i18nConfig.rootDirs?.length ? i18nConfig.rootDirs : [i18nConfig.rootDir],
+    rootDirs: i18nConfig.rootDirs,
     translationDir: i18nConfig.translationDir,
     additionalTranslationDirs: i18nConfig.additionalTranslationDirs
   });
   log(`Watching for translation changes in: ${translationRoots.join(", ")}`, additionalRoots.length ? `(+${additionalRoots.length} additional)` : "");
   const contentTracker = new TranslationContentTracker();
-  const readMergedLocaleFile = createTranslationDirReader(translationRoots, additionalRoots);
-  const toWatchRelativePath = (filePath) => {
-    for (const translationsRoot of translationRoots) {
-      const fromPrimary = path.relative(translationsRoot, filePath);
-      if (!fromPrimary.startsWith("..") && !path.isAbsolute(fromPrimary)) {
-        return fromPrimary.replace(/\\/g, "/");
-      }
-    }
-    for (const extraRoot of additionalRoots) {
-      const fromExtra = path.relative(extraRoot, filePath);
-      if (fromExtra.startsWith("..") || path.isAbsolute(fromExtra)) continue;
-      const normalized = fromExtra.replace(/\\/g, "/");
-      if (!normalized.includes("/") && normalized.endsWith(".json")) return normalized;
-    }
-    return null;
-  };
   const invalidateAndRefresh = async (filePath, event) => {
-    const relativePath = toWatchRelativePath(filePath);
+    const relativePath = translationRelativePath(filePath, { translationRoots, additionalRoots });
     if (!relativePath) return;
     if (event === "unlink") {
       contentTracker.forget(filePath);
     } else if (!contentTracker.shouldProcess(filePath)) {
       return;
     }
-    const runtimeConfig = getI18nConfig();
     try {
-      const result = await handleTranslationWatchChange({
+      const change = await handleTranslationWatchChange({
         relativePath,
         configuredLocales,
-        listPageNames: () => {
-          const names = /* @__PURE__ */ new Set();
-          for (const translationsRoot of translationRoots) {
-            const pagesDir = path.join(translationsRoot, "pages");
-            if (!existsSync(pagesDir)) continue;
-            for (const entry of readdirSync(pagesDir, { withFileTypes: true })) {
-              if (entry.isDirectory()) names.add(entry.name);
-            }
-          }
-          return [...names];
-        },
         serverCache: getOrCreateServerTranslationCache(),
-        storageCache: getStorageCache(),
-        routesLocaleLinks,
-        mergeInput: {
-          locales: runtimeConfig.locales,
-          fallbackLocale: runtimeConfig.fallbackLocale,
-          disablePageLocales: runtimeConfig.disablePageLocales,
-          readLocaleFile: readMergedLocaleFile
-        }
+        storageCache: globalThis[STORAGE_CC_KEY]
       });
-      if (result === "root") {
-        const parsed = parseTranslationRelativePath(relativePath);
-        if (parsed.type === "root") {
-          log(`Re-merged ALL pages for locale '${parsed.locale}'`);
-        }
-      } else if (result === "page") {
-        log(`Re-merged page cache for '${relativePath}'`);
-      } else if (result === "ignored") {
-        const parsed = parseTranslationRelativePath(relativePath);
-        if (parsed.type === "root" && !configuredLocales.has(parsed.locale)) {
-          warn(`Detected ${event} for '${relativePath}', but locale '${parsed.locale}' is not in i18n.locales. Update config and restart dev server.`);
-        }
+      if (change.dropped) {
+        log(`Dropped cached translations after a change to '${change.type === "root" ? change.locale : relativePath}'`);
+      } else if (change.type === "root") {
+        warn(`Detected ${event} for '${relativePath}', but locale '${change.locale}' is not in i18n.locales. Update config and restart dev server.`);
       }
     } catch (e) {
       contentTracker.forget(filePath);

package/dist/runtime/server/routes/i18n.js

@@ -1,29 +1,28 @@
 import { isEnabledLocale } from "@i18n-micro/utils/active-locales";
-import { buildTranslationPayloadCacheControl } from "@i18n-micro/utils/payload-url";
-import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
-import { createError, defineEventHandler, getQuery, getRouterParam, send, setResponseHeader } from "h3";
-import { getI18nConfig } from "#i18n-internal/strategy";
-import { useRuntimeConfig } from "#imports";
-import { loadTranslationsFromServer } from "../utils/server-loader.js";
+import { createError, defineEventHandler, getRouterParam, send, setResponseHeader } from "h3";
+import { getI18nServerConfig } from "../utils/locale-detector.js";
+import { payloadCacheControl } from "../utils/payload-cache.js";
+import { loadTranslationsFromServer, NO_FILE } from "../utils/server-loader.js";
 export default defineEventHandler(async (event) => {
   const page = getRouterParam(event, "page");
   const locale = getRouterParam(event, "locale");
   if (!locale || !page) {
     throw createError({ statusCode: 400, statusMessage: "Missing locale or page" });
   }
-  const config = resolveI18nConfigWithRuntimeOverrides(
-    getI18nConfig(),
-    useRuntimeConfig(event).public
-  );
+  const config = getI18nServerConfig(event);
   if (!isEnabledLocale(config.locales, locale)) {
     throw createError({ statusCode: 404, statusMessage: "Locale not found" });
   }
-  const { json } = await loadTranslationsFromServer(locale, page);
+  const entry = await loadTranslationsFromServer(locale, page).catch((cause) => {
+    console.warn("[i18n] Translation load failed:", locale, page);
+    setResponseHeader(event, "Cache-Control", "no-store");
+    throw createError({ statusCode: 503, statusMessage: "Translations unavailable", cause });
+  });
+  if (entry === NO_FILE) throw createError({ statusCode: 404, statusMessage: "No such file" });
+  const { json } = entry;
   setResponseHeader(event, "Content-Type", "application/json; charset=utf-8");
   if (!import.meta.dev) {
-    const requested = getQuery(event).v;
-    const versioned = Boolean(config.dateBuild) && String(requested ?? "") === String(config.dateBuild);
-    const cacheControl = buildTranslationPayloadCacheControl(config.httpCacheDuration, versioned);
+    const cacheControl = payloadCacheControl(event, config, json === "{}");
     if (cacheControl) {
       setResponseHeader(event, "Cache-Control", cacheControl);
     }

package/dist/runtime/server/utils/locale-detector.d.ts

@@ -1,4 +1,27 @@
+import type { ResolvedI18nConfig } from '@i18n-micro/types';
 import type { H3Event } from 'h3';
+/**
+ * The module config with runtime overrides (`runtimeConfig.public.i18nRuntime`, then env), resolved
+ * once: every caller of a request, and every request with the same overrides and host, gets the
+ * same object (so override warnings are logged once). Read-only: deep-frozen in dev.
+ */
+export declare function getI18nServerConfig(event?: H3Event): ResolvedI18nConfig;
+type DetectionConfig = Pick<ResolvedI18nConfig, 'defaultLocale' | 'localeCookie' | 'autoDetectLanguage' | 'strategy' | 'hashMode'> & {
+    locales?: {
+        code: string;
+        disabled?: boolean;
+    }[];
+};
+/**
+ * - `page`: what the page render shows. The URL decides wherever the router does: a prefix, or the
+ *   default locale for an unprefixed URL under prefix_except_default and prefix_and_default (a cookie
+ *   must not render `de` on the `en` page). `?locale=` counts only under no_prefix, where no URL
+ *   locale exists.
+ * - `api`: server API helpers — `?locale=`, a `[locale]` route param or prefix, cookie, header.
+ */
+export type RequestLocaleMode = 'page' | 'api';
+/** The one server detection: i18n.global stores it in `event.context.i18n.locale`, the helpers reuse it. */
+export declare function detectRequestLocale(event: H3Event, config: DetectionConfig, mode: RequestLocaleMode, path?: string): string;
 export interface DetectCurrentLocaleConfig {
     fallbackLocale?: string;
     defaultLocale?: string;
@@ -9,7 +32,14 @@ export interface DetectCurrentLocaleConfig {
     autoDetectLanguage?: boolean;
 }
 /**
- * Detects the current locale based on various sources (server-only).
- * Thin wrapper around `resolveServerLocale` with configured cookie name.
+ * Detects the current locale of a server API request: `detectRequestLocale` with the `api` rules.
+ * @deprecated use `useLocaleServerMiddleware(event).current`, which applies the same rules.
  */
 export declare const detectCurrentLocale: (event: H3Event, config: DetectCurrentLocaleConfig, defaultLocale?: string) => string;
+/**
+ * This request's locale for server API helpers, with the documented API order (query → route
+ * param / prefix → cookie → Accept-Language) on every route, `/api` or not — never the page
+ * render's locale, which ignores `?locale` under the prefix strategies.
+ */
+export declare function getRequestLocale(event: H3Event, config: ResolvedI18nConfig, defaultLocale?: string): string;
+export {};

package/dist/runtime/server/utils/locale-detector.js

@@ -1,32 +1,53 @@
 import { getEnabledLocaleCodes } from "@i18n-micro/utils/active-locales";
 import { withoutAppBaseURL } from "@i18n-micro/utils/app-path";
-import { getLocaleCookieName } from "@i18n-micro/utils/cookie";
-import { resolveServerLocale } from "@i18n-micro/utils/resolve-locale";
-import { getCookie, getQuery, getRequestURL } from "h3";
-import { useRuntimeConfig } from "#imports";
-export const detectCurrentLocale = (event, config, defaultLocale) => {
-  const { fallbackLocale, defaultLocale: configDefaultLocale, locales, localeCookie, autoDetectLanguage } = config;
-  const resolvedDefault = defaultLocale || configDefaultLocale || "en";
-  const validLocales = getEnabledLocaleCodes(locales ?? []);
-  const url = getRequestURL(event);
-  const rawPath = url.pathname.split("?")[0]?.split("#")[0] ?? url.pathname;
-  const cleanPath = withoutAppBaseURL(rawPath, useRuntimeConfig(event).app.baseURL);
-  const firstSegment = cleanPath.split("/").filter(Boolean)[0] ?? "";
-  const fromParams = event.context.params?.locale?.toString();
-  const urlLocale = (fromParams && validLocales.includes(fromParams) ? fromParams : firstSegment) || null;
-  const hasLocaleInUrl = Boolean(urlLocale && validLocales.includes(urlLocale));
-  const queryLocale = getQuery(event)?.locale ? String(getQuery(event).locale) : null;
-  const cookieName = getLocaleCookieName({ localeCookie });
-  const cookieLocale = cookieName ? getCookie(event, cookieName) : null;
-  const locale = resolveServerLocale({
-    defaultLocale: resolvedDefault,
+import { getPreferenceCookieName } from "@i18n-micro/utils/cookie";
+import { configForHost } from "@i18n-micro/utils/domains";
+import { firstQueryValue, localeFromPath, resolveLocale } from "@i18n-micro/utils/resolve-locale";
+import { createI18nConfigResolver } from "@i18n-micro/utils/runtime-config";
+import { getCookie, getHeader, getQuery, getRequestHost } from "h3";
+import { domains, getI18nConfig } from "#i18n-internal/strategy";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { requestURL } from "../../utils/request-url.js";
+const resolveConfig = createI18nConfigResolver();
+function fixedHost() {
+  try {
+    return process.env.NUXT_I18N_DOMAIN;
+  } catch {
+    return void 0;
+  }
+}
+export function getI18nServerConfig(event) {
+  const config = resolveConfig(getI18nConfig(), useRuntimeConfig().public);
+  if (!domains) return config;
+  const host = fixedHost() || event && getRequestHost(event, { xForwardedHost: config.trustForwardedHost === true });
+  return host ? configForHost(config, host) : config;
+}
+export function detectRequestLocale(event, config, mode, path) {
+  const validLocales = getEnabledLocaleCodes(config.locales);
+  const defaultLocale = config.defaultLocale;
+  const urlless = config.strategy === "no_prefix" || Boolean(config.hashMode);
+  const unprefixedIsDefault = config.strategy === "prefix_except_default" || config.strategy === "prefix_and_default";
+  const cookieName = getPreferenceCookieName(config);
+  return resolveLocale({
+    defaultLocale,
     validLocales,
-    autoDetectLanguage,
-    hasLocaleInUrl,
-    urlLocale,
-    queryLocale,
-    cookieLocale,
-    acceptLanguageHeader: event.headers.get("accept-language")
+    autoDetectLanguage: config.autoDetectLanguage,
+    url: urlless && mode === "page" ? null : urlLocale(event, mode, path, validLocales, unprefixedIsDefault ? defaultLocale : null),
+    query: mode === "api" || config.strategy === "no_prefix" ? firstQueryValue(getQuery(event).locale) : null,
+    queryFirst: mode === "api",
+    cookie: cookieName ? getCookie(event, cookieName) : null,
+    acceptLanguage: getHeader(event, "accept-language")
   });
-  return locale || fallbackLocale || resolvedDefault;
+}
+function urlLocale(event, mode, path, validLocales, unprefixed) {
+  const param = firstQueryValue(event.context.params?.locale);
+  if (mode === "api" && param && validLocales.includes(param)) return param;
+  const prefix = localeFromPath(path ?? withoutAppBaseURL(requestURL(event).pathname, useRuntimeConfig().app.baseURL), validLocales);
+  return prefix ?? (mode === "page" ? unprefixed : null);
+}
+export const detectCurrentLocale = (event, config, defaultLocale) => {
+  return detectRequestLocale(event, { ...config, defaultLocale: defaultLocale || config.defaultLocale }, "api");
 };
+export function getRequestLocale(event, config, defaultLocale) {
+  return detectRequestLocale(event, defaultLocale ? { ...config, defaultLocale } : config, "api");
+}

package/dist/runtime/server/utils/locale-server-middleware.js

@@ -1,37 +1,18 @@
-import { getEnabledLocaleCodes, getEnabledLocales } from "@i18n-micro/utils/active-locales";
-import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
-import { getI18nConfig } from "#i18n-internal/strategy";
-import { useRuntimeConfig } from "#imports";
-import { detectCurrentLocale } from "./locale-detector.js";
+import { getEnabledLocales } from "@i18n-micro/utils/active-locales";
+import { getI18nServerConfig, getRequestLocale } from "./locale-detector.js";
 export const useLocaleServerMiddleware = (event, defaultLocale, currentLocale) => {
-  const config = resolveI18nConfigWithRuntimeOverrides(
-    getI18nConfig(),
-    useRuntimeConfig(event).public
-  );
-  const { locales, defaultLocale: configDefaultLocale, fallbackLocale } = config;
-  const enabledLocales = getEnabledLocales(locales);
-  const detectedLocale = currentLocale || detectCurrentLocale(
-    event,
-    {
-      fallbackLocale,
-      defaultLocale: defaultLocale || configDefaultLocale,
-      locales: enabledLocales,
-      localeCookie: config.localeCookie || "user-locale",
-      autoDetectLanguage: true
-    },
-    defaultLocale
-  );
-  const localeConfig = enabledLocales.find((l) => l.code === detectedLocale) ?? null;
-  const availableLocales = getEnabledLocaleCodes(locales);
-  const isDefault = detectedLocale === (defaultLocale || configDefaultLocale || "en");
-  const isFallback = detectedLocale === (fallbackLocale || defaultLocale || configDefaultLocale || "en");
+  const config = getI18nServerConfig(event);
+  const enabledLocales = getEnabledLocales(config.locales);
+  const resolvedDefault = defaultLocale || config.defaultLocale;
+  const fallback = config.fallbackLocale || resolvedDefault;
+  const current = currentLocale || getRequestLocale(event, config, defaultLocale);
   return {
-    current: detectedLocale,
-    default: defaultLocale || configDefaultLocale || "en",
-    fallback: fallbackLocale || defaultLocale || configDefaultLocale || "en",
-    available: availableLocales,
-    locale: localeConfig,
-    isDefault,
-    isFallback
+    current,
+    default: resolvedDefault,
+    fallback,
+    available: enabledLocales.map((l) => l.code),
+    locale: enabledLocales.find((l) => l.code === current) ?? null,
+    isDefault: current === resolvedDefault,
+    isFallback: current === fallback
   };
 };

package/dist/runtime/server/utils/payload-cache.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedI18nConfig } from '@i18n-micro/types';
+import { type H3Event } from 'h3';
+/** The header of a payload response, by the `?v=` of its request. */
+export declare function payloadCacheControl(event: H3Event, config: ResolvedI18nConfig, empty?: boolean): string | null;

package/dist/runtime/server/utils/payload-cache.js

@@ -0,0 +1,13 @@
+import { resolveTranslationPayloadCachePolicy } from "@i18n-micro/utils/payload-url";
+import { getQuery } from "h3";
+import { resolveServerHost } from "./server-loader.js";
+export function payloadCacheControl(event, config, empty = false) {
+  const policy = resolveTranslationPayloadCachePolicy({
+    httpCacheDuration: config.httpCacheDuration,
+    httpCacheControl: config.httpCacheControl,
+    dateBuild: config.dateBuild,
+    live: config.translationPayloadMode === "source" || Boolean(config.cacheTtl) || Boolean(resolveServerHost())
+  });
+  const current = Boolean(config.dateBuild) && String(getQuery(event).v ?? "") === String(config.dateBuild) && !empty;
+  return current ? policy.current : policy.stale;
+}

package/dist/runtime/server/utils/server-loader.d.ts

@@ -2,11 +2,22 @@
  * Server-side translation loader.
  * - Node: JSON from public locales dir (`#i18n-internal/payload-source` → fs)
  * - Edge: Nitro `serverAssets` (`assets:i18n`)
- * - Dev cache miss: live locale-file merge (not stale `.nuxt/i18n-*`)
+ * - Dev: live locale files on every read (no cache to go stale on edits)
+ * - `cacheStorage`: a storage mount shared by instances, between the LRU and the above
  * `premerged` reads one file; `source` merges root+page+fallback at runtime.
+ *
+ * Bounded: entries live in one LRU cache, concurrent loads of a chunk share one read, and in
+ * premerged mode every page without its own payload shares the root entry — so request URLs
+ * with made-up page names cannot grow memory. (With `cacheStorage` such a name keeps one LRU slot.)
+ *
+ * A failed read rejects: no level may keep it, the next request reads again. A 404 from a host is an
+ * answer, `NO_FILE`, for this request only: a file can appear with the host's next deploy, and `cacheTtl`
+ * is off by default. ponytail: a page the host has no file for costs one request per render; a negative
+ * cache would hide the file for as long as it lives.
  */
-import type { Translations } from '@i18n-micro/types';
-export declare function loadTranslationsFromServer(locale: string, routeName: string): Promise<{
-    data: Translations;
-    json: string;
-}>;
+import { type ServerTranslationCacheEntry } from '../internal/server-translation-cache.js';
+/** The host has no such file. By identity: a host's own empty file is a dictionary, and stays cached. */
+export declare const NO_FILE: ServerTranslationCacheEntry;
+/** The host dictionaries come from: read per load, as `$fetch` in the page render does, so one artifact can run against several. */
+export declare function resolveServerHost(): string | undefined;
+export declare function loadTranslationsFromServer(locale: string, routeName: string): Promise<ServerTranslationCacheEntry>;